From 3da97a07ebb1f1d17c8214f2e4f980dfc40935da Mon Sep 17 00:00:00 2001 From: yungselm Date: Sun, 8 Mar 2026 15:37:29 +0100 Subject: [PATCH 01/30] add notes how to build WrapVTK and xml file with WrapVTK --- README.md | 61 +++++++++++++++++++++++++++++++++++++++++++++ vtk-rs-9.1/build.rs | 7 ++++++ 2 files changed, 68 insertions(+) diff --git a/README.md b/README.md index 1e3a669..3ca58d9 100644 --- a/README.md +++ b/README.md @@ -61,6 +61,67 @@ However, we do not use `cxx` to compile the code but rather let `cmake` handle t To implement the desired class methods, we use Rust [macros](https://doc.rust-lang.org/reference/macros-by-example.html). +## Contributing / Development Setup + +This section is for contributors who want to regenerate bindings for a new VTK version. +If you only want to *use* the existing `vtk-rs-9.1` bindings, skip this section — a system VTK install and `cargo build` is sufficient. + +### 1. Initialize the WrapVTK submodule + +`WrapVTK` (by [David Gobbi](https://github.com/dgobbi/WrapVTK)) is included as a git submodule. +It appears as an empty (blue) folder in IDEs until initialized: + +```bash +git submodule update --init --recursive +``` + +### 2. Build VTK from source + +`libvtk9-dev` (the system package) does **not** install the internal wrapping tool headers (e.g. `vtkParseAttributes.h`) that WrapVTK needs. +You must build VTK from source. + +```bash +cd ~ +git clone https://github.com/Kitware/VTK.git --branch v9.1.0 --depth 1 +cd VTK && mkdir build && cd build +cmake .. \ + -DVTK_WRAP_PYTHON=OFF \ + -DVTK_WRAP_JAVA=OFF \ + -DBUILD_TESTING=OFF \ + -DBUILD_SHARED_LIBS=OFF +cmake --build . -j$(nproc) +``` + +This takes roughly 15-30 minutes depending on your machine. + +### 3. Build WrapVTK + +```bash +cd /path/to/vtk-rs/WrapVTK +mkdir build && cd build +cmake .. -DVTK_DIR=~/VTK/build +cmake --build . +``` + +Verify that XML files were generated: + +```bash +ls build/xml/ +``` + +You should see directories like `vtkCommonCore`, `vtkCommonDataModel`, etc. + +### 4. Regenerate bindings with vtk-gen + +```bash +cargo run -p vtk-gen -- \ + --opath vtk-rs-9.1 \ + --wrap-vtk WrapVTK +``` + +This regenerates all files in `vtk-rs-9.1/` from the WrapVTK XML output. +To target a different VTK version, repeat steps 2-4 with a different git tag (e.g. `v9.3.0`) and a new output path (e.g. `--opath vtk-rs-9.3`). + ## Roadmap 1. [x] Stabilize Build system 2. [x] Automate system library detection and generate linker flags diff --git a/vtk-rs-9.1/build.rs b/vtk-rs-9.1/build.rs index 6654c5d..e8c8ee1 100644 --- a/vtk-rs-9.1/build.rs +++ b/vtk-rs-9.1/build.rs @@ -1,12 +1,19 @@ use cmake::Config; use vtk_rs_link::{Result, WARN, log}; + fn build_cmake() { println!("cargo:rerun-if-changed=libvtkrs"); let mut config = Config::new("libvtkrs"); + + if let Ok(vtk_dir) = std::env::var("VTK_DIR") { + config.define("VTK_DIR", &vtk_dir); + } + let dst = config.build(); println!("cargo:rustc-link-search=native={}", dst.display()); println!("cargo:rustc-link-lib=static=vtkrs"); } + fn main() -> Result<()> { if std::env::var("DOCS_RS").is_ok() { return Ok(()); From 2a76bdb408fa64cac479df2d5bdef6a35a1b3118 Mon Sep 17 00:00:00 2001 From: yungselm Date: Sun, 8 Mar 2026 22:10:54 +0100 Subject: [PATCH 02/30] set up bash script --- README.md | 42 ++++---------- setup_vtk.sh | 154 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 166 insertions(+), 30 deletions(-) create mode 100755 setup_vtk.sh diff --git a/README.md b/README.md index 3ca58d9..7df2c87 100644 --- a/README.md +++ b/README.md @@ -75,43 +75,25 @@ It appears as an empty (blue) folder in IDEs until initialized: git submodule update --init --recursive ``` -### 2. Build VTK from source +### 2. Run the setup script `libvtk9-dev` (the system package) does **not** install the internal wrapping tool headers (e.g. `vtkParseAttributes.h`) that WrapVTK needs. -You must build VTK from source. +Use the provided `setup_vtk.sh` script to clone VTK from source, build it, build WrapVTK against it, and verify the XML output — all in one step: ```bash -cd ~ -git clone https://github.com/Kitware/VTK.git --branch v9.1.0 --depth 1 -cd VTK && mkdir build && cd build -cmake .. \ - -DVTK_WRAP_PYTHON=OFF \ - -DVTK_WRAP_JAVA=OFF \ - -DBUILD_TESTING=OFF \ - -DBUILD_SHARED_LIBS=OFF -cmake --build . -j$(nproc) +./setup_vtk.sh 9.1.0 ``` -This takes roughly 15-30 minutes depending on your machine. +The version argument is optional and defaults to `9.1.0`. This takes roughly 15–30 minutes depending on your machine. -### 3. Build WrapVTK +The script will: +1. Wipe any existing `~/VTK` clone and `WrapVTK/build` directory +2. Clone VTK at the exact tag (e.g. `v9.1.0`) into `~/VTK` +3. Build VTK with static libs and the required modules (`CommonArchive`, `CommonPython`) +4. Build WrapVTK against the fresh VTK build +5. Verify that XML files were generated under `WrapVTK/build/xml/` -```bash -cd /path/to/vtk-rs/WrapVTK -mkdir build && cd build -cmake .. -DVTK_DIR=~/VTK/build -cmake --build . -``` - -Verify that XML files were generated: - -```bash -ls build/xml/ -``` - -You should see directories like `vtkCommonCore`, `vtkCommonDataModel`, etc. - -### 4. Regenerate bindings with vtk-gen +### 3. Regenerate bindings with vtk-gen ```bash cargo run -p vtk-gen -- \ @@ -120,7 +102,7 @@ cargo run -p vtk-gen -- \ ``` This regenerates all files in `vtk-rs-9.1/` from the WrapVTK XML output. -To target a different VTK version, repeat steps 2-4 with a different git tag (e.g. `v9.3.0`) and a new output path (e.g. `--opath vtk-rs-9.3`). +To target a different VTK version, run `./setup_vtk.sh ` first, then repeat this step with a matching output path (e.g. `--opath vtk-rs-9.3`). ## Roadmap 1. [x] Stabilize Build system diff --git a/setup_vtk.sh b/setup_vtk.sh new file mode 100755 index 0000000..2e62d2a --- /dev/null +++ b/setup_vtk.sh @@ -0,0 +1,154 @@ +#!/usr/bin/env bash +# setup_vtk.sh — Download VTK from source, build WrapVTK, and generate XML files. +# +# Usage: +# ./setup_vtk.sh [VTK_VERSION] +# +# Example: +# ./setup_vtk.sh 9.1.0 (default) +# ./setup_vtk.sh 9.3.0 +# +# What this script does: +# 1. Wipes any existing ~/VTK clone and WrapVTK/build directory. +# 2. Clones VTK at the exact tag v into ~/VTK. +# 3. Builds VTK (static libs, no Python/Java/testing). +# 4. Builds WrapVTK against the fresh VTK build. +# 5. Verifies that XML files were generated. + +set -euo pipefail + +# --------------------------------------------------------------------------- +# Configuration +# --------------------------------------------------------------------------- +VTK_VERSION="${1:-9.1.0}" +VTK_TAG="v${VTK_VERSION}" +VTK_SRC="${HOME}/VTK" +VTK_BUILD="${VTK_SRC}/build" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +WRAP_VTK_DIR="${SCRIPT_DIR}/WrapVTK" +WRAP_BUILD="${WRAP_VTK_DIR}/build" +JOBS="$(nproc)" + +echo "==========================================" +echo " VTK setup script" +echo " VTK version : ${VTK_TAG}" +echo " VTK source : ${VTK_SRC}" +echo " WrapVTK dir : ${WRAP_VTK_DIR}" +echo " Parallel jobs: ${JOBS}" +echo "==========================================" + +# --------------------------------------------------------------------------- +# Step 0: Wipe existing builds +# --------------------------------------------------------------------------- +echo "" +echo "[0/4] Wiping existing builds..." + +if [ -d "${VTK_SRC}" ]; then + echo " Removing ${VTK_SRC} ..." + rm -rf "${VTK_SRC}" +fi + +if [ -d "${WRAP_BUILD}" ]; then + echo " Removing ${WRAP_BUILD} ..." + rm -rf "${WRAP_BUILD}" +fi + +echo " Done." + +# --------------------------------------------------------------------------- +# Step 1: Clone VTK at the exact version tag +# --------------------------------------------------------------------------- +echo "" +echo "[1/4] Cloning VTK ${VTK_TAG} into ${VTK_SRC} ..." + +git clone \ + https://github.com/Kitware/VTK.git \ + --branch "${VTK_TAG}" \ + --depth 1 \ + "${VTK_SRC}" + +echo " Clone complete." + +# --------------------------------------------------------------------------- +# Step 2: Build VTK from source +# --------------------------------------------------------------------------- +echo "" +echo "[2/4] Building VTK (this takes 15-30 minutes) ..." + +mkdir -p "${VTK_BUILD}" +cmake -S "${VTK_SRC}" -B "${VTK_BUILD}" \ + -DVTK_WRAP_PYTHON=ON \ + -DVTK_WRAP_JAVA=OFF \ + -DBUILD_TESTING=OFF \ + -DBUILD_SHARED_LIBS=OFF \ + -DCMAKE_BUILD_TYPE=Release \ + -DVTK_MODULE_ENABLE_VTK_CommonArchive=YES \ + -DVTK_MODULE_ENABLE_VTK_CommonPython=YES + +cmake --build "${VTK_BUILD}" -j"${JOBS}" + +echo " VTK build complete." + +# Sanity check: ensure wrapping headers are present +if [ ! -f "${VTK_BUILD}/Wrapping/Tools/vtkParseAttributes.h" ] && \ + [ ! -f "${VTK_SRC}/Wrapping/Tools/vtkParseAttributes.h" ]; then + echo "" + echo "WARNING: vtkParseAttributes.h not found." + echo " WrapVTK may fail if wrapping headers are missing." +fi + +# --------------------------------------------------------------------------- +# Step 3: Build WrapVTK +# --------------------------------------------------------------------------- +echo "" +echo "[3/4] Building WrapVTK ..." + +# Ensure the submodule is initialised +if [ ! -f "${WRAP_VTK_DIR}/CMakeLists.txt" ]; then + echo " WrapVTK source not found at ${WRAP_VTK_DIR}." + echo " Run: git submodule update --init --recursive" + exit 1 +fi + +mkdir -p "${WRAP_BUILD}" +cmake -S "${WRAP_VTK_DIR}" -B "${WRAP_BUILD}" \ + -DVTK_DIR="${VTK_BUILD}" + +cmake --build "${WRAP_BUILD}" -j"${JOBS}" + +echo " WrapVTK build complete." + +# --------------------------------------------------------------------------- +# Step 4: Verify XML output +# --------------------------------------------------------------------------- +echo "" +echo "[4/4] Verifying XML output ..." + +XML_DIR="${WRAP_BUILD}/xml" + +if [ ! -d "${XML_DIR}" ]; then + echo "ERROR: XML directory not found at ${XML_DIR}" + echo " Something went wrong during the WrapVTK build." + exit 1 +fi + +XML_COUNT="$(ls -1 "${XML_DIR}" | wc -l)" +echo " Found ${XML_COUNT} XML module directories in ${XML_DIR}." + +if [ "${XML_COUNT}" -eq 0 ]; then + echo "ERROR: No XML files were generated. Check the WrapVTK build output." + exit 1 +fi + +echo "" +echo "==========================================" +echo " Setup complete for VTK ${VTK_TAG}!" +echo "" +echo " VTK build : ${VTK_BUILD}" +echo " XML output: ${XML_DIR}" +echo "" +echo " Next step — regenerate Rust bindings:" +echo " cargo run -p vtk-gen -- \\" +echo " --opath vtk-rs-${VTK_VERSION%.*} \\" +echo " --wrap-vtk WrapVTK" +echo "==========================================" From f996d9adac81e9bc21a787ea8e2388a92aa0ffe6 Mon Sep 17 00:00:00 2001 From: yungselm Date: Mon, 9 Mar 2026 09:18:00 +0100 Subject: [PATCH 03/30] working set up to add functions to current vtk-rs-9.1 (had to update to 9.2.0) --- README.md | 10 ++-- setup_vtk.sh | 4 +- vtk-rs-9.1/build.rs | 43 ++++++++++++-- .../libvtkrs/include/vtk_common_archive.h | 4 ++ vtk-rs-9.1/libvtkrs/include/vtk_common_core.h | 2 + .../libvtkrs/src/vtk_common_archive.cpp | 4 ++ vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp | 2 + vtk-rs-9.1/src/vtkCommonArchive.rs | 58 +++++++++++++++++++ vtk-rs-9.1/src/vtkCommonCore.rs | 32 ++++++++++ 9 files changed, 147 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index 7df2c87..3c1fd52 100644 --- a/README.md +++ b/README.md @@ -81,14 +81,14 @@ git submodule update --init --recursive Use the provided `setup_vtk.sh` script to clone VTK from source, build it, build WrapVTK against it, and verify the XML output — all in one step: ```bash -./setup_vtk.sh 9.1.0 +./setup_vtk.sh 9.2.0 ``` -The version argument is optional and defaults to `9.1.0`. This takes roughly 15–30 minutes depending on your machine. +The version argument is optional and defaults to `9.2.0`. This takes roughly 15–30 minutes depending on your machine. The script will: 1. Wipe any existing `~/VTK` clone and `WrapVTK/build` directory -2. Clone VTK at the exact tag (e.g. `v9.1.0`) into `~/VTK` +2. Clone VTK at the exact tag (e.g. `v9.2.0`) into `~/VTK` 3. Build VTK with static libs and the required modules (`CommonArchive`, `CommonPython`) 4. Build WrapVTK against the fresh VTK build 5. Verify that XML files were generated under `WrapVTK/build/xml/` @@ -97,11 +97,11 @@ The script will: ```bash cargo run -p vtk-gen -- \ - --opath vtk-rs-9.1 \ + --opath vtk-rs-9.2 \ --wrap-vtk WrapVTK ``` -This regenerates all files in `vtk-rs-9.1/` from the WrapVTK XML output. +This regenerates all files in `vtk-rs-9.2/` from the WrapVTK XML output. To target a different VTK version, run `./setup_vtk.sh ` first, then repeat this step with a matching output path (e.g. `--opath vtk-rs-9.3`). ## Roadmap diff --git a/setup_vtk.sh b/setup_vtk.sh index 2e62d2a..574cb4a 100755 --- a/setup_vtk.sh +++ b/setup_vtk.sh @@ -5,7 +5,7 @@ # ./setup_vtk.sh [VTK_VERSION] # # Example: -# ./setup_vtk.sh 9.1.0 (default) +# ./setup_vtk.sh 9.2.0 (default) # ./setup_vtk.sh 9.3.0 # # What this script does: @@ -20,7 +20,7 @@ set -euo pipefail # --------------------------------------------------------------------------- # Configuration # --------------------------------------------------------------------------- -VTK_VERSION="${1:-9.1.0}" +VTK_VERSION="${1:-9.2.0}" VTK_TAG="v${VTK_VERSION}" VTK_SRC="${HOME}/VTK" VTK_BUILD="${VTK_SRC}/build" diff --git a/vtk-rs-9.1/build.rs b/vtk-rs-9.1/build.rs index e8c8ee1..83f4188 100644 --- a/vtk-rs-9.1/build.rs +++ b/vtk-rs-9.1/build.rs @@ -1,12 +1,17 @@ use cmake::Config; -use vtk_rs_link::{Result, WARN, log}; +use vtk_rs_link::{Result, WARN, log, find_vtk_info}; fn build_cmake() { println!("cargo:rerun-if-changed=libvtkrs"); + println!("cargo:rerun-if-env-changed=VTK_DIR"); + println!("cargo:rerun-if-env-changed=VTK_VERSION"); let mut config = Config::new("libvtkrs"); - + if let Ok(vtk_dir) = std::env::var("VTK_DIR") { config.define("VTK_DIR", &vtk_dir); + // Also add the lib subdirectory to the linker search path so that + // source-built VTK libraries (e.g. ~/VTK/build/lib) are found. + println!("cargo:rustc-link-search=native={}/lib", vtk_dir); } let dst = config.build(); @@ -25,8 +30,12 @@ fn main() -> Result<()> { } } build_cmake(); - let modules = vec![ - "vtksys", + + let info = find_vtk_info()?; + let v = &info.version_suffix; + + // VTK modules + let modules = [ // "vtktoken", "vtkCommonArchive", "vtkCommonColor", @@ -40,6 +49,30 @@ fn main() -> Result<()> { "vtkCommonSystem", "vtkCommonTransforms", ]; - vtk_rs_link::link_cmake_project(modules)?; + + // Bundled third-party libs that VTK modules depend on + let third_party = [ + "vtkpugixml", + "vtkkissfft", + "vtkloguru", + "vtksys", + "vtkdoubleconversion", + ]; + + // Build a single -Wl,--start-group,...,--end-group argument so the linker + // makes multiple passes and resolves out-of-order static dependencies. + // -lm is included inside the group so it is available when VTK libs need it. + let libs: Vec = modules + .iter() + .map(|m| format!("-l{}{}", m, v)) + .chain(third_party.iter().map(|m| format!("-l{}{}", m, v))) + .chain(["-lm".to_string(), "-lstdc++".to_string(), "-larchive".to_string(), "-lc".to_string()]) + .collect(); + + println!( + "cargo:rustc-link-arg=-Wl,--start-group,{},--end-group", + libs.join(",") + ); + Ok(()) } diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_archive.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_archive.h index 8d2fd80..b414342 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_archive.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_archive.h @@ -10,6 +10,10 @@ extern "C" vtkNew < vtkBufferedArchiver > vtkBufferedArchiver_new () ; extern "C" void vtkBufferedArchiver_destructor (vtkNew < vtkBufferedArchiver > sself) ; extern "C" void * vtkBufferedArchiver_get_ptr (vtkNew < vtkBufferedArchiver > sself) ; +extern "C" void vtkBufferedArchiver_set_archive_name (vtkNew < vtkBufferedArchiver > sself, const char * name) ; +extern "C" const char * vtkBufferedArchiver_get_archive_name (vtkNew < vtkBufferedArchiver > sself) ; extern "C" vtkNew < vtkPartitionedArchiver > vtkPartitionedArchiver_new () ; extern "C" void vtkPartitionedArchiver_destructor (vtkNew < vtkPartitionedArchiver > sself) ; extern "C" void * vtkPartitionedArchiver_get_ptr (vtkNew < vtkPartitionedArchiver > sself) ; +extern "C" void vtkPartitionedArchiver_set_archive_name (vtkNew < vtkPartitionedArchiver > sself, const char * name) ; +extern "C" const char * vtkPartitionedArchiver_get_archive_name (vtkNew < vtkPartitionedArchiver > sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h index 62c7072..f2811cf 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h @@ -167,6 +167,8 @@ extern "C" void * vtkAnimationCue_get_ptr (vtkNew < vtkAnimationCue > sself) ; extern "C" vtkNew < vtkArchiver > vtkArchiver_new () ; extern "C" void vtkArchiver_destructor (vtkNew < vtkArchiver > sself) ; extern "C" void * vtkArchiver_get_ptr (vtkNew < vtkArchiver > sself) ; +extern "C" void vtkArchiver_set_archive_name (vtkNew < vtkArchiver > sself, const char * name) ; +extern "C" const char * vtkArchiver_get_archive_name (vtkNew < vtkArchiver > sself) ; extern "C" vtkNew < vtkBitArray > vtkBitArray_new () ; extern "C" void vtkBitArray_destructor (vtkNew < vtkBitArray > sself) ; extern "C" void * vtkBitArray_get_ptr (vtkNew < vtkBitArray > sself) ; diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_archive.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_archive.cpp index 1ebfbe0..11eff3a 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_archive.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_archive.cpp @@ -13,6 +13,10 @@ extern "C" vtkNew < vtkBufferedArchiver > vtkBufferedArchiver_new () {return vtkNew < vtkBufferedArchiver > () ;} extern "C" void vtkBufferedArchiver_destructor (vtkNew < vtkBufferedArchiver > sself) {sself . Reset () ; return ;} extern "C" void * vtkBufferedArchiver_get_ptr (vtkNew < vtkBufferedArchiver > sself) {return sself . GetPointer () ;} +extern "C" void vtkBufferedArchiver_set_archive_name (vtkNew < vtkBufferedArchiver > sself, const char * name) {sself->SetArchiveName(name);} +extern "C" const char * vtkBufferedArchiver_get_archive_name (vtkNew < vtkBufferedArchiver > sself) {return sself->GetArchiveName();} extern "C" vtkNew < vtkPartitionedArchiver > vtkPartitionedArchiver_new () {return vtkNew < vtkPartitionedArchiver > () ;} extern "C" void vtkPartitionedArchiver_destructor (vtkNew < vtkPartitionedArchiver > sself) {sself . Reset () ; return ;} extern "C" void * vtkPartitionedArchiver_get_ptr (vtkNew < vtkPartitionedArchiver > sself) {return sself . GetPointer () ;} +extern "C" void vtkPartitionedArchiver_set_archive_name (vtkNew < vtkPartitionedArchiver > sself, const char * name) {sself->SetArchiveName(name);} +extern "C" const char * vtkPartitionedArchiver_get_archive_name (vtkNew < vtkPartitionedArchiver > sself) {return sself->GetArchiveName();} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp index bb509e5..b4da45f 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp @@ -170,6 +170,8 @@ extern "C" void * vtkAnimationCue_get_ptr (vtkNew < vtkAnimationCue > sself) {re extern "C" vtkNew < vtkArchiver > vtkArchiver_new () {return vtkNew < vtkArchiver > () ;} extern "C" void vtkArchiver_destructor (vtkNew < vtkArchiver > sself) {sself . Reset () ; return ;} extern "C" void * vtkArchiver_get_ptr (vtkNew < vtkArchiver > sself) {return sself . GetPointer () ;} +extern "C" void vtkArchiver_set_archive_name (vtkNew < vtkArchiver > sself, const char * name) {sself->SetArchiveName(name);} +extern "C" const char * vtkArchiver_get_archive_name (vtkNew < vtkArchiver > sself) {return sself->GetArchiveName();} extern "C" vtkNew < vtkBitArray > vtkBitArray_new () {return vtkNew < vtkBitArray > () ;} extern "C" void vtkBitArray_destructor (vtkNew < vtkBitArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkBitArray_get_ptr (vtkNew < vtkBitArray > sself) {return sself . GetPointer () ;} diff --git a/vtk-rs-9.1/src/vtkCommonArchive.rs b/vtk-rs-9.1/src/vtkCommonArchive.rs index c0a53bf..070b0b3 100644 --- a/vtk-rs-9.1/src/vtkCommonArchive.rs +++ b/vtk-rs-9.1/src/vtkCommonArchive.rs @@ -27,6 +27,28 @@ impl vtkBufferedArchiver { unsafe { vtkBufferedArchiver_get_ptr(self.0) } } } +impl crate::vtkCommonCore::VtkArchiver for vtkBufferedArchiver { + fn set_archive_name(&self, name: &str) { + unsafe extern "C" { + fn vtkBufferedArchiver_set_archive_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe { vtkBufferedArchiver_set_archive_name(self.0, c_name.as_ptr()) } + } + fn get_archive_name(&self) -> &str { + unsafe extern "C" { + fn vtkBufferedArchiver_get_archive_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtkBufferedArchiver_get_archive_name(self.0) }; + if ptr.is_null() { return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} impl std::default::Default for vtkBufferedArchiver { fn default() -> Self { Self::new() @@ -51,6 +73,13 @@ fn test_vtkBufferedArchiver_create_drop() { let new_obj = vtkBufferedArchiver(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } +#[test] +fn test_vtkBufferedArchiver_set_archive_name() { + use crate::vtkCommonCore::VtkArchiver; + let obj = vtkBufferedArchiver::new(); + obj.set_archive_name("test_archive"); + assert_eq!(obj.get_archive_name(), "test_archive"); +} /// Writes an archive to several buffers /// /// @@ -81,6 +110,28 @@ impl vtkPartitionedArchiver { unsafe { vtkPartitionedArchiver_get_ptr(self.0) } } } +impl crate::vtkCommonCore::VtkArchiver for vtkPartitionedArchiver { + fn set_archive_name(&self, name: &str) { + unsafe extern "C" { + fn vtkPartitionedArchiver_set_archive_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe { vtkPartitionedArchiver_set_archive_name(self.0, c_name.as_ptr()) } + } + fn get_archive_name(&self) -> &str { + unsafe extern "C" { + fn vtkPartitionedArchiver_get_archive_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtkPartitionedArchiver_get_archive_name(self.0) }; + if ptr.is_null() { return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} impl std::default::Default for vtkPartitionedArchiver { fn default() -> Self { Self::new() @@ -105,3 +156,10 @@ fn test_vtkPartitionedArchiver_create_drop() { let new_obj = vtkPartitionedArchiver(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } +#[test] +fn test_vtkPartitionedArchiver_set_archive_name() { + use crate::vtkCommonCore::VtkArchiver; + let obj = vtkPartitionedArchiver::new(); + obj.set_archive_name("test_archive"); + assert_eq!(obj.get_archive_name(), "test_archive"); +} diff --git a/vtk-rs-9.1/src/vtkCommonCore.rs b/vtk-rs-9.1/src/vtkCommonCore.rs index 208cbee..3ba0b97 100644 --- a/vtk-rs-9.1/src/vtkCommonCore.rs +++ b/vtk-rs-9.1/src/vtkCommonCore.rs @@ -117,6 +117,38 @@ fn test_vtkArchiver_create_drop() { let new_obj = vtkArchiver(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } +pub trait VtkArchiver { + fn set_archive_name(&self, name: &str); + fn get_archive_name(&self) -> &str; +} +impl VtkArchiver for vtkArchiver { + fn set_archive_name(&self, name: &str) { + unsafe extern "C" { + fn vtkArchiver_set_archive_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe { vtkArchiver_set_archive_name(self.0, c_name.as_ptr()) } + } + fn get_archive_name(&self) -> &str { + unsafe extern "C" { + fn vtkArchiver_get_archive_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtkArchiver_get_archive_name(self.0) }; + if ptr.is_null() { return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} +#[test] +fn test_vtkArchiver_set_archive_name() { + let obj = vtkArchiver::new(); + obj.set_archive_name("my_archive"); + assert_eq!(obj.get_archive_name(), "my_archive"); +} /// dynamic, self-adjusting array of bits /// /// From 102147852826a8cef47a2363f6b837b7bbfb26dd Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 11:37:22 +0200 Subject: [PATCH 04/30] address several problems in automated pipeline --- .gitignore | 1 + README.md | 41 +++++++++++++++++++++++++++++++---------- setup_vtk.sh | 31 +++++++++++++++++++++++++------ vtk-gen/Cargo.toml | 4 ++-- 4 files changed, 59 insertions(+), 18 deletions(-) diff --git a/.gitignore b/.gitignore index 41faf70..776e528 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ /target vtk-rs/libvtkrs/build Cargo.lock +/WrapVTK \ No newline at end of file diff --git a/README.md b/README.md index 3c1fd52..2115507 100644 --- a/README.md +++ b/README.md @@ -66,19 +66,39 @@ To implement the desired class methods, we use Rust This section is for contributors who want to regenerate bindings for a new VTK version. If you only want to *use* the existing `vtk-rs-9.1` bindings, skip this section — a system VTK install and `cargo build` is sufficient. -### 1. Initialize the WrapVTK submodule +### Prerequisites -`WrapVTK` (by [David Gobbi](https://github.com/dgobbi/WrapVTK)) is included as a git submodule. -It appears as an empty (blue) folder in IDEs until initialized: +Before following the steps below, ensure you have the following tools installed: +| Tool | Required | Purpose | +| --- | --- | --- | +| `cmake` (≥ 3.12) | Yes | Build VTK from source and build WrapVTK | +| `git` | Yes | Clone the VTK source repository | +| C++ compiler (`gcc` or `clang`) | Yes | Compile VTK and WrapVTK | +| Python dev headers | Yes | Required by VTK's Python wrapping layer, which WrapVTK depends on to generate XML | +| `libarchive` dev headers | Optional | Enables the `vtkCommonArchive` module; skipped gracefully if absent | +| ~10 GB free disk space | Yes | VTK source clone + build artifacts | + +Install on Ubuntu 22 / 24: +```bash +# Required +sudo apt install cmake build-essential python3-dev +# Optional (for vtkCommonArchive) +sudo apt install libarchive-dev +``` +Install on Arch Linux: +```bash +sudo pacman -S cmake gcc python libarchive +``` +Install on macOS: ```bash -git submodule update --init --recursive +brew install cmake python libarchive ``` -### 2. Run the setup script +### 1. Run the setup script `libvtk9-dev` (the system package) does **not** install the internal wrapping tool headers (e.g. `vtkParseAttributes.h`) that WrapVTK needs. -Use the provided `setup_vtk.sh` script to clone VTK from source, build it, build WrapVTK against it, and verify the XML output — all in one step: +Use the provided `setup_vtk.sh` script to clone VTK from source, build it, initialise the `WrapVTK` submodule if needed, build WrapVTK against it, and verify the XML output — all in one step: ```bash ./setup_vtk.sh 9.2.0 @@ -89,11 +109,12 @@ The version argument is optional and defaults to `9.2.0`. This takes roughly 15 The script will: 1. Wipe any existing `~/VTK` clone and `WrapVTK/build` directory 2. Clone VTK at the exact tag (e.g. `v9.2.0`) into `~/VTK` -3. Build VTK with static libs and the required modules (`CommonArchive`, `CommonPython`) -4. Build WrapVTK against the fresh VTK build -5. Verify that XML files were generated under `WrapVTK/build/xml/` +3. Build VTK with static libs, Python wrapping enabled (required by WrapVTK), and the non-Common groups disabled (Rendering, Imaging, Qt, Web, Views, MPI — not needed for XML generation, and some contain version-specific compile bugs) +4. Initialise the `WrapVTK` git submodule automatically if not already done +5. Build WrapVTK against the fresh VTK build +6. Verify that XML files were generated under `WrapVTK/build/xml/` -### 3. Regenerate bindings with vtk-gen +### 2. Regenerate bindings with vtk-gen ```bash cargo run -p vtk-gen -- \ diff --git a/setup_vtk.sh b/setup_vtk.sh index 574cb4a..68bf98e 100755 --- a/setup_vtk.sh +++ b/setup_vtk.sh @@ -76,14 +76,34 @@ echo "" echo "[2/4] Building VTK (this takes 15-30 minutes) ..." mkdir -p "${VTK_BUILD}" + +# Module disable notes: +# - VTK_WRAP_PYTHON=ON is required for the wrapping tools (vtkWrapHierarchy etc.) +# that WrapVTK depends on to generate XML, but it also enables Python wrapper +# compilation for every built module — so we disable all module groups we don't +# need to avoid compiling broken or unnecessary code. +# - IOImage and IOImage are in the StandAlone group alongside Common modules, +# so they cannot be excluded via group flags. DONT_WANT is overridden by the +# group DEFAULT, so NO is required — it is unconditional and ignores group +# membership. vtkSEPReader.cxx in IOImage fails to compile on GCC with +# VTK <= 9.1 (out-of-sync header/impl: missing EndiannessType, DataFormat +# members and std::int32_t). Safe to hard-disable: vtk-gen only reads +# vtkCommon* XML. cmake -S "${VTK_SRC}" -B "${VTK_BUILD}" \ -DVTK_WRAP_PYTHON=ON \ -DVTK_WRAP_JAVA=OFF \ -DBUILD_TESTING=OFF \ -DBUILD_SHARED_LIBS=OFF \ -DCMAKE_BUILD_TYPE=Release \ - -DVTK_MODULE_ENABLE_VTK_CommonArchive=YES \ - -DVTK_MODULE_ENABLE_VTK_CommonPython=YES + -DVTK_MODULE_ENABLE_VTK_CommonArchive=DONT_WANT \ + -DVTK_MODULE_ENABLE_VTK_CommonPython=DONT_WANT \ + -DVTK_MODULE_ENABLE_VTK_IOImage=NO \ + -DVTK_GROUP_ENABLE_Rendering=DONT_WANT \ + -DVTK_GROUP_ENABLE_Qt=DONT_WANT \ + -DVTK_GROUP_ENABLE_Web=DONT_WANT \ + -DVTK_GROUP_ENABLE_Views=DONT_WANT \ + -DVTK_GROUP_ENABLE_MPI=DONT_WANT \ + -DVTK_GROUP_ENABLE_Imaging=DONT_WANT cmake --build "${VTK_BUILD}" -j"${JOBS}" @@ -103,11 +123,10 @@ fi echo "" echo "[3/4] Building WrapVTK ..." -# Ensure the submodule is initialised +# Initialise the submodule if it hasn't been cloned yet if [ ! -f "${WRAP_VTK_DIR}/CMakeLists.txt" ]; then - echo " WrapVTK source not found at ${WRAP_VTK_DIR}." - echo " Run: git submodule update --init --recursive" - exit 1 + echo " WrapVTK submodule not initialised — running git submodule update ..." + git -C "${SCRIPT_DIR}" submodule update --init --recursive fi mkdir -p "${WRAP_BUILD}" diff --git a/vtk-gen/Cargo.toml b/vtk-gen/Cargo.toml index a0dceaa..31fd0bd 100644 --- a/vtk-gen/Cargo.toml +++ b/vtk-gen/Cargo.toml @@ -11,7 +11,7 @@ include = ["src/*.rs", "/Default/*"] anyhow = "1.0.98" cargo_toml = "0.22.3" clap = { version = "4.5.54", features = ["derive"] } -convert_case = "0.10.0" +convert_case = "0.11.0" glob = "0.3.2" log = "0.4.27" pretty_env_logger = "0.5.0" @@ -23,4 +23,4 @@ regex = "1.11.1" serde = { version = "1.0.219", features = ["derive"] } serde-xml-rs = "0.8.1" syn = "2.0.101" -toml = "0.9.11" +toml = "1.1.2" From c8ad22cb71c2eba3f5bd98eeae13d72455478c09 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 11:37:50 +0200 Subject: [PATCH 05/30] small fix --- .gitignore | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index 776e528..4e552a0 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,3 @@ /target vtk-rs/libvtkrs/build -Cargo.lock -/WrapVTK \ No newline at end of file +Cargo.lock \ No newline at end of file From d41e5ff43658ac42fab1f7e720a2f826c38a9287 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 13:18:25 +0200 Subject: [PATCH 06/30] working setup_vtk.sh --- setup_vtk.sh | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/setup_vtk.sh b/setup_vtk.sh index 68bf98e..e299f1f 100755 --- a/setup_vtk.sh +++ b/setup_vtk.sh @@ -89,6 +89,9 @@ mkdir -p "${VTK_BUILD}" # VTK <= 9.1 (out-of-sync header/impl: missing EndiannessType, DataFormat # members and std::int32_t). Safe to hard-disable: vtk-gen only reads # vtkCommon* XML. +# - libproj (ThirdParty): bundled PROJ library uses std::int64_t without +# including ; fails on GCC >= 13. Pulled in by IO/GeoJSON and +# similar StandAlone modules we don't need. cmake -S "${VTK_SRC}" -B "${VTK_BUILD}" \ -DVTK_WRAP_PYTHON=ON \ -DVTK_WRAP_JAVA=OFF \ @@ -98,6 +101,7 @@ cmake -S "${VTK_SRC}" -B "${VTK_BUILD}" \ -DVTK_MODULE_ENABLE_VTK_CommonArchive=DONT_WANT \ -DVTK_MODULE_ENABLE_VTK_CommonPython=DONT_WANT \ -DVTK_MODULE_ENABLE_VTK_IOImage=NO \ + -DVTK_MODULE_ENABLE_VTK_libproj=NO \ -DVTK_GROUP_ENABLE_Rendering=DONT_WANT \ -DVTK_GROUP_ENABLE_Qt=DONT_WANT \ -DVTK_GROUP_ENABLE_Web=DONT_WANT \ From d91c1396ee62c572de2c4dd4cf4f697a05547878 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 13:37:53 +0200 Subject: [PATCH 07/30] add vtk_name field to IRMethod and short_name() helper IRMethod now stores both the full snake_case binding name (used as the extern "C" symbol) and the original PascalCase VTK method name (needed to generate the C++ call sself->SetRadius(...)). The short_name() helper strips the class prefix for use in trait method signatures. --- vtk-gen/src/code_gen_rust.rs | 1 + vtk-gen/src/intermediate_representation.rs | 16 +++++++++++++++- 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/vtk-gen/src/code_gen_rust.rs b/vtk-gen/src/code_gen_rust.rs index 7e1e77a..a47ae52 100644 --- a/vtk-gen/src/code_gen_rust.rs +++ b/vtk-gen/src/code_gen_rust.rs @@ -77,6 +77,7 @@ impl ToTokens for crate::IRMethod { name, return_type, args, + .. } = &self; let name = quote::format_ident!("{name}"); diff --git a/vtk-gen/src/intermediate_representation.rs b/vtk-gen/src/intermediate_representation.rs index 0e0daf2..5609459 100644 --- a/vtk-gen/src/intermediate_representation.rs +++ b/vtk-gen/src/intermediate_representation.rs @@ -97,12 +97,26 @@ impl From for IRIdent { } pub struct IRMethod { + /// Full snake_case binding name, e.g. `vtk_sphere_source_set_radius` pub name: String, + /// Original PascalCase VTK method name, e.g. `SetRadius` (used in C++ call) + pub vtk_name: String, pub return_type: IRType, pub args: Vec<(IRIdent, IRType)>, } impl IRMethod { + /// Strip the class snake_case prefix to get the short method name. + /// e.g. `vtk_sphere_source_set_radius` → `set_radius` (for `vtkSphereSource`) + pub fn short_name(&self, class_name: &str) -> String { + use convert_case::Casing; + let prefix = format!("{}_", class_name.to_case(convert_case::Case::Snake)); + self.name + .strip_prefix(&prefix) + .unwrap_or(&self.name) + .to_string() + } + fn convert_from_class(class: &crate::Class, value: &crate::Method) -> Result { use crate::parse_cpp::Parse; let return_type = if let Some(crate::ReturnType { ret_type, pointer }) = &value.return_type @@ -128,7 +142,6 @@ impl IRMethod { .map(|(n, param)| { let name = match ¶m.name { Some(name) => name.clone(), - // TODO make this better None => format!("p{n}"), }; let name = crate::parse_cpp::Ident::parse(&name)?; @@ -141,6 +154,7 @@ impl IRMethod { use convert_case::*; Ok(IRMethod { name: format!("{}_{}", class.name, value.name).to_case(Case::Snake), + vtk_name: value.name.clone(), return_type, args, }) From 1791c971b136e977d6ebb8d124b31f21c86588eb Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 15:10:37 +0200 Subject: [PATCH 08/30] update gitignore to exlude notes, small typo fix --- .gitignore | 4 +++- vtk-gen/src/parse_wrap_vtk_xml.rs | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index 4e552a0..b876876 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ /target vtk-rs/libvtkrs/build -Cargo.lock \ No newline at end of file +Cargo.lock +LEARNINGS.md +WORKFLOW.md \ No newline at end of file diff --git a/vtk-gen/src/parse_wrap_vtk_xml.rs b/vtk-gen/src/parse_wrap_vtk_xml.rs index 9d9763f..d6b2263 100644 --- a/vtk-gen/src/parse_wrap_vtk_xml.rs +++ b/vtk-gen/src/parse_wrap_vtk_xml.rs @@ -32,7 +32,7 @@ pub fn get_modules(path: impl Into) -> Result> { let files = glob::glob( path.join("*") .to_str() - .context("could not convert path tot string")?, + .context("could not convert path to String")?, )? .map(|x| { let f = x?.to_path_buf(); From 1391bf63ea991fe0a0380fd5fbd32e2d1615ad18 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 15:55:18 +0200 Subject: [PATCH 09/30] write tests for intermediate representaiton --- vtk-gen/src/intermediate_representation.rs | 101 +++++++++++++++++++++ 1 file changed, 101 insertions(+) diff --git a/vtk-gen/src/intermediate_representation.rs b/vtk-gen/src/intermediate_representation.rs index 5609459..eb84a11 100644 --- a/vtk-gen/src/intermediate_representation.rs +++ b/vtk-gen/src/intermediate_representation.rs @@ -269,3 +269,104 @@ impl IRModule { }) } } + +// test helpers (available to all test modules in this crate) +#[cfg(test)] +impl IRMethod { + pub(crate) fn test_new( + name: &str, + vtk_name: &str, + return_type: IRType, + args: Vec<(IRIdent, IRType)>, + ) -> Self { + IRMethod { + name: name.to_string(), + vtk_name: vtk_name.to_string(), + return_type, + args, + } + } +} + +#[cfg(test)] +impl IRStruct { + pub(crate) fn test_new(name: &str, parents: Vec<&str>, methods: Vec) -> Self { + use crate::parse_wrap_vtk_xml::{Access, Constructor, Destructor}; + IRStruct { + name: name.to_string(), + description: vec![], + parents: parents.iter().map(|s| s.to_string()).collect(), + exposable_methods: methods, + is_abstract: false, + is_template: false, + filename: format!("{}.h", name), + constructors: vec![Constructor { + access: Access::Public, + signature: String::new(), + }], + destructors: vec![Destructor { + access: Access::Public, + signature: String::new(), + }], + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_short_name_strips_class_prefix() { + let m = IRMethod::test_new( + "vtk_sphere_source_set_radius", + "SetRadius", + IRType::Unit, + vec![], + ); + assert_eq!(m.short_name("vtkSphereSource"), "set_radius"); + } + + #[test] + fn test_short_name_multi_word_class() { + let m = IRMethod::test_new( + "vtk_object_base_get_class_name", + "GetClassName", + IRType::Unit, + vec![], + ); + assert_eq!(m.short_name("vtkObjectBase"), "get_class_name"); + } + + #[test] + fn test_short_name_no_matching_prefix_returns_full() { + let m = IRMethod::test_new("vtk_foo_bar", "FooBar", IRType::Unit, vec![]); + assert_eq!(m.short_name("vtkOther"), "vtk_foo_bar"); + } + + #[test] + fn test_is_constructable_happy_path() { + let s = IRStruct::test_new( + "vtkFoo", + vec!["vtkObjectBase"], + vec![IRMethod::test_new("vtk_foo_update", "Update", IRType::Unit, vec![])], + ); + assert!(s.is_constructable()); + } + + #[test] + fn test_is_constructable_requires_objectbase_ancestor() { + let s = IRStruct::test_new( + "vtkFoo", + vec!["vtkOther"], + vec![IRMethod::test_new("vtk_foo_update", "Update", IRType::Unit, vec![])], + ); + assert!(!s.is_constructable()); + } + + #[test] + fn test_is_constructable_requires_methods() { + let s = IRStruct::test_new("vtkFoo", vec!["vtkObjectBase"], vec![]); + assert!(!s.is_constructable()); + } +} From d79542179c661508b78ea4491a3b30b39a38fe70 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 15:55:32 +0200 Subject: [PATCH 10/30] prepare a CHANGELOG.md --- CHANGELOG.md | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 CHANGELOG.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..a22f95d --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,9 @@ +## [0.3.0] - 2026-05-29 + +## [0.2.0] - 2025-06-03 + +## [0.1.3] - 2025-05-25 + +## [0.1.2] - 2025-05-24 + +## [0.1.1] - 2025-04-01 \ No newline at end of file From 6d426b03af554ab0aa22c3e70608fe6c814b8865 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 15:58:48 +0200 Subject: [PATCH 11/30] add tests to inheritance_hierarchy --- vtk-gen/src/inheritance_hierarchy.rs | 137 +++++++++++++++++++++++++++ 1 file changed, 137 insertions(+) diff --git a/vtk-gen/src/inheritance_hierarchy.rs b/vtk-gen/src/inheritance_hierarchy.rs index 199bb87..8b72b72 100644 --- a/vtk-gen/src/inheritance_hierarchy.rs +++ b/vtk-gen/src/inheritance_hierarchy.rs @@ -136,3 +136,140 @@ impl ClassHierarchy { Ok(unique_methods) } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::parse_wrap_vtk_xml::{ + Access, CContext, Class, Constructor, Destructor, File, Inheritance, Method, Methods, + Module, + }; + + fn make_method(name: &str) -> Method { + Method { + name: name.to_string(), + property: None, + access: Access::Public, + is_const: false, + is_static: false, + is_virtual: true, + signature: format!("void {}()", name), + parameters: vec![], + comment: None, + return_type: None, + } + } + + fn make_class(name: &str, parents: Vec<&str>, methods: Vec<&str>) -> Class { + Class { + name: name.to_string(), + is_abstract: false, + is_template: false, + comment: None, + base: vec![], + inheritance: if parents.is_empty() { + None + } else { + Some(Inheritance { + context: parents + .iter() + .map(|p| CContext { + name: p.to_string(), + access: Access::Public, + }) + .collect(), + }) + }, + methods: Methods { + public: methods.iter().map(|m| make_method(m)).collect(), + private: vec![], + protected: vec![], + }, + typedefs: vec![], + properties: vec![], + members: vec![], + constructors: vec![Constructor { + access: Access::Public, + signature: String::new(), + }], + destructors: vec![Destructor { + access: Access::Public, + signature: String::new(), + }], + } + } + + fn make_module(classes: Vec) -> Module { + Module { + name: "TestModule".to_string(), + path: std::path::PathBuf::new(), + files: vec![( + std::path::PathBuf::new(), + File { + name: "test.h".to_string(), + classes, + }, + )], + } + } + + #[test] + fn test_get_parent_names_direct_parent() { + let base = make_class("Base", vec![], vec!["BaseMethod"]); + let child = make_class("Child", vec!["Base"], vec!["ChildMethod"]); + let module = make_module(vec![base, child]); + let hierarchy = ClassHierarchy::new(&[module]).unwrap(); + + let parents: Vec<_> = hierarchy.get_parent_names("Child").into_iter().collect(); + assert_eq!(parents, vec!["Base"]); + } + + #[test] + fn test_get_parent_names_root_class_has_no_parents() { + let base = make_class("Base", vec![], vec!["BaseMethod"]); + let module = make_module(vec![base]); + let hierarchy = ClassHierarchy::new(&[module]).unwrap(); + + let parents: Vec<_> = hierarchy.get_parent_names("Base").into_iter().collect(); + assert!(parents.is_empty()); + } + + #[test] + fn test_get_exposable_methods_unique_to_child() { + let base = make_class("Base", vec![], vec!["SharedMethod"]); + let child = make_class("Child", vec!["Base"], vec!["SharedMethod", "ChildOnly"]); + let module = make_module(vec![base, child]); + let hierarchy = ClassHierarchy::new(&[module]).unwrap(); + + let methods = hierarchy.get_exposable_methods("Child").unwrap(); + let names: Vec<_> = methods.iter().map(|m| m.name.as_str()).collect(); + assert_eq!(names, vec!["ChildOnly"]); + } + + #[test] + fn test_get_exposable_methods_all_when_no_parent() { + let base = make_class("Base", vec![], vec!["Method1", "Method2"]); + let module = make_module(vec![base]); + let hierarchy = ClassHierarchy::new(&[module]).unwrap(); + + let methods = hierarchy.get_exposable_methods("Base").unwrap(); + assert_eq!(methods.len(), 2); + } + + #[test] + fn test_get_exposable_methods_filters_template_signatures() { + let mut class = make_class("Foo", vec![], vec![]); + class.methods.public.push(Method { + name: "TplMethod".to_string(), + signature: "template void TplMethod()".to_string(), + ..make_method("TplMethod") + }); + class.methods.public.push(make_method("NormalMethod")); + let module = make_module(vec![class]); + let hierarchy = ClassHierarchy::new(&[module]).unwrap(); + + let methods = hierarchy.get_exposable_methods("Foo").unwrap(); + let names: Vec<_> = methods.iter().map(|m| m.name.as_str()).collect(); + assert_eq!(names, vec!["NormalMethod"]); + } +} From 464ed7786d59cd0fc1386834f14ce6c4172f8b23 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 16:30:00 +0200 Subject: [PATCH 12/30] initial draft, that resolves all the errors especially for types and passes prewritten tests --- vtk-gen/src/code_gen_cpp.rs | 240 +++++++++++--- vtk-gen/src/code_gen_rust.rs | 470 ++++++++++++++++++++++++++- vtk-gen/src/inheritance_hierarchy.rs | 2 +- 3 files changed, 658 insertions(+), 54 deletions(-) diff --git a/vtk-gen/src/code_gen_cpp.rs b/vtk-gen/src/code_gen_cpp.rs index 3c2b906..725ba87 100644 --- a/vtk-gen/src/code_gen_cpp.rs +++ b/vtk-gen/src/code_gen_cpp.rs @@ -88,6 +88,35 @@ impl FormatCppStr for IRType { } } +fn ir_type_to_cpp_string(irtype: &IRType) -> Result { + use IRType::*; + match irtype { + Unit => Ok("void".to_string()), + c_uchar => Ok("unsigned char".to_string()), + c_ushort => Ok("unsigned short".to_string()), + c_uint => Ok("unsigned int".to_string()), + c_ulong => Ok("unsigned long".to_string()), + c_ulonglong => Ok("unsigned long long".to_string()), + c_char => Ok("char".to_string()), + c_short => Ok("short".to_string()), + c_int => Ok("int".to_string()), + c_long => Ok("long".to_string()), + c_longlong => Ok("long long".to_string()), + bool => Ok("bool".to_string()), + float => Ok("float".to_string()), + double => Ok("double".to_string()), + usize => Ok("size_t".to_string()), + String => Ok("const char*".to_string()), + Const(inner) => match inner.as_ref() { + String => Ok("const char*".to_string()), + other => Ok(format!("const {}", ir_type_to_cpp_string(other)?)), + }, + Pointer(inner) => Ok(format!("{}*", ir_type_to_cpp_string(inner)?)), + Ref(inner) => Ok(format!("{}&", ir_type_to_cpp_string(inner)?)), + _ => anyhow::bail!("C++ type not supported: skipping method"), + } +} + impl IRModule { fn write_includes(&self, writer: &mut impl std::io::Write) -> Result<()> { writeln!(writer, "// Default include in all modules")?; @@ -110,20 +139,18 @@ impl IRModule { writeln!(writer)?; writeln!(writer, "// Implement declared functions")?; - // Include vtk libraries required - for (_, ir_struct) in self.classes.iter() { - if ir_struct.is_constructable() { - ir_struct.build_constructor(writer)?; - } - /* for method in ir_struct.exposable_methods.iter() { - match ir_struct.method_to_cpp(method, writer) { - Ok(_) => (), - Err(e) => log::warn!( + for (_, irstruct) in self.classes.iter() { + if irstruct.is_constructable() { + irstruct.build_constructor(writer)?; + for method in irstruct.exposable_methods.iter() { + if let Err(e) = irstruct.method_to_cpp(method, writer) { + log::warn!( "[Cpp] skipping method \"{}\" due to error: \"{e}\"", method.name - ), + ); + } } - }*/ + } } Ok(()) } @@ -133,9 +160,17 @@ impl IRModule { writeln!(writer)?; writeln!(writer, "// Declare exported functions")?; - for (_, ir_struct) in self.classes.iter() { - if ir_struct.is_constructable() { - ir_struct.build_constructor_headers(writer)?; + for (_, irstruct) in self.classes.iter() { + if irstruct.is_constructable() { + irstruct.build_constructor_headers(writer)?; + for method in irstruct.exposable_methods.iter() { + if let Err(e) = irstruct.method_to_cpp_header(method, writer) { + log::warn!( + "[Cpp] skipping method header \"{}\" due to: \"{e}\"", + method.name + ); + } + } } } Ok(()) @@ -155,31 +190,48 @@ impl IRModule { impl IRStruct { fn method_to_cpp(&self, method: &IRMethod, writer: &mut impl std::io::Write) -> Result<()> { - let mut params = String::new(); - for (n, (ident, ty)) in method.args.iter().enumerate() { - params.push_str(ty.to_cpp_str()?.as_ref()); - params.push(' '); - params.push_str(&ident.0); - if n + 1 < method.args.len() { - params.push_str(", "); - } + let ret_str = ir_type_to_cpp_string(&method.return_type)?; + let is_void = matches!(method.return_type, IRType::Unit); + + let mut param_strs: Vec = vec![format!("vtkNew<{}> sself", self.name)]; + let mut call_args: Vec = vec![]; + for (ident, irtype) in &method.args { + param_strs.push(format!("{} {}", ir_type_to_cpp_string(irtype)?, ident.0)); + call_args.push(ident.0.clone()); } - let ty = &self.name; - let spointer = if params.is_empty() { - cpp!(vtkNew<#ty> self)? + let params = param_strs.join(", "); + let args = call_args.join(", "); + let body = if is_void { + format!("sself->{}({});", method.vtk_name, args) } else { - cpp!(vtkNew<#ty> self)? + format!("return sself->{}({});", method.vtk_name, args) }; - let ret = &method.return_type; - let vtk_name = &method.name; - let binding = format!("{}_{}", self.name, method.name); - let method = cpp!(#ret #binding (#spointer, #(#params),*) { - return self->#vtk_name(#(params),*); - })?; - writeln!(writer, "{}", method)?; + writeln!( + writer, + "extern \"C\" {} {}({}) {{ {} }}", + ret_str, method.name, params, body + )?; + Ok(()) + } + fn method_to_cpp_header( + &self, + method: &IRMethod, + writer: &mut impl std::io::Write, + ) -> Result<()> { + let ret_str = ir_type_to_cpp_string(&method.return_type)?; + let mut param_strs: Vec = vec![format!("vtkNew<{}> sself", self.name)]; + for (ident, irtype) in &method.args { + param_strs.push(format!("{} {}", ir_type_to_cpp_string(irtype)?, ident.0)); + } + let params = param_strs.join(", "); + writeln!( + writer, + "extern \"C\" {} {}({});", + ret_str, method.name, params + )?; Ok(()) } @@ -223,22 +275,6 @@ impl IRStruct { } } -#[test] -fn test_cpp_macro() { - let out = cpp!(extern "C" void use_this(void* ptr) {return;}).unwrap(); - assert_eq!(out, "extern \"C\" void use_this (void * ptr) {return ;}"); -} - -#[test] -fn test_cpp_macro_repitition() { - let args = vec!["int indent", "char* stream", "bool flag"]; - let out = cpp!(void do_stuff(#(#args,)*) { return; }).unwrap(); - assert_eq!( - out, - "void do_stuff (int indent, char* stream, bool flag) {return ;}" - ); -} - /* impl FormatCpp for Option { fn to_cpp(&self, writer: &mut impl core::fmt::Write) -> Result<()> { match self { @@ -326,3 +362,109 @@ impl FormatCpp for IRMethod { Ok(()) } }*/ + +#[cfg(test)] +mod gen_cpp_tests { + use super::*; + use crate::intermediate_representation::{IRIdent, IRMethod, IRStruct}; + + #[test] + fn test_cpp_macro() { + let out = cpp!(extern "C" void use_this(void* ptr) {return;}).unwrap(); + assert_eq!(out, "extern \"C\" void use_this (void * ptr) {return ;}"); + } + + #[test] + fn test_cpp_macro_repetition() { + let args = vec!["int indent", "char* stream", "bool flag"]; + let out = cpp!(void do_stuff(#(#args,)*) { return; }).unwrap(); + assert_eq!( + out, + "void do_stuff (int indent, char* stream, bool flag) {return ;}" + ); + } + + #[test] + fn test_cpp_type_primitives() { + assert_eq!(ir_type_to_cpp_string(&IRType::Unit).unwrap(), "void"); + assert_eq!(ir_type_to_cpp_string(&IRType::c_int).unwrap(), "int"); + assert_eq!(ir_type_to_cpp_string(&IRType::double).unwrap(), "double"); + assert_eq!(ir_type_to_cpp_string(&IRType::bool).unwrap(), "bool"); + assert_eq!(ir_type_to_cpp_string(&IRType::float).unwrap(), "float"); + assert_eq!(ir_type_to_cpp_string(&IRType::usize).unwrap(), "size_t"); + } + + #[test] + fn test_cpp_type_string_maps_to_const_char_ptr() { + assert_eq!( + ir_type_to_cpp_string(&IRType::String).unwrap(), + "const char*" + ); + } + + #[test] + fn test_cpp_type_const_string_maps_to_const_char_ptr() { + assert_eq!( + ir_type_to_cpp_string(&IRType::Const(Box::new(IRType::String))).unwrap(), + "const char*" + ); + } + + #[test] + fn test_cpp_type_pointer_wraps_inner() { + assert_eq!( + ir_type_to_cpp_string(&IRType::Pointer(Box::new(IRType::Unit))).unwrap(), + "void*" + ); + } + + #[test] + fn test_cpp_type_unsupported_returns_error() { + assert!(ir_type_to_cpp_string(&IRType::FileMode).is_err()); + } + + fn make_struct(name: &str) -> IRStruct { + IRStruct::test_new(name, vec!["vtkObjectBase"], vec![]) + } + + #[test] + fn test_method_to_cpp_void_no_args() { + let s = make_struct("vtkFoo"); + let m = IRMethod::test_new("vtk_foo_update", "Update", IRType::Unit, vec![]); + let mut out = Vec::new(); + s.method_to_cpp(&m, &mut out).unwrap(); + let src = String::from_utf8(out).unwrap(); + assert!(src.contains("extern \"C\" void vtk_foo_update")); + assert!(src.contains("vtkNew sself")); + assert!(src.contains("sself->Update()")); + } + + #[test] + fn test_method_to_cpp_with_args_and_return() { + let s = make_struct("vtkFoo"); + let m = IRMethod::test_new( + "vtk_foo_set_radius", + "SetRadius", + IRType::double, + vec![(IRIdent("r".to_string()), IRType::double)], + ); + let mut out = Vec::new(); + s.method_to_cpp(&m, &mut out).unwrap(); + let src = String::from_utf8(out).unwrap(); + assert!(src.contains("extern \"C\" double vtk_foo_set_radius")); + assert!(src.contains("double r")); + assert!(src.contains("return sself->SetRadius(r)")); + } + + #[test] + fn test_method_to_cpp_header_declaration() { + let s = make_struct("vtkFoo"); + let m = IRMethod::test_new("vtk_foo_update", "Update", IRType::Unit, vec![]); + let mut out = Vec::new(); + s.method_to_cpp_header(&m, &mut out).unwrap(); + let src = String::from_utf8(out).unwrap(); + assert!(src.contains("extern \"C\" void vtk_foo_update")); + assert!(src.ends_with(";\n")); + assert!(!src.contains("sself->"), "header must not contain body"); + } +} \ No newline at end of file diff --git a/vtk-gen/src/code_gen_rust.rs b/vtk-gen/src/code_gen_rust.rs index a47ae52..55e4174 100644 --- a/vtk-gen/src/code_gen_rust.rs +++ b/vtk-gen/src/code_gen_rust.rs @@ -3,7 +3,202 @@ use quote::ToTokens; use crate::intermediate_representation::IRIdent; -// use crate::parse_cpp::StdFunction; + +fn is_rust_keyword(s: &str) -> bool { + matches!( + s, + "as" + | "async" + | "await" + | "become" + | "box" + | "break" + | "const" + | "continue" + | "crate" + | "do" + | "dyn" + | "else" + | "enum" + | "extern" + | "false" + | "final" + | "fn" + | "for" + | "if" + | "impl" + | "in" + | "let" + | "loop" + | "macro" + | "match" + | "mod" + | "move" + | "mut" + | "override" + | "priv" + | "pub" + | "ref" + | "return" + | "self" + | "Self" + | "static" + | "struct" + | "super" + | "trait" + | "true" + | "try" + | "type" + | "typeof" + | "unsafe" + | "unsized" + | "use" + | "virtual" + | "where" + | "while" + | "yield" + ) +} + +/// Returns false for IRType variants that have no Rust representation yet. +/// Methods containing unsupported types are skipped before code gen. +fn ir_type_is_supported(irtype: &crate::IRType) -> bool { + use crate::IRType::*; + match irtype { + FileMode | File => false, + Ref(inner) | Pointer(inner) | Const(inner) | Vec(inner) | LinkedList(inner) => { + ir_type_is_supported(inner) + } + Array(inner, _) => ir_type_is_supported(inner), + Map(k, v) => ir_type_is_supported(k) && ir_type_is_supported(v), + _ => true, + } +} + +fn method_is_supported(method: &crate::IRMethod) -> bool { + ir_type_is_supported(&method.return_type) + && method.args.iter().all(|(_, irtype)| ir_type_is_supported(irtype)) +} + +/// Returns a safe Rust identifier by appending an underscore if the given string is a Rust keyword. +fn safe_ident(s: &str) -> String { + if is_rust_keyword(s) { + format!("{}_", s) + } else { + s.to_string() + } +} + +fn capitalize_first(s: &str) -> String { + let mut chars = s.chars(); + match chars.next() { + None => String::new(), + Some(c) => c.to_uppercase().collect::() + chars.as_str(), + } +} + +fn is_string_type(irtype: &crate::IRType) -> bool { + use crate::IRType::*; + match irtype { + String => true, + Const(inner) | Ref(inner) | Pointer(inner) => is_string_type(inner), + _ => false, + } +} + +/// Rust type used in the trait method signature (user-facing). +fn ir_type_as_param_sig(irtype: &crate::IRType) -> TokenStream { + if is_string_type(irtype) { + quote::quote!(&str) + } else { + quote::quote!(#irtype) + } +} + +/// Rust type used in the extern "C" declaration inside an impl body. +fn ir_type_as_c_extern(irtype: &crate::IRType) -> TokenStream { + match irtype { + crate::IRType::String => quote::quote!(*const core::ffi::c_char), + crate::IRType::Const(inner) if matches!(inner.as_ref(), crate::IRType::String) => { + quote::quote!(*const core::ffi::c_char) + } + crate::IRType::Path(_) => quote::quote!(*mut core::ffi::c_void), + crate::IRType::Pointer(inner) if matches!(inner.as_ref(), crate::IRType::Path(_)) => { + quote::quote!(*mut core::ffi::c_void) + } + other => quote::quote!(#other), + } +} + +fn build_method_impl(class_name: &str, method: &crate::IRMethod) -> TokenStream { + use quote::quote; + + let short = safe_ident(&method.short_name(class_name)); + let method_ident = quote::format_ident!("{}", short); + let full_name_ident = quote::format_ident!("{}", &method.name); + + let ret_sig = ir_type_as_param_sig(&method.return_type); + let ret_c = ir_type_as_c_extern(&method.return_type); + let is_string_ret = is_string_type(&method.return_type); + let is_void_ret = matches!(&method.return_type, crate::IRType::Unit); + + let mut pre_call: Vec = vec![]; + let mut extern_args: Vec = vec![quote!(sself: *mut core::ffi::c_void)]; + let mut trait_params: Vec = vec![]; + let mut call_args: Vec = vec![quote!(self.0)]; + + for (name, irtype) in &method.args { + let param_ty = ir_type_as_param_sig(irtype); + trait_params.push(quote!(#name: #param_ty)); + + if is_string_type(irtype) { + let c_name = quote::format_ident!("c_{}", name.0); + pre_call.push(quote!( + let #c_name = std::ffi::CString::new(#name).expect("CString::new failed"); + )); + extern_args.push(quote!(#name: *const core::ffi::c_char)); + call_args.push(quote!(#c_name.as_ptr())); + } else { + let c_type = ir_type_as_c_extern(irtype); + extern_args.push(quote!(#name: #c_type)); + call_args.push(quote!(#name)); + } + } + + let body = if is_string_ret { + quote!( + #(#pre_call)* + unsafe extern "C" { + fn #full_name_ident(#(#extern_args),*) -> *const core::ffi::c_char; + } + let ptr = unsafe { #full_name_ident(#(#call_args),*) }; + if ptr.is_null() { return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + ) + } else if is_void_ret { + quote!( + #(#pre_call)* + unsafe extern "C" { + fn #full_name_ident(#(#extern_args),*); + } + unsafe { #full_name_ident(#(#call_args),*) } + ) + } else { + quote!( + #(#pre_call)* + unsafe extern "C" { + fn #full_name_ident(#(#extern_args),*) -> #ret_c; + } + unsafe { #full_name_ident(#(#call_args),*) } + ) + }; + + quote!( + fn #method_ident(&mut self, #(#trait_params),*) -> #ret_sig { + #body + } + ) +} impl ToTokens for crate::IRType { fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { @@ -66,7 +261,12 @@ impl ToTokens for crate::IRType { impl ToTokens for IRIdent { fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { - let id = quote::format_ident!("{}", self.0); + let name = if is_rust_keyword(&self.0) { + format!("{}_", self.0) + } else { + self.0.clone() + }; + let id = quote::format_ident!("{}", name); tokens.extend(quote::quote!(#id)) } } @@ -90,11 +290,90 @@ impl ToTokens for crate::IRMethod { impl crate::IRModule { fn identify_traits(&self) -> TokenStream { - TokenStream::new() + let mut output = TokenStream::new(); + for (class_name, ir_struct) in &self.classes { + if ir_struct.exposable_methods.is_empty() { + continue; + } + let trait_ident = quote::format_ident!("{}", capitalize_first(class_name)); + + // Supertrait bounds: parents in this same module that also have traits + let parent_bounds: Vec = ir_struct + .parents + .iter() + .filter(|p| { + self.classes + .get(*p) + .map_or(false, |c| !c.exposable_methods.is_empty()) + }) + .map(|p| { + let pident = quote::format_ident!("{}", capitalize_first(p)); + quote::quote!(#pident) + }) + .collect(); + + let method_sigs: Vec = ir_struct + .exposable_methods + .iter() + .filter(|m| method_is_supported(m)) + .map(|method| { + let short = safe_ident(&method.short_name(class_name)); + let method_ident = quote::format_ident!("{}", short); + let args: Vec = method + .args + .iter() + .map(|(name, irtype)| { + let sig_ty = ir_type_as_param_sig(irtype); + quote::quote!(#name: #sig_ty) + }) + .collect(); + let ret = ir_type_as_param_sig(&method.return_type); + quote::quote!(fn #method_ident(&mut self, #(#args),*) -> #ret;) + }) + .collect(); + + let trait_def = if parent_bounds.is_empty() { + quote::quote!( + pub trait #trait_ident { + #(#method_sigs)* + } + ) + } else { + quote::quote!( + pub trait #trait_ident: #(#parent_bounds)+* { + #(#method_sigs)* + } + ) + }; + + output.extend(trait_def); + } + output } fn implement_own_traits(&self) -> TokenStream { - TokenStream::new() + let mut output = TokenStream::new(); + for (class_name, ir_struct) in &self.classes { + if !ir_struct.is_constructable() || ir_struct.exposable_methods.is_empty() { + continue; + } + let struct_ident = quote::format_ident!("{}", class_name); + let trait_ident = quote::format_ident!("{}", capitalize_first(class_name)); + + let methods: Vec = ir_struct + .exposable_methods + .iter() + .filter(|m| method_is_supported(m)) + .map(|method| build_method_impl(class_name, method)) + .collect(); + + output.extend(quote::quote!( + impl #trait_ident for #struct_ident { + #(#methods)* + } + )); + } + output } fn create_bindings(&self) -> TokenStream { @@ -255,3 +534,186 @@ impl quote::ToTokens for crate::parse_cpp::Path { tokens.extend(r); } } + +#[cfg(test)] +mod gen_rust_tests { + use super::*; + use crate::intermediate_representation::{IRIdent, IRMethod, IRModule, IRStruct, IRType}; + use std::collections::BTreeMap; + + fn make_module(classes: BTreeMap) -> IRModule { + IRModule { + name: "TestModule".to_string(), + classes, + } + } + + #[test] + fn test_is_rust_keyword_true_for_keywords() { + for kw in &["type", "self", "break", "fn", "impl", "trait", "use", "ref", "unsafe"] { + assert!(is_rust_keyword(kw), "{kw} should be a keyword"); + } + } + + #[test] + fn test_is_rust_keyword_false_for_non_keywords() { + for word in &["radius", "vtkFoo", "set_value", "get_output", ""] { + assert!(!is_rust_keyword(word), "{word} should not be a keyword"); + } + } + + #[test] + fn test_safe_ident_appends_underscore_for_keywords() { + assert_eq!(safe_ident("type"), "type_"); + assert_eq!(safe_ident("self"), "self_"); + assert_eq!(safe_ident("break"), "break_"); + assert_eq!(safe_ident("ref"), "ref_"); + } + + #[test] + fn test_safe_ident_unchanged_for_non_keywords() { + assert_eq!(safe_ident("radius"), "radius"); + assert_eq!(safe_ident("get_output"), "get_output"); + } + + #[test] + fn test_capitalize_first_vtk_class() { + assert_eq!(capitalize_first("vtkFoo"), "VtkFoo"); + assert_eq!(capitalize_first("vtkObjectBase"), "VtkObjectBase"); + } + + #[test] + fn test_capitalize_first_edge_cases() { + assert_eq!(capitalize_first(""), ""); + assert_eq!(capitalize_first("a"), "A"); + } + + #[test] + fn test_ir_type_is_supported_rejects_filemode() { + assert!(!ir_type_is_supported(&IRType::FileMode)); + assert!(!ir_type_is_supported(&IRType::File)); + assert!(!ir_type_is_supported(&IRType::Pointer(Box::new(IRType::FileMode)))); + } + + #[test] + fn test_ir_type_is_supported_accepts_primitives() { + assert!(ir_type_is_supported(&IRType::c_int)); + assert!(ir_type_is_supported(&IRType::double)); + assert!(ir_type_is_supported(&IRType::bool)); + assert!(ir_type_is_supported(&IRType::String)); + assert!(ir_type_is_supported(&IRType::Unit)); + } + + #[test] + fn test_ir_ident_keyword_gets_underscore_suffix() { + let id = IRIdent("type".to_string()); + assert_eq!(quote::quote!(#id).to_string(), "type_"); + } + + #[test] + fn test_ir_ident_self_gets_underscore_suffix() { + let id = IRIdent("self".to_string()); + assert_eq!(quote::quote!(#id).to_string(), "self_"); + } + + #[test] + fn test_ir_ident_normal_name_unchanged() { + let id = IRIdent("radius".to_string()); + assert_eq!(quote::quote!(#id).to_string(), "radius"); + } + + #[test] + fn test_identify_traits_empty_module_produces_no_tokens() { + let module = make_module(BTreeMap::new()); + assert!(module.identify_traits().is_empty()); + } + + #[test] + fn test_identify_traits_skips_class_with_no_methods() { + let mut classes = BTreeMap::new(); + classes.insert( + "vtkFoo".to_string(), + IRStruct::test_new("vtkFoo", vec!["vtkObjectBase"], vec![]), + ); + let module = make_module(classes); + assert!(module.identify_traits().is_empty()); + } + + #[test] + fn test_identify_traits_generates_trait_for_class_with_methods() { + let mut classes = BTreeMap::new(); + classes.insert( + "vtkFoo".to_string(), + IRStruct::test_new( + "vtkFoo", + vec!["vtkObjectBase"], + vec![IRMethod::test_new("vtk_foo_update", "Update", IRType::Unit, vec![])], + ), + ); + let module = make_module(classes); + let output = module.identify_traits().to_string(); + assert!(output.contains("VtkFoo"), "trait name VtkFoo missing"); + assert!(output.contains("update"), "method name update missing"); + } + + #[test] + fn test_identify_traits_keyword_method_name_gets_suffix() { + let mut classes = BTreeMap::new(); + classes.insert( + "vtkBreakPoint".to_string(), + IRStruct::test_new( + "vtkBreakPoint", + vec!["vtkObjectBase"], + vec![IRMethod::test_new( + "vtk_break_point_break", + "Break", + IRType::Unit, + vec![], + )], + ), + ); + let module = make_module(classes); + let output = module.identify_traits().to_string(); + assert!(output.contains("break_"), "keyword method should be renamed to break_"); + assert!(!output.contains(" break ("), "bare keyword 'break' must not appear as method name"); + } + + #[test] + fn test_implement_own_traits_skips_non_constructable() { + let mut classes = BTreeMap::new(); + // no "vtkObjectBase" parent -> not constructable + classes.insert( + "vtkAbstract".to_string(), + IRStruct::test_new( + "vtkAbstract", + vec![], + vec![IRMethod::test_new("vtk_abstract_run", "Run", IRType::Unit, vec![])], + ), + ); + let module = make_module(classes); + assert!(module.implement_own_traits().is_empty()); + } + + #[test] + fn test_implement_own_traits_generates_impl_for_constructable() { + let mut classes = BTreeMap::new(); + classes.insert( + "vtkFoo".to_string(), + IRStruct::test_new( + "vtkFoo", + vec!["vtkObjectBase"], + vec![IRMethod::test_new( + "vtk_foo_set_value", + "SetValue", + IRType::Unit, + vec![(IRIdent("v".to_string()), IRType::c_int)], + )], + ), + ); + let module = make_module(classes); + let output = module.implement_own_traits().to_string(); + assert!(output.contains("impl VtkFoo for vtkFoo")); + assert!(output.contains("vtk_foo_set_value")); + assert!(output.contains("set_value")); + } +} diff --git a/vtk-gen/src/inheritance_hierarchy.rs b/vtk-gen/src/inheritance_hierarchy.rs index 8b72b72..c0534f3 100644 --- a/vtk-gen/src/inheritance_hierarchy.rs +++ b/vtk-gen/src/inheritance_hierarchy.rs @@ -138,7 +138,7 @@ impl ClassHierarchy { } #[cfg(test)] -mod tests { +mod inheritance_tests { use super::*; use crate::parse_wrap_vtk_xml::{ Access, CContext, Class, Constructor, Destructor, File, Inheritance, Method, Methods, From 949768698684048235ab252d43e917e2d108dfa9 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 16:48:04 +0200 Subject: [PATCH 13/30] fix to work with full ancestor chain --- vtk-gen/src/code_gen_rust.rs | 12 +++-- vtk-gen/src/inheritance_hierarchy.rs | 20 +++++++++ vtk-gen/src/intermediate_representation.rs | 7 ++- vtk-rs-9.1/build.rs | 52 +++------------------- 4 files changed, 40 insertions(+), 51 deletions(-) diff --git a/vtk-gen/src/code_gen_rust.rs b/vtk-gen/src/code_gen_rust.rs index 55e4174..d400a00 100644 --- a/vtk-gen/src/code_gen_rust.rs +++ b/vtk-gen/src/code_gen_rust.rs @@ -109,9 +109,15 @@ fn is_string_type(irtype: &crate::IRType) -> bool { /// Rust type used in the trait method signature (user-facing). fn ir_type_as_param_sig(irtype: &crate::IRType) -> TokenStream { if is_string_type(irtype) { - quote::quote!(&str) - } else { - quote::quote!(#irtype) + return quote::quote!(&str); + } + match irtype { + // VTK object pointers are always passed as opaque c_void pointers across the C bridge. + crate::IRType::Path(_) => quote::quote!(*mut core::ffi::c_void), + crate::IRType::Pointer(inner) if matches!(inner.as_ref(), crate::IRType::Path(_)) => { + quote::quote!(*mut core::ffi::c_void) + } + _ => quote::quote!(#irtype), } } diff --git a/vtk-gen/src/inheritance_hierarchy.rs b/vtk-gen/src/inheritance_hierarchy.rs index c0534f3..5e157a9 100644 --- a/vtk-gen/src/inheritance_hierarchy.rs +++ b/vtk-gen/src/inheritance_hierarchy.rs @@ -88,6 +88,26 @@ impl ClassHierarchy { .filter_map(|name| self.classes.get(name)) } + /// Returns true if `target` appears anywhere in the full ancestor chain of `class_name`. + pub fn has_ancestor(&self, class_name: &str, target: &str) -> bool { + let mut stack = vec![class_name.to_string()]; + let mut visited = std::collections::HashSet::new(); + while let Some(current) = stack.pop() { + if !visited.insert(current.clone()) { + continue; + } + if let Some((_, parents)) = self.tree.get(¤t) { + for parent in parents { + if parent == target { + return true; + } + stack.push(parent.clone()); + } + } + } + false + } + pub fn has_dependant(&self, class: &Class) -> bool { self.dependents .get(&class.name.clone()) diff --git a/vtk-gen/src/intermediate_representation.rs b/vtk-gen/src/intermediate_representation.rs index eb84a11..fb88140 100644 --- a/vtk-gen/src/intermediate_representation.rs +++ b/vtk-gen/src/intermediate_representation.rs @@ -169,6 +169,8 @@ pub struct IRStruct { pub is_abstract: bool, pub is_template: bool, pub filename: String, + /// True when vtkObjectBase appears anywhere in the full ancestor chain (not just direct parents). + pub has_vtk_object_base_ancestor: bool, constructors: Vec, destructors: Vec, } @@ -196,7 +198,7 @@ impl IRStruct { && !self.exposable_methods.is_empty() // This could be lifted in the future when considering objects which can be constructed // not via vtkNew<..>() - && self.parents.iter().any(|c| c == "vtkObjectBase") + && self.has_vtk_object_base_ancestor } } @@ -256,6 +258,8 @@ impl IRModule { is_abstract: class.is_abstract, is_template: class.is_template, filename: filename.clone(), + has_vtk_object_base_ancestor: class_hierarchy + .has_ancestor(&class.name, "vtkObjectBase"), constructors: class.constructors, destructors: class.destructors, }, @@ -300,6 +304,7 @@ impl IRStruct { is_abstract: false, is_template: false, filename: format!("{}.h", name), + has_vtk_object_base_ancestor: parents.contains(&"vtkObjectBase"), constructors: vec![Constructor { access: Access::Public, signature: String::new(), diff --git a/vtk-rs-9.1/build.rs b/vtk-rs-9.1/build.rs index 83f4188..187c983 100644 --- a/vtk-rs-9.1/build.rs +++ b/vtk-rs-9.1/build.rs @@ -1,24 +1,12 @@ use cmake::Config; -use vtk_rs_link::{Result, WARN, log, find_vtk_info}; - +use vtk_rs_link::{log, Result, WARN}; fn build_cmake() { println!("cargo:rerun-if-changed=libvtkrs"); - println!("cargo:rerun-if-env-changed=VTK_DIR"); - println!("cargo:rerun-if-env-changed=VTK_VERSION"); let mut config = Config::new("libvtkrs"); - - if let Ok(vtk_dir) = std::env::var("VTK_DIR") { - config.define("VTK_DIR", &vtk_dir); - // Also add the lib subdirectory to the linker search path so that - // source-built VTK libraries (e.g. ~/VTK/build/lib) are found. - println!("cargo:rustc-link-search=native={}/lib", vtk_dir); - } - let dst = config.build(); println!("cargo:rustc-link-search=native={}", dst.display()); println!("cargo:rustc-link-lib=static=vtkrs"); } - fn main() -> Result<()> { if std::env::var("DOCS_RS").is_ok() { return Ok(()); @@ -30,14 +18,9 @@ fn main() -> Result<()> { } } build_cmake(); - - let info = find_vtk_info()?; - let v = &info.version_suffix; - - // VTK modules - let modules = [ - // "vtktoken", - "vtkCommonArchive", + let modules = vec![ + "vtksys", + "vtktoken", "vtkCommonColor", "vtkCommonComputationalGeometry", "vtkCommonCore", @@ -45,34 +28,9 @@ fn main() -> Result<()> { "vtkCommonExecutionModel", "vtkCommonMath", "vtkCommonMisc", - "vtkCommonPython", "vtkCommonSystem", "vtkCommonTransforms", ]; - - // Bundled third-party libs that VTK modules depend on - let third_party = [ - "vtkpugixml", - "vtkkissfft", - "vtkloguru", - "vtksys", - "vtkdoubleconversion", - ]; - - // Build a single -Wl,--start-group,...,--end-group argument so the linker - // makes multiple passes and resolves out-of-order static dependencies. - // -lm is included inside the group so it is available when VTK libs need it. - let libs: Vec = modules - .iter() - .map(|m| format!("-l{}{}", m, v)) - .chain(third_party.iter().map(|m| format!("-l{}{}", m, v))) - .chain(["-lm".to_string(), "-lstdc++".to_string(), "-larchive".to_string(), "-lc".to_string()]) - .collect(); - - println!( - "cargo:rustc-link-arg=-Wl,--start-group,{},--end-group", - libs.join(",") - ); - + vtk_rs_link::link_cmake_project(modules)?; Ok(()) } From 27f9ee156c3e428c07a6643d6fff5b36690b8c61 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 16:48:48 +0200 Subject: [PATCH 14/30] update newly generated vtk v9.1.0 --- vtk-rs-9.1/libvtkrs/CMakeLists.txt | 6 - .../libvtkrs/include/vtk_common_color.h | 9 + .../vtk_common_computational_geometry.h | 184 + vtk-rs-9.1/libvtkrs/include/vtk_common_core.h | 1053 +- .../libvtkrs/include/vtk_common_data_model.h | 2470 +- .../include/vtk_common_execution_model.h | 210 + vtk-rs-9.1/libvtkrs/include/vtk_common_math.h | 127 + vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h | 116 + .../libvtkrs/include/vtk_common_system.h | 52 + .../libvtkrs/include/vtk_common_transforms.h | 141 + vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp | 9 + .../src/vtk_common_computational_geometry.cpp | 184 + vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp | 1053 +- .../libvtkrs/src/vtk_common_data_model.cpp | 2470 +- .../src/vtk_common_execution_model.cpp | 210 + vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp | 127 + vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp | 116 + vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp | 52 + .../libvtkrs/src/vtk_common_transforms.cpp | 141 + vtk-rs-9.1/src/lib.rs | 2 - vtk-rs-9.1/src/vtkCommonColor.rs | 704 + .../src/vtkCommonComputationalGeometry.rs | 3251 + vtk-rs-9.1/src/vtkCommonCore.rs | 24489 +++++- vtk-rs-9.1/src/vtkCommonDataModel.rs | 71193 +++++++++++++++- vtk-rs-9.1/src/vtkCommonExecutionModel.rs | 8959 +- vtk-rs-9.1/src/vtkCommonMath.rs | 2972 +- vtk-rs-9.1/src/vtkCommonMisc.rs | 1857 + vtk-rs-9.1/src/vtkCommonSystem.rs | 818 + vtk-rs-9.1/src/vtkCommonTransforms.rs | 3184 + 29 files changed, 125752 insertions(+), 407 deletions(-) diff --git a/vtk-rs-9.1/libvtkrs/CMakeLists.txt b/vtk-rs-9.1/libvtkrs/CMakeLists.txt index b178a1c..6ccacbc 100644 --- a/vtk-rs-9.1/libvtkrs/CMakeLists.txt +++ b/vtk-rs-9.1/libvtkrs/CMakeLists.txt @@ -3,7 +3,6 @@ cmake_minimum_required(VERSION 3.12) project(vtkrs) find_package(VTK COMPONENTS - CommonArchive CommonColor CommonComputationalGeometry CommonCore @@ -11,7 +10,6 @@ find_package(VTK COMPONENTS CommonExecutionModel CommonMath CommonMisc - CommonPython CommonSystem CommonTransforms ) @@ -24,7 +22,6 @@ endif() set(CMAKE_NINJA_FORCE_RESPONSE_FILE "ON" CACHE BOOL "Force Ninja to use response files.") add_library(vtkrs STATIC - ${PROJECT_SOURCE_DIR}/include/vtk_common_archive.h ${PROJECT_SOURCE_DIR}/include/vtk_common_color.h ${PROJECT_SOURCE_DIR}/include/vtk_common_computational_geometry.h ${PROJECT_SOURCE_DIR}/include/vtk_common_core.h @@ -32,7 +29,6 @@ add_library(vtkrs STATIC ${PROJECT_SOURCE_DIR}/include/vtk_common_execution_model.h ${PROJECT_SOURCE_DIR}/include/vtk_common_math.h ${PROJECT_SOURCE_DIR}/include/vtk_common_misc.h - ${PROJECT_SOURCE_DIR}/include/vtk_common_python.h ${PROJECT_SOURCE_DIR}/include/vtk_common_system.h ${PROJECT_SOURCE_DIR}/include/vtk_common_transforms.h ) @@ -44,7 +40,6 @@ endif() include_directories(${PROJECT_SOURCE_DIR}/include/) target_sources(vtkrs PRIVATE - ${PROJECT_SOURCE_DIR}/src/vtk_common_archive.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_color.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_computational_geometry.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_core.cpp @@ -52,7 +47,6 @@ target_sources(vtkrs ${PROJECT_SOURCE_DIR}/src/vtk_common_execution_model.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_math.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_misc.cpp - ${PROJECT_SOURCE_DIR}/src/vtk_common_python.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_system.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_transforms.cpp ) diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h index 2ad94d6..b1f0102 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h @@ -10,6 +10,15 @@ extern "C" vtkNew < vtkColorSeries > vtkColorSeries_new () ; extern "C" void vtkColorSeries_destructor (vtkNew < vtkColorSeries > sself) ; extern "C" void * vtkColorSeries_get_ptr (vtkNew < vtkColorSeries > sself) ; +extern "C" void vtk_color_series_set_color_scheme(vtkNew sself, int scheme); +extern "C" int vtk_color_series_get_number_of_color_schemes(vtkNew sself); +extern "C" int vtk_color_series_get_color_scheme(vtkNew sself); +extern "C" int vtk_color_series_get_number_of_colors(vtkNew sself); +extern "C" void vtk_color_series_set_number_of_colors(vtkNew sself, int numColors); +extern "C" void vtk_color_series_remove_color(vtkNew sself, int index); +extern "C" void vtk_color_series_clear_colors(vtkNew sself); extern "C" vtkNew < vtkNamedColors > vtkNamedColors_new () ; extern "C" void vtkNamedColors_destructor (vtkNew < vtkNamedColors > sself) ; extern "C" void * vtkNamedColors_get_ptr (vtkNew < vtkNamedColors > sself) ; +extern "C" int vtk_named_colors_get_number_of_colors(vtkNew sself); +extern "C" void vtk_named_colors_reset_colors(vtkNew sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h index c7d8ace..813395c 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h @@ -34,72 +34,256 @@ extern "C" vtkNew < vtkCardinalSpline > vtkCardinalSpline_new () ; extern "C" void vtkCardinalSpline_destructor (vtkNew < vtkCardinalSpline > sself) ; extern "C" void * vtkCardinalSpline_get_ptr (vtkNew < vtkCardinalSpline > sself) ; +extern "C" void vtk_cardinal_spline_compute(vtkNew sself); +extern "C" double vtk_cardinal_spline_evaluate(vtkNew sself, double t); extern "C" vtkNew < vtkKochanekSpline > vtkKochanekSpline_new () ; extern "C" void vtkKochanekSpline_destructor (vtkNew < vtkKochanekSpline > sself) ; extern "C" void * vtkKochanekSpline_get_ptr (vtkNew < vtkKochanekSpline > sself) ; +extern "C" void vtk_kochanek_spline_compute(vtkNew sself); +extern "C" double vtk_kochanek_spline_evaluate(vtkNew sself, double t); +extern "C" void vtk_kochanek_spline_set_default_bias(vtkNew sself, double _arg); +extern "C" double vtk_kochanek_spline_get_default_bias(vtkNew sself); +extern "C" void vtk_kochanek_spline_set_default_tension(vtkNew sself, double _arg); +extern "C" double vtk_kochanek_spline_get_default_tension(vtkNew sself); +extern "C" void vtk_kochanek_spline_set_default_continuity(vtkNew sself, double _arg); +extern "C" double vtk_kochanek_spline_get_default_continuity(vtkNew sself); extern "C" vtkNew < vtkParametricBohemianDome > vtkParametricBohemianDome_new () ; extern "C" void vtkParametricBohemianDome_destructor (vtkNew < vtkParametricBohemianDome > sself) ; extern "C" void * vtkParametricBohemianDome_get_ptr (vtkNew < vtkParametricBohemianDome > sself) ; +extern "C" double vtk_parametric_bohemian_dome_get_a(vtkNew sself); +extern "C" void vtk_parametric_bohemian_dome_set_a(vtkNew sself, double _arg); +extern "C" double vtk_parametric_bohemian_dome_get_b(vtkNew sself); +extern "C" void vtk_parametric_bohemian_dome_set_b(vtkNew sself, double _arg); +extern "C" double vtk_parametric_bohemian_dome_get_c(vtkNew sself); +extern "C" void vtk_parametric_bohemian_dome_set_c(vtkNew sself, double _arg); +extern "C" int vtk_parametric_bohemian_dome_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_bohemian_dome_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_bohemian_dome_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricBour > vtkParametricBour_new () ; extern "C" void vtkParametricBour_destructor (vtkNew < vtkParametricBour > sself) ; extern "C" void * vtkParametricBour_get_ptr (vtkNew < vtkParametricBour > sself) ; +extern "C" int vtk_parametric_bour_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_bour_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_bour_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricBoy > vtkParametricBoy_new () ; extern "C" void vtkParametricBoy_destructor (vtkNew < vtkParametricBoy > sself) ; extern "C" void * vtkParametricBoy_get_ptr (vtkNew < vtkParametricBoy > sself) ; +extern "C" int vtk_parametric_boy_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_boy_set_z_scale(vtkNew sself, double _arg); +extern "C" double vtk_parametric_boy_get_z_scale(vtkNew sself); +extern "C" void vtk_parametric_boy_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_boy_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricCatalanMinimal > vtkParametricCatalanMinimal_new () ; extern "C" void vtkParametricCatalanMinimal_destructor (vtkNew < vtkParametricCatalanMinimal > sself) ; extern "C" void * vtkParametricCatalanMinimal_get_ptr (vtkNew < vtkParametricCatalanMinimal > sself) ; +extern "C" int vtk_parametric_catalan_minimal_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_catalan_minimal_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_catalan_minimal_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricConicSpiral > vtkParametricConicSpiral_new () ; extern "C" void vtkParametricConicSpiral_destructor (vtkNew < vtkParametricConicSpiral > sself) ; extern "C" void * vtkParametricConicSpiral_get_ptr (vtkNew < vtkParametricConicSpiral > sself) ; +extern "C" int vtk_parametric_conic_spiral_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_conic_spiral_set_a(vtkNew sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_a(vtkNew sself); +extern "C" void vtk_parametric_conic_spiral_set_b(vtkNew sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_b(vtkNew sself); +extern "C" void vtk_parametric_conic_spiral_set_c(vtkNew sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_c(vtkNew sself); +extern "C" void vtk_parametric_conic_spiral_set_n(vtkNew sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_n(vtkNew sself); +extern "C" void vtk_parametric_conic_spiral_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_conic_spiral_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricCrossCap > vtkParametricCrossCap_new () ; extern "C" void vtkParametricCrossCap_destructor (vtkNew < vtkParametricCrossCap > sself) ; extern "C" void * vtkParametricCrossCap_get_ptr (vtkNew < vtkParametricCrossCap > sself) ; +extern "C" int vtk_parametric_cross_cap_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_cross_cap_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_cross_cap_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricDini > vtkParametricDini_new () ; extern "C" void vtkParametricDini_destructor (vtkNew < vtkParametricDini > sself) ; extern "C" void * vtkParametricDini_get_ptr (vtkNew < vtkParametricDini > sself) ; +extern "C" int vtk_parametric_dini_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_dini_set_a(vtkNew sself, double _arg); +extern "C" double vtk_parametric_dini_get_a(vtkNew sself); +extern "C" void vtk_parametric_dini_set_b(vtkNew sself, double _arg); +extern "C" double vtk_parametric_dini_get_b(vtkNew sself); +extern "C" void vtk_parametric_dini_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_dini_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricEllipsoid > vtkParametricEllipsoid_new () ; extern "C" void vtkParametricEllipsoid_destructor (vtkNew < vtkParametricEllipsoid > sself) ; extern "C" void * vtkParametricEllipsoid_get_ptr (vtkNew < vtkParametricEllipsoid > sself) ; +extern "C" int vtk_parametric_ellipsoid_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_ellipsoid_set_x_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_ellipsoid_get_x_radius(vtkNew sself); +extern "C" void vtk_parametric_ellipsoid_set_y_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_ellipsoid_get_y_radius(vtkNew sself); +extern "C" void vtk_parametric_ellipsoid_set_z_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_ellipsoid_get_z_radius(vtkNew sself); +extern "C" void vtk_parametric_ellipsoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_ellipsoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricEnneper > vtkParametricEnneper_new () ; extern "C" void vtkParametricEnneper_destructor (vtkNew < vtkParametricEnneper > sself) ; extern "C" void * vtkParametricEnneper_get_ptr (vtkNew < vtkParametricEnneper > sself) ; +extern "C" int vtk_parametric_enneper_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_enneper_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_enneper_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricFigure8Klein > vtkParametricFigure8Klein_new () ; extern "C" void vtkParametricFigure8Klein_destructor (vtkNew < vtkParametricFigure8Klein > sself) ; extern "C" void * vtkParametricFigure8Klein_get_ptr (vtkNew < vtkParametricFigure8Klein > sself) ; +extern "C" void vtk_parametric_figure_8_klein_set_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_figure_8_klein_get_radius(vtkNew sself); +extern "C" int vtk_parametric_figure_8_klein_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_figure_8_klein_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_figure_8_klein_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricHenneberg > vtkParametricHenneberg_new () ; extern "C" void vtkParametricHenneberg_destructor (vtkNew < vtkParametricHenneberg > sself) ; extern "C" void * vtkParametricHenneberg_get_ptr (vtkNew < vtkParametricHenneberg > sself) ; +extern "C" int vtk_parametric_henneberg_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_henneberg_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_henneberg_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricKlein > vtkParametricKlein_new () ; extern "C" void vtkParametricKlein_destructor (vtkNew < vtkParametricKlein > sself) ; extern "C" void * vtkParametricKlein_get_ptr (vtkNew < vtkParametricKlein > sself) ; +extern "C" int vtk_parametric_klein_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_klein_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_klein_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricKuen > vtkParametricKuen_new () ; extern "C" void vtkParametricKuen_destructor (vtkNew < vtkParametricKuen > sself) ; extern "C" void * vtkParametricKuen_get_ptr (vtkNew < vtkParametricKuen > sself) ; +extern "C" int vtk_parametric_kuen_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_kuen_set_delta_v_0(vtkNew sself, double _arg); +extern "C" double vtk_parametric_kuen_get_delta_v_0(vtkNew sself); +extern "C" void vtk_parametric_kuen_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_kuen_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricMobius > vtkParametricMobius_new () ; extern "C" void vtkParametricMobius_destructor (vtkNew < vtkParametricMobius > sself) ; extern "C" void * vtkParametricMobius_get_ptr (vtkNew < vtkParametricMobius > sself) ; +extern "C" void vtk_parametric_mobius_set_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_mobius_get_radius(vtkNew sself); +extern "C" int vtk_parametric_mobius_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_mobius_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_mobius_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricPluckerConoid > vtkParametricPluckerConoid_new () ; extern "C" void vtkParametricPluckerConoid_destructor (vtkNew < vtkParametricPluckerConoid > sself) ; extern "C" void * vtkParametricPluckerConoid_get_ptr (vtkNew < vtkParametricPluckerConoid > sself) ; +extern "C" int vtk_parametric_plucker_conoid_get_n(vtkNew sself); +extern "C" void vtk_parametric_plucker_conoid_set_n(vtkNew sself, int _arg); +extern "C" int vtk_parametric_plucker_conoid_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_plucker_conoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_plucker_conoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricPseudosphere > vtkParametricPseudosphere_new () ; extern "C" void vtkParametricPseudosphere_destructor (vtkNew < vtkParametricPseudosphere > sself) ; extern "C" void * vtkParametricPseudosphere_get_ptr (vtkNew < vtkParametricPseudosphere > sself) ; +extern "C" int vtk_parametric_pseudosphere_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_pseudosphere_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_pseudosphere_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricRandomHills > vtkParametricRandomHills_new () ; extern "C" void vtkParametricRandomHills_destructor (vtkNew < vtkParametricRandomHills > sself) ; extern "C" void * vtkParametricRandomHills_get_ptr (vtkNew < vtkParametricRandomHills > sself) ; +extern "C" int vtk_parametric_random_hills_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_random_hills_set_number_of_hills(vtkNew sself, int _arg); +extern "C" int vtk_parametric_random_hills_get_number_of_hills(vtkNew sself); +extern "C" void vtk_parametric_random_hills_set_hill_x_variance(vtkNew sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_hill_x_variance(vtkNew sself); +extern "C" void vtk_parametric_random_hills_set_hill_y_variance(vtkNew sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_hill_y_variance(vtkNew sself); +extern "C" void vtk_parametric_random_hills_set_hill_amplitude(vtkNew sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_hill_amplitude(vtkNew sself); +extern "C" void vtk_parametric_random_hills_set_random_seed(vtkNew sself, int _arg); +extern "C" int vtk_parametric_random_hills_get_random_seed(vtkNew sself); +extern "C" void vtk_parametric_random_hills_set_allow_random_generation(vtkNew sself, int _arg); +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_min_value(vtkNew sself); +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_max_value(vtkNew sself); +extern "C" int vtk_parametric_random_hills_get_allow_random_generation(vtkNew sself); +extern "C" void vtk_parametric_random_hills_allow_random_generation_on(vtkNew sself); +extern "C" void vtk_parametric_random_hills_allow_random_generation_off(vtkNew sself); +extern "C" void vtk_parametric_random_hills_set_x_variance_scale_factor(vtkNew sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_x_variance_scale_factor(vtkNew sself); +extern "C" void vtk_parametric_random_hills_set_y_variance_scale_factor(vtkNew sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_y_variance_scale_factor(vtkNew sself); +extern "C" void vtk_parametric_random_hills_set_amplitude_scale_factor(vtkNew sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_amplitude_scale_factor(vtkNew sself); +extern "C" void vtk_parametric_random_hills_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_random_hills_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricRoman > vtkParametricRoman_new () ; extern "C" void vtkParametricRoman_destructor (vtkNew < vtkParametricRoman > sself) ; extern "C" void * vtkParametricRoman_get_ptr (vtkNew < vtkParametricRoman > sself) ; +extern "C" int vtk_parametric_roman_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_roman_set_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_roman_get_radius(vtkNew sself); +extern "C" void vtk_parametric_roman_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_roman_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricSpline > vtkParametricSpline_new () ; extern "C" void vtkParametricSpline_destructor (vtkNew < vtkParametricSpline > sself) ; extern "C" void * vtkParametricSpline_get_ptr (vtkNew < vtkParametricSpline > sself) ; +extern "C" int vtk_parametric_spline_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_spline_evaluate(vtkNew sself, double u, double Pt, double Du); +extern "C" double vtk_parametric_spline_evaluate_scalar(vtkNew sself, double u, double Pt, double Du); +extern "C" void vtk_parametric_spline_set_number_of_points(vtkNew sself, long long numPts); +extern "C" void vtk_parametric_spline_set_point(vtkNew sself, long long index, double x, double y, double z); +extern "C" void vtk_parametric_spline_set_closed(vtkNew sself, int _arg); +extern "C" int vtk_parametric_spline_get_closed(vtkNew sself); +extern "C" void vtk_parametric_spline_closed_on(vtkNew sself); +extern "C" void vtk_parametric_spline_closed_off(vtkNew sself); +extern "C" void vtk_parametric_spline_set_parameterize_by_length(vtkNew sself, int _arg); +extern "C" int vtk_parametric_spline_get_parameterize_by_length(vtkNew sself); +extern "C" void vtk_parametric_spline_parameterize_by_length_on(vtkNew sself); +extern "C" void vtk_parametric_spline_parameterize_by_length_off(vtkNew sself); +extern "C" void vtk_parametric_spline_set_left_constraint(vtkNew sself, int _arg); +extern "C" int vtk_parametric_spline_get_left_constraint_min_value(vtkNew sself); +extern "C" int vtk_parametric_spline_get_left_constraint_max_value(vtkNew sself); +extern "C" int vtk_parametric_spline_get_left_constraint(vtkNew sself); +extern "C" void vtk_parametric_spline_set_right_constraint(vtkNew sself, int _arg); +extern "C" int vtk_parametric_spline_get_right_constraint_min_value(vtkNew sself); +extern "C" int vtk_parametric_spline_get_right_constraint_max_value(vtkNew sself); +extern "C" int vtk_parametric_spline_get_right_constraint(vtkNew sself); +extern "C" void vtk_parametric_spline_set_left_value(vtkNew sself, double _arg); +extern "C" double vtk_parametric_spline_get_left_value(vtkNew sself); +extern "C" void vtk_parametric_spline_set_right_value(vtkNew sself, double _arg); +extern "C" double vtk_parametric_spline_get_right_value(vtkNew sself); extern "C" vtkNew < vtkParametricSuperEllipsoid > vtkParametricSuperEllipsoid_new () ; extern "C" void vtkParametricSuperEllipsoid_destructor (vtkNew < vtkParametricSuperEllipsoid > sself) ; extern "C" void * vtkParametricSuperEllipsoid_get_ptr (vtkNew < vtkParametricSuperEllipsoid > sself) ; +extern "C" int vtk_parametric_super_ellipsoid_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_super_ellipsoid_set_x_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_x_radius(vtkNew sself); +extern "C" void vtk_parametric_super_ellipsoid_set_y_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_y_radius(vtkNew sself); +extern "C" void vtk_parametric_super_ellipsoid_set_z_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_z_radius(vtkNew sself); +extern "C" void vtk_parametric_super_ellipsoid_set_n_1(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_n_1(vtkNew sself); +extern "C" void vtk_parametric_super_ellipsoid_set_n_2(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_n_2(vtkNew sself); +extern "C" void vtk_parametric_super_ellipsoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_super_ellipsoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricSuperToroid > vtkParametricSuperToroid_new () ; extern "C" void vtkParametricSuperToroid_destructor (vtkNew < vtkParametricSuperToroid > sself) ; extern "C" void * vtkParametricSuperToroid_get_ptr (vtkNew < vtkParametricSuperToroid > sself) ; +extern "C" int vtk_parametric_super_toroid_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_super_toroid_set_ring_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_ring_radius(vtkNew sself); +extern "C" void vtk_parametric_super_toroid_set_cross_section_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_cross_section_radius(vtkNew sself); +extern "C" void vtk_parametric_super_toroid_set_x_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_x_radius(vtkNew sself); +extern "C" void vtk_parametric_super_toroid_set_y_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_y_radius(vtkNew sself); +extern "C" void vtk_parametric_super_toroid_set_z_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_z_radius(vtkNew sself); +extern "C" void vtk_parametric_super_toroid_set_n_1(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_n_1(vtkNew sself); +extern "C" void vtk_parametric_super_toroid_set_n_2(vtkNew sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_n_2(vtkNew sself); +extern "C" void vtk_parametric_super_toroid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_super_toroid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); extern "C" vtkNew < vtkParametricTorus > vtkParametricTorus_new () ; extern "C" void vtkParametricTorus_destructor (vtkNew < vtkParametricTorus > sself) ; extern "C" void * vtkParametricTorus_get_ptr (vtkNew < vtkParametricTorus > sself) ; +extern "C" void vtk_parametric_torus_set_ring_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_torus_get_ring_radius(vtkNew sself); +extern "C" void vtk_parametric_torus_set_cross_section_radius(vtkNew sself, double _arg); +extern "C" double vtk_parametric_torus_get_cross_section_radius(vtkNew sself); +extern "C" int vtk_parametric_torus_get_dimension(vtkNew sself); +extern "C" void vtk_parametric_torus_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" double vtk_parametric_torus_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h index f2811cf..eecd38c 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h @@ -16,7 +16,6 @@ #include #include #include -#include #include #include #include @@ -145,6 +144,8 @@ #include #include #include +#include +#include #include #include #include @@ -164,170 +165,1067 @@ extern "C" vtkNew < vtkAnimationCue > vtkAnimationCue_new () ; extern "C" void vtkAnimationCue_destructor (vtkNew < vtkAnimationCue > sself) ; extern "C" void * vtkAnimationCue_get_ptr (vtkNew < vtkAnimationCue > sself) ; +extern "C" void vtk_animation_cue_set_time_mode(vtkNew sself, int mode); +extern "C" int vtk_animation_cue_get_time_mode(vtkNew sself); +extern "C" void vtk_animation_cue_set_time_mode_to_relative(vtkNew sself); +extern "C" void vtk_animation_cue_set_time_mode_to_normalized(vtkNew sself); +extern "C" void vtk_animation_cue_set_start_time(vtkNew sself, double _arg); +extern "C" double vtk_animation_cue_get_start_time(vtkNew sself); +extern "C" void vtk_animation_cue_set_end_time(vtkNew sself, double _arg); +extern "C" double vtk_animation_cue_get_end_time(vtkNew sself); +extern "C" void vtk_animation_cue_tick(vtkNew sself, double currenttime, double deltatime, double clocktime); +extern "C" void vtk_animation_cue_initialize(vtkNew sself); +extern "C" void vtk_animation_cue_finalize(vtkNew sself); +extern "C" double vtk_animation_cue_get_animation_time(vtkNew sself); +extern "C" double vtk_animation_cue_get_delta_time(vtkNew sself); +extern "C" double vtk_animation_cue_get_clock_time(vtkNew sself); extern "C" vtkNew < vtkArchiver > vtkArchiver_new () ; extern "C" void vtkArchiver_destructor (vtkNew < vtkArchiver > sself) ; extern "C" void * vtkArchiver_get_ptr (vtkNew < vtkArchiver > sself) ; -extern "C" void vtkArchiver_set_archive_name (vtkNew < vtkArchiver > sself, const char * name) ; -extern "C" const char * vtkArchiver_get_archive_name (vtkNew < vtkArchiver > sself) ; +extern "C" char* vtk_archiver_get_archive_name(vtkNew sself); +extern "C" void vtk_archiver_set_archive_name(vtkNew sself, const char _arg); +extern "C" void vtk_archiver_open_archive(vtkNew sself); +extern "C" void vtk_archiver_close_archive(vtkNew sself); +extern "C" void vtk_archiver_insert_into_archive(vtkNew sself, const char* relativePath, const char data, size_t size); +extern "C" bool vtk_archiver_contains(vtkNew sself, const char* relativePath); extern "C" vtkNew < vtkBitArray > vtkBitArray_new () ; extern "C" void vtkBitArray_destructor (vtkNew < vtkBitArray > sself) ; extern "C" void * vtkBitArray_get_ptr (vtkNew < vtkBitArray > sself) ; +extern "C" int vtk_bit_array_allocate(vtkNew sself, long long sz, long long ext); +extern "C" void vtk_bit_array_initialize(vtkNew sself); +extern "C" int vtk_bit_array_get_data_type(vtkNew sself); +extern "C" int vtk_bit_array_get_data_type_size(vtkNew sself); +extern "C" void vtk_bit_array_set_number_of_tuples(vtkNew sself, long long number); +extern "C" bool vtk_bit_array_set_number_of_values(vtkNew sself, long long number); +extern "C" double* vtk_bit_array_get_tuple(vtkNew sself, long long i); +extern "C" void vtk_bit_array_get_tuple(vtkNew sself, long long i, double tuple); +extern "C" void vtk_bit_array_set_tuple(vtkNew sself, long long i, const float tuple); +extern "C" void vtk_bit_array_set_tuple(vtkNew sself, long long i, const double tuple); +extern "C" void vtk_bit_array_insert_tuple(vtkNew sself, long long i, const float tuple); +extern "C" void vtk_bit_array_insert_tuple(vtkNew sself, long long i, const double tuple); +extern "C" long long vtk_bit_array_insert_next_tuple(vtkNew sself, const float tuple); +extern "C" long long vtk_bit_array_insert_next_tuple(vtkNew sself, const double tuple); +extern "C" void vtk_bit_array_remove_tuple(vtkNew sself, long long id); +extern "C" void vtk_bit_array_set_component(vtkNew sself, long long i, int j, double c); +extern "C" void vtk_bit_array_squeeze(vtkNew sself); +extern "C" int vtk_bit_array_resize(vtkNew sself, long long numTuples); +extern "C" int vtk_bit_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_bit_array_set_value(vtkNew sself, long long id, int value); +extern "C" void vtk_bit_array_insert_value(vtkNew sself, long long id, int i); +extern "C" long long vtk_bit_array_insert_next_value(vtkNew sself, int i); +extern "C" void vtk_bit_array_insert_component(vtkNew sself, long long i, int j, double c); +extern "C" unsigned char* vtk_bit_array_get_pointer(vtkNew sself, long long id); +extern "C" unsigned char* vtk_bit_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" void* vtk_bit_array_write_void_pointer(vtkNew sself, long long id, long long number); +extern "C" void* vtk_bit_array_get_void_pointer(vtkNew sself, long long id); +extern "C" void vtk_bit_array_set_void_array(vtkNew sself, void array, long long size, int save); +extern "C" long long vtk_bit_array_lookup_value(vtkNew sself, int value); +extern "C" void vtk_bit_array_data_changed(vtkNew sself); +extern "C" void vtk_bit_array_clear_lookup(vtkNew sself); extern "C" vtkNew < vtkBitArrayIterator > vtkBitArrayIterator_new () ; extern "C" void vtkBitArrayIterator_destructor (vtkNew < vtkBitArrayIterator > sself) ; extern "C" void * vtkBitArrayIterator_get_ptr (vtkNew < vtkBitArrayIterator > sself) ; +extern "C" int* vtk_bit_array_iterator_get_tuple(vtkNew sself, long long id); +extern "C" int vtk_bit_array_iterator_get_value(vtkNew sself, long long id); +extern "C" long long vtk_bit_array_iterator_get_number_of_tuples(vtkNew sself); +extern "C" long long vtk_bit_array_iterator_get_number_of_values(vtkNew sself); +extern "C" int vtk_bit_array_iterator_get_number_of_components(vtkNew sself); +extern "C" int vtk_bit_array_iterator_get_data_type(vtkNew sself); +extern "C" int vtk_bit_array_iterator_get_data_type_size(vtkNew sself); +extern "C" void vtk_bit_array_iterator_set_value(vtkNew sself, long long id, int value); extern "C" vtkNew < vtkBoxMuellerRandomSequence > vtkBoxMuellerRandomSequence_new () ; extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkNew < vtkBoxMuellerRandomSequence > sself) ; extern "C" void * vtkBoxMuellerRandomSequence_get_ptr (vtkNew < vtkBoxMuellerRandomSequence > sself) ; +extern "C" void vtk_box_mueller_random_sequence_initialize(vtkNew sself, unsigned int seed); +extern "C" double vtk_box_mueller_random_sequence_get_value(vtkNew sself); +extern "C" void vtk_box_mueller_random_sequence_next(vtkNew sself); extern "C" vtkNew < vtkByteSwap > vtkByteSwap_new () ; extern "C" void vtkByteSwap_destructor (vtkNew < vtkByteSwap > sself) ; extern "C" void * vtkByteSwap_get_ptr (vtkNew < vtkByteSwap > sself) ; +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, float p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, float p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, float p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, float p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, double p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, double p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, double p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, double p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, char p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, char p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, char p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, char p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, short p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, short p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, short p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, short p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, int p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, int p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, int p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, int p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, long p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, long p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, long p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, long p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, long long p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, long long p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, long long p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, long long p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, char p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, char p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, char p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, char p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned char p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned char p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned char p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned char p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned short p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned short p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned short p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned short p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned int p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned int p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned int p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned int p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned long p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned long p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned long p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned long p, size_t num); +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned long long p); +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned long long p); +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned long long p, size_t num); +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned long long p, size_t num); +extern "C" void vtk_byte_swap_swap_2_le(vtkNew sself, void p); +extern "C" void vtk_byte_swap_swap_4_le(vtkNew sself, void p); +extern "C" void vtk_byte_swap_swap_8_le(vtkNew sself, void p); +extern "C" void vtk_byte_swap_swap_2_le_range(vtkNew sself, void p, size_t num); +extern "C" void vtk_byte_swap_swap_4_le_range(vtkNew sself, void p, size_t num); +extern "C" void vtk_byte_swap_swap_8_le_range(vtkNew sself, void p, size_t num); +extern "C" void vtk_byte_swap_swap_2_be(vtkNew sself, void p); +extern "C" void vtk_byte_swap_swap_4_be(vtkNew sself, void p); +extern "C" void vtk_byte_swap_swap_8_be(vtkNew sself, void p); +extern "C" void vtk_byte_swap_swap_2_be_range(vtkNew sself, void p, size_t num); +extern "C" void vtk_byte_swap_swap_4_be_range(vtkNew sself, void p, size_t num); +extern "C" void vtk_byte_swap_swap_8_be_range(vtkNew sself, void p, size_t num); +extern "C" void vtk_byte_swap_swap_void_range(vtkNew sself, void buffer, size_t numWords, size_t wordSize); extern "C" vtkNew < vtkCallbackCommand > vtkCallbackCommand_new () ; extern "C" void vtkCallbackCommand_destructor (vtkNew < vtkCallbackCommand > sself) ; extern "C" void * vtkCallbackCommand_get_ptr (vtkNew < vtkCallbackCommand > sself) ; +extern "C" void vtk_callback_command_set_client_data(vtkNew sself, void cd); +extern "C" void* vtk_callback_command_get_client_data(vtkNew sself); +extern "C" void vtk_callback_command_set_abort_flag_on_execute(vtkNew sself, int f); +extern "C" int vtk_callback_command_get_abort_flag_on_execute(vtkNew sself); +extern "C" void vtk_callback_command_abort_flag_on_execute_on(vtkNew sself); +extern "C" void vtk_callback_command_abort_flag_on_execute_off(vtkNew sself); extern "C" vtkNew < vtkCharArray > vtkCharArray_new () ; extern "C" void vtkCharArray_destructor (vtkNew < vtkCharArray > sself) ; extern "C" void * vtkCharArray_get_ptr (vtkNew < vtkCharArray > sself) ; +extern "C" int vtk_char_array_get_data_type(vtkNew sself); +extern "C" void vtk_char_array_get_typed_tuple(vtkNew sself, long long i, char tuple); +extern "C" void vtk_char_array_set_typed_tuple(vtkNew sself, long long i, const char tuple); +extern "C" void vtk_char_array_insert_typed_tuple(vtkNew sself, long long i, const char tuple); +extern "C" long long vtk_char_array_insert_next_typed_tuple(vtkNew sself, const char tuple); +extern "C" char vtk_char_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_char_array_set_value(vtkNew sself, long long id, char value); +extern "C" bool vtk_char_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_char_array_insert_value(vtkNew sself, long long id, char f); +extern "C" long long vtk_char_array_insert_next_value(vtkNew sself, char f); +extern "C" char* vtk_char_array_get_value_range(vtkNew sself, int comp); +extern "C" char* vtk_char_array_get_value_range(vtkNew sself); +extern "C" char* vtk_char_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" char* vtk_char_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_char_array_set_array(vtkNew sself, char array, long long size, int save); +extern "C" void vtk_char_array_set_array(vtkNew sself, char array, long long size, int save, int deleteMethod); +extern "C" char vtk_char_array_get_data_type_value_min(vtkNew sself); +extern "C" char vtk_char_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkCollection > vtkCollection_new () ; extern "C" void vtkCollection_destructor (vtkNew < vtkCollection > sself) ; extern "C" void * vtkCollection_get_ptr (vtkNew < vtkCollection > sself) ; +extern "C" void vtk_collection_remove_item(vtkNew sself, int i); +extern "C" void vtk_collection_remove_all_items(vtkNew sself); +extern "C" int vtk_collection_get_number_of_items(vtkNew sself); +extern "C" void vtk_collection_init_traversal(vtkNew sself); +extern "C" void vtk_collection_init_traversal(vtkNew sself, void cookie); extern "C" vtkNew < vtkCollectionIterator > vtkCollectionIterator_new () ; extern "C" void vtkCollectionIterator_destructor (vtkNew < vtkCollectionIterator > sself) ; extern "C" void * vtkCollectionIterator_get_ptr (vtkNew < vtkCollectionIterator > sself) ; +extern "C" void vtk_collection_iterator_init_traversal(vtkNew sself); +extern "C" void vtk_collection_iterator_go_to_first_item(vtkNew sself); +extern "C" void vtk_collection_iterator_go_to_next_item(vtkNew sself); +extern "C" int vtk_collection_iterator_is_done_with_traversal(vtkNew sself); extern "C" vtkNew < vtkCriticalSection > vtkCriticalSection_new () ; extern "C" void vtkCriticalSection_destructor (vtkNew < vtkCriticalSection > sself) ; extern "C" void * vtkCriticalSection_get_ptr (vtkNew < vtkCriticalSection > sself) ; +extern "C" void vtk_critical_section_lock(vtkNew sself); +extern "C" void vtk_critical_section_unlock(vtkNew sself); extern "C" vtkNew < vtkDataArrayCollection > vtkDataArrayCollection_new () ; extern "C" void vtkDataArrayCollection_destructor (vtkNew < vtkDataArrayCollection > sself) ; extern "C" void * vtkDataArrayCollection_get_ptr (vtkNew < vtkDataArrayCollection > sself) ; +extern "C" int vtk_data_array_collection_get_number_of_items(vtkNew sself); extern "C" vtkNew < vtkDataArrayCollectionIterator > vtkDataArrayCollectionIterator_new () ; extern "C" void vtkDataArrayCollectionIterator_destructor (vtkNew < vtkDataArrayCollectionIterator > sself) ; extern "C" void * vtkDataArrayCollectionIterator_get_ptr (vtkNew < vtkDataArrayCollectionIterator > sself) ; extern "C" vtkNew < vtkDataArraySelection > vtkDataArraySelection_new () ; extern "C" void vtkDataArraySelection_destructor (vtkNew < vtkDataArraySelection > sself) ; extern "C" void * vtkDataArraySelection_get_ptr (vtkNew < vtkDataArraySelection > sself) ; +extern "C" void vtk_data_array_selection_enable_array(vtkNew sself, const char name); +extern "C" void vtk_data_array_selection_disable_array(vtkNew sself, const char name); +extern "C" int vtk_data_array_selection_array_is_enabled(vtkNew sself, const char name); +extern "C" int vtk_data_array_selection_array_exists(vtkNew sself, const char name); +extern "C" void vtk_data_array_selection_enable_all_arrays(vtkNew sself); +extern "C" void vtk_data_array_selection_disable_all_arrays(vtkNew sself); +extern "C" int vtk_data_array_selection_get_number_of_arrays(vtkNew sself); +extern "C" int vtk_data_array_selection_get_number_of_arrays_enabled(vtkNew sself); +extern "C" const char* vtk_data_array_selection_get_array_name(vtkNew sself, int index); +extern "C" int vtk_data_array_selection_get_array_index(vtkNew sself, const char name); +extern "C" int vtk_data_array_selection_get_enabled_array_index(vtkNew sself, const char name); +extern "C" int vtk_data_array_selection_get_array_setting(vtkNew sself, int index); +extern "C" int vtk_data_array_selection_get_array_setting(vtkNew sself, const char name); +extern "C" void vtk_data_array_selection_set_array_setting(vtkNew sself, const char name, int setting); +extern "C" void vtk_data_array_selection_remove_all_arrays(vtkNew sself); +extern "C" int vtk_data_array_selection_add_array(vtkNew sself, const char name, bool state); +extern "C" void vtk_data_array_selection_remove_array_by_index(vtkNew sself, int index); +extern "C" void vtk_data_array_selection_remove_array_by_name(vtkNew sself, const char name); +extern "C" void vtk_data_array_selection_set_arrays(vtkNew sself, const char names, int numArrays); +extern "C" void vtk_data_array_selection_set_arrays_with_default(vtkNew sself, const char names, int numArrays, int defaultStatus); +extern "C" void vtk_data_array_selection_set_unknown_array_setting(vtkNew sself, int _arg); +extern "C" int vtk_data_array_selection_get_unknown_array_setting(vtkNew sself); extern "C" vtkNew < vtkDebugLeaks > vtkDebugLeaks_new () ; extern "C" void vtkDebugLeaks_destructor (vtkNew < vtkDebugLeaks > sself) ; extern "C" void * vtkDebugLeaks_get_ptr (vtkNew < vtkDebugLeaks > sself) ; +extern "C" void vtk_debug_leaks_construct_class(vtkNew sself, const char className); +extern "C" void vtk_debug_leaks_destruct_class(vtkNew sself, const char className); +extern "C" int vtk_debug_leaks_print_current_leaks(vtkNew sself); +extern "C" int vtk_debug_leaks_get_exit_error(vtkNew sself); +extern "C" void vtk_debug_leaks_set_exit_error(vtkNew sself, int p0); extern "C" vtkNew < vtkDoubleArray > vtkDoubleArray_new () ; extern "C" void vtkDoubleArray_destructor (vtkNew < vtkDoubleArray > sself) ; extern "C" void * vtkDoubleArray_get_ptr (vtkNew < vtkDoubleArray > sself) ; +extern "C" int vtk_double_array_get_data_type(vtkNew sself); +extern "C" void vtk_double_array_get_typed_tuple(vtkNew sself, long long i, double tuple); +extern "C" void vtk_double_array_set_typed_tuple(vtkNew sself, long long i, const double tuple); +extern "C" void vtk_double_array_insert_typed_tuple(vtkNew sself, long long i, const double tuple); +extern "C" long long vtk_double_array_insert_next_typed_tuple(vtkNew sself, const double tuple); +extern "C" double vtk_double_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_double_array_set_value(vtkNew sself, long long id, double value); +extern "C" bool vtk_double_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_double_array_insert_value(vtkNew sself, long long id, double f); +extern "C" long long vtk_double_array_insert_next_value(vtkNew sself, double f); +extern "C" double* vtk_double_array_get_value_range(vtkNew sself, int comp); +extern "C" double* vtk_double_array_get_value_range(vtkNew sself); +extern "C" double* vtk_double_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" double* vtk_double_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_double_array_set_array(vtkNew sself, double array, long long size, int save); +extern "C" void vtk_double_array_set_array(vtkNew sself, double array, long long size, int save, int deleteMethod); +extern "C" double vtk_double_array_get_data_type_value_min(vtkNew sself); +extern "C" double vtk_double_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkDynamicLoader > vtkDynamicLoader_new () ; extern "C" void vtkDynamicLoader_destructor (vtkNew < vtkDynamicLoader > sself) ; extern "C" void * vtkDynamicLoader_get_ptr (vtkNew < vtkDynamicLoader > sself) ; +extern "C" const char* vtk_dynamic_loader_lib_prefix(vtkNew sself); +extern "C" const char* vtk_dynamic_loader_lib_extension(vtkNew sself); +extern "C" const char* vtk_dynamic_loader_last_error(vtkNew sself); extern "C" vtkNew < vtkEventDataDevice3D > vtkEventDataDevice3D_new () ; extern "C" void vtkEventDataDevice3D_destructor (vtkNew < vtkEventDataDevice3D > sself) ; extern "C" void * vtkEventDataDevice3D_get_ptr (vtkNew < vtkEventDataDevice3D > sself) ; +extern "C" void vtk_event_data_device_3_d_get_world_position(vtkNew sself, double v); +extern "C" const double* vtk_event_data_device_3_d_get_world_position(vtkNew sself); +extern "C" void vtk_event_data_device_3_d_set_world_position(vtkNew sself, const double p); +extern "C" void vtk_event_data_device_3_d_get_world_direction(vtkNew sself, double v); +extern "C" const double* vtk_event_data_device_3_d_get_world_direction(vtkNew sself); +extern "C" void vtk_event_data_device_3_d_set_world_direction(vtkNew sself, const double p); +extern "C" void vtk_event_data_device_3_d_get_world_orientation(vtkNew sself, double v); +extern "C" const double* vtk_event_data_device_3_d_get_world_orientation(vtkNew sself); +extern "C" void vtk_event_data_device_3_d_set_world_orientation(vtkNew sself, const double p); +extern "C" void vtk_event_data_device_3_d_get_track_pad_position(vtkNew sself, double v); +extern "C" const double* vtk_event_data_device_3_d_get_track_pad_position(vtkNew sself); +extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkNew sself, const double p); +extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkNew sself, double x, double y); extern "C" vtkNew < vtkEventDataForDevice > vtkEventDataForDevice_new () ; extern "C" void vtkEventDataForDevice_destructor (vtkNew < vtkEventDataForDevice > sself) ; extern "C" void * vtkEventDataForDevice_get_ptr (vtkNew < vtkEventDataForDevice > sself) ; extern "C" vtkNew < vtkEventForwarderCommand > vtkEventForwarderCommand_new () ; extern "C" void vtkEventForwarderCommand_destructor (vtkNew < vtkEventForwarderCommand > sself) ; extern "C" void * vtkEventForwarderCommand_get_ptr (vtkNew < vtkEventForwarderCommand > sself) ; +extern "C" void* vtk_event_forwarder_command_get_target(vtkNew sself); extern "C" vtkNew < vtkFileOutputWindow > vtkFileOutputWindow_new () ; extern "C" void vtkFileOutputWindow_destructor (vtkNew < vtkFileOutputWindow > sself) ; extern "C" void * vtkFileOutputWindow_get_ptr (vtkNew < vtkFileOutputWindow > sself) ; +extern "C" void vtk_file_output_window_display_text(vtkNew sself, const char p0); +extern "C" void vtk_file_output_window_set_file_name(vtkNew sself, const char _arg); +extern "C" char* vtk_file_output_window_get_file_name(vtkNew sself); +extern "C" void vtk_file_output_window_set_flush(vtkNew sself, int _arg); +extern "C" int vtk_file_output_window_get_flush(vtkNew sself); +extern "C" void vtk_file_output_window_flush_on(vtkNew sself); +extern "C" void vtk_file_output_window_flush_off(vtkNew sself); +extern "C" void vtk_file_output_window_set_append(vtkNew sself, int _arg); +extern "C" int vtk_file_output_window_get_append(vtkNew sself); +extern "C" void vtk_file_output_window_append_on(vtkNew sself); +extern "C" void vtk_file_output_window_append_off(vtkNew sself); extern "C" vtkNew < vtkFloatArray > vtkFloatArray_new () ; extern "C" void vtkFloatArray_destructor (vtkNew < vtkFloatArray > sself) ; extern "C" void * vtkFloatArray_get_ptr (vtkNew < vtkFloatArray > sself) ; +extern "C" int vtk_float_array_get_data_type(vtkNew sself); +extern "C" void vtk_float_array_get_typed_tuple(vtkNew sself, long long i, float tuple); +extern "C" void vtk_float_array_set_typed_tuple(vtkNew sself, long long i, const float tuple); +extern "C" void vtk_float_array_insert_typed_tuple(vtkNew sself, long long i, const float tuple); +extern "C" long long vtk_float_array_insert_next_typed_tuple(vtkNew sself, const float tuple); +extern "C" float vtk_float_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_float_array_set_value(vtkNew sself, long long id, float value); +extern "C" bool vtk_float_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_float_array_insert_value(vtkNew sself, long long id, float f); +extern "C" long long vtk_float_array_insert_next_value(vtkNew sself, float f); +extern "C" float* vtk_float_array_get_value_range(vtkNew sself, int comp); +extern "C" float* vtk_float_array_get_value_range(vtkNew sself); +extern "C" float* vtk_float_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" float* vtk_float_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_float_array_set_array(vtkNew sself, float array, long long size, int save); +extern "C" void vtk_float_array_set_array(vtkNew sself, float array, long long size, int save, int deleteMethod); +extern "C" float vtk_float_array_get_data_type_value_min(vtkNew sself); +extern "C" float vtk_float_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkGarbageCollector > vtkGarbageCollector_new () ; extern "C" void vtkGarbageCollector_destructor (vtkNew < vtkGarbageCollector > sself) ; extern "C" void * vtkGarbageCollector_get_ptr (vtkNew < vtkGarbageCollector > sself) ; +extern "C" void vtk_garbage_collector_collect(vtkNew sself); +extern "C" void vtk_garbage_collector_deferred_collection_push(vtkNew sself); +extern "C" void vtk_garbage_collector_deferred_collection_pop(vtkNew sself); +extern "C" void vtk_garbage_collector_set_global_debug_flag(vtkNew sself, bool flag); +extern "C" bool vtk_garbage_collector_get_global_debug_flag(vtkNew sself); extern "C" vtkNew < vtkIdList > vtkIdList_new () ; extern "C" void vtkIdList_destructor (vtkNew < vtkIdList > sself) ; extern "C" void * vtkIdList_get_ptr (vtkNew < vtkIdList > sself) ; +extern "C" void vtk_id_list_initialize(vtkNew sself); +extern "C" int vtk_id_list_allocate(vtkNew sself, const long long sz, const int strategy); +extern "C" long long vtk_id_list_get_number_of_ids(vtkNew sself); +extern "C" long long vtk_id_list_get_id(vtkNew sself, const long long i); +extern "C" long long vtk_id_list_find_id_location(vtkNew sself, const long long id); +extern "C" void vtk_id_list_set_number_of_ids(vtkNew sself, const long long number); +extern "C" void vtk_id_list_set_id(vtkNew sself, const long long i, const long long vtkid); +extern "C" void vtk_id_list_insert_id(vtkNew sself, const long long i, const long long vtkid); +extern "C" long long vtk_id_list_insert_next_id(vtkNew sself, const long long vtkid); +extern "C" long long vtk_id_list_insert_unique_id(vtkNew sself, const long long vtkid); +extern "C" void vtk_id_list_sort(vtkNew sself); +extern "C" void vtk_id_list_fill(vtkNew sself, long long value); +extern "C" long long* vtk_id_list_get_pointer(vtkNew sself, const long long i); +extern "C" long long* vtk_id_list_write_pointer(vtkNew sself, const long long i, const long long number); +extern "C" void vtk_id_list_set_array(vtkNew sself, long long array, long long size); +extern "C" void vtk_id_list_reset(vtkNew sself); +extern "C" void vtk_id_list_squeeze(vtkNew sself); +extern "C" void vtk_id_list_delete_id(vtkNew sself, long long vtkid); +extern "C" long long vtk_id_list_is_id(vtkNew sself, long long vtkid); +extern "C" long long* vtk_id_list_resize(vtkNew sself, const long long sz); +extern "C" long long* vtk_id_list_begin(vtkNew sself); +extern "C" long long* vtk_id_list_end(vtkNew sself); +extern "C" const long long* vtk_id_list_begin(vtkNew sself); +extern "C" const long long* vtk_id_list_end(vtkNew sself); extern "C" vtkNew < vtkIdListCollection > vtkIdListCollection_new () ; extern "C" void vtkIdListCollection_destructor (vtkNew < vtkIdListCollection > sself) ; extern "C" void * vtkIdListCollection_get_ptr (vtkNew < vtkIdListCollection > sself) ; +extern "C" int vtk_id_list_collection_get_number_of_items(vtkNew sself); extern "C" vtkNew < vtkIdTypeArray > vtkIdTypeArray_new () ; extern "C" void vtkIdTypeArray_destructor (vtkNew < vtkIdTypeArray > sself) ; extern "C" void * vtkIdTypeArray_get_ptr (vtkNew < vtkIdTypeArray > sself) ; +extern "C" int vtk_id_type_array_get_data_type(vtkNew sself); +extern "C" void vtk_id_type_array_get_typed_tuple(vtkNew sself, long long i, long long tuple); +extern "C" void vtk_id_type_array_set_typed_tuple(vtkNew sself, long long i, const long long tuple); +extern "C" void vtk_id_type_array_insert_typed_tuple(vtkNew sself, long long i, const long long tuple); +extern "C" long long vtk_id_type_array_insert_next_typed_tuple(vtkNew sself, const long long tuple); +extern "C" long long vtk_id_type_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_id_type_array_set_value(vtkNew sself, long long id, long long value); +extern "C" bool vtk_id_type_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_id_type_array_insert_value(vtkNew sself, long long id, long long f); +extern "C" long long vtk_id_type_array_insert_next_value(vtkNew sself, long long f); +extern "C" long long* vtk_id_type_array_get_value_range(vtkNew sself, int comp); +extern "C" long long* vtk_id_type_array_get_value_range(vtkNew sself); +extern "C" long long* vtk_id_type_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" long long* vtk_id_type_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_id_type_array_set_array(vtkNew sself, long long array, long long size, int save); +extern "C" void vtk_id_type_array_set_array(vtkNew sself, long long array, long long size, int save, int deleteMethod); +extern "C" long long vtk_id_type_array_get_data_type_value_min(vtkNew sself); +extern "C" long long vtk_id_type_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkInformation > vtkInformation_new () ; extern "C" void vtkInformation_destructor (vtkNew < vtkInformation > sself) ; extern "C" void * vtkInformation_get_ptr (vtkNew < vtkInformation > sself) ; +extern "C" void vtk_information_modified(vtkNew sself); +extern "C" void vtk_information_clear(vtkNew sself); +extern "C" int vtk_information_get_number_of_keys(vtkNew sself); extern "C" vtkNew < vtkInformationIterator > vtkInformationIterator_new () ; extern "C" void vtkInformationIterator_destructor (vtkNew < vtkInformationIterator > sself) ; extern "C" void * vtkInformationIterator_get_ptr (vtkNew < vtkInformationIterator > sself) ; +extern "C" void vtk_information_iterator_init_traversal(vtkNew sself); +extern "C" void vtk_information_iterator_go_to_first_item(vtkNew sself); +extern "C" void vtk_information_iterator_go_to_next_item(vtkNew sself); +extern "C" int vtk_information_iterator_is_done_with_traversal(vtkNew sself); extern "C" vtkNew < vtkInformationKeyLookup > vtkInformationKeyLookup_new () ; extern "C" void vtkInformationKeyLookup_destructor (vtkNew < vtkInformationKeyLookup > sself) ; extern "C" void * vtkInformationKeyLookup_get_ptr (vtkNew < vtkInformationKeyLookup > sself) ; extern "C" vtkNew < vtkInformationVector > vtkInformationVector_new () ; extern "C" void vtkInformationVector_destructor (vtkNew < vtkInformationVector > sself) ; extern "C" void * vtkInformationVector_get_ptr (vtkNew < vtkInformationVector > sself) ; +extern "C" int vtk_information_vector_get_number_of_information_objects(vtkNew sself); +extern "C" void vtk_information_vector_set_number_of_information_objects(vtkNew sself, int n); +extern "C" void vtk_information_vector_remove(vtkNew sself, int idx); extern "C" vtkNew < vtkIntArray > vtkIntArray_new () ; extern "C" void vtkIntArray_destructor (vtkNew < vtkIntArray > sself) ; extern "C" void * vtkIntArray_get_ptr (vtkNew < vtkIntArray > sself) ; +extern "C" int vtk_int_array_get_data_type(vtkNew sself); +extern "C" void vtk_int_array_get_typed_tuple(vtkNew sself, long long i, int tuple); +extern "C" void vtk_int_array_set_typed_tuple(vtkNew sself, long long i, const int tuple); +extern "C" void vtk_int_array_insert_typed_tuple(vtkNew sself, long long i, const int tuple); +extern "C" long long vtk_int_array_insert_next_typed_tuple(vtkNew sself, const int tuple); +extern "C" int vtk_int_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_int_array_set_value(vtkNew sself, long long id, int value); +extern "C" bool vtk_int_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_int_array_insert_value(vtkNew sself, long long id, int f); +extern "C" long long vtk_int_array_insert_next_value(vtkNew sself, int f); +extern "C" int* vtk_int_array_get_value_range(vtkNew sself, int comp); +extern "C" int* vtk_int_array_get_value_range(vtkNew sself); +extern "C" int* vtk_int_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" int* vtk_int_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_int_array_set_array(vtkNew sself, int array, long long size, int save); +extern "C" void vtk_int_array_set_array(vtkNew sself, int array, long long size, int save, int deleteMethod); +extern "C" int vtk_int_array_get_data_type_value_min(vtkNew sself); +extern "C" int vtk_int_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkLongArray > vtkLongArray_new () ; extern "C" void vtkLongArray_destructor (vtkNew < vtkLongArray > sself) ; extern "C" void * vtkLongArray_get_ptr (vtkNew < vtkLongArray > sself) ; +extern "C" int vtk_long_array_get_data_type(vtkNew sself); +extern "C" void vtk_long_array_get_typed_tuple(vtkNew sself, long long i, long tuple); +extern "C" void vtk_long_array_set_typed_tuple(vtkNew sself, long long i, const long tuple); +extern "C" void vtk_long_array_insert_typed_tuple(vtkNew sself, long long i, const long tuple); +extern "C" long long vtk_long_array_insert_next_typed_tuple(vtkNew sself, const long tuple); +extern "C" long vtk_long_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_long_array_set_value(vtkNew sself, long long id, long value); +extern "C" bool vtk_long_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_long_array_insert_value(vtkNew sself, long long id, long f); +extern "C" long long vtk_long_array_insert_next_value(vtkNew sself, long f); +extern "C" long* vtk_long_array_get_value_range(vtkNew sself, int comp); +extern "C" long* vtk_long_array_get_value_range(vtkNew sself); +extern "C" long* vtk_long_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" long* vtk_long_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_long_array_set_array(vtkNew sself, long array, long long size, int save); +extern "C" void vtk_long_array_set_array(vtkNew sself, long array, long long size, int save, int deleteMethod); +extern "C" long vtk_long_array_get_data_type_value_min(vtkNew sself); +extern "C" long vtk_long_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkLongLongArray > vtkLongLongArray_new () ; extern "C" void vtkLongLongArray_destructor (vtkNew < vtkLongLongArray > sself) ; extern "C" void * vtkLongLongArray_get_ptr (vtkNew < vtkLongLongArray > sself) ; +extern "C" int vtk_long_long_array_get_data_type(vtkNew sself); +extern "C" void vtk_long_long_array_get_typed_tuple(vtkNew sself, long long i, long long tuple); +extern "C" void vtk_long_long_array_set_typed_tuple(vtkNew sself, long long i, const long long tuple); +extern "C" void vtk_long_long_array_insert_typed_tuple(vtkNew sself, long long i, const long long tuple); +extern "C" long long vtk_long_long_array_insert_next_typed_tuple(vtkNew sself, const long long tuple); +extern "C" long long vtk_long_long_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_long_long_array_set_value(vtkNew sself, long long id, long long value); +extern "C" bool vtk_long_long_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_long_long_array_insert_value(vtkNew sself, long long id, long long f); +extern "C" long long vtk_long_long_array_insert_next_value(vtkNew sself, long long f); +extern "C" long long* vtk_long_long_array_get_value_range(vtkNew sself, int comp); +extern "C" long long* vtk_long_long_array_get_value_range(vtkNew sself); +extern "C" long long* vtk_long_long_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" long long* vtk_long_long_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_long_long_array_set_array(vtkNew sself, long long array, long long size, int save); +extern "C" void vtk_long_long_array_set_array(vtkNew sself, long long array, long long size, int save, int deleteMethod); +extern "C" long long vtk_long_long_array_get_data_type_value_min(vtkNew sself); +extern "C" long long vtk_long_long_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkLookupTable > vtkLookupTable_new () ; extern "C" void vtkLookupTable_destructor (vtkNew < vtkLookupTable > sself) ; extern "C" void * vtkLookupTable_get_ptr (vtkNew < vtkLookupTable > sself) ; +extern "C" int vtk_lookup_table_is_opaque(vtkNew sself); +extern "C" int vtk_lookup_table_allocate(vtkNew sself, int sz, int ext); +extern "C" void vtk_lookup_table_build(vtkNew sself); +extern "C" void vtk_lookup_table_force_build(vtkNew sself); +extern "C" void vtk_lookup_table_build_special_colors(vtkNew sself); +extern "C" void vtk_lookup_table_set_ramp(vtkNew sself, int _arg); +extern "C" void vtk_lookup_table_set_ramp_to_linear(vtkNew sself); +extern "C" void vtk_lookup_table_set_ramp_to_s_curve(vtkNew sself); +extern "C" void vtk_lookup_table_set_ramp_to_sqrt(vtkNew sself); +extern "C" int vtk_lookup_table_get_ramp(vtkNew sself); +extern "C" void vtk_lookup_table_set_scale(vtkNew sself, int scale); +extern "C" void vtk_lookup_table_set_scale_to_linear(vtkNew sself); +extern "C" void vtk_lookup_table_set_scale_to_log_10(vtkNew sself); +extern "C" int vtk_lookup_table_get_scale(vtkNew sself); +extern "C" void vtk_lookup_table_set_table_range(vtkNew sself, const double r); +extern "C" void vtk_lookup_table_set_table_range(vtkNew sself, double min, double max); +extern "C" double* vtk_lookup_table_get_table_range(vtkNew sself); +extern "C" void vtk_lookup_table_get_table_range(vtkNew sself, double data); +extern "C" void vtk_lookup_table_set_hue_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_hue_range(vtkNew sself, const double _arg); +extern "C" double* vtk_lookup_table_get_hue_range(vtkNew sself); +extern "C" void vtk_lookup_table_get_hue_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_get_hue_range(vtkNew sself, double _arg); +extern "C" void vtk_lookup_table_set_saturation_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_saturation_range(vtkNew sself, const double _arg); +extern "C" double* vtk_lookup_table_get_saturation_range(vtkNew sself); +extern "C" void vtk_lookup_table_get_saturation_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_get_saturation_range(vtkNew sself, double _arg); +extern "C" void vtk_lookup_table_set_value_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_value_range(vtkNew sself, const double _arg); +extern "C" double* vtk_lookup_table_get_value_range(vtkNew sself); +extern "C" void vtk_lookup_table_get_value_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_get_value_range(vtkNew sself, double _arg); +extern "C" void vtk_lookup_table_set_alpha_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_alpha_range(vtkNew sself, const double _arg); +extern "C" double* vtk_lookup_table_get_alpha_range(vtkNew sself); +extern "C" void vtk_lookup_table_get_alpha_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_get_alpha_range(vtkNew sself, double _arg); +extern "C" void vtk_lookup_table_set_nan_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_set_nan_color(vtkNew sself, const double _arg); +extern "C" double* vtk_lookup_table_get_nan_color(vtkNew sself); +extern "C" void vtk_lookup_table_get_nan_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_get_nan_color(vtkNew sself, double _arg); +extern "C" unsigned char* vtk_lookup_table_get_nan_color_as_unsigned_chars(vtkNew sself); +extern "C" void vtk_lookup_table_get_color_as_unsigned_chars(vtkNew sself, const double colorIn, unsigned char colorOut); +extern "C" void vtk_lookup_table_set_below_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_set_below_range_color(vtkNew sself, const double _arg); +extern "C" double* vtk_lookup_table_get_below_range_color(vtkNew sself); +extern "C" void vtk_lookup_table_get_below_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_get_below_range_color(vtkNew sself, double _arg); +extern "C" void vtk_lookup_table_set_use_below_range_color(vtkNew sself, int _arg); +extern "C" int vtk_lookup_table_get_use_below_range_color(vtkNew sself); +extern "C" void vtk_lookup_table_use_below_range_color_on(vtkNew sself); +extern "C" void vtk_lookup_table_use_below_range_color_off(vtkNew sself); +extern "C" void vtk_lookup_table_set_above_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_set_above_range_color(vtkNew sself, const double _arg); +extern "C" double* vtk_lookup_table_get_above_range_color(vtkNew sself); +extern "C" void vtk_lookup_table_get_above_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_get_above_range_color(vtkNew sself, double _arg); +extern "C" void vtk_lookup_table_set_use_above_range_color(vtkNew sself, int _arg); +extern "C" int vtk_lookup_table_get_use_above_range_color(vtkNew sself); +extern "C" void vtk_lookup_table_use_above_range_color_on(vtkNew sself); +extern "C" void vtk_lookup_table_use_above_range_color_off(vtkNew sself); +extern "C" const unsigned char* vtk_lookup_table_map_value(vtkNew sself, double v); +extern "C" void vtk_lookup_table_get_color(vtkNew sself, double v, double rgb); +extern "C" double vtk_lookup_table_get_opacity(vtkNew sself, double v); +extern "C" long long vtk_lookup_table_get_index(vtkNew sself, double v); +extern "C" void vtk_lookup_table_set_number_of_table_values(vtkNew sself, long long number); +extern "C" long long vtk_lookup_table_get_number_of_table_values(vtkNew sself); +extern "C" void vtk_lookup_table_set_table_value(vtkNew sself, long long indx, const double rgba); +extern "C" void vtk_lookup_table_set_table_value(vtkNew sself, long long indx, double r, double g, double b, double a); +extern "C" double* vtk_lookup_table_get_table_value(vtkNew sself, long long indx); +extern "C" void vtk_lookup_table_get_table_value(vtkNew sself, long long indx, double rgba); +extern "C" unsigned char* vtk_lookup_table_get_pointer(vtkNew sself, long long id); +extern "C" unsigned char* vtk_lookup_table_write_pointer(vtkNew sself, long long id, int number); +extern "C" double* vtk_lookup_table_get_range(vtkNew sself); +extern "C" void vtk_lookup_table_get_log_range(vtkNew sself, const double range, double log_range); +extern "C" double vtk_lookup_table_apply_log_scale(vtkNew sself, double v, const double range, const double log_range); +extern "C" void vtk_lookup_table_set_number_of_colors(vtkNew sself, long long _arg); +extern "C" long long vtk_lookup_table_get_number_of_colors_min_value(vtkNew sself); +extern "C" long long vtk_lookup_table_get_number_of_colors_max_value(vtkNew sself); +extern "C" long long vtk_lookup_table_get_number_of_colors(vtkNew sself); +extern "C" void vtk_lookup_table_map_scalars_through_table_2(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat); +extern "C" int vtk_lookup_table_using_log_scale(vtkNew sself); +extern "C" void vtk_lookup_table_get_indexed_color(vtkNew sself, long long idx, double rgba); extern "C" vtkNew < vtkMath > vtkMath_new () ; extern "C" void vtkMath_destructor (vtkNew < vtkMath > sself) ; extern "C" void * vtkMath_get_ptr (vtkNew < vtkMath > sself) ; +extern "C" double vtk_math_pi(vtkNew sself); +extern "C" float vtk_math_radians_from_degrees(vtkNew sself, float degrees); +extern "C" double vtk_math_radians_from_degrees(vtkNew sself, double degrees); +extern "C" float vtk_math_degrees_from_radians(vtkNew sself, float radians); +extern "C" double vtk_math_degrees_from_radians(vtkNew sself, double radians); +extern "C" int vtk_math_round(vtkNew sself, float f); +extern "C" int vtk_math_round(vtkNew sself, double f); +extern "C" int vtk_math_floor(vtkNew sself, double x); +extern "C" int vtk_math_ceil(vtkNew sself, double x); +extern "C" int vtk_math_ceil_log_2(vtkNew sself, unsigned long long x); +extern "C" bool vtk_math_is_power_of_two(vtkNew sself, unsigned long long x); +extern "C" int vtk_math_nearest_power_of_two(vtkNew sself, int x); +extern "C" long long vtk_math_factorial(vtkNew sself, int N); +extern "C" long long vtk_math_binomial(vtkNew sself, int m, int n); +extern "C" int* vtk_math_begin_combination(vtkNew sself, int m, int n); +extern "C" int vtk_math_next_combination(vtkNew sself, int m, int n, int combination); +extern "C" void vtk_math_free_combination(vtkNew sself, int combination); +extern "C" void vtk_math_random_seed(vtkNew sself, int s); +extern "C" int vtk_math_get_seed(vtkNew sself); +extern "C" double vtk_math_random(vtkNew sself); +extern "C" double vtk_math_random(vtkNew sself, double min, double max); +extern "C" double vtk_math_gaussian(vtkNew sself); +extern "C" double vtk_math_gaussian(vtkNew sself, double mean, double std); +extern "C" void vtk_math_assign(vtkNew sself, const double a, double b); +extern "C" void vtk_math_add(vtkNew sself, const float a, const float b, float c); +extern "C" void vtk_math_add(vtkNew sself, const double a, const double b, double c); +extern "C" void vtk_math_subtract(vtkNew sself, const float a, const float b, float c); +extern "C" void vtk_math_subtract(vtkNew sself, const double a, const double b, double c); +extern "C" void vtk_math_multiply_scalar(vtkNew sself, float a, float s); +extern "C" void vtk_math_multiply_scalar_2_d(vtkNew sself, float a, float s); +extern "C" void vtk_math_multiply_scalar(vtkNew sself, double a, double s); +extern "C" void vtk_math_multiply_scalar_2_d(vtkNew sself, double a, double s); +extern "C" float vtk_math_dot(vtkNew sself, const float a, const float b); +extern "C" double vtk_math_dot(vtkNew sself, const double a, const double b); +extern "C" void vtk_math_outer(vtkNew sself, const float a, const float b, float c); +extern "C" void vtk_math_outer(vtkNew sself, const double a, const double b, double c); +extern "C" void vtk_math_cross(vtkNew sself, const float a, const float b, float c); +extern "C" void vtk_math_cross(vtkNew sself, const double a, const double b, double c); +extern "C" float vtk_math_norm(vtkNew sself, const float x, int n); +extern "C" double vtk_math_norm(vtkNew sself, const double x, int n); +extern "C" float vtk_math_norm(vtkNew sself, const float v); +extern "C" double vtk_math_norm(vtkNew sself, const double v); +extern "C" float vtk_math_normalize(vtkNew sself, float v); +extern "C" double vtk_math_normalize(vtkNew sself, double v); +extern "C" void vtk_math_perpendiculars(vtkNew sself, const double v1, double v2, double v3, double theta); +extern "C" void vtk_math_perpendiculars(vtkNew sself, const float v1, float v2, float v3, double theta); +extern "C" bool vtk_math_project_vector(vtkNew sself, const float a, const float b, float projection); +extern "C" bool vtk_math_project_vector(vtkNew sself, const double a, const double b, double projection); +extern "C" bool vtk_math_project_vector_2_d(vtkNew sself, const float a, const float b, float projection); +extern "C" bool vtk_math_project_vector_2_d(vtkNew sself, const double a, const double b, double projection); +extern "C" float vtk_math_distance_2_between_points(vtkNew sself, const float p1, const float p2); +extern "C" double vtk_math_distance_2_between_points(vtkNew sself, const double p1, const double p2); +extern "C" double vtk_math_angle_between_vectors(vtkNew sself, const double v1, const double v2); +extern "C" double vtk_math_signed_angle_between_vectors(vtkNew sself, const double v1, const double v2, const double vn); +extern "C" double vtk_math_gaussian_amplitude(vtkNew sself, const double variance, const double distanceFromMean); +extern "C" double vtk_math_gaussian_amplitude(vtkNew sself, const double mean, const double variance, const double position); +extern "C" double vtk_math_gaussian_weight(vtkNew sself, const double variance, const double distanceFromMean); +extern "C" double vtk_math_gaussian_weight(vtkNew sself, const double mean, const double variance, const double position); +extern "C" float vtk_math_dot_2_d(vtkNew sself, const float x, const float y); +extern "C" double vtk_math_dot_2_d(vtkNew sself, const double x, const double y); +extern "C" void vtk_math_outer_2_d(vtkNew sself, const float x, const float y, float A); +extern "C" void vtk_math_outer_2_d(vtkNew sself, const double x, const double y, double A); +extern "C" float vtk_math_norm_2_d(vtkNew sself, const float x); +extern "C" double vtk_math_norm_2_d(vtkNew sself, const double x); +extern "C" float vtk_math_normalize_2_d(vtkNew sself, float v); +extern "C" double vtk_math_normalize_2_d(vtkNew sself, double v); +extern "C" float vtk_math_determinant_2_x_2(vtkNew sself, const float c1, const float c2); +extern "C" double vtk_math_determinant_2_x_2(vtkNew sself, double a, double b, double c, double d); +extern "C" double vtk_math_determinant_2_x_2(vtkNew sself, const double c1, const double c2); +extern "C" void vtk_math_lu_factor_3_x_3(vtkNew sself, float A, int index); +extern "C" void vtk_math_lu_factor_3_x_3(vtkNew sself, double A, int index); +extern "C" void vtk_math_lu_solve_3_x_3(vtkNew sself, const float A, const int index, float x); +extern "C" void vtk_math_lu_solve_3_x_3(vtkNew sself, const double A, const int index, double x); +extern "C" void vtk_math_linear_solve_3_x_3(vtkNew sself, const float A, const float x, float y); +extern "C" void vtk_math_linear_solve_3_x_3(vtkNew sself, const double A, const double x, double y); +extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const float A, const float v, float u); +extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const double A, const double v, double u); +extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const float A, const float B, float C); +extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const double A, const double B, double C); +extern "C" void vtk_math_multiply_matrix(vtkNew sself, const double A, const double B, unsigned int rowA, unsigned int colA, unsigned int rowB, unsigned int colB, double C); +extern "C" void vtk_math_transpose_3_x_3(vtkNew sself, const float A, float AT); +extern "C" void vtk_math_transpose_3_x_3(vtkNew sself, const double A, double AT); +extern "C" void vtk_math_invert_3_x_3(vtkNew sself, const float A, float AI); +extern "C" void vtk_math_invert_3_x_3(vtkNew sself, const double A, double AI); +extern "C" void vtk_math_identity_3_x_3(vtkNew sself, float A); +extern "C" void vtk_math_identity_3_x_3(vtkNew sself, double A); +extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const float A); +extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const double A); +extern "C" float vtk_math_determinant_3_x_3(vtkNew sself, const float c1, const float c2, const float c3); +extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const double c1, const double c2, const double c3); +extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3); +extern "C" void vtk_math_quaternion_to_matrix_3_x_3(vtkNew sself, const float quat, float A); +extern "C" void vtk_math_quaternion_to_matrix_3_x_3(vtkNew sself, const double quat, double A); +extern "C" void vtk_math_matrix_3_x_3_to_quaternion(vtkNew sself, const float A, float quat); +extern "C" void vtk_math_matrix_3_x_3_to_quaternion(vtkNew sself, const double A, double quat); +extern "C" void vtk_math_multiply_quaternion(vtkNew sself, const float q1, const float q2, float q); +extern "C" void vtk_math_multiply_quaternion(vtkNew sself, const double q1, const double q2, double q); +extern "C" void vtk_math_rotate_vector_by_normalized_quaternion(vtkNew sself, const float v, const float q, float r); +extern "C" void vtk_math_rotate_vector_by_normalized_quaternion(vtkNew sself, const double v, const double q, double r); +extern "C" void vtk_math_rotate_vector_by_wxyz(vtkNew sself, const float v, const float q, float r); +extern "C" void vtk_math_rotate_vector_by_wxyz(vtkNew sself, const double v, const double q, double r); +extern "C" void vtk_math_orthogonalize_3_x_3(vtkNew sself, const float A, float B); +extern "C" void vtk_math_orthogonalize_3_x_3(vtkNew sself, const double A, double B); +extern "C" void vtk_math_diagonalize_3_x_3(vtkNew sself, const float A, float w, float V); +extern "C" void vtk_math_diagonalize_3_x_3(vtkNew sself, const double A, double w, double V); +extern "C" void vtk_math_singular_value_decomposition_3_x_3(vtkNew sself, const float A, float U, float w, float VT); +extern "C" void vtk_math_singular_value_decomposition_3_x_3(vtkNew sself, const double A, double U, double w, double VT); +extern "C" int vtk_math_solve_linear_system_gepp_2_x_2(vtkNew sself, double a00, double a01, double a10, double a11, double b0, double b1, double x0, double x1); +extern "C" int vtk_math_solve_linear_system(vtkNew sself, double A, double x, int size); +extern "C" int vtk_math_invert_matrix(vtkNew sself, double A, double AI, int size); +extern "C" int vtk_math_invert_matrix(vtkNew sself, double A, double AI, int size, int tmp1Size, double tmp2Size); +extern "C" int vtk_math_lu_factor_linear_system(vtkNew sself, double A, int index, int size); +extern "C" int vtk_math_lu_factor_linear_system(vtkNew sself, double A, int index, int size, double tmpSize); +extern "C" void vtk_math_lu_solve_linear_system(vtkNew sself, double A, int index, double x, int size); +extern "C" double vtk_math_estimate_matrix_condition(vtkNew sself, const double A, int size); +extern "C" int vtk_math_jacobi(vtkNew sself, float a, float w, float v); +extern "C" int vtk_math_jacobi(vtkNew sself, double a, double w, double v); +extern "C" int vtk_math_jacobi_n(vtkNew sself, float a, int n, float w, float v); +extern "C" int vtk_math_jacobi_n(vtkNew sself, double a, int n, double w, double v); +extern "C" int vtk_math_solve_homogeneous_least_squares(vtkNew sself, int numberOfSamples, double xt, int xOrder, double mt); +extern "C" int vtk_math_solve_least_squares(vtkNew sself, int numberOfSamples, double xt, int xOrder, double yt, int yOrder, double mt, int checkHomogeneous); +extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, const float rgb, float hsv); +extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, float r, float g, float b, float h, float s, float v); +extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, const double rgb, double hsv); +extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, double r, double g, double b, double h, double s, double v); +extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, const float hsv, float rgb); +extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, float h, float s, float v, float r, float g, float b); +extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, const double hsv, double rgb); +extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, double h, double s, double v, double r, double g, double b); +extern "C" void vtk_math_lab_to_xyz(vtkNew sself, const double lab, double xyz); +extern "C" void vtk_math_lab_to_xyz(vtkNew sself, double L, double a, double b, double x, double y, double z); +extern "C" void vtk_math_xyz_to_lab(vtkNew sself, const double xyz, double lab); +extern "C" void vtk_math_xyz_to_lab(vtkNew sself, double x, double y, double z, double L, double a, double b); +extern "C" void vtk_math_xyz_to_rgb(vtkNew sself, const double xyz, double rgb); +extern "C" void vtk_math_xyz_to_rgb(vtkNew sself, double x, double y, double z, double r, double g, double b); +extern "C" void vtk_math_rgb_to_xyz(vtkNew sself, const double rgb, double xyz); +extern "C" void vtk_math_rgb_to_xyz(vtkNew sself, double r, double g, double b, double x, double y, double z); +extern "C" void vtk_math_rgb_to_lab(vtkNew sself, const double rgb, double lab); +extern "C" void vtk_math_rgb_to_lab(vtkNew sself, double red, double green, double blue, double L, double a, double b); +extern "C" void vtk_math_lab_to_rgb(vtkNew sself, const double lab, double rgb); +extern "C" void vtk_math_lab_to_rgb(vtkNew sself, double L, double a, double b, double red, double green, double blue); +extern "C" void vtk_math_uninitialize_bounds(vtkNew sself, double bounds); +extern "C" int vtk_math_are_bounds_initialized(vtkNew sself, const double bounds); +extern "C" void vtk_math_clamp_value(vtkNew sself, double value, const double range); +extern "C" void vtk_math_clamp_value(vtkNew sself, double value, const double range, double clamped_value); +extern "C" void vtk_math_clamp_values(vtkNew sself, double values, int nb_values, const double range); +extern "C" void vtk_math_clamp_values(vtkNew sself, const double values, int nb_values, const double range, double clamped_values); +extern "C" double vtk_math_clamp_and_normalize_value(vtkNew sself, double value, const double range); +extern "C" int vtk_math_get_scalar_type_fitting_range(vtkNew sself, double range_min, double range_max, double scale, double shift); +extern "C" int vtk_math_extent_is_within_other_extent(vtkNew sself, const int extent1, const int extent2); +extern "C" int vtk_math_bounds_is_within_other_bounds(vtkNew sself, const double bounds1, const double bounds2, const double delta); +extern "C" int vtk_math_point_is_within_bounds(vtkNew sself, const double point, const double bounds, const double delta); +extern "C" int vtk_math_plane_intersects_aabb(vtkNew sself, const double bounds, const double normal, const double point); +extern "C" double vtk_math_solve_3_point_circle(vtkNew sself, const double p1, const double p2, const double p3, double center); +extern "C" double vtk_math_inf(vtkNew sself); +extern "C" double vtk_math_neg_inf(vtkNew sself); +extern "C" double vtk_math_nan(vtkNew sself); +extern "C" int vtk_math_is_inf(vtkNew sself, double x); +extern "C" int vtk_math_is_nan(vtkNew sself, double x); +extern "C" bool vtk_math_is_finite(vtkNew sself, double x); +extern "C" int vtk_math_quadratic_root(vtkNew sself, double a, double b, double c, double min, double max, double u); extern "C" vtkNew < vtkMersenneTwister > vtkMersenneTwister_new () ; extern "C" void vtkMersenneTwister_destructor (vtkNew < vtkMersenneTwister > sself) ; extern "C" void * vtkMersenneTwister_get_ptr (vtkNew < vtkMersenneTwister > sself) ; +extern "C" void vtk_mersenne_twister_initialize(vtkNew sself, unsigned int seed); +extern "C" unsigned int vtk_mersenne_twister_initialize_new_sequence(vtkNew sself, unsigned int seed, int p); +extern "C" void vtk_mersenne_twister_initialize_sequence(vtkNew sself, unsigned int id, unsigned int seed, int p); +extern "C" double vtk_mersenne_twister_get_value(vtkNew sself, unsigned int id); +extern "C" double vtk_mersenne_twister_get_value(vtkNew sself); +extern "C" void vtk_mersenne_twister_next(vtkNew sself, unsigned int id); +extern "C" void vtk_mersenne_twister_next(vtkNew sself); extern "C" vtkNew < vtkMinimalStandardRandomSequence > vtkMinimalStandardRandomSequence_new () ; extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkNew < vtkMinimalStandardRandomSequence > sself) ; extern "C" void * vtkMinimalStandardRandomSequence_get_ptr (vtkNew < vtkMinimalStandardRandomSequence > sself) ; +extern "C" void vtk_minimal_standard_random_sequence_initialize(vtkNew sself, unsigned int seed); +extern "C" void vtk_minimal_standard_random_sequence_set_seed(vtkNew sself, int value); +extern "C" void vtk_minimal_standard_random_sequence_set_seed_only(vtkNew sself, int value); +extern "C" int vtk_minimal_standard_random_sequence_get_seed(vtkNew sself); +extern "C" double vtk_minimal_standard_random_sequence_get_value(vtkNew sself); +extern "C" void vtk_minimal_standard_random_sequence_next(vtkNew sself); +extern "C" double vtk_minimal_standard_random_sequence_get_range_value(vtkNew sself, double rangeMin, double rangeMax); +extern "C" double vtk_minimal_standard_random_sequence_get_next_range_value(vtkNew sself, double rangeMin, double rangeMax); extern "C" vtkNew < vtkMultiThreader > vtkMultiThreader_new () ; extern "C" void vtkMultiThreader_destructor (vtkNew < vtkMultiThreader > sself) ; extern "C" void * vtkMultiThreader_get_ptr (vtkNew < vtkMultiThreader > sself) ; +extern "C" void vtk_multi_threader_set_number_of_threads(vtkNew sself, int _arg); +extern "C" int vtk_multi_threader_get_number_of_threads_min_value(vtkNew sself); +extern "C" int vtk_multi_threader_get_number_of_threads_max_value(vtkNew sself); +extern "C" int vtk_multi_threader_get_number_of_threads(vtkNew sself); +extern "C" int vtk_multi_threader_get_global_static_maximum_number_of_threads(vtkNew sself); +extern "C" void vtk_multi_threader_set_global_maximum_number_of_threads(vtkNew sself, int val); +extern "C" int vtk_multi_threader_get_global_maximum_number_of_threads(vtkNew sself); +extern "C" void vtk_multi_threader_set_global_default_number_of_threads(vtkNew sself, int val); +extern "C" int vtk_multi_threader_get_global_default_number_of_threads(vtkNew sself); +extern "C" void vtk_multi_threader_single_method_execute(vtkNew sself); +extern "C" void vtk_multi_threader_multiple_method_execute(vtkNew sself); +extern "C" void vtk_multi_threader_terminate_thread(vtkNew sself, int threadId); +extern "C" int vtk_multi_threader_is_thread_active(vtkNew sself, int threadId); extern "C" vtkNew < vtkObject > vtkObject_new () ; extern "C" void vtkObject_destructor (vtkNew < vtkObject > sself) ; extern "C" void * vtkObject_get_ptr (vtkNew < vtkObject > sself) ; +extern "C" int vtk_object_is_type_of(vtkNew sself, const char type); +extern "C" int vtk_object_is_a(vtkNew sself, const char type); +extern "C" long long vtk_object_get_number_of_generations_from_base_type(vtkNew sself, const char type); +extern "C" long long vtk_object_get_number_of_generations_from_base(vtkNew sself, const char type); +extern "C" void vtk_object_debug_on(vtkNew sself); +extern "C" void vtk_object_debug_off(vtkNew sself); +extern "C" bool vtk_object_get_debug(vtkNew sself); +extern "C" void vtk_object_set_debug(vtkNew sself, bool debugFlag); +extern "C" void vtk_object_break_on_error(vtkNew sself); +extern "C" void vtk_object_modified(vtkNew sself); +extern "C" unsigned long vtk_object_get_m_time(vtkNew sself); +extern "C" void vtk_object_set_global_warning_display(vtkNew sself, int val); +extern "C" void vtk_object_global_warning_display_on(vtkNew sself); +extern "C" void vtk_object_global_warning_display_off(vtkNew sself); +extern "C" int vtk_object_get_global_warning_display(vtkNew sself); +extern "C" void vtk_object_remove_observer(vtkNew sself, unsigned long tag); +extern "C" void vtk_object_remove_observers(vtkNew sself, unsigned long event); +extern "C" void vtk_object_remove_observers(vtkNew sself, const char event); +extern "C" void vtk_object_remove_all_observers(vtkNew sself); +extern "C" int vtk_object_has_observer(vtkNew sself, unsigned long event); +extern "C" int vtk_object_has_observer(vtkNew sself, const char event); +extern "C" int vtk_object_invoke_event(vtkNew sself, unsigned long event, void callData); +extern "C" int vtk_object_invoke_event(vtkNew sself, const char event, void callData); +extern "C" int vtk_object_invoke_event(vtkNew sself, unsigned long event); +extern "C" int vtk_object_invoke_event(vtkNew sself, const char event); extern "C" vtkNew < vtkObjectFactoryCollection > vtkObjectFactoryCollection_new () ; extern "C" void vtkObjectFactoryCollection_destructor (vtkNew < vtkObjectFactoryCollection > sself) ; extern "C" void * vtkObjectFactoryCollection_get_ptr (vtkNew < vtkObjectFactoryCollection > sself) ; extern "C" vtkNew < vtkOldStyleCallbackCommand > vtkOldStyleCallbackCommand_new () ; extern "C" void vtkOldStyleCallbackCommand_destructor (vtkNew < vtkOldStyleCallbackCommand > sself) ; extern "C" void * vtkOldStyleCallbackCommand_get_ptr (vtkNew < vtkOldStyleCallbackCommand > sself) ; +extern "C" void vtk_old_style_callback_command_set_client_data(vtkNew sself, void cd); extern "C" vtkNew < vtkOutputWindow > vtkOutputWindow_new () ; extern "C" void vtkOutputWindow_destructor (vtkNew < vtkOutputWindow > sself) ; extern "C" void * vtkOutputWindow_get_ptr (vtkNew < vtkOutputWindow > sself) ; +extern "C" void vtk_output_window_display_text(vtkNew sself, const char p0); +extern "C" void vtk_output_window_display_error_text(vtkNew sself, const char p0); +extern "C" void vtk_output_window_display_warning_text(vtkNew sself, const char p0); +extern "C" void vtk_output_window_display_generic_warning_text(vtkNew sself, const char p0); +extern "C" void vtk_output_window_display_debug_text(vtkNew sself, const char p0); +extern "C" void vtk_output_window_prompt_user_on(vtkNew sself); +extern "C" void vtk_output_window_prompt_user_off(vtkNew sself); +extern "C" void vtk_output_window_set_prompt_user(vtkNew sself, bool _arg); +extern "C" void vtk_output_window_set_use_std_error_for_all_messages(vtkNew sself, bool p0); +extern "C" bool vtk_output_window_get_use_std_error_for_all_messages(vtkNew sself); +extern "C" void vtk_output_window_use_std_error_for_all_messages_on(vtkNew sself); +extern "C" void vtk_output_window_use_std_error_for_all_messages_off(vtkNew sself); +extern "C" void vtk_output_window_set_display_mode(vtkNew sself, int _arg); +extern "C" int vtk_output_window_get_display_mode_min_value(vtkNew sself); +extern "C" int vtk_output_window_get_display_mode_max_value(vtkNew sself); +extern "C" int vtk_output_window_get_display_mode(vtkNew sself); +extern "C" void vtk_output_window_set_display_mode_to_default(vtkNew sself); +extern "C" void vtk_output_window_set_display_mode_to_never(vtkNew sself); +extern "C" void vtk_output_window_set_display_mode_to_always(vtkNew sself); +extern "C" void vtk_output_window_set_display_mode_to_always_std_err(vtkNew sself); extern "C" vtkNew < vtkOverrideInformationCollection > vtkOverrideInformationCollection_new () ; extern "C" void vtkOverrideInformationCollection_destructor (vtkNew < vtkOverrideInformationCollection > sself) ; extern "C" void * vtkOverrideInformationCollection_get_ptr (vtkNew < vtkOverrideInformationCollection > sself) ; extern "C" vtkNew < vtkPoints > vtkPoints_new () ; extern "C" void vtkPoints_destructor (vtkNew < vtkPoints > sself) ; extern "C" void * vtkPoints_get_ptr (vtkNew < vtkPoints > sself) ; +extern "C" int vtk_points_allocate(vtkNew sself, long long sz, long long ext); +extern "C" void vtk_points_initialize(vtkNew sself); +extern "C" int vtk_points_get_data_type(vtkNew sself); +extern "C" void vtk_points_set_data_type(vtkNew sself, int dataType); +extern "C" void vtk_points_set_data_type_to_bit(vtkNew sself); +extern "C" void vtk_points_set_data_type_to_char(vtkNew sself); +extern "C" void vtk_points_set_data_type_to_unsigned_char(vtkNew sself); +extern "C" void vtk_points_set_data_type_to_short(vtkNew sself); +extern "C" void vtk_points_set_data_type_to_unsigned_short(vtkNew sself); +extern "C" void vtk_points_set_data_type_to_int(vtkNew sself); +extern "C" void vtk_points_set_data_type_to_unsigned_int(vtkNew sself); +extern "C" void vtk_points_set_data_type_to_long(vtkNew sself); +extern "C" void vtk_points_set_data_type_to_unsigned_long(vtkNew sself); +extern "C" void vtk_points_set_data_type_to_float(vtkNew sself); +extern "C" void vtk_points_set_data_type_to_double(vtkNew sself); +extern "C" void* vtk_points_get_void_pointer(vtkNew sself, const int id); +extern "C" void vtk_points_squeeze(vtkNew sself); +extern "C" void vtk_points_reset(vtkNew sself); +extern "C" unsigned long vtk_points_get_actual_memory_size(vtkNew sself); +extern "C" long long vtk_points_get_number_of_points(vtkNew sself); +extern "C" double* vtk_points_get_point(vtkNew sself, long long id); +extern "C" void vtk_points_get_point(vtkNew sself, long long id, double x); +extern "C" void vtk_points_set_point(vtkNew sself, long long id, const float x); +extern "C" void vtk_points_set_point(vtkNew sself, long long id, const double x); +extern "C" void vtk_points_set_point(vtkNew sself, long long id, double x, double y, double z); +extern "C" void vtk_points_insert_point(vtkNew sself, long long id, const float x); +extern "C" void vtk_points_insert_point(vtkNew sself, long long id, const double x); +extern "C" void vtk_points_insert_point(vtkNew sself, long long id, double x, double y, double z); +extern "C" long long vtk_points_insert_next_point(vtkNew sself, const float x); +extern "C" long long vtk_points_insert_next_point(vtkNew sself, const double x); +extern "C" long long vtk_points_insert_next_point(vtkNew sself, double x, double y, double z); +extern "C" void vtk_points_set_number_of_points(vtkNew sself, long long numPoints); +extern "C" int vtk_points_resize(vtkNew sself, long long numPoints); +extern "C" void vtk_points_compute_bounds(vtkNew sself); +extern "C" double* vtk_points_get_bounds(vtkNew sself); +extern "C" void vtk_points_get_bounds(vtkNew sself, double bounds); +extern "C" unsigned long vtk_points_get_m_time(vtkNew sself); +extern "C" void vtk_points_modified(vtkNew sself); extern "C" vtkNew < vtkPoints2D > vtkPoints2D_new () ; extern "C" void vtkPoints2D_destructor (vtkNew < vtkPoints2D > sself) ; extern "C" void * vtkPoints2D_get_ptr (vtkNew < vtkPoints2D > sself) ; +extern "C" int vtk_points_2_d_allocate(vtkNew sself, long long sz, long long ext); +extern "C" void vtk_points_2_d_initialize(vtkNew sself); +extern "C" int vtk_points_2_d_get_data_type(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type(vtkNew sself, int dataType); +extern "C" void vtk_points_2_d_set_data_type_to_bit(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type_to_char(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_char(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type_to_short(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_short(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type_to_int(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_int(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type_to_long(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_long(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type_to_float(vtkNew sself); +extern "C" void vtk_points_2_d_set_data_type_to_double(vtkNew sself); +extern "C" void* vtk_points_2_d_get_void_pointer(vtkNew sself, const int id); +extern "C" void vtk_points_2_d_squeeze(vtkNew sself); +extern "C" void vtk_points_2_d_reset(vtkNew sself); +extern "C" unsigned long vtk_points_2_d_get_actual_memory_size(vtkNew sself); +extern "C" long long vtk_points_2_d_get_number_of_points(vtkNew sself); +extern "C" double* vtk_points_2_d_get_point(vtkNew sself, long long id); +extern "C" void vtk_points_2_d_get_point(vtkNew sself, long long id, double x); +extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, const float x); +extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, const double x); +extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, double x, double y); +extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, const float x); +extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, const double x); +extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, double x, double y); +extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, const float x); +extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, const double x); +extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, double x, double y); +extern "C" void vtk_points_2_d_remove_point(vtkNew sself, long long id); +extern "C" void vtk_points_2_d_set_number_of_points(vtkNew sself, long long numPoints); +extern "C" int vtk_points_2_d_resize(vtkNew sself, long long numPoints); +extern "C" void vtk_points_2_d_compute_bounds(vtkNew sself); +extern "C" double* vtk_points_2_d_get_bounds(vtkNew sself); +extern "C" void vtk_points_2_d_get_bounds(vtkNew sself, double bounds); extern "C" vtkNew < vtkPriorityQueue > vtkPriorityQueue_new () ; extern "C" void vtkPriorityQueue_destructor (vtkNew < vtkPriorityQueue > sself) ; extern "C" void * vtkPriorityQueue_get_ptr (vtkNew < vtkPriorityQueue > sself) ; +extern "C" void vtk_priority_queue_allocate(vtkNew sself, long long sz, long long ext); +extern "C" void vtk_priority_queue_insert(vtkNew sself, double priority, long long id); +extern "C" long long vtk_priority_queue_pop(vtkNew sself, long long location, double priority); +extern "C" long long vtk_priority_queue_pop(vtkNew sself, long long location); +extern "C" long long vtk_priority_queue_peek(vtkNew sself, long long location, double priority); +extern "C" long long vtk_priority_queue_peek(vtkNew sself, long long location); +extern "C" double vtk_priority_queue_delete_id(vtkNew sself, long long id); +extern "C" double vtk_priority_queue_get_priority(vtkNew sself, long long id); +extern "C" long long vtk_priority_queue_get_number_of_items(vtkNew sself); +extern "C" void vtk_priority_queue_reset(vtkNew sself); extern "C" vtkNew < vtkRandomPool > vtkRandomPool_new () ; extern "C" void vtkRandomPool_destructor (vtkNew < vtkRandomPool > sself) ; extern "C" void * vtkRandomPool_get_ptr (vtkNew < vtkRandomPool > sself) ; +extern "C" void vtk_random_pool_set_size(vtkNew sself, long long _arg); +extern "C" long long vtk_random_pool_get_size_min_value(vtkNew sself); +extern "C" long long vtk_random_pool_get_size_max_value(vtkNew sself); +extern "C" long long vtk_random_pool_get_size(vtkNew sself); +extern "C" void vtk_random_pool_set_number_of_components(vtkNew sself, long long _arg); +extern "C" long long vtk_random_pool_get_number_of_components_min_value(vtkNew sself); +extern "C" long long vtk_random_pool_get_number_of_components_max_value(vtkNew sself); +extern "C" long long vtk_random_pool_get_number_of_components(vtkNew sself); +extern "C" long long vtk_random_pool_get_total_size(vtkNew sself); +extern "C" const double* vtk_random_pool_generate_pool(vtkNew sself); +extern "C" const double* vtk_random_pool_get_pool(vtkNew sself); +extern "C" double vtk_random_pool_get_value(vtkNew sself, long long i); +extern "C" double vtk_random_pool_get_value(vtkNew sself, long long i, int compNum); +extern "C" void vtk_random_pool_set_chunk_size(vtkNew sself, long long _arg); +extern "C" long long vtk_random_pool_get_chunk_size_min_value(vtkNew sself); +extern "C" long long vtk_random_pool_get_chunk_size_max_value(vtkNew sself); +extern "C" long long vtk_random_pool_get_chunk_size(vtkNew sself); extern "C" vtkNew < vtkReferenceCount > vtkReferenceCount_new () ; extern "C" void vtkReferenceCount_destructor (vtkNew < vtkReferenceCount > sself) ; extern "C" void * vtkReferenceCount_get_ptr (vtkNew < vtkReferenceCount > sself) ; extern "C" vtkNew < vtkScalarsToColors > vtkScalarsToColors_new () ; extern "C" void vtkScalarsToColors_destructor (vtkNew < vtkScalarsToColors > sself) ; extern "C" void * vtkScalarsToColors_get_ptr (vtkNew < vtkScalarsToColors > sself) ; +extern "C" int vtk_scalars_to_colors_is_opaque(vtkNew sself); +extern "C" void vtk_scalars_to_colors_build(vtkNew sself); +extern "C" double* vtk_scalars_to_colors_get_range(vtkNew sself); +extern "C" void vtk_scalars_to_colors_set_range(vtkNew sself, double min, double max); +extern "C" void vtk_scalars_to_colors_set_range(vtkNew sself, const double rng); +extern "C" const unsigned char* vtk_scalars_to_colors_map_value(vtkNew sself, double v); +extern "C" void vtk_scalars_to_colors_get_color(vtkNew sself, double v, double rgb); +extern "C" double* vtk_scalars_to_colors_get_color(vtkNew sself, double v); +extern "C" double vtk_scalars_to_colors_get_opacity(vtkNew sself, double v); +extern "C" double vtk_scalars_to_colors_get_luminance(vtkNew sself, double x); +extern "C" void vtk_scalars_to_colors_set_alpha(vtkNew sself, double alpha); +extern "C" double vtk_scalars_to_colors_get_alpha(vtkNew sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode(vtkNew sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_vector_mode(vtkNew sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_magnitude(vtkNew sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_component(vtkNew sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_rgb_colors(vtkNew sself); +extern "C" void vtk_scalars_to_colors_set_vector_component(vtkNew sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_vector_component(vtkNew sself); +extern "C" void vtk_scalars_to_colors_set_vector_size(vtkNew sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_vector_size(vtkNew sself); +extern "C" void vtk_scalars_to_colors_map_vectors_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat, int vectorComponent, int vectorSize); +extern "C" void vtk_scalars_to_colors_map_vectors_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat); +extern "C" void vtk_scalars_to_colors_map_scalars_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat); +extern "C" void vtk_scalars_to_colors_map_scalars_through_table_2(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat); +extern "C" int vtk_scalars_to_colors_using_log_scale(vtkNew sself); +extern "C" long long vtk_scalars_to_colors_get_number_of_available_colors(vtkNew sself); +extern "C" long long vtk_scalars_to_colors_get_number_of_annotated_values(vtkNew sself); +extern "C" void vtk_scalars_to_colors_get_indexed_color(vtkNew sself, long long i, double rgba); +extern "C" void vtk_scalars_to_colors_reset_annotations(vtkNew sself); +extern "C" void vtk_scalars_to_colors_set_indexed_lookup(vtkNew sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_indexed_lookup(vtkNew sself); +extern "C" void vtk_scalars_to_colors_indexed_lookup_on(vtkNew sself); +extern "C" void vtk_scalars_to_colors_indexed_lookup_off(vtkNew sself); extern "C" vtkNew < vtkShortArray > vtkShortArray_new () ; extern "C" void vtkShortArray_destructor (vtkNew < vtkShortArray > sself) ; extern "C" void * vtkShortArray_get_ptr (vtkNew < vtkShortArray > sself) ; +extern "C" int vtk_short_array_get_data_type(vtkNew sself); +extern "C" void vtk_short_array_get_typed_tuple(vtkNew sself, long long i, short tuple); +extern "C" void vtk_short_array_set_typed_tuple(vtkNew sself, long long i, const short tuple); +extern "C" void vtk_short_array_insert_typed_tuple(vtkNew sself, long long i, const short tuple); +extern "C" long long vtk_short_array_insert_next_typed_tuple(vtkNew sself, const short tuple); +extern "C" short vtk_short_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_short_array_set_value(vtkNew sself, long long id, short value); +extern "C" bool vtk_short_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_short_array_insert_value(vtkNew sself, long long id, short f); +extern "C" long long vtk_short_array_insert_next_value(vtkNew sself, short f); +extern "C" short* vtk_short_array_get_value_range(vtkNew sself, int comp); +extern "C" short* vtk_short_array_get_value_range(vtkNew sself); +extern "C" short* vtk_short_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" short* vtk_short_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_short_array_set_array(vtkNew sself, short array, long long size, int save); +extern "C" void vtk_short_array_set_array(vtkNew sself, short array, long long size, int save, int deleteMethod); +extern "C" short vtk_short_array_get_data_type_value_min(vtkNew sself); +extern "C" short vtk_short_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkSignedCharArray > vtkSignedCharArray_new () ; extern "C" void vtkSignedCharArray_destructor (vtkNew < vtkSignedCharArray > sself) ; extern "C" void * vtkSignedCharArray_get_ptr (vtkNew < vtkSignedCharArray > sself) ; +extern "C" int vtk_signed_char_array_get_data_type(vtkNew sself); +extern "C" void vtk_signed_char_array_get_typed_tuple(vtkNew sself, long long i, char tuple); +extern "C" void vtk_signed_char_array_set_typed_tuple(vtkNew sself, long long i, const char tuple); +extern "C" void vtk_signed_char_array_insert_typed_tuple(vtkNew sself, long long i, const char tuple); +extern "C" long long vtk_signed_char_array_insert_next_typed_tuple(vtkNew sself, const char tuple); +extern "C" char vtk_signed_char_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_signed_char_array_set_value(vtkNew sself, long long id, char value); +extern "C" bool vtk_signed_char_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_signed_char_array_insert_value(vtkNew sself, long long id, char f); +extern "C" long long vtk_signed_char_array_insert_next_value(vtkNew sself, char f); +extern "C" char* vtk_signed_char_array_get_value_range(vtkNew sself, int comp); +extern "C" char* vtk_signed_char_array_get_value_range(vtkNew sself); +extern "C" char* vtk_signed_char_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" char* vtk_signed_char_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_signed_char_array_set_array(vtkNew sself, char array, long long size, int save); +extern "C" void vtk_signed_char_array_set_array(vtkNew sself, char array, long long size, int save, int deleteMethod); +extern "C" char vtk_signed_char_array_get_data_type_value_min(vtkNew sself); +extern "C" char vtk_signed_char_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkSortDataArray > vtkSortDataArray_new () ; extern "C" void vtkSortDataArray_destructor (vtkNew < vtkSortDataArray > sself) ; extern "C" void * vtkSortDataArray_get_ptr (vtkNew < vtkSortDataArray > sself) ; +extern "C" long long* vtk_sort_data_array_initialize_sort_indices(vtkNew sself, long long numKeys); +extern "C" void vtk_sort_data_array_generate_sort_indices(vtkNew sself, int dataType, void dataIn, long long numKeys, int numComp, int k, long long idx); extern "C" vtkNew < vtkStringArray > vtkStringArray_new () ; extern "C" void vtkStringArray_destructor (vtkNew < vtkStringArray > sself) ; extern "C" void * vtkStringArray_get_ptr (vtkNew < vtkStringArray > sself) ; +extern "C" int vtk_string_array_get_data_type(vtkNew sself); +extern "C" int vtk_string_array_is_numeric(vtkNew sself); +extern "C" void vtk_string_array_initialize(vtkNew sself); +extern "C" int vtk_string_array_get_data_type_size(vtkNew sself); +extern "C" void vtk_string_array_squeeze(vtkNew sself); +extern "C" int vtk_string_array_resize(vtkNew sself, long long numTuples); +extern "C" int vtk_string_array_allocate(vtkNew sself, long long sz, long long ext); +extern "C" void vtk_string_array_set_value(vtkNew sself, long long id, const char value); +extern "C" void vtk_string_array_set_number_of_tuples(vtkNew sself, long long number); +extern "C" long long vtk_string_array_get_number_of_values(vtkNew sself); +extern "C" int vtk_string_array_get_number_of_element_components(vtkNew sself); +extern "C" int vtk_string_array_get_element_component_size(vtkNew sself); +extern "C" void vtk_string_array_insert_value(vtkNew sself, long long id, const char val); +extern "C" long long vtk_string_array_insert_next_value(vtkNew sself, const char f); +extern "C" void* vtk_string_array_get_void_pointer(vtkNew sself, long long id); +extern "C" void vtk_string_array_set_void_array(vtkNew sself, void array, long long size, int save); +extern "C" unsigned long vtk_string_array_get_actual_memory_size(vtkNew sself); +extern "C" long long vtk_string_array_get_data_size(vtkNew sself); +extern "C" long long vtk_string_array_lookup_value(vtkNew sself, const char value); +extern "C" void vtk_string_array_data_changed(vtkNew sself); +extern "C" void vtk_string_array_data_element_changed(vtkNew sself, long long id); +extern "C" void vtk_string_array_clear_lookup(vtkNew sself); extern "C" vtkNew < vtkStringOutputWindow > vtkStringOutputWindow_new () ; extern "C" void vtkStringOutputWindow_destructor (vtkNew < vtkStringOutputWindow > sself) ; extern "C" void * vtkStringOutputWindow_get_ptr (vtkNew < vtkStringOutputWindow > sself) ; +extern "C" void vtk_string_output_window_display_text(vtkNew sself, const char p0); +extern "C" const char* vtk_string_output_window_get_output(vtkNew sself); extern "C" vtkNew < vtkTimePointUtility > vtkTimePointUtility_new () ; extern "C" void vtkTimePointUtility_destructor (vtkNew < vtkTimePointUtility > sself) ; extern "C" void * vtkTimePointUtility_get_ptr (vtkNew < vtkTimePointUtility > sself) ; +extern "C" unsigned long long vtk_time_point_utility_date_to_time_point(vtkNew sself, int year, int month, int day); +extern "C" unsigned long long vtk_time_point_utility_time_to_time_point(vtkNew sself, int hour, int minute, int second, int millis); +extern "C" unsigned long long vtk_time_point_utility_date_time_to_time_point(vtkNew sself, int year, int month, int day, int hour, int minute, int sec, int millis); +extern "C" void vtk_time_point_utility_get_date(vtkNew sself, unsigned long long time, int year, int month, int day); +extern "C" void vtk_time_point_utility_get_time(vtkNew sself, unsigned long long time, int hour, int minute, int second, int millis); +extern "C" void vtk_time_point_utility_get_date_time(vtkNew sself, unsigned long long time, int year, int month, int day, int hour, int minute, int second, int millis); +extern "C" int vtk_time_point_utility_get_year(vtkNew sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_month(vtkNew sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_day(vtkNew sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_hour(vtkNew sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_minute(vtkNew sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_second(vtkNew sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_millisecond(vtkNew sself, unsigned long long time); +extern "C" unsigned long long vtk_time_point_utility_iso_8601_to_time_point(vtkNew sself, const char str, bool ok); +extern "C" const char* vtk_time_point_utility_time_point_to_iso_8601(vtkNew sself, unsigned long long p0, int format); extern "C" vtkNew < vtkTypeFloat32Array > vtkTypeFloat32Array_new () ; extern "C" void vtkTypeFloat32Array_destructor (vtkNew < vtkTypeFloat32Array > sself) ; extern "C" void * vtkTypeFloat32Array_get_ptr (vtkNew < vtkTypeFloat32Array > sself) ; @@ -358,33 +1256,182 @@ extern "C" void * vtkTypeUInt64Array_get_ptr (vtkNew < vtkTypeUInt64Array > ssel extern "C" vtkNew < vtkTypeUInt8Array > vtkTypeUInt8Array_new () ; extern "C" void vtkTypeUInt8Array_destructor (vtkNew < vtkTypeUInt8Array > sself) ; extern "C" void * vtkTypeUInt8Array_get_ptr (vtkNew < vtkTypeUInt8Array > sself) ; +extern "C" vtkNew < vtkUnicodeStringArray > vtkUnicodeStringArray_new () ; +extern "C" void vtkUnicodeStringArray_destructor (vtkNew < vtkUnicodeStringArray > sself) ; +extern "C" void * vtkUnicodeStringArray_get_ptr (vtkNew < vtkUnicodeStringArray > sself) ; +extern "C" int vtk_unicode_string_array_allocate(vtkNew sself, long long sz, long long ext); +extern "C" void vtk_unicode_string_array_initialize(vtkNew sself); +extern "C" int vtk_unicode_string_array_get_data_type(vtkNew sself); +extern "C" int vtk_unicode_string_array_get_data_type_size(vtkNew sself); +extern "C" int vtk_unicode_string_array_get_element_component_size(vtkNew sself); +extern "C" void vtk_unicode_string_array_set_number_of_tuples(vtkNew sself, long long number); +extern "C" void* vtk_unicode_string_array_get_void_pointer(vtkNew sself, long long id); +extern "C" void vtk_unicode_string_array_squeeze(vtkNew sself); +extern "C" int vtk_unicode_string_array_resize(vtkNew sself, long long numTuples); +extern "C" void vtk_unicode_string_array_set_void_array(vtkNew sself, void array, long long size, int save); +extern "C" unsigned long vtk_unicode_string_array_get_actual_memory_size(vtkNew sself); +extern "C" int vtk_unicode_string_array_is_numeric(vtkNew sself); +extern "C" void vtk_unicode_string_array_data_changed(vtkNew sself); +extern "C" void vtk_unicode_string_array_clear_lookup(vtkNew sself); +extern "C" void vtk_unicode_string_array_insert_next_utf_8_value(vtkNew sself, const char p0); +extern "C" void vtk_unicode_string_array_set_utf_8_value(vtkNew sself, long long i, const char p1); +extern "C" const char* vtk_unicode_string_array_get_utf_8_value(vtkNew sself, long long i); extern "C" vtkNew < vtkUnsignedCharArray > vtkUnsignedCharArray_new () ; extern "C" void vtkUnsignedCharArray_destructor (vtkNew < vtkUnsignedCharArray > sself) ; extern "C" void * vtkUnsignedCharArray_get_ptr (vtkNew < vtkUnsignedCharArray > sself) ; +extern "C" int vtk_unsigned_char_array_get_data_type(vtkNew sself); +extern "C" void vtk_unsigned_char_array_get_typed_tuple(vtkNew sself, long long i, unsigned char tuple); +extern "C" void vtk_unsigned_char_array_set_typed_tuple(vtkNew sself, long long i, const unsigned char tuple); +extern "C" void vtk_unsigned_char_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned char tuple); +extern "C" long long vtk_unsigned_char_array_insert_next_typed_tuple(vtkNew sself, const unsigned char tuple); +extern "C" unsigned char vtk_unsigned_char_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_unsigned_char_array_set_value(vtkNew sself, long long id, unsigned char value); +extern "C" bool vtk_unsigned_char_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_unsigned_char_array_insert_value(vtkNew sself, long long id, unsigned char f); +extern "C" long long vtk_unsigned_char_array_insert_next_value(vtkNew sself, unsigned char f); +extern "C" unsigned char* vtk_unsigned_char_array_get_value_range(vtkNew sself, int comp); +extern "C" unsigned char* vtk_unsigned_char_array_get_value_range(vtkNew sself); +extern "C" unsigned char* vtk_unsigned_char_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" unsigned char* vtk_unsigned_char_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_unsigned_char_array_set_array(vtkNew sself, unsigned char array, long long size, int save); +extern "C" void vtk_unsigned_char_array_set_array(vtkNew sself, unsigned char array, long long size, int save, int deleteMethod); +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_min(vtkNew sself); +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkUnsignedIntArray > vtkUnsignedIntArray_new () ; extern "C" void vtkUnsignedIntArray_destructor (vtkNew < vtkUnsignedIntArray > sself) ; extern "C" void * vtkUnsignedIntArray_get_ptr (vtkNew < vtkUnsignedIntArray > sself) ; +extern "C" int vtk_unsigned_int_array_get_data_type(vtkNew sself); +extern "C" void vtk_unsigned_int_array_get_typed_tuple(vtkNew sself, long long i, unsigned int tuple); +extern "C" void vtk_unsigned_int_array_set_typed_tuple(vtkNew sself, long long i, const unsigned int tuple); +extern "C" void vtk_unsigned_int_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned int tuple); +extern "C" long long vtk_unsigned_int_array_insert_next_typed_tuple(vtkNew sself, const unsigned int tuple); +extern "C" unsigned int vtk_unsigned_int_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_unsigned_int_array_set_value(vtkNew sself, long long id, unsigned int value); +extern "C" bool vtk_unsigned_int_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_unsigned_int_array_insert_value(vtkNew sself, long long id, unsigned int f); +extern "C" long long vtk_unsigned_int_array_insert_next_value(vtkNew sself, unsigned int f); +extern "C" unsigned int* vtk_unsigned_int_array_get_value_range(vtkNew sself, int comp); +extern "C" unsigned int* vtk_unsigned_int_array_get_value_range(vtkNew sself); +extern "C" unsigned int* vtk_unsigned_int_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" unsigned int* vtk_unsigned_int_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_unsigned_int_array_set_array(vtkNew sself, unsigned int array, long long size, int save); +extern "C" void vtk_unsigned_int_array_set_array(vtkNew sself, unsigned int array, long long size, int save, int deleteMethod); +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_min(vtkNew sself); +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkUnsignedLongArray > vtkUnsignedLongArray_new () ; extern "C" void vtkUnsignedLongArray_destructor (vtkNew < vtkUnsignedLongArray > sself) ; extern "C" void * vtkUnsignedLongArray_get_ptr (vtkNew < vtkUnsignedLongArray > sself) ; +extern "C" int vtk_unsigned_long_array_get_data_type(vtkNew sself); +extern "C" void vtk_unsigned_long_array_get_typed_tuple(vtkNew sself, long long i, unsigned long tuple); +extern "C" void vtk_unsigned_long_array_set_typed_tuple(vtkNew sself, long long i, const unsigned long tuple); +extern "C" void vtk_unsigned_long_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned long tuple); +extern "C" long long vtk_unsigned_long_array_insert_next_typed_tuple(vtkNew sself, const unsigned long tuple); +extern "C" unsigned long vtk_unsigned_long_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_unsigned_long_array_set_value(vtkNew sself, long long id, unsigned long value); +extern "C" bool vtk_unsigned_long_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_unsigned_long_array_insert_value(vtkNew sself, long long id, unsigned long f); +extern "C" long long vtk_unsigned_long_array_insert_next_value(vtkNew sself, unsigned long f); +extern "C" unsigned long* vtk_unsigned_long_array_get_value_range(vtkNew sself, int comp); +extern "C" unsigned long* vtk_unsigned_long_array_get_value_range(vtkNew sself); +extern "C" unsigned long* vtk_unsigned_long_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" unsigned long* vtk_unsigned_long_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_unsigned_long_array_set_array(vtkNew sself, unsigned long array, long long size, int save); +extern "C" void vtk_unsigned_long_array_set_array(vtkNew sself, unsigned long array, long long size, int save, int deleteMethod); +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_min(vtkNew sself); +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkUnsignedLongLongArray > vtkUnsignedLongLongArray_new () ; extern "C" void vtkUnsignedLongLongArray_destructor (vtkNew < vtkUnsignedLongLongArray > sself) ; extern "C" void * vtkUnsignedLongLongArray_get_ptr (vtkNew < vtkUnsignedLongLongArray > sself) ; +extern "C" int vtk_unsigned_long_long_array_get_data_type(vtkNew sself); +extern "C" void vtk_unsigned_long_long_array_get_typed_tuple(vtkNew sself, long long i, unsigned long long tuple); +extern "C" void vtk_unsigned_long_long_array_set_typed_tuple(vtkNew sself, long long i, const unsigned long long tuple); +extern "C" void vtk_unsigned_long_long_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned long long tuple); +extern "C" long long vtk_unsigned_long_long_array_insert_next_typed_tuple(vtkNew sself, const unsigned long long tuple); +extern "C" unsigned long long vtk_unsigned_long_long_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_unsigned_long_long_array_set_value(vtkNew sself, long long id, unsigned long long value); +extern "C" bool vtk_unsigned_long_long_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_unsigned_long_long_array_insert_value(vtkNew sself, long long id, unsigned long long f); +extern "C" long long vtk_unsigned_long_long_array_insert_next_value(vtkNew sself, unsigned long long f); +extern "C" unsigned long long* vtk_unsigned_long_long_array_get_value_range(vtkNew sself, int comp); +extern "C" unsigned long long* vtk_unsigned_long_long_array_get_value_range(vtkNew sself); +extern "C" unsigned long long* vtk_unsigned_long_long_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" unsigned long long* vtk_unsigned_long_long_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_unsigned_long_long_array_set_array(vtkNew sself, unsigned long long array, long long size, int save); +extern "C" void vtk_unsigned_long_long_array_set_array(vtkNew sself, unsigned long long array, long long size, int save, int deleteMethod); +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_min(vtkNew sself); +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkUnsignedShortArray > vtkUnsignedShortArray_new () ; extern "C" void vtkUnsignedShortArray_destructor (vtkNew < vtkUnsignedShortArray > sself) ; extern "C" void * vtkUnsignedShortArray_get_ptr (vtkNew < vtkUnsignedShortArray > sself) ; +extern "C" int vtk_unsigned_short_array_get_data_type(vtkNew sself); +extern "C" void vtk_unsigned_short_array_get_typed_tuple(vtkNew sself, long long i, unsigned short tuple); +extern "C" void vtk_unsigned_short_array_set_typed_tuple(vtkNew sself, long long i, const unsigned short tuple); +extern "C" void vtk_unsigned_short_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned short tuple); +extern "C" long long vtk_unsigned_short_array_insert_next_typed_tuple(vtkNew sself, const unsigned short tuple); +extern "C" unsigned short vtk_unsigned_short_array_get_value(vtkNew sself, long long id); +extern "C" void vtk_unsigned_short_array_set_value(vtkNew sself, long long id, unsigned short value); +extern "C" bool vtk_unsigned_short_array_set_number_of_values(vtkNew sself, long long number); +extern "C" void vtk_unsigned_short_array_insert_value(vtkNew sself, long long id, unsigned short f); +extern "C" long long vtk_unsigned_short_array_insert_next_value(vtkNew sself, unsigned short f); +extern "C" unsigned short* vtk_unsigned_short_array_get_value_range(vtkNew sself, int comp); +extern "C" unsigned short* vtk_unsigned_short_array_get_value_range(vtkNew sself); +extern "C" unsigned short* vtk_unsigned_short_array_write_pointer(vtkNew sself, long long id, long long number); +extern "C" unsigned short* vtk_unsigned_short_array_get_pointer(vtkNew sself, long long id); +extern "C" void vtk_unsigned_short_array_set_array(vtkNew sself, unsigned short array, long long size, int save); +extern "C" void vtk_unsigned_short_array_set_array(vtkNew sself, unsigned short array, long long size, int save, int deleteMethod); +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_min(vtkNew sself); +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_max(vtkNew sself); extern "C" vtkNew < vtkVariantArray > vtkVariantArray_new () ; extern "C" void vtkVariantArray_destructor (vtkNew < vtkVariantArray > sself) ; extern "C" void * vtkVariantArray_get_ptr (vtkNew < vtkVariantArray > sself) ; +extern "C" int vtk_variant_array_allocate(vtkNew sself, long long sz, long long ext); +extern "C" void vtk_variant_array_initialize(vtkNew sself); +extern "C" int vtk_variant_array_get_data_type(vtkNew sself); +extern "C" int vtk_variant_array_get_data_type_size(vtkNew sself); +extern "C" int vtk_variant_array_get_element_component_size(vtkNew sself); +extern "C" void vtk_variant_array_set_number_of_tuples(vtkNew sself, long long number); +extern "C" void* vtk_variant_array_get_void_pointer(vtkNew sself, long long id); +extern "C" void vtk_variant_array_squeeze(vtkNew sself); +extern "C" int vtk_variant_array_resize(vtkNew sself, long long numTuples); +extern "C" void vtk_variant_array_set_void_array(vtkNew sself, void arr, long long size, int save); +extern "C" void vtk_variant_array_set_void_array(vtkNew sself, void arr, long long size, int save, int deleteM); +extern "C" unsigned long vtk_variant_array_get_actual_memory_size(vtkNew sself); +extern "C" int vtk_variant_array_is_numeric(vtkNew sself); +extern "C" long long vtk_variant_array_get_number_of_values(vtkNew sself); +extern "C" void vtk_variant_array_data_changed(vtkNew sself); +extern "C" void vtk_variant_array_data_element_changed(vtkNew sself, long long id); +extern "C" void vtk_variant_array_clear_lookup(vtkNew sself); extern "C" vtkNew < vtkVersion > vtkVersion_new () ; extern "C" void vtkVersion_destructor (vtkNew < vtkVersion > sself) ; extern "C" void * vtkVersion_get_ptr (vtkNew < vtkVersion > sself) ; +extern "C" const char* vtk_version_get_vtk_version(vtkNew sself); +extern "C" const char* vtk_version_get_vtk_version_full(vtkNew sself); +extern "C" int vtk_version_get_vtk_major_version(vtkNew sself); +extern "C" int vtk_version_get_vtk_minor_version(vtkNew sself); +extern "C" int vtk_version_get_vtk_build_version(vtkNew sself); +extern "C" const char* vtk_version_get_vtk_source_version(vtkNew sself); extern "C" vtkNew < vtkVoidArray > vtkVoidArray_new () ; extern "C" void vtkVoidArray_destructor (vtkNew < vtkVoidArray > sself) ; extern "C" void * vtkVoidArray_get_ptr (vtkNew < vtkVoidArray > sself) ; +extern "C" int vtk_void_array_allocate(vtkNew sself, long long sz, long long ext); +extern "C" void vtk_void_array_initialize(vtkNew sself); +extern "C" int vtk_void_array_get_data_type(vtkNew sself); +extern "C" int vtk_void_array_get_data_type_size(vtkNew sself); +extern "C" void vtk_void_array_set_number_of_pointers(vtkNew sself, long long number); +extern "C" long long vtk_void_array_get_number_of_pointers(vtkNew sself); +extern "C" void* vtk_void_array_get_void_pointer(vtkNew sself, long long id); +extern "C" void vtk_void_array_set_void_pointer(vtkNew sself, long long id, void ptr); +extern "C" void vtk_void_array_insert_void_pointer(vtkNew sself, long long i, void ptr); +extern "C" long long vtk_void_array_insert_next_void_pointer(vtkNew sself, void tuple); +extern "C" void vtk_void_array_reset(vtkNew sself); +extern "C" void vtk_void_array_squeeze(vtkNew sself); +extern "C" void&* vtk_void_array_get_pointer(vtkNew sself, long long id); +extern "C" void&* vtk_void_array_write_pointer(vtkNew sself, long long id, long long number); extern "C" vtkNew < vtkWeakReference > vtkWeakReference_new () ; extern "C" void vtkWeakReference_destructor (vtkNew < vtkWeakReference > sself) ; extern "C" void * vtkWeakReference_get_ptr (vtkNew < vtkWeakReference > sself) ; extern "C" vtkNew < vtkXMLFileOutputWindow > vtkXMLFileOutputWindow_new () ; extern "C" void vtkXMLFileOutputWindow_destructor (vtkNew < vtkXMLFileOutputWindow > sself) ; extern "C" void * vtkXMLFileOutputWindow_get_ptr (vtkNew < vtkXMLFileOutputWindow > sself) ; +extern "C" void vtk_xml_file_output_window_display_text(vtkNew sself, const char p0); +extern "C" void vtk_xml_file_output_window_display_tag(vtkNew sself, const char p0); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h index 3e7878d..4cf9ada 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h @@ -44,7 +44,6 @@ #include #include #include -#include #include #include #include @@ -60,7 +59,6 @@ #include #include #include -#include #include #include #include @@ -230,7 +228,6 @@ #include #include #include -#include #include #include #include @@ -285,138 +282,597 @@ extern "C" vtkNew < vtkAMRDataInternals > vtkAMRDataInternals_new () ; extern "C" void vtkAMRDataInternals_destructor (vtkNew < vtkAMRDataInternals > sself) ; extern "C" void * vtkAMRDataInternals_get_ptr (vtkNew < vtkAMRDataInternals > sself) ; +extern "C" void vtk_amr_data_internals_initialize(vtkNew sself); +extern "C" bool vtk_amr_data_internals_empty(vtkNew sself); +extern "C" unsigned int vtk_amr_data_internals_get_number_of_blocks(vtkNew sself); extern "C" vtkNew < vtkAdjacentVertexIterator > vtkAdjacentVertexIterator_new () ; extern "C" void vtkAdjacentVertexIterator_destructor (vtkNew < vtkAdjacentVertexIterator > sself) ; extern "C" void * vtkAdjacentVertexIterator_get_ptr (vtkNew < vtkAdjacentVertexIterator > sself) ; +extern "C" long long vtk_adjacent_vertex_iterator_get_vertex(vtkNew sself); +extern "C" long long vtk_adjacent_vertex_iterator_next(vtkNew sself); +extern "C" bool vtk_adjacent_vertex_iterator_has_next(vtkNew sself); extern "C" vtkNew < vtkAnimationScene > vtkAnimationScene_new () ; extern "C" void vtkAnimationScene_destructor (vtkNew < vtkAnimationScene > sself) ; extern "C" void * vtkAnimationScene_get_ptr (vtkNew < vtkAnimationScene > sself) ; +extern "C" void vtk_animation_scene_set_play_mode(vtkNew sself, int _arg); +extern "C" void vtk_animation_scene_set_mode_to_sequence(vtkNew sself); +extern "C" void vtk_animation_scene_set_mode_to_real_time(vtkNew sself); +extern "C" int vtk_animation_scene_get_play_mode(vtkNew sself); +extern "C" void vtk_animation_scene_set_frame_rate(vtkNew sself, double _arg); +extern "C" double vtk_animation_scene_get_frame_rate(vtkNew sself); +extern "C" void vtk_animation_scene_remove_all_cues(vtkNew sself); +extern "C" int vtk_animation_scene_get_number_of_cues(vtkNew sself); +extern "C" void vtk_animation_scene_play(vtkNew sself); +extern "C" void vtk_animation_scene_stop(vtkNew sself); +extern "C" void vtk_animation_scene_set_loop(vtkNew sself, int _arg); +extern "C" int vtk_animation_scene_get_loop(vtkNew sself); +extern "C" void vtk_animation_scene_set_animation_time(vtkNew sself, double time); +extern "C" void vtk_animation_scene_set_time_mode(vtkNew sself, int mode); +extern "C" int vtk_animation_scene_is_in_play(vtkNew sself); extern "C" vtkNew < vtkAnnotation > vtkAnnotation_new () ; extern "C" void vtkAnnotation_destructor (vtkNew < vtkAnnotation > sself) ; extern "C" void * vtkAnnotation_get_ptr (vtkNew < vtkAnnotation > sself) ; +extern "C" int vtk_annotation_get_data_object_type(vtkNew sself); +extern "C" void vtk_annotation_initialize(vtkNew sself); +extern "C" unsigned long vtk_annotation_get_m_time(vtkNew sself); extern "C" vtkNew < vtkAnnotationLayers > vtkAnnotationLayers_new () ; extern "C" void vtkAnnotationLayers_destructor (vtkNew < vtkAnnotationLayers > sself) ; extern "C" void * vtkAnnotationLayers_get_ptr (vtkNew < vtkAnnotationLayers > sself) ; +extern "C" int vtk_annotation_layers_get_data_object_type(vtkNew sself); +extern "C" unsigned int vtk_annotation_layers_get_number_of_annotations(vtkNew sself); +extern "C" void vtk_annotation_layers_initialize(vtkNew sself); +extern "C" unsigned long vtk_annotation_layers_get_m_time(vtkNew sself); extern "C" vtkNew < vtkArrayData > vtkArrayData_new () ; extern "C" void vtkArrayData_destructor (vtkNew < vtkArrayData > sself) ; extern "C" void * vtkArrayData_get_ptr (vtkNew < vtkArrayData > sself) ; +extern "C" void vtk_array_data_clear_arrays(vtkNew sself); +extern "C" long long vtk_array_data_get_number_of_arrays(vtkNew sself); +extern "C" int vtk_array_data_get_data_object_type(vtkNew sself); extern "C" vtkNew < vtkAttributesErrorMetric > vtkAttributesErrorMetric_new () ; extern "C" void vtkAttributesErrorMetric_destructor (vtkNew < vtkAttributesErrorMetric > sself) ; extern "C" void * vtkAttributesErrorMetric_get_ptr (vtkNew < vtkAttributesErrorMetric > sself) ; +extern "C" double vtk_attributes_error_metric_get_absolute_attribute_tolerance(vtkNew sself); +extern "C" void vtk_attributes_error_metric_set_absolute_attribute_tolerance(vtkNew sself, double value); +extern "C" double vtk_attributes_error_metric_get_attribute_tolerance(vtkNew sself); +extern "C" void vtk_attributes_error_metric_set_attribute_tolerance(vtkNew sself, double value); +extern "C" int vtk_attributes_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); +extern "C" double vtk_attributes_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); extern "C" vtkNew < vtkBSPCuts > vtkBSPCuts_new () ; extern "C" void vtkBSPCuts_destructor (vtkNew < vtkBSPCuts > sself) ; extern "C" void * vtkBSPCuts_get_ptr (vtkNew < vtkBSPCuts > sself) ; +extern "C" int vtk_bsp_cuts_get_data_object_type(vtkNew sself); +extern "C" void vtk_bsp_cuts_create_cuts(vtkNew sself, double bounds, int ncuts, int dim, double coord, int lower, int upper, double lowerDataCoord, double upperDataCoord, int npoints); +extern "C" int vtk_bsp_cuts_get_number_of_cuts(vtkNew sself); +extern "C" int vtk_bsp_cuts_get_arrays(vtkNew sself, int len, int dim, double coord, int lower, int upper, double lowerDataCoord, double upperDataCoord, int npoints); +extern "C" void vtk_bsp_cuts_print_tree(vtkNew sself); +extern "C" void vtk_bsp_cuts_print_arrays(vtkNew sself); extern "C" vtkNew < vtkBSPIntersections > vtkBSPIntersections_new () ; extern "C" void vtkBSPIntersections_destructor (vtkNew < vtkBSPIntersections > sself) ; extern "C" void * vtkBSPIntersections_get_ptr (vtkNew < vtkBSPIntersections > sself) ; +extern "C" int vtk_bsp_intersections_get_bounds(vtkNew sself, double bounds); +extern "C" int vtk_bsp_intersections_get_number_of_regions(vtkNew sself); +extern "C" int vtk_bsp_intersections_get_region_bounds(vtkNew sself, int regionID, double bounds); +extern "C" int vtk_bsp_intersections_get_region_data_bounds(vtkNew sself, int regionID, double bounds); +extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int regionId, double x); +extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int regionId, double x0, double x1, double y0, double y1, double z0, double z1); +extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int ids, int len, double x); +extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int ids, int len, double x0, double x1, double y0, double y1, double z0, double z1); +extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkNew sself, int regionId, double x, double y, double z, double rSquared); +extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkNew sself, int ids, int len, double x, double y, double z, double rSquared); +extern "C" int vtk_bsp_intersections_get_compute_intersections_using_data_bounds(vtkNew sself); +extern "C" void vtk_bsp_intersections_set_compute_intersections_using_data_bounds(vtkNew sself, int c); +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_on(vtkNew sself); +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_off(vtkNew sself); extern "C" vtkNew < vtkBezierCurve > vtkBezierCurve_new () ; extern "C" void vtkBezierCurve_destructor (vtkNew < vtkBezierCurve > sself) ; extern "C" void * vtkBezierCurve_get_ptr (vtkNew < vtkBezierCurve > sself) ; +extern "C" int vtk_bezier_curve_get_cell_type(vtkNew sself); +extern "C" void vtk_bezier_curve_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); +extern "C" void vtk_bezier_curve_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkBezierHexahedron > vtkBezierHexahedron_new () ; extern "C" void vtkBezierHexahedron_destructor (vtkNew < vtkBezierHexahedron > sself) ; extern "C" void * vtkBezierHexahedron_get_ptr (vtkNew < vtkBezierHexahedron > sself) ; +extern "C" int vtk_bezier_hexahedron_get_cell_type(vtkNew sself); +extern "C" void vtk_bezier_hexahedron_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); +extern "C" void vtk_bezier_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkBezierInterpolation > vtkBezierInterpolation_new () ; extern "C" void vtkBezierInterpolation_destructor (vtkNew < vtkBezierInterpolation > sself) ; extern "C" void * vtkBezierInterpolation_get_ptr (vtkNew < vtkBezierInterpolation > sself) ; +extern "C" void vtk_bezier_interpolation_de_casteljau_simplex(vtkNew sself, const int dim, const int deg, const double pcoords, double weights); +extern "C" void vtk_bezier_interpolation_de_casteljau_simplex(vtkNew sself, const int dim, const int deg, const double pcoords, double weights); +extern "C" void vtk_bezier_interpolation_de_casteljau_simplex_deriv(vtkNew sself, const int dim, const int deg, const double pcoords, double weights); +extern "C" void vtk_bezier_interpolation_de_casteljau_simplex_deriv(vtkNew sself, const int dim, const int deg, const double pcoords, double weights); +extern "C" void vtk_bezier_interpolation_evaluate_shape_functions(vtkNew sself, int order, double pcoord, double shape); +extern "C" void vtk_bezier_interpolation_evaluate_shape_and_gradient(vtkNew sself, int order, double pcoord, double shape, double grad); +extern "C" int vtk_bezier_interpolation_tensor_1_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); +extern "C" int vtk_bezier_interpolation_tensor_1_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); +extern "C" int vtk_bezier_interpolation_tensor_2_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); +extern "C" int vtk_bezier_interpolation_tensor_2_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); +extern "C" int vtk_bezier_interpolation_tensor_3_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); +extern "C" int vtk_bezier_interpolation_tensor_3_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); +extern "C" void vtk_bezier_interpolation_wedge_shape_functions(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double shape); +extern "C" void vtk_bezier_interpolation_wedge_shape_derivatives(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double derivs); +extern "C" void vtk_bezier_interpolation_wedge_evaluate(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double fieldVals, int fieldDim, double fieldAtPCoords); extern "C" vtkNew < vtkBezierQuadrilateral > vtkBezierQuadrilateral_new () ; extern "C" void vtkBezierQuadrilateral_destructor (vtkNew < vtkBezierQuadrilateral > sself) ; extern "C" void * vtkBezierQuadrilateral_get_ptr (vtkNew < vtkBezierQuadrilateral > sself) ; +extern "C" int vtk_bezier_quadrilateral_get_cell_type(vtkNew sself); +extern "C" void vtk_bezier_quadrilateral_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); +extern "C" void vtk_bezier_quadrilateral_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkBezierTetra > vtkBezierTetra_new () ; extern "C" void vtkBezierTetra_destructor (vtkNew < vtkBezierTetra > sself) ; extern "C" void * vtkBezierTetra_get_ptr (vtkNew < vtkBezierTetra > sself) ; +extern "C" int vtk_bezier_tetra_get_cell_type(vtkNew sself); +extern "C" void vtk_bezier_tetra_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); +extern "C" void vtk_bezier_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkBezierTriangle > vtkBezierTriangle_new () ; extern "C" void vtkBezierTriangle_destructor (vtkNew < vtkBezierTriangle > sself) ; extern "C" void * vtkBezierTriangle_get_ptr (vtkNew < vtkBezierTriangle > sself) ; +extern "C" int vtk_bezier_triangle_get_cell_type(vtkNew sself); +extern "C" void vtk_bezier_triangle_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); +extern "C" void vtk_bezier_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkBezierWedge > vtkBezierWedge_new () ; extern "C" void vtkBezierWedge_destructor (vtkNew < vtkBezierWedge > sself) ; extern "C" void * vtkBezierWedge_get_ptr (vtkNew < vtkBezierWedge > sself) ; +extern "C" int vtk_bezier_wedge_get_cell_type(vtkNew sself); +extern "C" void vtk_bezier_wedge_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); +extern "C" void vtk_bezier_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkBiQuadraticQuad > vtkBiQuadraticQuad_new () ; extern "C" void vtkBiQuadraticQuad_destructor (vtkNew < vtkBiQuadraticQuad > sself) ; extern "C" void * vtkBiQuadraticQuad_get_ptr (vtkNew < vtkBiQuadraticQuad > sself) ; +extern "C" int vtk_bi_quadratic_quad_get_cell_type(vtkNew sself); +extern "C" int vtk_bi_quadratic_quad_get_cell_dimension(vtkNew sself); +extern "C" int vtk_bi_quadratic_quad_get_number_of_edges(vtkNew sself); +extern "C" int vtk_bi_quadratic_quad_get_number_of_faces(vtkNew sself); +extern "C" int vtk_bi_quadratic_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_bi_quadratic_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_bi_quadratic_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_bi_quadratic_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_bi_quadratic_quad_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_bi_quadratic_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_bi_quadratic_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); extern "C" vtkNew < vtkBiQuadraticQuadraticHexahedron > vtkBiQuadraticQuadraticHexahedron_new () ; extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) ; extern "C" void * vtkBiQuadraticQuadraticHexahedron_get_ptr (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) ; +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(vtkNew sself); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(vtkNew sself); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(vtkNew sself); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(vtkNew sself); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_bi_quadratic_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_bi_quadratic_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId); +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkBiQuadraticQuadraticWedge > vtkBiQuadraticQuadraticWedge_new () ; extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkNew < vtkBiQuadraticQuadraticWedge > sself) ; extern "C" void * vtkBiQuadraticQuadraticWedge_get_ptr (vtkNew < vtkBiQuadraticQuadraticWedge > sself) ; +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_type(vtkNew sself); +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(vtkNew sself); +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(vtkNew sself); +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(vtkNew sself); +extern "C" int vtk_bi_quadratic_quadratic_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_bi_quadratic_quadratic_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_bi_quadratic_quadratic_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_bi_quadratic_quadratic_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_bi_quadratic_quadratic_wedge_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_bi_quadratic_quadratic_wedge_get_face_array(vtkNew sself, long long faceId); +extern "C" void vtk_bi_quadratic_quadratic_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkBiQuadraticTriangle > vtkBiQuadraticTriangle_new () ; extern "C" void vtkBiQuadraticTriangle_destructor (vtkNew < vtkBiQuadraticTriangle > sself) ; extern "C" void * vtkBiQuadraticTriangle_get_ptr (vtkNew < vtkBiQuadraticTriangle > sself) ; +extern "C" int vtk_bi_quadratic_triangle_get_cell_type(vtkNew sself); +extern "C" int vtk_bi_quadratic_triangle_get_cell_dimension(vtkNew sself); +extern "C" int vtk_bi_quadratic_triangle_get_number_of_edges(vtkNew sself); +extern "C" int vtk_bi_quadratic_triangle_get_number_of_faces(vtkNew sself); +extern "C" int vtk_bi_quadratic_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_bi_quadratic_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_bi_quadratic_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_bi_quadratic_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_bi_quadratic_triangle_get_parametric_center(vtkNew sself, double pcoords); +extern "C" double vtk_bi_quadratic_triangle_get_parametric_distance(vtkNew sself, const double pcoords); +extern "C" void vtk_bi_quadratic_triangle_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_bi_quadratic_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_bi_quadratic_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_bi_quadratic_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); extern "C" vtkNew < vtkBox > vtkBox_new () ; extern "C" void vtkBox_destructor (vtkNew < vtkBox > sself) ; extern "C" void * vtkBox_get_ptr (vtkNew < vtkBox > sself) ; +extern "C" double vtk_box_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_box_evaluate_gradient(vtkNew sself, double x, double n); +extern "C" void vtk_box_set_x_min(vtkNew sself, double p); +extern "C" void vtk_box_set_x_min(vtkNew sself, double x, double y, double z); +extern "C" void vtk_box_get_x_min(vtkNew sself, double p); +extern "C" void vtk_box_get_x_min(vtkNew sself, double x, double y, double z); +extern "C" void vtk_box_set_x_max(vtkNew sself, double p); +extern "C" void vtk_box_set_x_max(vtkNew sself, double x, double y, double z); +extern "C" void vtk_box_get_x_max(vtkNew sself, double p); +extern "C" void vtk_box_get_x_max(vtkNew sself, double x, double y, double z); +extern "C" void vtk_box_set_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" void vtk_box_set_bounds(vtkNew sself, const double bounds); +extern "C" void vtk_box_get_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" void vtk_box_get_bounds(vtkNew sself, double bounds); +extern "C" double* vtk_box_get_bounds(vtkNew sself); +extern "C" void vtk_box_add_bounds(vtkNew sself, const double bounds); +extern "C" char vtk_box_intersect_box(vtkNew sself, const double bounds, const double origin, const double dir, double coord, double t, const double tolerance); +extern "C" int vtk_box_intersect_with_line(vtkNew sself, const double bounds, const double p1, const double p2, double t1, double t2, double x1, double x2, int plane1, int plane2); +extern "C" bool vtk_box_intersect_with_infinite_line(vtkNew sself, const double bounds, const double p1, const double p2, double t1, double t2, double x1, double x2, int plane1, int plane2); +extern "C" int vtk_box_intersect_with_plane(vtkNew sself, double bounds, double origin, double normal); +extern "C" int vtk_box_intersect_with_plane(vtkNew sself, double bounds, double origin, double normal, double xout); +extern "C" int vtk_box_is_box_in_frustum(vtkNew sself, double planes, double bounds); extern "C" vtkNew < vtkCellArray > vtkCellArray_new () ; extern "C" void vtkCellArray_destructor (vtkNew < vtkCellArray > sself) ; extern "C" void * vtkCellArray_get_ptr (vtkNew < vtkCellArray > sself) ; +extern "C" int vtk_cell_array_allocate(vtkNew sself, long long sz, long long ext); +extern "C" bool vtk_cell_array_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize); +extern "C" bool vtk_cell_array_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize); +extern "C" bool vtk_cell_array_resize_exact(vtkNew sself, long long numCells, long long connectivitySize); +extern "C" void vtk_cell_array_initialize(vtkNew sself); +extern "C" void vtk_cell_array_reset(vtkNew sself); +extern "C" void vtk_cell_array_squeeze(vtkNew sself); +extern "C" bool vtk_cell_array_is_valid(vtkNew sself); +extern "C" long long vtk_cell_array_get_number_of_cells(vtkNew sself); +extern "C" long long vtk_cell_array_get_number_of_offsets(vtkNew sself); +extern "C" long long vtk_cell_array_get_number_of_connectivity_ids(vtkNew sself); +extern "C" bool vtk_cell_array_is_storage_64_bit(vtkNew sself); +extern "C" bool vtk_cell_array_is_storage_shareable(vtkNew sself); +extern "C" void vtk_cell_array_use_32_bit_storage(vtkNew sself); +extern "C" void vtk_cell_array_use_64_bit_storage(vtkNew sself); +extern "C" void vtk_cell_array_use_default_storage(vtkNew sself); +extern "C" bool vtk_cell_array_can_convert_to_32_bit_storage(vtkNew sself); +extern "C" bool vtk_cell_array_can_convert_to_64_bit_storage(vtkNew sself); +extern "C" bool vtk_cell_array_can_convert_to_default_storage(vtkNew sself); +extern "C" bool vtk_cell_array_convert_to_32_bit_storage(vtkNew sself); +extern "C" bool vtk_cell_array_convert_to_64_bit_storage(vtkNew sself); +extern "C" bool vtk_cell_array_convert_to_default_storage(vtkNew sself); +extern "C" bool vtk_cell_array_convert_to_smallest_storage(vtkNew sself); +extern "C" long long vtk_cell_array_is_homogeneous(vtkNew sself); +extern "C" void vtk_cell_array_init_traversal(vtkNew sself); +extern "C" int vtk_cell_array_get_next_cell(vtkNew sself, long long npts, const long long pts); +extern "C" void vtk_cell_array_get_cell_at_id(vtkNew sself, long long cellId, long long cellSize, const long long cellPoints); +extern "C" long long vtk_cell_array_get_cell_size(vtkNew sself, const long long cellId); +extern "C" long long vtk_cell_array_insert_next_cell(vtkNew sself, long long npts, const long long pts); +extern "C" long long vtk_cell_array_insert_next_cell(vtkNew sself, int npts); +extern "C" void vtk_cell_array_insert_cell_point(vtkNew sself, long long id); +extern "C" void vtk_cell_array_update_cell_count(vtkNew sself, int npts); +extern "C" long long vtk_cell_array_get_traversal_cell_id(vtkNew sself); +extern "C" void vtk_cell_array_set_traversal_cell_id(vtkNew sself, long long cellId); +extern "C" void vtk_cell_array_reverse_cell_at_id(vtkNew sself, long long cellId); +extern "C" void vtk_cell_array_replace_cell_at_id(vtkNew sself, long long cellId, long long cellSize, const long long cellPoints); +extern "C" int vtk_cell_array_get_max_cell_size(vtkNew sself); +extern "C" void vtk_cell_array_import_legacy_format(vtkNew sself, const long long data, long long len); +extern "C" void vtk_cell_array_append_legacy_format(vtkNew sself, const long long data, long long len, long long ptOffset); +extern "C" unsigned long vtk_cell_array_get_actual_memory_size(vtkNew sself); +extern "C" void vtk_cell_array_set_number_of_cells(vtkNew sself, long long p0); +extern "C" long long vtk_cell_array_estimate_size(vtkNew sself, long long numCells, int maxPtsPerCell); +extern "C" long long vtk_cell_array_get_size(vtkNew sself); +extern "C" long long vtk_cell_array_get_number_of_connectivity_entries(vtkNew sself); +extern "C" void vtk_cell_array_get_cell(vtkNew sself, long long loc, long long npts, const long long pts); +extern "C" long long vtk_cell_array_get_insert_location(vtkNew sself, int npts); +extern "C" long long vtk_cell_array_get_traversal_location(vtkNew sself); +extern "C" long long vtk_cell_array_get_traversal_location(vtkNew sself, long long npts); +extern "C" void vtk_cell_array_set_traversal_location(vtkNew sself, long long loc); +extern "C" void vtk_cell_array_reverse_cell(vtkNew sself, long long loc); +extern "C" void vtk_cell_array_replace_cell(vtkNew sself, long long loc, int npts, const long long pts); extern "C" vtkNew < vtkCellArrayIterator > vtkCellArrayIterator_new () ; extern "C" void vtkCellArrayIterator_destructor (vtkNew < vtkCellArrayIterator > sself) ; extern "C" void * vtkCellArrayIterator_get_ptr (vtkNew < vtkCellArrayIterator > sself) ; +extern "C" void vtk_cell_array_iterator_go_to_cell(vtkNew sself, long long cellId); +extern "C" void vtk_cell_array_iterator_get_cell_at_id(vtkNew sself, long long cellId, long long numCellPts, const long long cellPts); +extern "C" void vtk_cell_array_iterator_go_to_first_cell(vtkNew sself); +extern "C" void vtk_cell_array_iterator_go_to_next_cell(vtkNew sself); +extern "C" bool vtk_cell_array_iterator_is_done_with_traversal(vtkNew sself); +extern "C" long long vtk_cell_array_iterator_get_current_cell_id(vtkNew sself); +extern "C" void vtk_cell_array_iterator_get_current_cell(vtkNew sself, long long cellSize, const long long cellPoints); +extern "C" void vtk_cell_array_iterator_replace_current_cell(vtkNew sself, long long npts, const long long pts); +extern "C" void vtk_cell_array_iterator_reverse_current_cell(vtkNew sself); extern "C" vtkNew < vtkCellData > vtkCellData_new () ; extern "C" void vtkCellData_destructor (vtkNew < vtkCellData > sself) ; extern "C" void * vtkCellData_get_ptr (vtkNew < vtkCellData > sself) ; extern "C" vtkNew < vtkCellLinks > vtkCellLinks_new () ; extern "C" void vtkCellLinks_destructor (vtkNew < vtkCellLinks > sself) ; extern "C" void * vtkCellLinks_get_ptr (vtkNew < vtkCellLinks > sself) ; +extern "C" void vtk_cell_links_allocate(vtkNew sself, long long numLinks, long long ext); +extern "C" void vtk_cell_links_initialize(vtkNew sself); +extern "C" long long vtk_cell_links_get_ncells(vtkNew sself, long long ptId); +extern "C" long long* vtk_cell_links_get_cells(vtkNew sself, long long ptId); +extern "C" void vtk_cell_links_select_cells(vtkNew sself, long long minMaxDegree, unsigned char cellSelection); +extern "C" long long vtk_cell_links_insert_next_point(vtkNew sself, int numLinks); +extern "C" void vtk_cell_links_insert_next_cell_reference(vtkNew sself, long long ptId, long long cellId); +extern "C" void vtk_cell_links_delete_point(vtkNew sself, long long ptId); +extern "C" void vtk_cell_links_remove_cell_reference(vtkNew sself, long long cellId, long long ptId); +extern "C" void vtk_cell_links_add_cell_reference(vtkNew sself, long long cellId, long long ptId); +extern "C" void vtk_cell_links_resize_cell_list(vtkNew sself, long long ptId, int size); +extern "C" void vtk_cell_links_squeeze(vtkNew sself); +extern "C" void vtk_cell_links_reset(vtkNew sself); +extern "C" unsigned long vtk_cell_links_get_actual_memory_size(vtkNew sself); extern "C" vtkNew < vtkCellLocator > vtkCellLocator_new () ; extern "C" void vtkCellLocator_destructor (vtkNew < vtkCellLocator > sself) ; extern "C" void * vtkCellLocator_get_ptr (vtkNew < vtkCellLocator > sself) ; +extern "C" void vtk_cell_locator_set_number_of_cells_per_bucket(vtkNew sself, int N); +extern "C" int vtk_cell_locator_get_number_of_cells_per_bucket(vtkNew sself); +extern "C" int vtk_cell_locator_get_number_of_buckets(vtkNew sself); +extern "C" void vtk_cell_locator_free_search_structure(vtkNew sself); +extern "C" void vtk_cell_locator_build_locator(vtkNew sself); +extern "C" void vtk_cell_locator_build_locator_if_needed(vtkNew sself); +extern "C" void vtk_cell_locator_force_build_locator(vtkNew sself); +extern "C" void vtk_cell_locator_build_locator_internal(vtkNew sself); extern "C" vtkNew < vtkCellLocatorStrategy > vtkCellLocatorStrategy_new () ; extern "C" void vtkCellLocatorStrategy_destructor (vtkNew < vtkCellLocatorStrategy > sself) ; extern "C" void * vtkCellLocatorStrategy_get_ptr (vtkNew < vtkCellLocatorStrategy > sself) ; -extern "C" vtkNew < vtkCellTreeLocator > vtkCellTreeLocator_new () ; -extern "C" void vtkCellTreeLocator_destructor (vtkNew < vtkCellTreeLocator > sself) ; -extern "C" void * vtkCellTreeLocator_get_ptr (vtkNew < vtkCellTreeLocator > sself) ; extern "C" vtkNew < vtkCellTypes > vtkCellTypes_new () ; extern "C" void vtkCellTypes_destructor (vtkNew < vtkCellTypes > sself) ; extern "C" void * vtkCellTypes_get_ptr (vtkNew < vtkCellTypes > sself) ; +extern "C" int vtk_cell_types_allocate(vtkNew sself, long long sz, long long ext); +extern "C" void vtk_cell_types_insert_cell(vtkNew sself, long long id, unsigned char type, long long loc); +extern "C" long long vtk_cell_types_insert_next_cell(vtkNew sself, unsigned char type, long long loc); +extern "C" long long vtk_cell_types_get_cell_location(vtkNew sself, long long cellId); +extern "C" void vtk_cell_types_delete_cell(vtkNew sself, long long cellId); +extern "C" long long vtk_cell_types_get_number_of_types(vtkNew sself); +extern "C" int vtk_cell_types_is_type(vtkNew sself, unsigned char type); +extern "C" long long vtk_cell_types_insert_next_type(vtkNew sself, unsigned char type); +extern "C" unsigned char vtk_cell_types_get_cell_type(vtkNew sself, long long cellId); +extern "C" void vtk_cell_types_squeeze(vtkNew sself); +extern "C" void vtk_cell_types_reset(vtkNew sself); +extern "C" unsigned long vtk_cell_types_get_actual_memory_size(vtkNew sself); +extern "C" const char* vtk_cell_types_get_class_name_from_type_id(vtkNew sself, int typeId); +extern "C" int vtk_cell_types_get_type_id_from_class_name(vtkNew sself, const char classname); +extern "C" int vtk_cell_types_is_linear(vtkNew sself, unsigned char type); extern "C" vtkNew < vtkClosestNPointsStrategy > vtkClosestNPointsStrategy_new () ; extern "C" void vtkClosestNPointsStrategy_destructor (vtkNew < vtkClosestNPointsStrategy > sself) ; extern "C" void * vtkClosestNPointsStrategy_get_ptr (vtkNew < vtkClosestNPointsStrategy > sself) ; +extern "C" void vtk_closest_n_points_strategy_set_closest_n_points(vtkNew sself, int _arg); +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_min_value(vtkNew sself); +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_max_value(vtkNew sself); +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points(vtkNew sself); extern "C" vtkNew < vtkClosestPointStrategy > vtkClosestPointStrategy_new () ; extern "C" void vtkClosestPointStrategy_destructor (vtkNew < vtkClosestPointStrategy > sself) ; extern "C" void * vtkClosestPointStrategy_get_ptr (vtkNew < vtkClosestPointStrategy > sself) ; extern "C" vtkNew < vtkCone > vtkCone_new () ; extern "C" void vtkCone_destructor (vtkNew < vtkCone > sself) ; extern "C" void * vtkCone_get_ptr (vtkNew < vtkCone > sself) ; +extern "C" double vtk_cone_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_cone_evaluate_gradient(vtkNew sself, double x, double g); +extern "C" void vtk_cone_set_angle(vtkNew sself, double _arg); +extern "C" double vtk_cone_get_angle_min_value(vtkNew sself); +extern "C" double vtk_cone_get_angle_max_value(vtkNew sself); +extern "C" double vtk_cone_get_angle(vtkNew sself); extern "C" vtkNew < vtkConvexPointSet > vtkConvexPointSet_new () ; extern "C" void vtkConvexPointSet_destructor (vtkNew < vtkConvexPointSet > sself) ; extern "C" void * vtkConvexPointSet_get_ptr (vtkNew < vtkConvexPointSet > sself) ; -extern "C" vtkNew < vtkCoordinateFrame > vtkCoordinateFrame_new () ; -extern "C" void vtkCoordinateFrame_destructor (vtkNew < vtkCoordinateFrame > sself) ; -extern "C" void * vtkCoordinateFrame_get_ptr (vtkNew < vtkCoordinateFrame > sself) ; +extern "C" int vtk_convex_point_set_has_fixed_topology(vtkNew sself); +extern "C" void vtk_convex_point_set_get_edge_points(vtkNew sself, long long edgeId, const long long pts); +extern "C" void vtk_convex_point_set_get_edge_points(vtkNew sself, int edgeId, int pts); +extern "C" long long vtk_convex_point_set_get_face_points(vtkNew sself, long long faceId, const long long pts); +extern "C" void vtk_convex_point_set_get_face_points(vtkNew sself, int faceId, int pts); +extern "C" void vtk_convex_point_set_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); +extern "C" long long vtk_convex_point_set_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); +extern "C" long long vtk_convex_point_set_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); +extern "C" long long vtk_convex_point_set_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); +extern "C" long long vtk_convex_point_set_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); +extern "C" bool vtk_convex_point_set_get_centroid(vtkNew sself, double centroid); +extern "C" double* vtk_convex_point_set_get_parametric_coords(vtkNew sself); +extern "C" int vtk_convex_point_set_get_cell_type(vtkNew sself); +extern "C" int vtk_convex_point_set_requires_initialization(vtkNew sself); +extern "C" int vtk_convex_point_set_get_number_of_edges(vtkNew sself); +extern "C" int vtk_convex_point_set_get_number_of_faces(vtkNew sself); +extern "C" int vtk_convex_point_set_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_convex_point_set_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_convex_point_set_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_convex_point_set_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_convex_point_set_get_parametric_center(vtkNew sself, double pcoords); +extern "C" int vtk_convex_point_set_is_primary_cell(vtkNew sself); +extern "C" void vtk_convex_point_set_interpolate_functions(vtkNew sself, const double pcoords, double sf); extern "C" vtkNew < vtkCubicLine > vtkCubicLine_new () ; extern "C" void vtkCubicLine_destructor (vtkNew < vtkCubicLine > sself) ; extern "C" void * vtkCubicLine_get_ptr (vtkNew < vtkCubicLine > sself) ; +extern "C" int vtk_cubic_line_get_cell_type(vtkNew sself); +extern "C" int vtk_cubic_line_get_cell_dimension(vtkNew sself); +extern "C" int vtk_cubic_line_get_number_of_edges(vtkNew sself); +extern "C" int vtk_cubic_line_get_number_of_faces(vtkNew sself); +extern "C" int vtk_cubic_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_cubic_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_cubic_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" double vtk_cubic_line_get_parametric_distance(vtkNew sself, const double pcoords); +extern "C" int vtk_cubic_line_get_parametric_center(vtkNew sself, double pcoords); +extern "C" int vtk_cubic_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_cubic_line_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_cubic_line_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_cubic_line_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_cubic_line_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); extern "C" vtkNew < vtkCylinder > vtkCylinder_new () ; extern "C" void vtkCylinder_destructor (vtkNew < vtkCylinder > sself) ; extern "C" void * vtkCylinder_get_ptr (vtkNew < vtkCylinder > sself) ; +extern "C" double vtk_cylinder_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_cylinder_evaluate_gradient(vtkNew sself, double x, double g); +extern "C" void vtk_cylinder_set_radius(vtkNew sself, double _arg); +extern "C" double vtk_cylinder_get_radius(vtkNew sself); +extern "C" void vtk_cylinder_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cylinder_set_center(vtkNew sself, const double _arg); +extern "C" double* vtk_cylinder_get_center(vtkNew sself); +extern "C" void vtk_cylinder_get_center(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cylinder_get_center(vtkNew sself, double _arg); +extern "C" void vtk_cylinder_set_axis(vtkNew sself, double ax, double ay, double az); +extern "C" void vtk_cylinder_set_axis(vtkNew sself, double a); +extern "C" double* vtk_cylinder_get_axis(vtkNew sself); +extern "C" void vtk_cylinder_get_axis(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cylinder_get_axis(vtkNew sself, double _arg); extern "C" vtkNew < vtkDataAssembly > vtkDataAssembly_new () ; extern "C" void vtkDataAssembly_destructor (vtkNew < vtkDataAssembly > sself) ; extern "C" void * vtkDataAssembly_get_ptr (vtkNew < vtkDataAssembly > sself) ; +extern "C" void vtk_data_assembly_initialize(vtkNew sself); +extern "C" bool vtk_data_assembly_initialize_from_xml(vtkNew sself, const char xmlcontents); +extern "C" int vtk_data_assembly_get_root_node(vtkNew sself); +extern "C" void vtk_data_assembly_set_root_node_name(vtkNew sself, const char name); +extern "C" const char* vtk_data_assembly_get_root_node_name(vtkNew sself); +extern "C" int vtk_data_assembly_add_node(vtkNew sself, const char name, int parent); +extern "C" bool vtk_data_assembly_remove_node(vtkNew sself, int id); +extern "C" void vtk_data_assembly_set_node_name(vtkNew sself, int id, const char name); +extern "C" const char* vtk_data_assembly_get_node_name(vtkNew sself, int id); +extern "C" const char* vtk_data_assembly_get_node_path(vtkNew sself, int id); +extern "C" int vtk_data_assembly_get_first_node_by_path(vtkNew sself, const char path); +extern "C" bool vtk_data_assembly_add_data_set_index(vtkNew sself, int id, unsigned int dataset_index); +extern "C" bool vtk_data_assembly_add_data_set_index_range(vtkNew sself, int id, unsigned int index_start, int count); +extern "C" bool vtk_data_assembly_remove_data_set_index(vtkNew sself, int id, unsigned int dataset_index); +extern "C" bool vtk_data_assembly_remove_all_data_set_indices(vtkNew sself, int id, bool traverse_subtree); +extern "C" int vtk_data_assembly_find_first_node_with_name(vtkNew sself, const char name, int traversal_order); +extern "C" int vtk_data_assembly_get_number_of_children(vtkNew sself, int parent); +extern "C" int vtk_data_assembly_get_child(vtkNew sself, int parent, int index); +extern "C" int vtk_data_assembly_get_child_index(vtkNew sself, int parent, int child); +extern "C" int vtk_data_assembly_get_parent(vtkNew sself, int id); +extern "C" bool vtk_data_assembly_has_attribute(vtkNew sself, int id, const char name); +extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, const char value); +extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, int value); +extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, unsigned int value); +extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, long long value); +extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, const char value); +extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, int value); +extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, unsigned int value); +extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, long long value); +extern "C" const char* vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, const char default_value); +extern "C" int vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, int default_value); +extern "C" unsigned int vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, unsigned int default_value); +extern "C" long long vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, long long default_value); +extern "C" bool vtk_data_assembly_is_node_name_valid(vtkNew sself, const char name); +extern "C" const char* vtk_data_assembly_make_valid_node_name(vtkNew sself, const char name); +extern "C" bool vtk_data_assembly_is_node_name_reserved(vtkNew sself, const char name); extern "C" vtkNew < vtkDataAssemblyUtilities > vtkDataAssemblyUtilities_new () ; extern "C" void vtkDataAssemblyUtilities_destructor (vtkNew < vtkDataAssemblyUtilities > sself) ; extern "C" void * vtkDataAssemblyUtilities_get_ptr (vtkNew < vtkDataAssemblyUtilities > sself) ; +extern "C" const char* vtk_data_assembly_utilities_hierarchy_name(vtkNew sself); extern "C" vtkNew < vtkDataObject > vtkDataObject_new () ; extern "C" void vtkDataObject_destructor (vtkNew < vtkDataObject > sself) ; extern "C" void * vtkDataObject_get_ptr (vtkNew < vtkDataObject > sself) ; +extern "C" unsigned long vtk_data_object_get_m_time(vtkNew sself); +extern "C" void vtk_data_object_initialize(vtkNew sself); +extern "C" void vtk_data_object_release_data(vtkNew sself); +extern "C" int vtk_data_object_get_data_released(vtkNew sself); +extern "C" void vtk_data_object_set_global_release_data_flag(vtkNew sself, int val); +extern "C" void vtk_data_object_global_release_data_flag_on(vtkNew sself); +extern "C" void vtk_data_object_global_release_data_flag_off(vtkNew sself); +extern "C" int vtk_data_object_get_global_release_data_flag(vtkNew sself); +extern "C" int vtk_data_object_get_data_object_type(vtkNew sself); +extern "C" unsigned long vtk_data_object_get_update_time(vtkNew sself); +extern "C" unsigned long vtk_data_object_get_actual_memory_size(vtkNew sself); +extern "C" void vtk_data_object_data_has_been_generated(vtkNew sself); +extern "C" void vtk_data_object_prepare_for_new_data(vtkNew sself); +extern "C" int vtk_data_object_get_extent_type(vtkNew sself); +extern "C" void vtk_data_object_crop(vtkNew sself, const int updateExtent); +extern "C" long long vtk_data_object_get_number_of_elements(vtkNew sself, int type); +extern "C" const char* vtk_data_object_get_association_type_as_string(vtkNew sself, int associationType); +extern "C" int vtk_data_object_get_association_type_from_string(vtkNew sself, const char associationName); extern "C" vtkNew < vtkDataObjectCollection > vtkDataObjectCollection_new () ; extern "C" void vtkDataObjectCollection_destructor (vtkNew < vtkDataObjectCollection > sself) ; extern "C" void * vtkDataObjectCollection_get_ptr (vtkNew < vtkDataObjectCollection > sself) ; +extern "C" int vtk_data_object_collection_get_number_of_items(vtkNew sself); extern "C" vtkNew < vtkDataObjectTreeIterator > vtkDataObjectTreeIterator_new () ; extern "C" void vtkDataObjectTreeIterator_destructor (vtkNew < vtkDataObjectTreeIterator > sself) ; extern "C" void * vtkDataObjectTreeIterator_get_ptr (vtkNew < vtkDataObjectTreeIterator > sself) ; +extern "C" void vtk_data_object_tree_iterator_go_to_first_item(vtkNew sself); +extern "C" void vtk_data_object_tree_iterator_go_to_next_item(vtkNew sself); +extern "C" int vtk_data_object_tree_iterator_is_done_with_traversal(vtkNew sself); +extern "C" int vtk_data_object_tree_iterator_has_current_meta_data(vtkNew sself); +extern "C" unsigned int vtk_data_object_tree_iterator_get_current_flat_index(vtkNew sself); +extern "C" void vtk_data_object_tree_iterator_set_visit_only_leaves(vtkNew sself, int _arg); +extern "C" int vtk_data_object_tree_iterator_get_visit_only_leaves(vtkNew sself); +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_on(vtkNew sself); +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_off(vtkNew sself); +extern "C" void vtk_data_object_tree_iterator_set_traverse_sub_tree(vtkNew sself, int _arg); +extern "C" int vtk_data_object_tree_iterator_get_traverse_sub_tree(vtkNew sself); +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_on(vtkNew sself); +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_off(vtkNew sself); extern "C" vtkNew < vtkDataObjectTypes > vtkDataObjectTypes_new () ; extern "C" void vtkDataObjectTypes_destructor (vtkNew < vtkDataObjectTypes > sself) ; extern "C" void * vtkDataObjectTypes_get_ptr (vtkNew < vtkDataObjectTypes > sself) ; +extern "C" const char* vtk_data_object_types_get_class_name_from_type_id(vtkNew sself, int typeId); +extern "C" int vtk_data_object_types_get_type_id_from_class_name(vtkNew sself, const char classname); +extern "C" bool vtk_data_object_types_type_id_is_a(vtkNew sself, int typeId, int targetTypeId); +extern "C" int vtk_data_object_types_get_common_base_type_id(vtkNew sself, int typeA, int typeB); extern "C" vtkNew < vtkDataSetAttributes > vtkDataSetAttributes_new () ; extern "C" void vtkDataSetAttributes_destructor (vtkNew < vtkDataSetAttributes > sself) ; extern "C" void * vtkDataSetAttributes_get_ptr (vtkNew < vtkDataSetAttributes > sself) ; +extern "C" void vtk_data_set_attributes_initialize(vtkNew sself); +extern "C" void vtk_data_set_attributes_update(vtkNew sself); +extern "C" const char* vtk_data_set_attributes_ghost_array_name(vtkNew sself); +extern "C" int vtk_data_set_attributes_set_active_scalars(vtkNew sself, const char name); +extern "C" int vtk_data_set_attributes_set_active_vectors(vtkNew sself, const char name); +extern "C" int vtk_data_set_attributes_set_active_normals(vtkNew sself, const char name); +extern "C" int vtk_data_set_attributes_set_active_tangents(vtkNew sself, const char name); +extern "C" int vtk_data_set_attributes_set_active_t_coords(vtkNew sself, const char name); +extern "C" int vtk_data_set_attributes_set_active_tensors(vtkNew sself, const char name); +extern "C" int vtk_data_set_attributes_set_active_global_ids(vtkNew sself, const char name); +extern "C" int vtk_data_set_attributes_set_active_pedigree_ids(vtkNew sself, const char name); +extern "C" int vtk_data_set_attributes_set_active_rational_weights(vtkNew sself, const char name); +extern "C" int vtk_data_set_attributes_set_active_higher_order_degrees(vtkNew sself, const char name); +extern "C" int vtk_data_set_attributes_set_active_attribute(vtkNew sself, const char name, int attributeType); +extern "C" int vtk_data_set_attributes_set_active_attribute(vtkNew sself, int index, int attributeType); +extern "C" void vtk_data_set_attributes_get_attribute_indices(vtkNew sself, int indexArray); +extern "C" int vtk_data_set_attributes_is_array_an_attribute(vtkNew sself, int idx); +extern "C" const char* vtk_data_set_attributes_get_attribute_type_as_string(vtkNew sself, int attributeType); +extern "C" const char* vtk_data_set_attributes_get_long_attribute_type_as_string(vtkNew sself, int attributeType); +extern "C" void vtk_data_set_attributes_set_copy_attribute(vtkNew sself, int index, int value, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_attribute(vtkNew sself, int index, int ctype); +extern "C" void vtk_data_set_attributes_set_copy_scalars(vtkNew sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_scalars(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_scalars_on(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_scalars_off(vtkNew sself); +extern "C" void vtk_data_set_attributes_set_copy_vectors(vtkNew sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_vectors(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_vectors_on(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_vectors_off(vtkNew sself); +extern "C" void vtk_data_set_attributes_set_copy_normals(vtkNew sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_normals(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_normals_on(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_normals_off(vtkNew sself); +extern "C" void vtk_data_set_attributes_set_copy_tangents(vtkNew sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_tangents(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_tangents_on(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_tangents_off(vtkNew sself); +extern "C" void vtk_data_set_attributes_set_copy_t_coords(vtkNew sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_t_coords(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_t_coords_on(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_t_coords_off(vtkNew sself); +extern "C" void vtk_data_set_attributes_set_copy_tensors(vtkNew sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_tensors(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_tensors_on(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_tensors_off(vtkNew sself); +extern "C" void vtk_data_set_attributes_set_copy_global_ids(vtkNew sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_global_ids(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_global_ids_on(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_global_ids_off(vtkNew sself); +extern "C" void vtk_data_set_attributes_set_copy_pedigree_ids(vtkNew sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_pedigree_ids(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_on(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_off(vtkNew sself); +extern "C" void vtk_data_set_attributes_set_copy_rational_weights(vtkNew sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_rational_weights(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_rational_weights_on(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_rational_weights_off(vtkNew sself); +extern "C" void vtk_data_set_attributes_set_copy_higher_order_degrees(vtkNew sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_higher_order_degrees(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_on(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_off(vtkNew sself); +extern "C" void vtk_data_set_attributes_copy_all_on(vtkNew sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_all_off(vtkNew sself, int ctype); extern "C" vtkNew < vtkDataSetCellIterator > vtkDataSetCellIterator_new () ; extern "C" void vtkDataSetCellIterator_destructor (vtkNew < vtkDataSetCellIterator > sself) ; extern "C" void * vtkDataSetCellIterator_get_ptr (vtkNew < vtkDataSetCellIterator > sself) ; +extern "C" bool vtk_data_set_cell_iterator_is_done_with_traversal(vtkNew sself); +extern "C" long long vtk_data_set_cell_iterator_get_cell_id(vtkNew sself); extern "C" vtkNew < vtkDataSetCollection > vtkDataSetCollection_new () ; extern "C" void vtkDataSetCollection_destructor (vtkNew < vtkDataSetCollection > sself) ; extern "C" void * vtkDataSetCollection_get_ptr (vtkNew < vtkDataSetCollection > sself) ; +extern "C" int vtk_data_set_collection_get_number_of_items(vtkNew sself); extern "C" vtkNew < vtkDirectedAcyclicGraph > vtkDirectedAcyclicGraph_new () ; extern "C" void vtkDirectedAcyclicGraph_destructor (vtkNew < vtkDirectedAcyclicGraph > sself) ; extern "C" void * vtkDirectedAcyclicGraph_get_ptr (vtkNew < vtkDirectedAcyclicGraph > sself) ; @@ -426,48 +882,312 @@ extern "C" void * vtkDirectedGraph_get_ptr (vtkNew < vtkDirectedGraph > sself) ; extern "C" vtkNew < vtkEdgeListIterator > vtkEdgeListIterator_new () ; extern "C" void vtkEdgeListIterator_destructor (vtkNew < vtkEdgeListIterator > sself) ; extern "C" void * vtkEdgeListIterator_get_ptr (vtkNew < vtkEdgeListIterator > sself) ; +extern "C" bool vtk_edge_list_iterator_has_next(vtkNew sself); extern "C" vtkNew < vtkEdgeTable > vtkEdgeTable_new () ; extern "C" void vtkEdgeTable_destructor (vtkNew < vtkEdgeTable > sself) ; extern "C" void * vtkEdgeTable_get_ptr (vtkNew < vtkEdgeTable > sself) ; +extern "C" void vtk_edge_table_initialize(vtkNew sself); +extern "C" int vtk_edge_table_init_edge_insertion(vtkNew sself, long long numPoints, int storeAttributes); +extern "C" long long vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2); +extern "C" void vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2, long long attributeId); +extern "C" void vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2, void ptr); +extern "C" long long vtk_edge_table_is_edge(vtkNew sself, long long p1, long long p2); +extern "C" void vtk_edge_table_is_edge(vtkNew sself, long long p1, long long p2, void ptr); +extern "C" int vtk_edge_table_insert_unique_point(vtkNew sself, long long p1, long long p2, double x, long long ptId); +extern "C" long long vtk_edge_table_get_number_of_edges(vtkNew sself); +extern "C" void vtk_edge_table_init_traversal(vtkNew sself); +extern "C" long long vtk_edge_table_get_next_edge(vtkNew sself, long long p1, long long p2); +extern "C" int vtk_edge_table_get_next_edge(vtkNew sself, long long p1, long long p2, void ptr); +extern "C" void vtk_edge_table_reset(vtkNew sself); extern "C" vtkNew < vtkEmptyCell > vtkEmptyCell_new () ; extern "C" void vtkEmptyCell_destructor (vtkNew < vtkEmptyCell > sself) ; extern "C" void * vtkEmptyCell_get_ptr (vtkNew < vtkEmptyCell > sself) ; +extern "C" int vtk_empty_cell_get_cell_type(vtkNew sself); +extern "C" int vtk_empty_cell_get_cell_dimension(vtkNew sself); +extern "C" int vtk_empty_cell_get_number_of_edges(vtkNew sself); +extern "C" int vtk_empty_cell_get_number_of_faces(vtkNew sself); +extern "C" int vtk_empty_cell_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_empty_cell_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_empty_cell_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_empty_cell_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); extern "C" vtkNew < vtkExplicitStructuredGrid > vtkExplicitStructuredGrid_new () ; extern "C" void vtkExplicitStructuredGrid_destructor (vtkNew < vtkExplicitStructuredGrid > sself) ; extern "C" void * vtkExplicitStructuredGrid_get_ptr (vtkNew < vtkExplicitStructuredGrid > sself) ; +extern "C" int vtk_explicit_structured_grid_get_data_object_type(vtkNew sself); +extern "C" void vtk_explicit_structured_grid_initialize(vtkNew sself); +extern "C" int vtk_explicit_structured_grid_get_cell_type(vtkNew sself, long long cellId); +extern "C" int vtk_explicit_structured_grid_get_data_dimension(vtkNew sself); +extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkNew sself, int i, int j, int k); +extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkNew sself, int dim); +extern "C" void vtk_explicit_structured_grid_get_dimensions(vtkNew sself, int dim); +extern "C" void vtk_explicit_structured_grid_get_cell_dims(vtkNew sself, int cellDims); +extern "C" int vtk_explicit_structured_grid_get_extent_type(vtkNew sself); +extern "C" void vtk_explicit_structured_grid_set_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" void vtk_explicit_structured_grid_set_extent(vtkNew sself, int extent); +extern "C" int* vtk_explicit_structured_grid_get_extent(vtkNew sself); +extern "C" void vtk_explicit_structured_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_explicit_structured_grid_get_extent(vtkNew sself, int _arg); +extern "C" void vtk_explicit_structured_grid_build_links(vtkNew sself); +extern "C" long long* vtk_explicit_structured_grid_get_cell_points(vtkNew sself, long long cellId); +extern "C" void vtk_explicit_structured_grid_get_cell_points(vtkNew sself, long long cellId, long long npts, long long pts); +extern "C" void vtk_explicit_structured_grid_get_cell_neighbors(vtkNew sself, long long cellId, long long neighbors, int wholeExtent); +extern "C" void vtk_explicit_structured_grid_compute_cell_structured_coords(vtkNew sself, long long cellId, int i, int j, int k, bool adjustForExtent); +extern "C" long long vtk_explicit_structured_grid_compute_cell_id(vtkNew sself, int i, int j, int k, bool adjustForExtent); +extern "C" void vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(vtkNew sself); +extern "C" void vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name(vtkNew sself, const char _arg); +extern "C" char* vtk_explicit_structured_grid_get_faces_connectivity_flags_array_name(vtkNew sself); +extern "C" void vtk_explicit_structured_grid_blank_cell(vtkNew sself, long long cellId); +extern "C" void vtk_explicit_structured_grid_un_blank_cell(vtkNew sself, long long cellId); +extern "C" bool vtk_explicit_structured_grid_has_any_blank_cells(vtkNew sself); +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_visible(vtkNew sself, long long cellId); +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_ghost(vtkNew sself, long long cellId); +extern "C" bool vtk_explicit_structured_grid_has_any_ghost_cells(vtkNew sself); +extern "C" void vtk_explicit_structured_grid_crop(vtkNew sself, const int updateExtent); +extern "C" unsigned long vtk_explicit_structured_grid_get_actual_memory_size(vtkNew sself); +extern "C" void vtk_explicit_structured_grid_check_and_reorder_faces(vtkNew sself); extern "C" vtkNew < vtkExtractStructuredGridHelper > vtkExtractStructuredGridHelper_new () ; extern "C" void vtkExtractStructuredGridHelper_destructor (vtkNew < vtkExtractStructuredGridHelper > sself) ; extern "C" void * vtkExtractStructuredGridHelper_get_ptr (vtkNew < vtkExtractStructuredGridHelper > sself) ; +extern "C" int* vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself); +extern "C" void vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself, int _arg); +extern "C" void vtk_extract_structured_grid_helper_initialize(vtkNew sself, int voi, int wholeExt, int sampleRate, bool includeBoundary); +extern "C" bool vtk_extract_structured_grid_helper_is_valid(vtkNew sself); +extern "C" int vtk_extract_structured_grid_helper_get_size(vtkNew sself, const int dim); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index(vtkNew sself, int dim, int outIdx); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value(vtkNew sself, int dim, int outExtVal); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value(vtkNew sself, int dim, int outExtVal); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index(vtkNew sself, int dim, int outIdx); +extern "C" void vtk_extract_structured_grid_helper_compute_begin_and_end(vtkNew sself, int inExt, int voi, int begin, int end); +extern "C" void vtk_extract_structured_grid_helper_get_partitioned_voi(vtkNew sself, const int globalVOI, const int partitionedExtent, const int sampleRate, bool includeBoundary, int partitionedVOI); +extern "C" void vtk_extract_structured_grid_helper_get_partitioned_output_extent(vtkNew sself, const int globalVOI, const int partitionedVOI, const int outputWholeExtent, const int sampleRate, bool includeBoundary, int partitionedOutputExtent); extern "C" vtkNew < vtkFieldData > vtkFieldData_new () ; extern "C" void vtkFieldData_destructor (vtkNew < vtkFieldData > sself) ; extern "C" void * vtkFieldData_get_ptr (vtkNew < vtkFieldData > sself) ; +extern "C" void vtk_field_data_initialize(vtkNew sself); +extern "C" int vtk_field_data_allocate(vtkNew sself, long long sz, long long ext); +extern "C" void vtk_field_data_allocate_arrays(vtkNew sself, int num); +extern "C" int vtk_field_data_get_number_of_arrays(vtkNew sself); +extern "C" void vtk_field_data_null_data(vtkNew sself, long long id); +extern "C" void vtk_field_data_remove_array(vtkNew sself, const char name); +extern "C" void vtk_field_data_remove_array(vtkNew sself, int index); +extern "C" int vtk_field_data_has_array(vtkNew sself, const char name); +extern "C" const char* vtk_field_data_get_array_name(vtkNew sself, int i); +extern "C" void vtk_field_data_copy_field_on(vtkNew sself, const char name); +extern "C" void vtk_field_data_copy_field_off(vtkNew sself, const char name); +extern "C" void vtk_field_data_copy_all_on(vtkNew sself, int unused); +extern "C" void vtk_field_data_copy_all_off(vtkNew sself, int unused); +extern "C" void vtk_field_data_squeeze(vtkNew sself); +extern "C" void vtk_field_data_reset(vtkNew sself); +extern "C" unsigned long vtk_field_data_get_actual_memory_size(vtkNew sself); +extern "C" unsigned long vtk_field_data_get_m_time(vtkNew sself); +extern "C" int vtk_field_data_get_array_containing_component(vtkNew sself, int i, int arrayComp); +extern "C" int vtk_field_data_get_number_of_components(vtkNew sself); +extern "C" long long vtk_field_data_get_number_of_tuples(vtkNew sself); +extern "C" void vtk_field_data_set_number_of_tuples(vtkNew sself, const long long number); extern "C" vtkNew < vtkGenericAttributeCollection > vtkGenericAttributeCollection_new () ; extern "C" void vtkGenericAttributeCollection_destructor (vtkNew < vtkGenericAttributeCollection > sself) ; extern "C" void * vtkGenericAttributeCollection_get_ptr (vtkNew < vtkGenericAttributeCollection > sself) ; +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes(vtkNew sself); +extern "C" int vtk_generic_attribute_collection_get_number_of_components(vtkNew sself); +extern "C" int vtk_generic_attribute_collection_get_number_of_point_centered_components(vtkNew sself); +extern "C" int vtk_generic_attribute_collection_get_max_number_of_components(vtkNew sself); +extern "C" unsigned long vtk_generic_attribute_collection_get_actual_memory_size(vtkNew sself); +extern "C" int vtk_generic_attribute_collection_is_empty(vtkNew sself); +extern "C" int vtk_generic_attribute_collection_find_attribute(vtkNew sself, const char name); +extern "C" int vtk_generic_attribute_collection_get_attribute_index(vtkNew sself, int i); +extern "C" void vtk_generic_attribute_collection_remove_attribute(vtkNew sself, int i); +extern "C" void vtk_generic_attribute_collection_reset(vtkNew sself); +extern "C" unsigned long vtk_generic_attribute_collection_get_m_time(vtkNew sself); +extern "C" int vtk_generic_attribute_collection_get_active_attribute(vtkNew sself); +extern "C" int vtk_generic_attribute_collection_get_active_component(vtkNew sself); +extern "C" void vtk_generic_attribute_collection_set_active_attribute(vtkNew sself, int attribute, int component); +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate(vtkNew sself); +extern "C" int* vtk_generic_attribute_collection_get_attributes_to_interpolate(vtkNew sself); +extern "C" int vtk_generic_attribute_collection_has_attribute(vtkNew sself, int size, int attributes, int attribute); +extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate(vtkNew sself, int size, int attributes); +extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(vtkNew sself); extern "C" vtkNew < vtkGenericCell > vtkGenericCell_new () ; extern "C" void vtkGenericCell_destructor (vtkNew < vtkGenericCell > sself) ; extern "C" void * vtkGenericCell_get_ptr (vtkNew < vtkGenericCell > sself) ; +extern "C" int vtk_generic_cell_get_cell_type(vtkNew sself); +extern "C" int vtk_generic_cell_get_cell_dimension(vtkNew sself); +extern "C" int vtk_generic_cell_get_number_of_edges(vtkNew sself); +extern "C" int vtk_generic_cell_get_number_of_faces(vtkNew sself); +extern "C" int vtk_generic_cell_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_generic_cell_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_generic_cell_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_generic_cell_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" void vtk_generic_cell_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_generic_cell_set_cell_type(vtkNew sself, int cellType); +extern "C" void vtk_generic_cell_set_cell_type_to_empty_cell(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_vertex(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_poly_vertex(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_line(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_poly_line(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_triangle(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_triangle_strip(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_polygon(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_pixel(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quad(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_tetra(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_voxel(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_hexahedron(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_wedge(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_pyramid(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_pentagonal_prism(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_hexagonal_prism(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_polyhedron(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_convex_point_set(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_edge(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_cubic_line(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_triangle(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_quad(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_polygon(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_tetra(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_hexahedron(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_wedge(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_pyramid(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_quad(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quad(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_triangle(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_tetra(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_curve(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_hexahedron(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_wedge(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_triangle(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_tetra(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_curve(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_quadrilateral(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_hexahedron(vtkNew sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_wedge(vtkNew sself); extern "C" vtkNew < vtkGenericEdgeTable > vtkGenericEdgeTable_new () ; extern "C" void vtkGenericEdgeTable_destructor (vtkNew < vtkGenericEdgeTable > sself) ; extern "C" void * vtkGenericEdgeTable_get_ptr (vtkNew < vtkGenericEdgeTable > sself) ; +extern "C" void vtk_generic_edge_table_insert_edge(vtkNew sself, long long e1, long long e2, long long cellId, int ref, long long ptId); +extern "C" void vtk_generic_edge_table_insert_edge(vtkNew sself, long long e1, long long e2, long long cellId, int ref); +extern "C" int vtk_generic_edge_table_remove_edge(vtkNew sself, long long e1, long long e2); +extern "C" int vtk_generic_edge_table_check_edge(vtkNew sself, long long e1, long long e2, long long ptId); +extern "C" int vtk_generic_edge_table_increment_edge_reference_count(vtkNew sself, long long e1, long long e2, long long cellId); +extern "C" int vtk_generic_edge_table_check_edge_reference_count(vtkNew sself, long long e1, long long e2); +extern "C" void vtk_generic_edge_table_initialize(vtkNew sself, long long start); +extern "C" int vtk_generic_edge_table_get_number_of_components(vtkNew sself); +extern "C" void vtk_generic_edge_table_set_number_of_components(vtkNew sself, int count); +extern "C" int vtk_generic_edge_table_check_point(vtkNew sself, long long ptId); +extern "C" int vtk_generic_edge_table_check_point(vtkNew sself, long long ptId, double point, double scalar); +extern "C" void vtk_generic_edge_table_insert_point(vtkNew sself, long long ptId, double point); +extern "C" void vtk_generic_edge_table_insert_point_and_scalar(vtkNew sself, long long ptId, double pt, double s); +extern "C" void vtk_generic_edge_table_remove_point(vtkNew sself, long long ptId); +extern "C" void vtk_generic_edge_table_increment_point_reference_count(vtkNew sself, long long ptId); +extern "C" void vtk_generic_edge_table_dump_table(vtkNew sself); +extern "C" void vtk_generic_edge_table_load_factor(vtkNew sself); extern "C" vtkNew < vtkGenericInterpolatedVelocityField > vtkGenericInterpolatedVelocityField_new () ; extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkNew < vtkGenericInterpolatedVelocityField > sself) ; extern "C" void * vtkGenericInterpolatedVelocityField_get_ptr (vtkNew < vtkGenericInterpolatedVelocityField > sself) ; +extern "C" int vtk_generic_interpolated_velocity_field_function_values(vtkNew sself, double x, double f); +extern "C" void vtk_generic_interpolated_velocity_field_clear_last_cell(vtkNew sself); +extern "C" int vtk_generic_interpolated_velocity_field_get_last_local_coordinates(vtkNew sself, double pcoords); +extern "C" int vtk_generic_interpolated_velocity_field_get_caching(vtkNew sself); +extern "C" void vtk_generic_interpolated_velocity_field_set_caching(vtkNew sself, int _arg); +extern "C" void vtk_generic_interpolated_velocity_field_caching_on(vtkNew sself); +extern "C" void vtk_generic_interpolated_velocity_field_caching_off(vtkNew sself); +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_hit(vtkNew sself); +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_miss(vtkNew sself); +extern "C" char* vtk_generic_interpolated_velocity_field_get_vectors_selection(vtkNew sself); +extern "C" void vtk_generic_interpolated_velocity_field_select_vectors(vtkNew sself, const char fieldName); extern "C" vtkNew < vtkGeometricErrorMetric > vtkGeometricErrorMetric_new () ; extern "C" void vtkGeometricErrorMetric_destructor (vtkNew < vtkGeometricErrorMetric > sself) ; extern "C" void * vtkGeometricErrorMetric_get_ptr (vtkNew < vtkGeometricErrorMetric > sself) ; +extern "C" double vtk_geometric_error_metric_get_absolute_geometric_tolerance(vtkNew sself); +extern "C" void vtk_geometric_error_metric_set_absolute_geometric_tolerance(vtkNew sself, double value); +extern "C" int vtk_geometric_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); +extern "C" double vtk_geometric_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); +extern "C" int vtk_geometric_error_metric_get_relative(vtkNew sself); extern "C" vtkNew < vtkGraphEdge > vtkGraphEdge_new () ; extern "C" void vtkGraphEdge_destructor (vtkNew < vtkGraphEdge > sself) ; extern "C" void * vtkGraphEdge_get_ptr (vtkNew < vtkGraphEdge > sself) ; +extern "C" void vtk_graph_edge_set_source(vtkNew sself, long long _arg); +extern "C" long long vtk_graph_edge_get_source(vtkNew sself); +extern "C" void vtk_graph_edge_set_target(vtkNew sself, long long _arg); +extern "C" long long vtk_graph_edge_get_target(vtkNew sself); +extern "C" void vtk_graph_edge_set_id(vtkNew sself, long long _arg); +extern "C" long long vtk_graph_edge_get_id(vtkNew sself); extern "C" vtkNew < vtkGraphInternals > vtkGraphInternals_new () ; extern "C" void vtkGraphInternals_destructor (vtkNew < vtkGraphInternals > sself) ; extern "C" void * vtkGraphInternals_get_ptr (vtkNew < vtkGraphInternals > sself) ; extern "C" vtkNew < vtkHexagonalPrism > vtkHexagonalPrism_new () ; extern "C" void vtkHexagonalPrism_destructor (vtkNew < vtkHexagonalPrism > sself) ; extern "C" void * vtkHexagonalPrism_get_ptr (vtkNew < vtkHexagonalPrism > sself) ; +extern "C" void vtk_hexagonal_prism_get_edge_points(vtkNew sself, long long edgeId, const long long pts); +extern "C" void vtk_hexagonal_prism_get_edge_points(vtkNew sself, int edgeId, int pts); +extern "C" long long vtk_hexagonal_prism_get_face_points(vtkNew sself, long long faceId, const long long pts); +extern "C" void vtk_hexagonal_prism_get_face_points(vtkNew sself, int faceId, int pts); +extern "C" void vtk_hexagonal_prism_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); +extern "C" long long vtk_hexagonal_prism_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); +extern "C" long long vtk_hexagonal_prism_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); +extern "C" long long vtk_hexagonal_prism_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); +extern "C" long long vtk_hexagonal_prism_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); +extern "C" bool vtk_hexagonal_prism_get_centroid(vtkNew sself, double centroid); +extern "C" int vtk_hexagonal_prism_get_cell_type(vtkNew sself); +extern "C" int vtk_hexagonal_prism_get_number_of_edges(vtkNew sself); +extern "C" int vtk_hexagonal_prism_get_number_of_faces(vtkNew sself); +extern "C" int vtk_hexagonal_prism_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_hexagonal_prism_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_hexagonal_prism_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_hexagonal_prism_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_hexagonal_prism_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_hexagonal_prism_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_hexagonal_prism_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_hexagonal_prism_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_hexagonal_prism_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_hexagonal_prism_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_hexagonal_prism_get_face_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_hexagonal_prism_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_hexagonal_prism_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_hexagonal_prism_get_point_to_incident_edges_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_hexagonal_prism_get_point_to_incident_faces_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_hexagonal_prism_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); +extern "C" void vtk_hexagonal_prism_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkHexahedron > vtkHexahedron_new () ; extern "C" void vtkHexahedron_destructor (vtkNew < vtkHexahedron > sself) ; extern "C" void * vtkHexahedron_get_ptr (vtkNew < vtkHexahedron > sself) ; +extern "C" void vtk_hexahedron_get_edge_points(vtkNew sself, long long edgeId, const long long pts); +extern "C" void vtk_hexahedron_get_edge_points(vtkNew sself, int edgeId, int pts); +extern "C" long long vtk_hexahedron_get_face_points(vtkNew sself, long long faceId, const long long pts); +extern "C" void vtk_hexahedron_get_face_points(vtkNew sself, int faceId, int pts); +extern "C" void vtk_hexahedron_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); +extern "C" long long vtk_hexahedron_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); +extern "C" long long vtk_hexahedron_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); +extern "C" long long vtk_hexahedron_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); +extern "C" long long vtk_hexahedron_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); +extern "C" bool vtk_hexahedron_get_centroid(vtkNew sself, double centroid); +extern "C" int vtk_hexahedron_get_cell_type(vtkNew sself); +extern "C" int vtk_hexahedron_get_number_of_edges(vtkNew sself); +extern "C" int vtk_hexahedron_get_number_of_faces(vtkNew sself); +extern "C" int vtk_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int* vtk_hexahedron_get_triangle_cases(vtkNew sself, int caseId); +extern "C" void vtk_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_hexahedron_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_hexahedron_get_face_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_hexahedron_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_hexahedron_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_hexahedron_get_point_to_incident_edges_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_hexahedron_get_point_to_incident_faces_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_hexahedron_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); +extern "C" void vtk_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkHierarchicalBoxDataIterator > vtkHierarchicalBoxDataIterator_new () ; extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkNew < vtkHierarchicalBoxDataIterator > sself) ; extern "C" void * vtkHierarchicalBoxDataIterator_get_ptr (vtkNew < vtkHierarchicalBoxDataIterator > sself) ; @@ -477,12 +1197,119 @@ extern "C" void * vtkHierarchicalBoxDataSet_get_ptr (vtkNew < vtkHierarchicalBox extern "C" vtkNew < vtkHyperTreeGrid > vtkHyperTreeGrid_new () ; extern "C" void vtkHyperTreeGrid_destructor (vtkNew < vtkHyperTreeGrid > sself) ; extern "C" void * vtkHyperTreeGrid_get_ptr (vtkNew < vtkHyperTreeGrid > sself) ; +extern "C" void vtk_hyper_tree_grid_set_mode_squeeze(vtkNew sself, const char _arg); +extern "C" char* vtk_hyper_tree_grid_get_mode_squeeze(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_squeeze(vtkNew sself); +extern "C" int vtk_hyper_tree_grid_get_data_object_type(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, const unsigned int dims); +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, const int dims); +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, unsigned int i, unsigned int j, unsigned int k); +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, int i, int j, int k); +extern "C" const unsigned int* vtk_hyper_tree_grid_get_dimensions(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_get_dimensions(vtkNew sself, int dim); +extern "C" void vtk_hyper_tree_grid_get_dimensions(vtkNew sself, unsigned int dim); +extern "C" void vtk_hyper_tree_grid_set_extent(vtkNew sself, const int extent); +extern "C" void vtk_hyper_tree_grid_set_extent(vtkNew sself, int x1, int x2, int y1, int y2, int z1, int z2); +extern "C" int* vtk_hyper_tree_grid_get_extent(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_hyper_tree_grid_get_extent(vtkNew sself, int _arg); +extern "C" const unsigned int* vtk_hyper_tree_grid_get_cell_dims(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_get_cell_dims(vtkNew sself, int cellDims); +extern "C" void vtk_hyper_tree_grid_get_cell_dims(vtkNew sself, unsigned int cellDims); +extern "C" unsigned int vtk_hyper_tree_grid_get_dimension(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_get_1_d_axis(vtkNew sself, unsigned int axis); +extern "C" void vtk_hyper_tree_grid_get_2_d_axes(vtkNew sself, unsigned int axis1, unsigned int axis2); +extern "C" const unsigned int* vtk_hyper_tree_grid_get_axes(vtkNew sself); +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_children(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_set_transposed_root_indexing(vtkNew sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_get_transposed_root_indexing(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_kji(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_ijk(vtkNew sself); +extern "C" unsigned int vtk_hyper_tree_grid_get_orientation(vtkNew sself); +extern "C" bool vtk_hyper_tree_grid_get_freeze_state(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_set_branch_factor(vtkNew sself, unsigned int p0); +extern "C" unsigned int vtk_hyper_tree_grid_get_branch_factor(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_get_max_number_of_trees(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_vertices(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_non_empty_trees(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_leaves(vtkNew sself); +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkNew sself, long long p0); +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_set_fixed_coordinates(vtkNew sself, unsigned int axis, double value); +extern "C" bool vtk_hyper_tree_grid_has_mask(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_set_has_interface(vtkNew sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_get_has_interface(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_has_interface_on(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_has_interface_off(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_set_interface_normals_name(vtkNew sself, const char _arg); +extern "C" char* vtk_hyper_tree_grid_get_interface_normals_name(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_set_interface_intercepts_name(vtkNew sself, const char _arg); +extern "C" char* vtk_hyper_tree_grid_get_interface_intercepts_name(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_set_depth_limiter(vtkNew sself, unsigned int _arg); +extern "C" unsigned int vtk_hyper_tree_grid_get_depth_limiter(vtkNew sself); +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_x(vtkNew sself, double value); +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_y(vtkNew sself, double value); +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_z(vtkNew sself, double value); +extern "C" void vtk_hyper_tree_grid_initialize(vtkNew sself); +extern "C" int vtk_hyper_tree_grid_get_extent_type(vtkNew sself); +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size_bytes(vtkNew sself); +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size(vtkNew sself); +extern "C" unsigned int vtk_hyper_tree_grid_get_child_mask(vtkNew sself, unsigned int p0); +extern "C" void vtk_hyper_tree_grid_get_index_from_level_zero_coordinates(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3); +extern "C" long long vtk_hyper_tree_grid_get_shifted_level_zero_index(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3); +extern "C" void vtk_hyper_tree_grid_get_level_zero_coordinates_from_index(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3); +extern "C" void vtk_hyper_tree_grid_get_level_zero_origin_and_size_from_index(vtkNew sself, long long p0, double p1, double p2); +extern "C" void vtk_hyper_tree_grid_get_level_zero_origin_from_index(vtkNew sself, long long p0, double p1); +extern "C" long long vtk_hyper_tree_grid_get_global_node_index_max(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_initialize_local_index_node(vtkNew sself); +extern "C" bool vtk_hyper_tree_grid_has_any_ghost_cells(vtkNew sself); +extern "C" double* vtk_hyper_tree_grid_get_bounds(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_get_bounds(vtkNew sself, double bounds); +extern "C" double* vtk_hyper_tree_grid_get_center(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_get_center(vtkNew sself, double center); +extern "C" long long vtk_hyper_tree_grid_get_number_of_elements(vtkNew sself, int type); extern "C" vtkNew < vtkHyperTreeGridNonOrientedCursor > vtkHyperTreeGridNonOrientedCursor_new () ; extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) ; extern "C" void * vtkHyperTreeGridNonOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) ; +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_has_tree(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(vtkNew sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_dimension(vtkNew sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(vtkNew sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local(vtkNew sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_mask(vtkNew sself, bool state); +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_masked(vtkNew sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_leaf(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf(vtkNew sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_root(vtkNew sself); +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_cursor_get_level(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_child(vtkNew sself, unsigned char ichild); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_root(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_parent(vtkNew sself); extern "C" vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > vtkHyperTreeGridNonOrientedGeometryCursor_new () ; extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) ; extern "C" void * vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) ; +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index(vtkNew sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension(vtkNew sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start(vtkNew sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local(vtkNew sself, long long index); +extern "C" double* vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_origin(vtkNew sself); +extern "C" double* vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_size(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_bounds(vtkNew sself, double bounds); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_point(vtkNew sself, double point); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask(vtkNew sself, bool state); +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked(vtkNew sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf(vtkNew sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root(vtkNew sself); +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child(vtkNew sself, unsigned char ichild); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(vtkNew sself); extern "C" vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > vtkHyperTreeGridNonOrientedMooreSuperCursor_new () ; extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) ; extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) ; @@ -498,357 +1325,1976 @@ extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr extern "C" vtkNew < vtkHyperTreeGridOrientedCursor > vtkHyperTreeGridOrientedCursor_new () ; extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkNew < vtkHyperTreeGridOrientedCursor > sself) ; extern "C" void * vtkHyperTreeGridOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedCursor > sself) ; +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_has_tree(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(vtkNew sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_dimension(vtkNew sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(vtkNew sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local(vtkNew sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_mask(vtkNew sself, bool state); +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_masked(vtkNew sself); +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_leaf(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf(vtkNew sself); +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_root(vtkNew sself); +extern "C" unsigned int vtk_hyper_tree_grid_oriented_cursor_get_level(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_to_child(vtkNew sself, unsigned char ichild); extern "C" vtkNew < vtkHyperTreeGridOrientedGeometryCursor > vtkHyperTreeGridOrientedGeometryCursor_new () ; extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) ; extern "C" void * vtkHyperTreeGridOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) ; +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(vtkNew sself); +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(vtkNew sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension(vtkNew sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start(vtkNew sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local(vtkNew sself, long long index); +extern "C" double* vtk_hyper_tree_grid_oriented_geometry_cursor_get_origin(vtkNew sself); +extern "C" double* vtk_hyper_tree_grid_oriented_geometry_cursor_get_size(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_get_bounds(vtkNew sself, double bounds); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_get_point(vtkNew sself, double point); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask(vtkNew sself, bool state); +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked(vtkNew sself); +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf(vtkNew sself); +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_root(vtkNew sself); +extern "C" unsigned int vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(vtkNew sself); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(vtkNew sself, unsigned char ichild); extern "C" vtkNew < vtkImageData > vtkImageData_new () ; extern "C" void vtkImageData_destructor (vtkNew < vtkImageData > sself) ; extern "C" void * vtkImageData_get_ptr (vtkNew < vtkImageData > sself) ; +extern "C" int vtk_image_data_get_data_object_type(vtkNew sself); +extern "C" long long vtk_image_data_get_number_of_cells(vtkNew sself); +extern "C" long long vtk_image_data_get_number_of_points(vtkNew sself); +extern "C" double* vtk_image_data_get_point(vtkNew sself, long long ptId); +extern "C" long long vtk_image_data_find_point(vtkNew sself, double x, double y, double z); +extern "C" long long vtk_image_data_find_point(vtkNew sself, double x); +extern "C" int vtk_image_data_get_cell_type(vtkNew sself, long long cellId); +extern "C" int vtk_image_data_get_max_cell_size(vtkNew sself); +extern "C" void vtk_image_data_initialize(vtkNew sself); +extern "C" unsigned char vtk_image_data_is_point_visible(vtkNew sself, long long ptId); +extern "C" unsigned char vtk_image_data_is_cell_visible(vtkNew sself, long long cellId); +extern "C" bool vtk_image_data_has_any_blank_points(vtkNew sself); +extern "C" bool vtk_image_data_has_any_blank_cells(vtkNew sself); +extern "C" void vtk_image_data_get_cell_dims(vtkNew sself, int cellDims); +extern "C" void vtk_image_data_set_dimensions(vtkNew sself, int i, int j, int k); +extern "C" void vtk_image_data_set_dimensions(vtkNew sself, const int dims); +extern "C" int* vtk_image_data_get_dimensions(vtkNew sself); +extern "C" void vtk_image_data_get_dimensions(vtkNew sself, int dims); +extern "C" void vtk_image_data_get_dimensions(vtkNew sself, long long dims); +extern "C" int vtk_image_data_compute_structured_coordinates(vtkNew sself, const double x, int ijk, double pcoords); +extern "C" int vtk_image_data_get_data_dimension(vtkNew sself); +extern "C" long long vtk_image_data_compute_point_id(vtkNew sself, int ijk); +extern "C" long long vtk_image_data_compute_cell_id(vtkNew sself, int ijk); +extern "C" void vtk_image_data_set_axis_update_extent(vtkNew sself, int axis, int min, int max, const int updateExtent, int axisUpdateExtent); +extern "C" void vtk_image_data_get_axis_update_extent(vtkNew sself, int axis, int min, int max, const int updateExtent); +extern "C" void vtk_image_data_set_extent(vtkNew sself, int extent); +extern "C" void vtk_image_data_set_extent(vtkNew sself, int x1, int x2, int y1, int y2, int z1, int z2); +extern "C" int* vtk_image_data_get_extent(vtkNew sself); +extern "C" void vtk_image_data_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_image_data_get_extent(vtkNew sself, int _arg); +extern "C" double vtk_image_data_get_scalar_type_min(vtkNew sself); +extern "C" double vtk_image_data_get_scalar_type_max(vtkNew sself); +extern "C" int vtk_image_data_get_scalar_size(vtkNew sself); +extern "C" long long* vtk_image_data_get_increments(vtkNew sself); +extern "C" void vtk_image_data_get_increments(vtkNew sself, long long incX, long long incY, long long incZ); +extern "C" void vtk_image_data_get_increments(vtkNew sself, long long inc); +extern "C" void vtk_image_data_get_continuous_increments(vtkNew sself, int extent, long long incX, long long incY, long long incZ); +extern "C" void* vtk_image_data_get_scalar_pointer_for_extent(vtkNew sself, int extent); +extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself, int coordinates); +extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself, int x, int y, int z); +extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself); +extern "C" long long vtk_image_data_get_scalar_index_for_extent(vtkNew sself, int extent); +extern "C" long long vtk_image_data_get_scalar_index(vtkNew sself, int coordinates); +extern "C" long long vtk_image_data_get_scalar_index(vtkNew sself, int x, int y, int z); +extern "C" float vtk_image_data_get_scalar_component_as_float(vtkNew sself, int x, int y, int z, int component); +extern "C" void vtk_image_data_set_scalar_component_from_float(vtkNew sself, int x, int y, int z, int component, float v); +extern "C" double vtk_image_data_get_scalar_component_as_double(vtkNew sself, int x, int y, int z, int component); +extern "C" void vtk_image_data_set_scalar_component_from_double(vtkNew sself, int x, int y, int z, int component, double v); +extern "C" void vtk_image_data_allocate_scalars(vtkNew sself, int dataType, int numComponents); +extern "C" void vtk_image_data_crop(vtkNew sself, const int updateExtent); +extern "C" double* vtk_image_data_get_spacing(vtkNew sself); +extern "C" void vtk_image_data_get_spacing(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_image_data_get_spacing(vtkNew sself, double _arg); +extern "C" void vtk_image_data_set_spacing(vtkNew sself, double i, double j, double k); +extern "C" void vtk_image_data_set_spacing(vtkNew sself, const double ijk); +extern "C" double* vtk_image_data_get_origin(vtkNew sself); +extern "C" void vtk_image_data_get_origin(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_image_data_get_origin(vtkNew sself, double _arg); +extern "C" void vtk_image_data_set_origin(vtkNew sself, double i, double j, double k); +extern "C" void vtk_image_data_set_origin(vtkNew sself, const double ijk); +extern "C" void vtk_image_data_set_direction_matrix(vtkNew sself, const double elements); +extern "C" void vtk_image_data_set_direction_matrix(vtkNew sself, double e00, double e01, double e02, double e10, double e11, double e12, double e20, double e21, double e22); +extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, double i, double j, double k, double xyz); +extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, const double ijk, double xyz); +extern "C" void vtk_image_data_transform_index_to_physical_point(vtkNew sself, int i, int j, int k, double xyz); +extern "C" void vtk_image_data_transform_index_to_physical_point(vtkNew sself, const int ijk, double xyz); +extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, double i, double j, double k, const double origin, const double spacing, const double direction, double xyz); +extern "C" void vtk_image_data_transform_physical_point_to_continuous_index(vtkNew sself, double x, double y, double z, double ijk); +extern "C" void vtk_image_data_transform_physical_point_to_continuous_index(vtkNew sself, const double xyz, double ijk); +extern "C" void vtk_image_data_compute_index_to_physical_matrix(vtkNew sself, const double origin, const double spacing, const double direction, double result); +extern "C" void vtk_image_data_transform_physical_normal_to_continuous_index(vtkNew sself, const double xyz, double ijk); +extern "C" void vtk_image_data_transform_physical_plane_to_continuous_index(vtkNew sself, const double pplane, double iplane); +extern "C" int vtk_image_data_get_scalar_type(vtkNew sself); +extern "C" const char* vtk_image_data_get_scalar_type_as_string(vtkNew sself); +extern "C" int vtk_image_data_get_number_of_scalar_components(vtkNew sself); +extern "C" void vtk_image_data_prepare_for_new_data(vtkNew sself); +extern "C" void vtk_image_data_compute_internal_extent(vtkNew sself, int intExt, int tgtExt, int bnds); +extern "C" int vtk_image_data_get_extent_type(vtkNew sself); extern "C" vtkNew < vtkImageTransform > vtkImageTransform_new () ; extern "C" void vtkImageTransform_destructor (vtkNew < vtkImageTransform > sself) ; extern "C" void * vtkImageTransform_get_ptr (vtkNew < vtkImageTransform > sself) ; extern "C" vtkNew < vtkImplicitBoolean > vtkImplicitBoolean_new () ; extern "C" void vtkImplicitBoolean_destructor (vtkNew < vtkImplicitBoolean > sself) ; extern "C" void * vtkImplicitBoolean_get_ptr (vtkNew < vtkImplicitBoolean > sself) ; +extern "C" double vtk_implicit_boolean_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_implicit_boolean_evaluate_gradient(vtkNew sself, double x, double g); +extern "C" unsigned long vtk_implicit_boolean_get_m_time(vtkNew sself); +extern "C" void vtk_implicit_boolean_set_operation_type(vtkNew sself, int _arg); +extern "C" int vtk_implicit_boolean_get_operation_type_min_value(vtkNew sself); +extern "C" int vtk_implicit_boolean_get_operation_type_max_value(vtkNew sself); +extern "C" int vtk_implicit_boolean_get_operation_type(vtkNew sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_union(vtkNew sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_intersection(vtkNew sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_difference(vtkNew sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(vtkNew sself); +extern "C" const char* vtk_implicit_boolean_get_operation_type_as_string(vtkNew sself); extern "C" vtkNew < vtkImplicitDataSet > vtkImplicitDataSet_new () ; extern "C" void vtkImplicitDataSet_destructor (vtkNew < vtkImplicitDataSet > sself) ; extern "C" void * vtkImplicitDataSet_get_ptr (vtkNew < vtkImplicitDataSet > sself) ; +extern "C" unsigned long vtk_implicit_data_set_get_m_time(vtkNew sself); +extern "C" double vtk_implicit_data_set_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_implicit_data_set_evaluate_gradient(vtkNew sself, double x, double n); +extern "C" void vtk_implicit_data_set_set_out_value(vtkNew sself, double _arg); +extern "C" double vtk_implicit_data_set_get_out_value(vtkNew sself); +extern "C" void vtk_implicit_data_set_set_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_implicit_data_set_set_out_gradient(vtkNew sself, const double _arg); +extern "C" double* vtk_implicit_data_set_get_out_gradient(vtkNew sself); +extern "C" void vtk_implicit_data_set_get_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_implicit_data_set_get_out_gradient(vtkNew sself, double _arg); extern "C" vtkNew < vtkImplicitFunctionCollection > vtkImplicitFunctionCollection_new () ; extern "C" void vtkImplicitFunctionCollection_destructor (vtkNew < vtkImplicitFunctionCollection > sself) ; extern "C" void * vtkImplicitFunctionCollection_get_ptr (vtkNew < vtkImplicitFunctionCollection > sself) ; extern "C" vtkNew < vtkImplicitHalo > vtkImplicitHalo_new () ; extern "C" void vtkImplicitHalo_destructor (vtkNew < vtkImplicitHalo > sself) ; extern "C" void * vtkImplicitHalo_get_ptr (vtkNew < vtkImplicitHalo > sself) ; +extern "C" double vtk_implicit_halo_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_implicit_halo_evaluate_gradient(vtkNew sself, double x, double g); +extern "C" void vtk_implicit_halo_set_radius(vtkNew sself, double _arg); +extern "C" double vtk_implicit_halo_get_radius(vtkNew sself); +extern "C" void vtk_implicit_halo_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_implicit_halo_set_center(vtkNew sself, const double _arg); +extern "C" double* vtk_implicit_halo_get_center(vtkNew sself); +extern "C" void vtk_implicit_halo_get_center(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_implicit_halo_get_center(vtkNew sself, double _arg); +extern "C" void vtk_implicit_halo_set_fade_out(vtkNew sself, double _arg); +extern "C" double vtk_implicit_halo_get_fade_out(vtkNew sself); extern "C" vtkNew < vtkImplicitSelectionLoop > vtkImplicitSelectionLoop_new () ; extern "C" void vtkImplicitSelectionLoop_destructor (vtkNew < vtkImplicitSelectionLoop > sself) ; extern "C" void * vtkImplicitSelectionLoop_get_ptr (vtkNew < vtkImplicitSelectionLoop > sself) ; +extern "C" double vtk_implicit_selection_loop_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_implicit_selection_loop_evaluate_gradient(vtkNew sself, double x, double n); +extern "C" void vtk_implicit_selection_loop_set_automatic_normal_generation(vtkNew sself, int _arg); +extern "C" int vtk_implicit_selection_loop_get_automatic_normal_generation(vtkNew sself); +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_on(vtkNew sself); +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_off(vtkNew sself); +extern "C" void vtk_implicit_selection_loop_set_normal(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_implicit_selection_loop_set_normal(vtkNew sself, const double _arg); +extern "C" double* vtk_implicit_selection_loop_get_normal(vtkNew sself); +extern "C" void vtk_implicit_selection_loop_get_normal(vtkNew sself, double data); +extern "C" unsigned long vtk_implicit_selection_loop_get_m_time(vtkNew sself); extern "C" vtkNew < vtkImplicitSum > vtkImplicitSum_new () ; extern "C" void vtkImplicitSum_destructor (vtkNew < vtkImplicitSum > sself) ; extern "C" void * vtkImplicitSum_get_ptr (vtkNew < vtkImplicitSum > sself) ; +extern "C" double vtk_implicit_sum_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_implicit_sum_evaluate_gradient(vtkNew sself, double x, double g); +extern "C" unsigned long vtk_implicit_sum_get_m_time(vtkNew sself); +extern "C" void vtk_implicit_sum_remove_all_functions(vtkNew sself); +extern "C" void vtk_implicit_sum_set_normalize_by_weight(vtkNew sself, int _arg); +extern "C" int vtk_implicit_sum_get_normalize_by_weight(vtkNew sself); +extern "C" void vtk_implicit_sum_normalize_by_weight_on(vtkNew sself); +extern "C" void vtk_implicit_sum_normalize_by_weight_off(vtkNew sself); extern "C" vtkNew < vtkImplicitVolume > vtkImplicitVolume_new () ; extern "C" void vtkImplicitVolume_destructor (vtkNew < vtkImplicitVolume > sself) ; extern "C" void * vtkImplicitVolume_get_ptr (vtkNew < vtkImplicitVolume > sself) ; +extern "C" unsigned long vtk_implicit_volume_get_m_time(vtkNew sself); +extern "C" double vtk_implicit_volume_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_implicit_volume_evaluate_gradient(vtkNew sself, double x, double n); +extern "C" void vtk_implicit_volume_set_out_value(vtkNew sself, double _arg); +extern "C" double vtk_implicit_volume_get_out_value(vtkNew sself); +extern "C" void vtk_implicit_volume_set_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_implicit_volume_set_out_gradient(vtkNew sself, const double _arg); +extern "C" double* vtk_implicit_volume_get_out_gradient(vtkNew sself); +extern "C" void vtk_implicit_volume_get_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_implicit_volume_get_out_gradient(vtkNew sself, double _arg); extern "C" vtkNew < vtkImplicitWindowFunction > vtkImplicitWindowFunction_new () ; extern "C" void vtkImplicitWindowFunction_destructor (vtkNew < vtkImplicitWindowFunction > sself) ; extern "C" void * vtkImplicitWindowFunction_get_ptr (vtkNew < vtkImplicitWindowFunction > sself) ; +extern "C" double vtk_implicit_window_function_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_implicit_window_function_evaluate_gradient(vtkNew sself, double x, double n); +extern "C" void vtk_implicit_window_function_set_window_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_implicit_window_function_set_window_range(vtkNew sself, const double _arg); +extern "C" double* vtk_implicit_window_function_get_window_range(vtkNew sself); +extern "C" void vtk_implicit_window_function_get_window_range(vtkNew sself, double data); +extern "C" void vtk_implicit_window_function_set_window_values(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_implicit_window_function_set_window_values(vtkNew sself, const double _arg); +extern "C" double* vtk_implicit_window_function_get_window_values(vtkNew sself); +extern "C" void vtk_implicit_window_function_get_window_values(vtkNew sself, double data); +extern "C" unsigned long vtk_implicit_window_function_get_m_time(vtkNew sself); extern "C" vtkNew < vtkInEdgeIterator > vtkInEdgeIterator_new () ; extern "C" void vtkInEdgeIterator_destructor (vtkNew < vtkInEdgeIterator > sself) ; extern "C" void * vtkInEdgeIterator_get_ptr (vtkNew < vtkInEdgeIterator > sself) ; +extern "C" long long vtk_in_edge_iterator_get_vertex(vtkNew sself); +extern "C" bool vtk_in_edge_iterator_has_next(vtkNew sself); extern "C" vtkNew < vtkIncrementalOctreeNode > vtkIncrementalOctreeNode_new () ; extern "C" void vtkIncrementalOctreeNode_destructor (vtkNew < vtkIncrementalOctreeNode > sself) ; extern "C" void * vtkIncrementalOctreeNode_get_ptr (vtkNew < vtkIncrementalOctreeNode > sself) ; +extern "C" int vtk_incremental_octree_node_get_number_of_points(vtkNew sself); +extern "C" void vtk_incremental_octree_node_delete_child_nodes(vtkNew sself); +extern "C" void vtk_incremental_octree_node_set_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2); +extern "C" void vtk_incremental_octree_node_get_bounds(vtkNew sself, double bounds); +extern "C" double* vtk_incremental_octree_node_get_min_bounds(vtkNew sself); +extern "C" void vtk_incremental_octree_node_get_min_bounds(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_incremental_octree_node_get_min_bounds(vtkNew sself, double _arg); +extern "C" double* vtk_incremental_octree_node_get_max_bounds(vtkNew sself); +extern "C" void vtk_incremental_octree_node_get_max_bounds(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_incremental_octree_node_get_max_bounds(vtkNew sself, double _arg); +extern "C" double* vtk_incremental_octree_node_get_min_data_bounds(vtkNew sself); +extern "C" double* vtk_incremental_octree_node_get_max_data_bounds(vtkNew sself); +extern "C" int vtk_incremental_octree_node_is_leaf(vtkNew sself); +extern "C" int vtk_incremental_octree_node_get_child_index(vtkNew sself, const double point); +extern "C" int vtk_incremental_octree_node_contains_point(vtkNew sself, const double pnt); +extern "C" int vtk_incremental_octree_node_contains_point_by_data(vtkNew sself, const double pnt); +extern "C" int vtk_incremental_octree_node_get_number_of_levels(vtkNew sself); +extern "C" int vtk_incremental_octree_node_get_id(vtkNew sself); extern "C" vtkNew < vtkIncrementalOctreePointLocator > vtkIncrementalOctreePointLocator_new () ; extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkNew < vtkIncrementalOctreePointLocator > sself) ; extern "C" void * vtkIncrementalOctreePointLocator_get_ptr (vtkNew < vtkIncrementalOctreePointLocator > sself) ; +extern "C" void vtk_incremental_octree_point_locator_set_max_points_per_leaf(vtkNew sself, int _arg); +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value(vtkNew sself); +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value(vtkNew sself); +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf(vtkNew sself); +extern "C" void vtk_incremental_octree_point_locator_set_build_cubic_octree(vtkNew sself, int _arg); +extern "C" int vtk_incremental_octree_point_locator_get_build_cubic_octree(vtkNew sself); +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_on(vtkNew sself); +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_off(vtkNew sself); +extern "C" void vtk_incremental_octree_point_locator_initialize(vtkNew sself); +extern "C" void vtk_incremental_octree_point_locator_free_search_structure(vtkNew sself); +extern "C" void vtk_incremental_octree_point_locator_get_bounds(vtkNew sself, double bounds); +extern "C" double* vtk_incremental_octree_point_locator_get_bounds(vtkNew sself); +extern "C" int vtk_incremental_octree_point_locator_get_number_of_points(vtkNew sself); +extern "C" int vtk_incremental_octree_point_locator_get_number_of_nodes(vtkNew sself); +extern "C" long long vtk_incremental_octree_point_locator_find_closest_inserted_point(vtkNew sself, const double x); +extern "C" void vtk_incremental_octree_point_locator_build_locator(vtkNew sself); +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, const double x); +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z); +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, const double x, double miniDist2); +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z, double miniDist2); +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point_within_squared_radius(vtkNew sself, double radius2, const double x, double dist2); +extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkNew sself, const double x); +extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkNew sself, double x, double y, double z); +extern "C" int vtk_incremental_octree_point_locator_insert_unique_point(vtkNew sself, const double point, long long pntId); +extern "C" void vtk_incremental_octree_point_locator_insert_point(vtkNew sself, long long ptId, const double x); +extern "C" long long vtk_incremental_octree_point_locator_insert_next_point(vtkNew sself, const double x); +extern "C" void vtk_incremental_octree_point_locator_insert_point_without_checking(vtkNew sself, const double point, long long pntId, int insert); +extern "C" int vtk_incremental_octree_point_locator_get_number_of_levels(vtkNew sself); extern "C" vtkNew < vtkIterativeClosestPointTransform > vtkIterativeClosestPointTransform_new () ; extern "C" void vtkIterativeClosestPointTransform_destructor (vtkNew < vtkIterativeClosestPointTransform > sself) ; extern "C" void * vtkIterativeClosestPointTransform_get_ptr (vtkNew < vtkIterativeClosestPointTransform > sself) ; +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_iterations(vtkNew sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_iterations(vtkNew sself); +extern "C" int vtk_iterative_closest_point_transform_get_number_of_iterations(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_set_check_mean_distance(vtkNew sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_check_mean_distance(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_on(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_off(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode(vtkNew sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value(vtkNew sself); +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value(vtkNew sself); +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value(vtkNew sself); +extern "C" const char* vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_set_maximum_mean_distance(vtkNew sself, double _arg); +extern "C" double vtk_iterative_closest_point_transform_get_maximum_mean_distance(vtkNew sself); +extern "C" double vtk_iterative_closest_point_transform_get_mean_distance(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks(vtkNew sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_set_start_by_matching_centroids(vtkNew sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_start_by_matching_centroids(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_on(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_off(vtkNew sself); +extern "C" void vtk_iterative_closest_point_transform_inverse(vtkNew sself); extern "C" vtkNew < vtkKdNode > vtkKdNode_new () ; extern "C" void vtkKdNode_destructor (vtkNew < vtkKdNode > sself) ; extern "C" void * vtkKdNode_get_ptr (vtkNew < vtkKdNode > sself) ; +extern "C" void vtk_kd_node_set_dim(vtkNew sself, int _arg); +extern "C" int vtk_kd_node_get_dim(vtkNew sself); +extern "C" double vtk_kd_node_get_division_position(vtkNew sself); +extern "C" void vtk_kd_node_set_number_of_points(vtkNew sself, int _arg); +extern "C" int vtk_kd_node_get_number_of_points(vtkNew sself); +extern "C" void vtk_kd_node_set_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2); +extern "C" void vtk_kd_node_set_bounds(vtkNew sself, const double b); +extern "C" void vtk_kd_node_get_bounds(vtkNew sself, double b); +extern "C" void vtk_kd_node_set_data_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2); +extern "C" void vtk_kd_node_get_data_bounds(vtkNew sself, double b); +extern "C" void vtk_kd_node_set_data_bounds(vtkNew sself, float v); +extern "C" double* vtk_kd_node_get_min_bounds(vtkNew sself); +extern "C" double* vtk_kd_node_get_max_bounds(vtkNew sself); +extern "C" void vtk_kd_node_set_min_bounds(vtkNew sself, const double mb); +extern "C" void vtk_kd_node_set_max_bounds(vtkNew sself, const double mb); +extern "C" double* vtk_kd_node_get_min_data_bounds(vtkNew sself); +extern "C" double* vtk_kd_node_get_max_data_bounds(vtkNew sself); +extern "C" void vtk_kd_node_set_min_data_bounds(vtkNew sself, const double mb); +extern "C" void vtk_kd_node_set_max_data_bounds(vtkNew sself, const double mb); +extern "C" void vtk_kd_node_set_id(vtkNew sself, int _arg); +extern "C" int vtk_kd_node_get_id(vtkNew sself); +extern "C" int vtk_kd_node_get_min_id(vtkNew sself); +extern "C" int vtk_kd_node_get_max_id(vtkNew sself); +extern "C" void vtk_kd_node_set_min_id(vtkNew sself, int _arg); +extern "C" void vtk_kd_node_set_max_id(vtkNew sself, int _arg); +extern "C" void vtk_kd_node_delete_child_nodes(vtkNew sself); +extern "C" int vtk_kd_node_intersects_box(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds); +extern "C" int vtk_kd_node_intersects_sphere_2(vtkNew sself, double x, double y, double z, double rSquared, int useDataBounds); +extern "C" int vtk_kd_node_contains_box(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds); +extern "C" int vtk_kd_node_contains_point(vtkNew sself, double x, double y, double z, int useDataBounds); +extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkNew sself, double x, double y, double z, int useDataBounds); +extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkNew sself, double x, double y, double z, double boundaryPt, int useDataBounds); +extern "C" double vtk_kd_node_get_distance_2_to_inner_boundary(vtkNew sself, double x, double y, double z); +extern "C" void vtk_kd_node_print_node(vtkNew sself, int depth); +extern "C" void vtk_kd_node_print_verbose_node(vtkNew sself, int depth); extern "C" vtkNew < vtkKdTree > vtkKdTree_new () ; extern "C" void vtkKdTree_destructor (vtkNew < vtkKdTree > sself) ; extern "C" void * vtkKdTree_get_ptr (vtkNew < vtkKdTree > sself) ; +extern "C" void vtk_kd_tree_timing_on(vtkNew sself); +extern "C" void vtk_kd_tree_timing_off(vtkNew sself); +extern "C" void vtk_kd_tree_set_timing(vtkNew sself, int _arg); +extern "C" int vtk_kd_tree_get_timing(vtkNew sself); +extern "C" void vtk_kd_tree_set_min_cells(vtkNew sself, int _arg); +extern "C" int vtk_kd_tree_get_min_cells(vtkNew sself); +extern "C" int vtk_kd_tree_get_number_of_regions_or_less(vtkNew sself); +extern "C" void vtk_kd_tree_set_number_of_regions_or_less(vtkNew sself, int _arg); +extern "C" int vtk_kd_tree_get_number_of_regions_or_more(vtkNew sself); +extern "C" void vtk_kd_tree_set_number_of_regions_or_more(vtkNew sself, int _arg); +extern "C" double vtk_kd_tree_get_fudge_factor(vtkNew sself); +extern "C" void vtk_kd_tree_set_fudge_factor(vtkNew sself, double _arg); +extern "C" void vtk_kd_tree_omit_x_partitioning(vtkNew sself); +extern "C" void vtk_kd_tree_omit_y_partitioning(vtkNew sself); +extern "C" void vtk_kd_tree_omit_z_partitioning(vtkNew sself); +extern "C" void vtk_kd_tree_omit_xy_partitioning(vtkNew sself); +extern "C" void vtk_kd_tree_omit_yz_partitioning(vtkNew sself); +extern "C" void vtk_kd_tree_omit_zx_partitioning(vtkNew sself); +extern "C" void vtk_kd_tree_omit_no_partitioning(vtkNew sself); +extern "C" void vtk_kd_tree_remove_data_set(vtkNew sself, int index); +extern "C" void vtk_kd_tree_remove_all_data_sets(vtkNew sself); +extern "C" int vtk_kd_tree_get_number_of_data_sets(vtkNew sself); +extern "C" void vtk_kd_tree_get_bounds(vtkNew sself, double bounds); +extern "C" void vtk_kd_tree_set_new_bounds(vtkNew sself, double bounds); +extern "C" int vtk_kd_tree_get_number_of_regions(vtkNew sself); +extern "C" void vtk_kd_tree_get_region_bounds(vtkNew sself, int regionID, double bounds); +extern "C" void vtk_kd_tree_get_region_data_bounds(vtkNew sself, int regionID, double bounds); +extern "C" void vtk_kd_tree_print_tree(vtkNew sself); +extern "C" void vtk_kd_tree_print_verbose_tree(vtkNew sself); +extern "C" void vtk_kd_tree_print_region(vtkNew sself, int id); +extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself, int dataSetIndex, int regionReqList, int reqListSize); +extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself, int regionReqList, int listSize); +extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself); +extern "C" void vtk_kd_tree_set_include_region_boundary_cells(vtkNew sself, int _arg); +extern "C" int vtk_kd_tree_get_include_region_boundary_cells(vtkNew sself); +extern "C" void vtk_kd_tree_include_region_boundary_cells_on(vtkNew sself); +extern "C" void vtk_kd_tree_include_region_boundary_cells_off(vtkNew sself); +extern "C" void vtk_kd_tree_delete_cell_lists(vtkNew sself); +extern "C" int vtk_kd_tree_get_region_containing_cell(vtkNew sself, int set, long long cellID); +extern "C" int vtk_kd_tree_get_region_containing_cell(vtkNew sself, long long cellID); +extern "C" int* vtk_kd_tree_all_get_region_containing_cell(vtkNew sself); +extern "C" int vtk_kd_tree_get_region_containing_point(vtkNew sself, double x, double y, double z); +extern "C" void vtk_kd_tree_build_locator(vtkNew sself); +extern "C" long long vtk_kd_tree_find_point(vtkNew sself, double x); +extern "C" long long vtk_kd_tree_find_point(vtkNew sself, double x, double y, double z); +extern "C" long long vtk_kd_tree_find_closest_point(vtkNew sself, double x, double dist2); +extern "C" long long vtk_kd_tree_find_closest_point(vtkNew sself, double x, double y, double z, double dist2); +extern "C" long long vtk_kd_tree_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); +extern "C" long long vtk_kd_tree_find_closest_point_in_region(vtkNew sself, int regionId, double x, double dist2); +extern "C" long long vtk_kd_tree_find_closest_point_in_region(vtkNew sself, int regionId, double x, double y, double z, double dist2); +extern "C" void vtk_kd_tree_free_search_structure(vtkNew sself); +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_on(vtkNew sself); +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_off(vtkNew sself); +extern "C" void vtk_kd_tree_set_generate_representation_using_data_bounds(vtkNew sself, int _arg); +extern "C" int vtk_kd_tree_get_generate_representation_using_data_bounds(vtkNew sself); +extern "C" int vtk_kd_tree_new_geometry(vtkNew sself); +extern "C" void vtk_kd_tree_invalidate_geometry(vtkNew sself); extern "C" vtkNew < vtkKdTreePointLocator > vtkKdTreePointLocator_new () ; extern "C" void vtkKdTreePointLocator_destructor (vtkNew < vtkKdTreePointLocator > sself) ; extern "C" void * vtkKdTreePointLocator_get_ptr (vtkNew < vtkKdTreePointLocator > sself) ; +extern "C" long long vtk_kd_tree_point_locator_find_closest_point(vtkNew sself, const double x); +extern "C" long long vtk_kd_tree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); +extern "C" void vtk_kd_tree_point_locator_free_search_structure(vtkNew sself); +extern "C" void vtk_kd_tree_point_locator_build_locator(vtkNew sself); extern "C" vtkNew < vtkLagrangeCurve > vtkLagrangeCurve_new () ; extern "C" void vtkLagrangeCurve_destructor (vtkNew < vtkLagrangeCurve > sself) ; extern "C" void * vtkLagrangeCurve_get_ptr (vtkNew < vtkLagrangeCurve > sself) ; +extern "C" int vtk_lagrange_curve_get_cell_type(vtkNew sself); +extern "C" void vtk_lagrange_curve_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkLagrangeHexahedron > vtkLagrangeHexahedron_new () ; extern "C" void vtkLagrangeHexahedron_destructor (vtkNew < vtkLagrangeHexahedron > sself) ; extern "C" void * vtkLagrangeHexahedron_get_ptr (vtkNew < vtkLagrangeHexahedron > sself) ; +extern "C" int vtk_lagrange_hexahedron_get_cell_type(vtkNew sself); +extern "C" void vtk_lagrange_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkLagrangeInterpolation > vtkLagrangeInterpolation_new () ; extern "C" void vtkLagrangeInterpolation_destructor (vtkNew < vtkLagrangeInterpolation > sself) ; extern "C" void * vtkLagrangeInterpolation_get_ptr (vtkNew < vtkLagrangeInterpolation > sself) ; +extern "C" void vtk_lagrange_interpolation_evaluate_shape_functions(vtkNew sself, const int order, const double pcoord, double shape); +extern "C" void vtk_lagrange_interpolation_evaluate_shape_and_gradient(vtkNew sself, const int order, const double pcoord, double shape, double grad); +extern "C" int vtk_lagrange_interpolation_tensor_1_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); +extern "C" int vtk_lagrange_interpolation_tensor_1_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); +extern "C" int vtk_lagrange_interpolation_tensor_2_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); +extern "C" int vtk_lagrange_interpolation_tensor_2_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); +extern "C" int vtk_lagrange_interpolation_tensor_3_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); +extern "C" int vtk_lagrange_interpolation_tensor_3_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); +extern "C" void vtk_lagrange_interpolation_wedge_shape_functions(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double shape); +extern "C" void vtk_lagrange_interpolation_wedge_shape_derivatives(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double derivs); +extern "C" void vtk_lagrange_interpolation_wedge_evaluate(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double fieldVals, int fieldDim, double fieldAtPCoords); extern "C" vtkNew < vtkLagrangeQuadrilateral > vtkLagrangeQuadrilateral_new () ; extern "C" void vtkLagrangeQuadrilateral_destructor (vtkNew < vtkLagrangeQuadrilateral > sself) ; extern "C" void * vtkLagrangeQuadrilateral_get_ptr (vtkNew < vtkLagrangeQuadrilateral > sself) ; +extern "C" int vtk_lagrange_quadrilateral_get_cell_type(vtkNew sself); +extern "C" void vtk_lagrange_quadrilateral_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkLagrangeTetra > vtkLagrangeTetra_new () ; extern "C" void vtkLagrangeTetra_destructor (vtkNew < vtkLagrangeTetra > sself) ; extern "C" void * vtkLagrangeTetra_get_ptr (vtkNew < vtkLagrangeTetra > sself) ; +extern "C" int vtk_lagrange_tetra_get_cell_type(vtkNew sself); +extern "C" void vtk_lagrange_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkLagrangeTriangle > vtkLagrangeTriangle_new () ; extern "C" void vtkLagrangeTriangle_destructor (vtkNew < vtkLagrangeTriangle > sself) ; extern "C" void * vtkLagrangeTriangle_get_ptr (vtkNew < vtkLagrangeTriangle > sself) ; +extern "C" int vtk_lagrange_triangle_get_cell_type(vtkNew sself); +extern "C" void vtk_lagrange_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkLagrangeWedge > vtkLagrangeWedge_new () ; extern "C" void vtkLagrangeWedge_destructor (vtkNew < vtkLagrangeWedge > sself) ; extern "C" void * vtkLagrangeWedge_get_ptr (vtkNew < vtkLagrangeWedge > sself) ; +extern "C" int vtk_lagrange_wedge_get_cell_type(vtkNew sself); +extern "C" void vtk_lagrange_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); extern "C" vtkNew < vtkLine > vtkLine_new () ; extern "C" void vtkLine_destructor (vtkNew < vtkLine > sself) ; extern "C" void * vtkLine_get_ptr (vtkNew < vtkLine > sself) ; +extern "C" int vtk_line_get_cell_type(vtkNew sself); +extern "C" int vtk_line_get_cell_dimension(vtkNew sself); +extern "C" int vtk_line_get_number_of_edges(vtkNew sself); +extern "C" int vtk_line_get_number_of_faces(vtkNew sself); +extern "C" int vtk_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_line_inflate(vtkNew sself, double dist); +extern "C" int vtk_line_get_parametric_center(vtkNew sself, double pcoords); +extern "C" int vtk_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_line_intersection(vtkNew sself, const double p1, const double p2, const double x1, const double x2, double u, double v, const double tolerance, int toleranceType); +extern "C" int vtk_line_intersection_3_d(vtkNew sself, double p1, double p2, double x1, double x2, double u, double v, const double tolerance); +extern "C" double vtk_line_distance_to_line(vtkNew sself, const double x, const double p1, const double p2, double t, double closestPoint); +extern "C" double vtk_line_distance_to_line(vtkNew sself, const double x, const double p1, const double p2); +extern "C" double vtk_line_distance_between_lines(vtkNew sself, double l0, double l1, double m0, double m1, double closestPt1, double closestPt2, double t1, double t2); +extern "C" double vtk_line_distance_between_line_segments(vtkNew sself, double l0, double l1, double m0, double m1, double closestPt1, double closestPt2, double t1, double t2); +extern "C" void vtk_line_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_line_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_line_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_line_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); extern "C" vtkNew < vtkMeanValueCoordinatesInterpolator > vtkMeanValueCoordinatesInterpolator_new () ; extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) ; extern "C" void * vtkMeanValueCoordinatesInterpolator_get_ptr (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) ; extern "C" vtkNew < vtkMergePoints > vtkMergePoints_new () ; extern "C" void vtkMergePoints_destructor (vtkNew < vtkMergePoints > sself) ; extern "C" void * vtkMergePoints_get_ptr (vtkNew < vtkMergePoints > sself) ; +extern "C" long long vtk_merge_points_is_inserted_point(vtkNew sself, const double x); +extern "C" int vtk_merge_points_insert_unique_point(vtkNew sself, const double x, long long ptId); extern "C" vtkNew < vtkMolecule > vtkMolecule_new () ; extern "C" void vtkMolecule_destructor (vtkNew < vtkMolecule > sself) ; extern "C" void * vtkMolecule_get_ptr (vtkNew < vtkMolecule > sself) ; +extern "C" long long vtk_molecule_get_number_of_atoms(vtkNew sself); +extern "C" long long vtk_molecule_get_number_of_bonds(vtkNew sself); +extern "C" unsigned short vtk_molecule_get_atom_atomic_number(vtkNew sself, long long atomId); +extern "C" void vtk_molecule_set_atom_atomic_number(vtkNew sself, long long atomId, unsigned short atomicNum); +extern "C" void vtk_molecule_set_atom_position(vtkNew sself, long long atomId, double x, double y, double z); +extern "C" void vtk_molecule_set_atom_position(vtkNew sself, long long atomId, double pos); +extern "C" void vtk_molecule_get_atom_position(vtkNew sself, long long atomId, float pos); +extern "C" void vtk_molecule_get_atom_position(vtkNew sself, long long atomId, double pos); +extern "C" void vtk_molecule_set_bond_order(vtkNew sself, long long bondId, unsigned short order); +extern "C" unsigned short vtk_molecule_get_bond_order(vtkNew sself, long long bondId); +extern "C" double vtk_molecule_get_bond_length(vtkNew sself, long long bondId); +extern "C" bool vtk_molecule_has_lattice(vtkNew sself); +extern "C" void vtk_molecule_clear_lattice(vtkNew sself); +extern "C" void vtk_molecule_allocate_atom_ghost_array(vtkNew sself); +extern "C" void vtk_molecule_allocate_bond_ghost_array(vtkNew sself); +extern "C" long long vtk_molecule_get_bond_id(vtkNew sself, long long a, long long b); +extern "C" void vtk_molecule_set_atomic_number_array_name(vtkNew sself, const char _arg); +extern "C" char* vtk_molecule_get_atomic_number_array_name(vtkNew sself); +extern "C" void vtk_molecule_set_bond_orders_array_name(vtkNew sself, const char _arg); +extern "C" char* vtk_molecule_get_bond_orders_array_name(vtkNew sself); extern "C" vtkNew < vtkMultiBlockDataSet > vtkMultiBlockDataSet_new () ; extern "C" void vtkMultiBlockDataSet_destructor (vtkNew < vtkMultiBlockDataSet > sself) ; extern "C" void * vtkMultiBlockDataSet_get_ptr (vtkNew < vtkMultiBlockDataSet > sself) ; +extern "C" void vtk_multi_block_data_set_set_number_of_blocks(vtkNew sself, unsigned int numBlocks); +extern "C" unsigned int vtk_multi_block_data_set_get_number_of_blocks(vtkNew sself); +extern "C" void vtk_multi_block_data_set_remove_block(vtkNew sself, unsigned int blockno); +extern "C" int vtk_multi_block_data_set_has_meta_data(vtkNew sself, unsigned int blockno); extern "C" vtkNew < vtkMultiPieceDataSet > vtkMultiPieceDataSet_new () ; extern "C" void vtkMultiPieceDataSet_destructor (vtkNew < vtkMultiPieceDataSet > sself) ; extern "C" void * vtkMultiPieceDataSet_get_ptr (vtkNew < vtkMultiPieceDataSet > sself) ; +extern "C" void vtk_multi_piece_data_set_set_number_of_pieces(vtkNew sself, unsigned int numpieces); +extern "C" unsigned int vtk_multi_piece_data_set_get_number_of_pieces(vtkNew sself); extern "C" vtkNew < vtkMutableDirectedGraph > vtkMutableDirectedGraph_new () ; extern "C" void vtkMutableDirectedGraph_destructor (vtkNew < vtkMutableDirectedGraph > sself) ; extern "C" void * vtkMutableDirectedGraph_get_ptr (vtkNew < vtkMutableDirectedGraph > sself) ; +extern "C" long long vtk_mutable_directed_graph_set_number_of_vertices(vtkNew sself, long long numVerts); +extern "C" long long vtk_mutable_directed_graph_add_vertex(vtkNew sself); +extern "C" void vtk_mutable_directed_graph_lazy_add_vertex(vtkNew sself); +extern "C" long long vtk_mutable_directed_graph_add_child(vtkNew sself, long long parent); +extern "C" void vtk_mutable_directed_graph_remove_vertex(vtkNew sself, long long v); +extern "C" void vtk_mutable_directed_graph_remove_edge(vtkNew sself, long long e); extern "C" vtkNew < vtkMutableUndirectedGraph > vtkMutableUndirectedGraph_new () ; extern "C" void vtkMutableUndirectedGraph_destructor (vtkNew < vtkMutableUndirectedGraph > sself) ; extern "C" void * vtkMutableUndirectedGraph_get_ptr (vtkNew < vtkMutableUndirectedGraph > sself) ; +extern "C" long long vtk_mutable_undirected_graph_set_number_of_vertices(vtkNew sself, long long numVerts); +extern "C" long long vtk_mutable_undirected_graph_add_vertex(vtkNew sself); +extern "C" void vtk_mutable_undirected_graph_lazy_add_vertex(vtkNew sself); +extern "C" void vtk_mutable_undirected_graph_lazy_add_edge(vtkNew sself, long long u, long long v); +extern "C" void vtk_mutable_undirected_graph_remove_vertex(vtkNew sself, long long v); +extern "C" void vtk_mutable_undirected_graph_remove_edge(vtkNew sself, long long e); extern "C" vtkNew < vtkNonMergingPointLocator > vtkNonMergingPointLocator_new () ; extern "C" void vtkNonMergingPointLocator_destructor (vtkNew < vtkNonMergingPointLocator > sself) ; extern "C" void * vtkNonMergingPointLocator_get_ptr (vtkNew < vtkNonMergingPointLocator > sself) ; +extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNew sself, const double p0); +extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNew sself, double p0, double p1, double p2); +extern "C" int vtk_non_merging_point_locator_insert_unique_point(vtkNew sself, const double x, long long ptId); extern "C" vtkNew < vtkNonOverlappingAMR > vtkNonOverlappingAMR_new () ; extern "C" void vtkNonOverlappingAMR_destructor (vtkNew < vtkNonOverlappingAMR > sself) ; extern "C" void * vtkNonOverlappingAMR_get_ptr (vtkNew < vtkNonOverlappingAMR > sself) ; +extern "C" int vtk_non_overlapping_amr_get_data_object_type(vtkNew sself); extern "C" vtkNew < vtkOctreePointLocator > vtkOctreePointLocator_new () ; extern "C" void vtkOctreePointLocator_destructor (vtkNew < vtkOctreePointLocator > sself) ; extern "C" void * vtkOctreePointLocator_get_ptr (vtkNew < vtkOctreePointLocator > sself) ; +extern "C" void vtk_octree_point_locator_set_maximum_points_per_region(vtkNew sself, int _arg); +extern "C" int vtk_octree_point_locator_get_maximum_points_per_region(vtkNew sself); +extern "C" void vtk_octree_point_locator_set_create_cubic_octants(vtkNew sself, int _arg); +extern "C" int vtk_octree_point_locator_get_create_cubic_octants(vtkNew sself); +extern "C" double vtk_octree_point_locator_get_fudge_factor(vtkNew sself); +extern "C" void vtk_octree_point_locator_set_fudge_factor(vtkNew sself, double _arg); +extern "C" double* vtk_octree_point_locator_get_bounds(vtkNew sself); +extern "C" void vtk_octree_point_locator_get_bounds(vtkNew sself, double bounds); +extern "C" int vtk_octree_point_locator_get_number_of_leaf_nodes(vtkNew sself); +extern "C" void vtk_octree_point_locator_get_region_bounds(vtkNew sself, int regionID, double bounds); +extern "C" void vtk_octree_point_locator_get_region_data_bounds(vtkNew sself, int leafNodeID, double bounds); +extern "C" int vtk_octree_point_locator_get_region_containing_point(vtkNew sself, double x, double y, double z); +extern "C" void vtk_octree_point_locator_build_locator(vtkNew sself); +extern "C" long long vtk_octree_point_locator_find_closest_point(vtkNew sself, const double x); +extern "C" long long vtk_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z, double dist2); +extern "C" long long vtk_octree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); +extern "C" long long vtk_octree_point_locator_find_closest_point_in_region(vtkNew sself, int regionId, double x, double dist2); +extern "C" long long vtk_octree_point_locator_find_closest_point_in_region(vtkNew sself, int regionId, double x, double y, double z, double dist2); +extern "C" void vtk_octree_point_locator_free_search_structure(vtkNew sself); extern "C" vtkNew < vtkOctreePointLocatorNode > vtkOctreePointLocatorNode_new () ; extern "C" void vtkOctreePointLocatorNode_destructor (vtkNew < vtkOctreePointLocatorNode > sself) ; extern "C" void * vtkOctreePointLocatorNode_get_ptr (vtkNew < vtkOctreePointLocatorNode > sself) ; +extern "C" void vtk_octree_point_locator_node_set_number_of_points(vtkNew sself, int numberOfPoints); +extern "C" int vtk_octree_point_locator_node_get_number_of_points(vtkNew sself); +extern "C" void vtk_octree_point_locator_node_set_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" void vtk_octree_point_locator_node_set_bounds(vtkNew sself, const double b); +extern "C" void vtk_octree_point_locator_node_get_bounds(vtkNew sself, double b); +extern "C" void vtk_octree_point_locator_node_set_data_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" void vtk_octree_point_locator_node_get_data_bounds(vtkNew sself, double b); +extern "C" double* vtk_octree_point_locator_node_get_min_bounds(vtkNew sself); +extern "C" double* vtk_octree_point_locator_node_get_max_bounds(vtkNew sself); +extern "C" void vtk_octree_point_locator_node_set_min_bounds(vtkNew sself, double minBounds); +extern "C" void vtk_octree_point_locator_node_set_max_bounds(vtkNew sself, double maxBounds); +extern "C" double* vtk_octree_point_locator_node_get_min_data_bounds(vtkNew sself); +extern "C" double* vtk_octree_point_locator_node_get_max_data_bounds(vtkNew sself); +extern "C" void vtk_octree_point_locator_node_set_min_data_bounds(vtkNew sself, double minDataBounds); +extern "C" void vtk_octree_point_locator_node_set_max_data_bounds(vtkNew sself, double maxDataBounds); +extern "C" int vtk_octree_point_locator_node_get_id(vtkNew sself); +extern "C" int vtk_octree_point_locator_node_get_min_id(vtkNew sself); +extern "C" void vtk_octree_point_locator_node_create_child_nodes(vtkNew sself); +extern "C" void vtk_octree_point_locator_node_delete_child_nodes(vtkNew sself); +extern "C" int vtk_octree_point_locator_node_contains_point(vtkNew sself, double x, double y, double z, int useDataBounds); +extern "C" int vtk_octree_point_locator_node_get_sub_octant_index(vtkNew sself, double point, int CheckContainment); extern "C" vtkNew < vtkOrderedTriangulator > vtkOrderedTriangulator_new () ; extern "C" void vtkOrderedTriangulator_destructor (vtkNew < vtkOrderedTriangulator > sself) ; extern "C" void * vtkOrderedTriangulator_get_ptr (vtkNew < vtkOrderedTriangulator > sself) ; +extern "C" void vtk_ordered_triangulator_init_triangulation(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts); +extern "C" void vtk_ordered_triangulator_init_triangulation(vtkNew sself, double bounds, int numPts); +extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, double x, double p, int type); +extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, long long sortid, double x, double p, int type); +extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, long long sortid, long long sortid2, double x, double p, int type); +extern "C" void vtk_ordered_triangulator_triangulate(vtkNew sself); +extern "C" void vtk_ordered_triangulator_template_triangulate(vtkNew sself, int cellType, int numPts, int numEdges); +extern "C" void vtk_ordered_triangulator_update_point_type(vtkNew sself, long long internalId, int type); +extern "C" double* vtk_ordered_triangulator_get_point_position(vtkNew sself, long long internalId); +extern "C" double* vtk_ordered_triangulator_get_point_location(vtkNew sself, long long internalId); +extern "C" long long vtk_ordered_triangulator_get_point_id(vtkNew sself, long long internalId); +extern "C" int vtk_ordered_triangulator_get_number_of_points(vtkNew sself); +extern "C" void vtk_ordered_triangulator_set_use_templates(vtkNew sself, int _arg); +extern "C" int vtk_ordered_triangulator_get_use_templates(vtkNew sself); +extern "C" void vtk_ordered_triangulator_use_templates_on(vtkNew sself); +extern "C" void vtk_ordered_triangulator_use_templates_off(vtkNew sself); +extern "C" void vtk_ordered_triangulator_set_pre_sorted(vtkNew sself, int _arg); +extern "C" int vtk_ordered_triangulator_get_pre_sorted(vtkNew sself); +extern "C" void vtk_ordered_triangulator_pre_sorted_on(vtkNew sself); +extern "C" void vtk_ordered_triangulator_pre_sorted_off(vtkNew sself); +extern "C" void vtk_ordered_triangulator_set_use_two_sort_ids(vtkNew sself, int _arg); +extern "C" int vtk_ordered_triangulator_get_use_two_sort_ids(vtkNew sself); +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_on(vtkNew sself); +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_off(vtkNew sself); +extern "C" void vtk_ordered_triangulator_init_tetra_traversal(vtkNew sself); extern "C" vtkNew < vtkOutEdgeIterator > vtkOutEdgeIterator_new () ; extern "C" void vtkOutEdgeIterator_destructor (vtkNew < vtkOutEdgeIterator > sself) ; extern "C" void * vtkOutEdgeIterator_get_ptr (vtkNew < vtkOutEdgeIterator > sself) ; +extern "C" long long vtk_out_edge_iterator_get_vertex(vtkNew sself); +extern "C" bool vtk_out_edge_iterator_has_next(vtkNew sself); extern "C" vtkNew < vtkOverlappingAMR > vtkOverlappingAMR_new () ; extern "C" void vtkOverlappingAMR_destructor (vtkNew < vtkOverlappingAMR > sself) ; extern "C" void * vtkOverlappingAMR_get_ptr (vtkNew < vtkOverlappingAMR > sself) ; +extern "C" void vtk_overlapping_amr_set_origin(vtkNew sself, const double origin); +extern "C" double* vtk_overlapping_amr_get_origin(vtkNew sself); +extern "C" void vtk_overlapping_amr_set_spacing(vtkNew sself, unsigned int level, const double spacing); +extern "C" void vtk_overlapping_amr_get_spacing(vtkNew sself, unsigned int level, double spacing); +extern "C" void vtk_overlapping_amr_get_bounds(vtkNew sself, unsigned int level, unsigned int id, double bb); +extern "C" void vtk_overlapping_amr_get_origin(vtkNew sself, unsigned int level, unsigned int id, double origin); +extern "C" void vtk_overlapping_amr_set_refinement_ratio(vtkNew sself, unsigned int level, int refRatio); +extern "C" int vtk_overlapping_amr_get_refinement_ratio(vtkNew sself, unsigned int level); +extern "C" void vtk_overlapping_amr_set_amr_block_source_index(vtkNew sself, unsigned int level, unsigned int id, int sourceId); +extern "C" int vtk_overlapping_amr_get_amr_block_source_index(vtkNew sself, unsigned int level, unsigned int id); +extern "C" bool vtk_overlapping_amr_has_children_information(vtkNew sself); +extern "C" void vtk_overlapping_amr_generate_parent_child_information(vtkNew sself); +extern "C" unsigned int* vtk_overlapping_amr_get_parents(vtkNew sself, unsigned int level, unsigned int index, unsigned int numParents); +extern "C" unsigned int* vtk_overlapping_amr_get_children(vtkNew sself, unsigned int level, unsigned int index, unsigned int numChildren); +extern "C" void vtk_overlapping_amr_print_parent_child_info(vtkNew sself, unsigned int level, unsigned int index); +extern "C" void vtk_overlapping_amr_get_bounds(vtkNew sself, double b); +extern "C" bool vtk_overlapping_amr_find_grid(vtkNew sself, double q, unsigned int level, unsigned int gridId); +extern "C" void vtk_overlapping_amr_audit(vtkNew sself); extern "C" vtkNew < vtkPartitionedDataSet > vtkPartitionedDataSet_new () ; extern "C" void vtkPartitionedDataSet_destructor (vtkNew < vtkPartitionedDataSet > sself) ; extern "C" void * vtkPartitionedDataSet_get_ptr (vtkNew < vtkPartitionedDataSet > sself) ; +extern "C" void vtk_partitioned_data_set_set_number_of_partitions(vtkNew sself, unsigned int numPartitions); +extern "C" unsigned int vtk_partitioned_data_set_get_number_of_partitions(vtkNew sself); +extern "C" int vtk_partitioned_data_set_has_meta_data(vtkNew sself, unsigned int idx); +extern "C" void vtk_partitioned_data_set_remove_null_partitions(vtkNew sself); extern "C" vtkNew < vtkPartitionedDataSetCollection > vtkPartitionedDataSetCollection_new () ; extern "C" void vtkPartitionedDataSetCollection_destructor (vtkNew < vtkPartitionedDataSetCollection > sself) ; extern "C" void * vtkPartitionedDataSetCollection_get_ptr (vtkNew < vtkPartitionedDataSetCollection > sself) ; +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets(vtkNew sself, unsigned int numDataSets); +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets(vtkNew sself); +extern "C" void vtk_partitioned_data_set_collection_remove_partitioned_data_set(vtkNew sself, unsigned int idx); +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitions(vtkNew sself, unsigned int idx); +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitions(vtkNew sself, unsigned int idx, unsigned int numPartitions); +extern "C" int vtk_partitioned_data_set_collection_has_meta_data(vtkNew sself, unsigned int idx); +extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkNew sself, unsigned int idx); +extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkNew sself, unsigned int idx, unsigned int partition); +extern "C" unsigned long vtk_partitioned_data_set_collection_get_m_time(vtkNew sself); extern "C" vtkNew < vtkPath > vtkPath_new () ; extern "C" void vtkPath_destructor (vtkNew < vtkPath > sself) ; extern "C" void * vtkPath_get_ptr (vtkNew < vtkPath > sself) ; +extern "C" int vtk_path_get_data_object_type(vtkNew sself); +extern "C" void vtk_path_insert_next_point(vtkNew sself, float pts, int code); +extern "C" void vtk_path_insert_next_point(vtkNew sself, double pts, int code); +extern "C" void vtk_path_insert_next_point(vtkNew sself, double x, double y, double z, int code); +extern "C" long long vtk_path_get_number_of_cells(vtkNew sself); +extern "C" int vtk_path_get_max_cell_size(vtkNew sself); +extern "C" void vtk_path_allocate(vtkNew sself, long long size, int extSize); +extern "C" void vtk_path_reset(vtkNew sself); extern "C" vtkNew < vtkPentagonalPrism > vtkPentagonalPrism_new () ; extern "C" void vtkPentagonalPrism_destructor (vtkNew < vtkPentagonalPrism > sself) ; extern "C" void * vtkPentagonalPrism_get_ptr (vtkNew < vtkPentagonalPrism > sself) ; +extern "C" void vtk_pentagonal_prism_get_edge_points(vtkNew sself, long long edgeId, const long long pts); +extern "C" void vtk_pentagonal_prism_get_edge_points(vtkNew sself, int edgeId, int pts); +extern "C" long long vtk_pentagonal_prism_get_face_points(vtkNew sself, long long faceId, const long long pts); +extern "C" void vtk_pentagonal_prism_get_face_points(vtkNew sself, int faceId, int pts); +extern "C" void vtk_pentagonal_prism_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); +extern "C" long long vtk_pentagonal_prism_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); +extern "C" long long vtk_pentagonal_prism_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); +extern "C" long long vtk_pentagonal_prism_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); +extern "C" long long vtk_pentagonal_prism_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); +extern "C" bool vtk_pentagonal_prism_get_centroid(vtkNew sself, double centroid); +extern "C" int vtk_pentagonal_prism_get_cell_type(vtkNew sself); +extern "C" int vtk_pentagonal_prism_get_number_of_edges(vtkNew sself); +extern "C" int vtk_pentagonal_prism_get_number_of_faces(vtkNew sself); +extern "C" int vtk_pentagonal_prism_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_pentagonal_prism_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_pentagonal_prism_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_pentagonal_prism_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_pentagonal_prism_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_pentagonal_prism_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_pentagonal_prism_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_pentagonal_prism_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_pentagonal_prism_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_pentagonal_prism_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_pentagonal_prism_get_face_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_pentagonal_prism_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_pentagonal_prism_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_pentagonal_prism_get_point_to_incident_edges_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_pentagonal_prism_get_point_to_incident_faces_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_pentagonal_prism_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); +extern "C" void vtk_pentagonal_prism_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkPerlinNoise > vtkPerlinNoise_new () ; extern "C" void vtkPerlinNoise_destructor (vtkNew < vtkPerlinNoise > sself) ; extern "C" void * vtkPerlinNoise_get_ptr (vtkNew < vtkPerlinNoise > sself) ; +extern "C" double vtk_perlin_noise_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_perlin_noise_evaluate_gradient(vtkNew sself, double x, double n); +extern "C" void vtk_perlin_noise_set_frequency(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_perlin_noise_set_frequency(vtkNew sself, const double _arg); +extern "C" double* vtk_perlin_noise_get_frequency(vtkNew sself); +extern "C" void vtk_perlin_noise_get_frequency(vtkNew sself, double data); +extern "C" void vtk_perlin_noise_set_phase(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_perlin_noise_set_phase(vtkNew sself, const double _arg); +extern "C" double* vtk_perlin_noise_get_phase(vtkNew sself); +extern "C" void vtk_perlin_noise_get_phase(vtkNew sself, double data); +extern "C" void vtk_perlin_noise_set_amplitude(vtkNew sself, double _arg); +extern "C" double vtk_perlin_noise_get_amplitude(vtkNew sself); extern "C" vtkNew < vtkPiecewiseFunction > vtkPiecewiseFunction_new () ; extern "C" void vtkPiecewiseFunction_destructor (vtkNew < vtkPiecewiseFunction > sself) ; extern "C" void * vtkPiecewiseFunction_get_ptr (vtkNew < vtkPiecewiseFunction > sself) ; +extern "C" int vtk_piecewise_function_get_data_object_type(vtkNew sself); +extern "C" int vtk_piecewise_function_get_size(vtkNew sself); +extern "C" int vtk_piecewise_function_add_point(vtkNew sself, double x, double y); +extern "C" int vtk_piecewise_function_add_point(vtkNew sself, double x, double y, double midpoint, double sharpness); +extern "C" bool vtk_piecewise_function_remove_point_by_index(vtkNew sself, size_t id); +extern "C" int vtk_piecewise_function_remove_point(vtkNew sself, double x); +extern "C" int vtk_piecewise_function_remove_point(vtkNew sself, double x, double y); +extern "C" void vtk_piecewise_function_remove_all_points(vtkNew sself); +extern "C" void vtk_piecewise_function_add_segment(vtkNew sself, double x1, double y1, double x2, double y2); +extern "C" double vtk_piecewise_function_get_value(vtkNew sself, double x); +extern "C" int vtk_piecewise_function_get_node_value(vtkNew sself, int index, double val); +extern "C" int vtk_piecewise_function_set_node_value(vtkNew sself, int index, double val); +extern "C" double* vtk_piecewise_function_get_data_pointer(vtkNew sself); +extern "C" void vtk_piecewise_function_fill_from_data_pointer(vtkNew sself, int p0, double p1); +extern "C" double* vtk_piecewise_function_get_range(vtkNew sself); +extern "C" void vtk_piecewise_function_get_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_piecewise_function_get_range(vtkNew sself, double _arg); +extern "C" int vtk_piecewise_function_adjust_range(vtkNew sself, double range); +extern "C" void vtk_piecewise_function_get_table(vtkNew sself, double x1, double x2, int size, float table, int stride, int logIncrements); +extern "C" void vtk_piecewise_function_get_table(vtkNew sself, double x1, double x2, int size, double table, int stride, int logIncrements); +extern "C" void vtk_piecewise_function_build_function_from_table(vtkNew sself, double x1, double x2, int size, double table, int stride); +extern "C" void vtk_piecewise_function_set_clamping(vtkNew sself, int _arg); +extern "C" int vtk_piecewise_function_get_clamping(vtkNew sself); +extern "C" void vtk_piecewise_function_clamping_on(vtkNew sself); +extern "C" void vtk_piecewise_function_clamping_off(vtkNew sself); +extern "C" void vtk_piecewise_function_set_use_log_scale(vtkNew sself, bool _arg); +extern "C" bool vtk_piecewise_function_get_use_log_scale(vtkNew sself); +extern "C" void vtk_piecewise_function_use_log_scale_on(vtkNew sself); +extern "C" void vtk_piecewise_function_use_log_scale_off(vtkNew sself); +extern "C" const char* vtk_piecewise_function_get_type(vtkNew sself); +extern "C" double vtk_piecewise_function_get_first_non_zero_value(vtkNew sself); +extern "C" void vtk_piecewise_function_initialize(vtkNew sself); +extern "C" void vtk_piecewise_function_set_allow_duplicate_scalars(vtkNew sself, int _arg); +extern "C" int vtk_piecewise_function_get_allow_duplicate_scalars(vtkNew sself); +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_on(vtkNew sself); +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_off(vtkNew sself); +extern "C" int vtk_piecewise_function_estimate_min_number_of_samples(vtkNew sself, const double x1, const double x2); extern "C" vtkNew < vtkPixel > vtkPixel_new () ; extern "C" void vtkPixel_destructor (vtkNew < vtkPixel > sself) ; extern "C" void * vtkPixel_get_ptr (vtkNew < vtkPixel > sself) ; +extern "C" int vtk_pixel_get_cell_type(vtkNew sself); +extern "C" int vtk_pixel_get_cell_dimension(vtkNew sself); +extern "C" int vtk_pixel_get_number_of_edges(vtkNew sself); +extern "C" int vtk_pixel_get_number_of_faces(vtkNew sself); +extern "C" int vtk_pixel_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_pixel_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_pixel_inflate(vtkNew sself, double dist); +extern "C" double vtk_pixel_compute_bounding_sphere(vtkNew sself, double center); +extern "C" int vtk_pixel_get_parametric_center(vtkNew sself, double pcoords); +extern "C" int vtk_pixel_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_pixel_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" void vtk_pixel_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_pixel_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_pixel_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_pixel_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" int vtk_pixel_compute_normal(vtkNew sself, double n); extern "C" vtkNew < vtkPlane > vtkPlane_new () ; extern "C" void vtkPlane_destructor (vtkNew < vtkPlane > sself) ; extern "C" void * vtkPlane_get_ptr (vtkNew < vtkPlane > sself) ; +extern "C" double vtk_plane_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_plane_evaluate_gradient(vtkNew sself, double x, double g); +extern "C" void vtk_plane_set_normal(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_plane_set_normal(vtkNew sself, const double _arg); +extern "C" double* vtk_plane_get_normal(vtkNew sself); +extern "C" void vtk_plane_get_normal(vtkNew sself, double data); +extern "C" void vtk_plane_set_origin(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_plane_set_origin(vtkNew sself, const double _arg); +extern "C" double* vtk_plane_get_origin(vtkNew sself); +extern "C" void vtk_plane_get_origin(vtkNew sself, double data); +extern "C" void vtk_plane_push(vtkNew sself, double distance); +extern "C" void vtk_plane_project_point(vtkNew sself, const double x, const double origin, const double normal, double xproj); +extern "C" void vtk_plane_project_point(vtkNew sself, const double x, double xproj); +extern "C" void vtk_plane_project_vector(vtkNew sself, const double v, const double origin, const double normal, double vproj); +extern "C" void vtk_plane_project_vector(vtkNew sself, const double v, double vproj); +extern "C" void vtk_plane_generalized_project_point(vtkNew sself, const double x, const double origin, const double normal, double xproj); +extern "C" void vtk_plane_generalized_project_point(vtkNew sself, const double x, double xproj); +extern "C" double vtk_plane_evaluate(vtkNew sself, double normal, double origin, double x); +extern "C" double vtk_plane_distance_to_plane(vtkNew sself, double x, double n, double p0); +extern "C" double vtk_plane_distance_to_plane(vtkNew sself, double x); +extern "C" int vtk_plane_intersect_with_line(vtkNew sself, const double p1, const double p2, double n, double p0, double t, double x); +extern "C" int vtk_plane_intersect_with_line(vtkNew sself, const double p1, const double p2, double t, double x); +extern "C" int vtk_plane_intersect_with_finite_plane(vtkNew sself, double n, double o, double pOrigin, double px, double py, double x0, double x1); +extern "C" int vtk_plane_intersect_with_finite_plane(vtkNew sself, double pOrigin, double px, double py, double x0, double x1); extern "C" vtkNew < vtkPlaneCollection > vtkPlaneCollection_new () ; extern "C" void vtkPlaneCollection_destructor (vtkNew < vtkPlaneCollection > sself) ; extern "C" void * vtkPlaneCollection_get_ptr (vtkNew < vtkPlaneCollection > sself) ; +extern "C" int vtk_plane_collection_get_number_of_items(vtkNew sself); extern "C" vtkNew < vtkPlanes > vtkPlanes_new () ; extern "C" void vtkPlanes_destructor (vtkNew < vtkPlanes > sself) ; extern "C" void * vtkPlanes_get_ptr (vtkNew < vtkPlanes > sself) ; +extern "C" double vtk_planes_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_planes_evaluate_gradient(vtkNew sself, double x, double n); +extern "C" void vtk_planes_set_frustum_planes(vtkNew sself, double planes); +extern "C" void vtk_planes_set_bounds(vtkNew sself, const double bounds); +extern "C" void vtk_planes_set_bounds(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax); +extern "C" int vtk_planes_get_number_of_planes(vtkNew sself); extern "C" vtkNew < vtkPlanesIntersection > vtkPlanesIntersection_new () ; extern "C" void vtkPlanesIntersection_destructor (vtkNew < vtkPlanesIntersection > sself) ; extern "C" void * vtkPlanesIntersection_get_ptr (vtkNew < vtkPlanesIntersection > sself) ; +extern "C" void vtk_planes_intersection_set_region_vertices(vtkNew sself, double v, int nvertices); +extern "C" int vtk_planes_intersection_get_number_of_region_vertices(vtkNew sself); +extern "C" int vtk_planes_intersection_get_num_region_vertices(vtkNew sself); +extern "C" int vtk_planes_intersection_get_region_vertices(vtkNew sself, double v, int nvertices); extern "C" vtkNew < vtkPointData > vtkPointData_new () ; extern "C" void vtkPointData_destructor (vtkNew < vtkPointData > sself) ; extern "C" void * vtkPointData_get_ptr (vtkNew < vtkPointData > sself) ; +extern "C" void vtk_point_data_null_point(vtkNew sself, long long ptId); extern "C" vtkNew < vtkPointLocator > vtkPointLocator_new () ; extern "C" void vtkPointLocator_destructor (vtkNew < vtkPointLocator > sself) ; extern "C" void * vtkPointLocator_get_ptr (vtkNew < vtkPointLocator > sself) ; +extern "C" void vtk_point_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3); +extern "C" void vtk_point_locator_set_divisions(vtkNew sself, const int _arg); +extern "C" int* vtk_point_locator_get_divisions(vtkNew sself); +extern "C" void vtk_point_locator_get_divisions(vtkNew sself, int data); +extern "C" void vtk_point_locator_set_number_of_points_per_bucket(vtkNew sself, int _arg); +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_min_value(vtkNew sself); +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_max_value(vtkNew sself); +extern "C" int vtk_point_locator_get_number_of_points_per_bucket(vtkNew sself); +extern "C" long long vtk_point_locator_find_closest_point(vtkNew sself, const double x); +extern "C" long long vtk_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); +extern "C" long long vtk_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2); +extern "C" void vtk_point_locator_insert_point(vtkNew sself, long long ptId, const double x); +extern "C" long long vtk_point_locator_insert_next_point(vtkNew sself, const double x); +extern "C" long long vtk_point_locator_is_inserted_point(vtkNew sself, double x, double y, double z); +extern "C" long long vtk_point_locator_is_inserted_point(vtkNew sself, const double x); +extern "C" int vtk_point_locator_insert_unique_point(vtkNew sself, const double x, long long ptId); +extern "C" long long vtk_point_locator_find_closest_inserted_point(vtkNew sself, const double x); +extern "C" void vtk_point_locator_initialize(vtkNew sself); +extern "C" void vtk_point_locator_free_search_structure(vtkNew sself); +extern "C" void vtk_point_locator_build_locator(vtkNew sself); extern "C" vtkNew < vtkPointSet > vtkPointSet_new () ; extern "C" void vtkPointSet_destructor (vtkNew < vtkPointSet > sself) ; extern "C" void * vtkPointSet_get_ptr (vtkNew < vtkPointSet > sself) ; +extern "C" void vtk_point_set_set_editable(vtkNew sself, bool _arg); +extern "C" bool vtk_point_set_get_editable(vtkNew sself); +extern "C" void vtk_point_set_editable_on(vtkNew sself); +extern "C" void vtk_point_set_editable_off(vtkNew sself); +extern "C" void vtk_point_set_initialize(vtkNew sself); +extern "C" long long vtk_point_set_get_number_of_points(vtkNew sself); +extern "C" void vtk_point_set_get_point(vtkNew sself, long long ptId, double x); +extern "C" long long vtk_point_set_find_point(vtkNew sself, double x); +extern "C" long long vtk_point_set_get_number_of_cells(vtkNew sself); +extern "C" int vtk_point_set_get_max_cell_size(vtkNew sself); +extern "C" int vtk_point_set_get_cell_type(vtkNew sself, long long p0); +extern "C" double* vtk_point_set_get_point(vtkNew sself, long long ptId); +extern "C" void vtk_point_set_build_point_locator(vtkNew sself); +extern "C" void vtk_point_set_build_locator(vtkNew sself); +extern "C" void vtk_point_set_build_cell_locator(vtkNew sself); +extern "C" unsigned long vtk_point_set_get_m_time(vtkNew sself); +extern "C" void vtk_point_set_compute_bounds(vtkNew sself); +extern "C" void vtk_point_set_squeeze(vtkNew sself); extern "C" vtkNew < vtkPointSetCellIterator > vtkPointSetCellIterator_new () ; extern "C" void vtkPointSetCellIterator_destructor (vtkNew < vtkPointSetCellIterator > sself) ; extern "C" void * vtkPointSetCellIterator_get_ptr (vtkNew < vtkPointSetCellIterator > sself) ; +extern "C" bool vtk_point_set_cell_iterator_is_done_with_traversal(vtkNew sself); +extern "C" long long vtk_point_set_cell_iterator_get_cell_id(vtkNew sself); extern "C" vtkNew < vtkPointsProjectedHull > vtkPointsProjectedHull_new () ; extern "C" void vtkPointsProjectedHull_destructor (vtkNew < vtkPointsProjectedHull > sself) ; extern "C" void * vtkPointsProjectedHull_get_ptr (vtkNew < vtkPointsProjectedHull > sself) ; +extern "C" int vtk_points_projected_hull_rectangle_intersection_x(vtkNew sself, float ymin, float ymax, float zmin, float zmax); +extern "C" int vtk_points_projected_hull_rectangle_intersection_x(vtkNew sself, double ymin, double ymax, double zmin, double zmax); +extern "C" int vtk_points_projected_hull_rectangle_intersection_y(vtkNew sself, float zmin, float zmax, float xmin, float xmax); +extern "C" int vtk_points_projected_hull_rectangle_intersection_y(vtkNew sself, double zmin, double zmax, double xmin, double xmax); +extern "C" int vtk_points_projected_hull_rectangle_intersection_z(vtkNew sself, float xmin, float xmax, float ymin, float ymax); +extern "C" int vtk_points_projected_hull_rectangle_intersection_z(vtkNew sself, double xmin, double xmax, double ymin, double ymax); +extern "C" int vtk_points_projected_hull_get_ccw_hull_x(vtkNew sself, float pts, int len); +extern "C" int vtk_points_projected_hull_get_ccw_hull_x(vtkNew sself, double pts, int len); +extern "C" int vtk_points_projected_hull_get_ccw_hull_y(vtkNew sself, float pts, int len); +extern "C" int vtk_points_projected_hull_get_ccw_hull_y(vtkNew sself, double pts, int len); +extern "C" int vtk_points_projected_hull_get_ccw_hull_z(vtkNew sself, float pts, int len); +extern "C" int vtk_points_projected_hull_get_ccw_hull_z(vtkNew sself, double pts, int len); +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_x(vtkNew sself); +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_y(vtkNew sself); +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_z(vtkNew sself); +extern "C" void vtk_points_projected_hull_update(vtkNew sself); extern "C" vtkNew < vtkPolyData > vtkPolyData_new () ; extern "C" void vtkPolyData_destructor (vtkNew < vtkPolyData > sself) ; extern "C" void * vtkPolyData_get_ptr (vtkNew < vtkPolyData > sself) ; +extern "C" int vtk_poly_data_get_data_object_type(vtkNew sself); +extern "C" long long vtk_poly_data_get_number_of_cells(vtkNew sself); +extern "C" int vtk_poly_data_get_cell_type(vtkNew sself, long long cellId); +extern "C" void vtk_poly_data_compute_cells_bounds(vtkNew sself); +extern "C" void vtk_poly_data_get_cells_bounds(vtkNew sself, double bounds); +extern "C" void vtk_poly_data_squeeze(vtkNew sself); +extern "C" int vtk_poly_data_get_max_cell_size(vtkNew sself); +extern "C" long long vtk_poly_data_get_cell_id_relative_to_cell_array(vtkNew sself, long long cellId); +extern "C" long long vtk_poly_data_get_number_of_verts(vtkNew sself); +extern "C" long long vtk_poly_data_get_number_of_lines(vtkNew sself); +extern "C" long long vtk_poly_data_get_number_of_polys(vtkNew sself); +extern "C" long long vtk_poly_data_get_number_of_strips(vtkNew sself); +extern "C" bool vtk_poly_data_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize); +extern "C" bool vtk_poly_data_allocate_estimate(vtkNew sself, long long numVerts, long long maxVertSize, long long numLines, long long maxLineSize, long long numPolys, long long maxPolySize, long long numStrips, long long maxStripSize); +extern "C" bool vtk_poly_data_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize); +extern "C" bool vtk_poly_data_allocate_exact(vtkNew sself, long long numVerts, long long vertConnSize, long long numLines, long long lineConnSize, long long numPolys, long long polyConnSize, long long numStrips, long long stripConnSize); +extern "C" void vtk_poly_data_allocate(vtkNew sself, long long numCells, int extSize); +extern "C" long long vtk_poly_data_insert_next_cell(vtkNew sself, int type, int npts, const long long pts); +extern "C" void vtk_poly_data_reset(vtkNew sself); +extern "C" void vtk_poly_data_build_cells(vtkNew sself); +extern "C" bool vtk_poly_data_need_to_build_cells(vtkNew sself); +extern "C" void vtk_poly_data_build_links(vtkNew sself, int initialSize); +extern "C" void vtk_poly_data_delete_cells(vtkNew sself); +extern "C" void vtk_poly_data_delete_links(vtkNew sself); +extern "C" void vtk_poly_data_get_point_cells(vtkNew sself, long long ptId, long long ncells, long long cells); +extern "C" void vtk_poly_data_get_point_cells(vtkNew sself, long long ptId, unsigned short ncells, long long cells); +extern "C" unsigned char vtk_poly_data_get_cell_points(vtkNew sself, long long cellId, long long npts, const long long pts); +extern "C" int vtk_poly_data_is_triangle(vtkNew sself, int v1, int v2, int v3); +extern "C" int vtk_poly_data_is_edge(vtkNew sself, long long p1, long long p2); +extern "C" int vtk_poly_data_is_point_used_by_cell(vtkNew sself, long long ptId, long long cellId); +extern "C" void vtk_poly_data_replace_cell(vtkNew sself, long long cellId, int npts, const long long pts); +extern "C" void vtk_poly_data_replace_cell_point(vtkNew sself, long long cellId, long long oldPtId, long long newPtId); +extern "C" void vtk_poly_data_reverse_cell(vtkNew sself, long long cellId); +extern "C" void vtk_poly_data_delete_point(vtkNew sself, long long ptId); +extern "C" void vtk_poly_data_delete_cell(vtkNew sself, long long cellId); +extern "C" void vtk_poly_data_remove_deleted_cells(vtkNew sself); +extern "C" long long vtk_poly_data_insert_next_linked_point(vtkNew sself, int numLinks); +extern "C" long long vtk_poly_data_insert_next_linked_point(vtkNew sself, double x, int numLinks); +extern "C" long long vtk_poly_data_insert_next_linked_cell(vtkNew sself, int type, int npts, const long long pts); +extern "C" void vtk_poly_data_replace_linked_cell(vtkNew sself, long long cellId, int npts, const long long pts); +extern "C" void vtk_poly_data_remove_cell_reference(vtkNew sself, long long cellId); +extern "C" void vtk_poly_data_add_cell_reference(vtkNew sself, long long cellId); +extern "C" void vtk_poly_data_remove_reference_to_cell(vtkNew sself, long long ptId, long long cellId); +extern "C" void vtk_poly_data_add_reference_to_cell(vtkNew sself, long long ptId, long long cellId); +extern "C" void vtk_poly_data_resize_cell_list(vtkNew sself, long long ptId, int size); +extern "C" void vtk_poly_data_initialize(vtkNew sself); +extern "C" int vtk_poly_data_get_piece(vtkNew sself); +extern "C" int vtk_poly_data_get_number_of_pieces(vtkNew sself); +extern "C" int vtk_poly_data_get_ghost_level(vtkNew sself); +extern "C" void vtk_poly_data_remove_ghost_cells(vtkNew sself); +extern "C" int vtk_poly_data_get_scalar_field_critical_index(vtkNew sself, long long pointId, int fieldId); +extern "C" int vtk_poly_data_get_scalar_field_critical_index(vtkNew sself, long long pointId, const char fieldName); +extern "C" unsigned long vtk_poly_data_get_mesh_m_time(vtkNew sself); +extern "C" unsigned long vtk_poly_data_get_m_time(vtkNew sself); +extern "C" unsigned char vtk_poly_data_get_cell(vtkNew sself, long long cellId, const long long pts); extern "C" vtkNew < vtkPolyDataCollection > vtkPolyDataCollection_new () ; extern "C" void vtkPolyDataCollection_destructor (vtkNew < vtkPolyDataCollection > sself) ; extern "C" void * vtkPolyDataCollection_get_ptr (vtkNew < vtkPolyDataCollection > sself) ; extern "C" vtkNew < vtkPolyLine > vtkPolyLine_new () ; extern "C" void vtkPolyLine_destructor (vtkNew < vtkPolyLine > sself) ; extern "C" void * vtkPolyLine_get_ptr (vtkNew < vtkPolyLine > sself) ; +extern "C" int vtk_poly_line_get_cell_type(vtkNew sself); +extern "C" int vtk_poly_line_get_cell_dimension(vtkNew sself); +extern "C" int vtk_poly_line_get_number_of_edges(vtkNew sself); +extern "C" int vtk_poly_line_get_number_of_faces(vtkNew sself); +extern "C" int vtk_poly_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_poly_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_poly_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_poly_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_poly_line_get_parametric_center(vtkNew sself, double pcoords); extern "C" vtkNew < vtkPolyPlane > vtkPolyPlane_new () ; extern "C" void vtkPolyPlane_destructor (vtkNew < vtkPolyPlane > sself) ; extern "C" void * vtkPolyPlane_get_ptr (vtkNew < vtkPolyPlane > sself) ; +extern "C" double vtk_poly_plane_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_poly_plane_evaluate_gradient(vtkNew sself, double x, double g); +extern "C" unsigned long vtk_poly_plane_get_m_time(vtkNew sself); extern "C" vtkNew < vtkPolyVertex > vtkPolyVertex_new () ; extern "C" void vtkPolyVertex_destructor (vtkNew < vtkPolyVertex > sself) ; extern "C" void * vtkPolyVertex_get_ptr (vtkNew < vtkPolyVertex > sself) ; +extern "C" int vtk_poly_vertex_get_cell_type(vtkNew sself); +extern "C" int vtk_poly_vertex_get_cell_dimension(vtkNew sself); +extern "C" int vtk_poly_vertex_get_number_of_edges(vtkNew sself); +extern "C" int vtk_poly_vertex_get_number_of_faces(vtkNew sself); +extern "C" int vtk_poly_vertex_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_poly_vertex_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_poly_vertex_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_poly_vertex_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_poly_vertex_get_parametric_center(vtkNew sself, double pcoords); extern "C" vtkNew < vtkPolygon > vtkPolygon_new () ; extern "C" void vtkPolygon_destructor (vtkNew < vtkPolygon > sself) ; extern "C" void * vtkPolygon_get_ptr (vtkNew < vtkPolygon > sself) ; +extern "C" int vtk_polygon_get_cell_type(vtkNew sself); +extern "C" int vtk_polygon_get_cell_dimension(vtkNew sself); +extern "C" int vtk_polygon_get_number_of_edges(vtkNew sself); +extern "C" int vtk_polygon_get_number_of_faces(vtkNew sself); +extern "C" int vtk_polygon_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_polygon_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_polygon_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_polygon_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" double vtk_polygon_compute_area(vtkNew sself); +extern "C" void vtk_polygon_interpolate_functions(vtkNew sself, const double x, double sf); +extern "C" void vtk_polygon_compute_normal(vtkNew sself, int numPts, double pts, double n); +extern "C" bool vtk_polygon_is_convex(vtkNew sself); +extern "C" int vtk_polygon_parameterize_polygon(vtkNew sself, double p0, double p10, double l10, double p20, double l20, double n); +extern "C" int vtk_polygon_point_in_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double n); +extern "C" double vtk_polygon_distance_to_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double closest); +extern "C" int vtk_polygon_intersect_polygon_with_polygon(vtkNew sself, int npts, double pts, double bounds, int npts2, double pts2, double bounds2, double tol, double x); +extern "C" bool vtk_polygon_get_use_mvc_interpolation(vtkNew sself); +extern "C" void vtk_polygon_set_use_mvc_interpolation(vtkNew sself, bool _arg); +extern "C" void vtk_polygon_set_tolerance(vtkNew sself, double _arg); +extern "C" double vtk_polygon_get_tolerance_min_value(vtkNew sself); +extern "C" double vtk_polygon_get_tolerance_max_value(vtkNew sself); +extern "C" double vtk_polygon_get_tolerance(vtkNew sself); +extern "C" int vtk_polygon_ear_cut_triangulation(vtkNew sself, int measure); +extern "C" int vtk_polygon_unbiased_ear_cut_triangulation(vtkNew sself, int seed, int measure); extern "C" vtkNew < vtkPolyhedron > vtkPolyhedron_new () ; extern "C" void vtkPolyhedron_destructor (vtkNew < vtkPolyhedron > sself) ; extern "C" void * vtkPolyhedron_get_ptr (vtkNew < vtkPolyhedron > sself) ; +extern "C" void vtk_polyhedron_get_edge_points(vtkNew sself, long long edgeId, const long long pts); +extern "C" void vtk_polyhedron_get_edge_points(vtkNew sself, int edgeId, int pts); +extern "C" long long vtk_polyhedron_get_face_points(vtkNew sself, long long faceId, const long long pts); +extern "C" void vtk_polyhedron_get_face_points(vtkNew sself, int faceId, int pts); +extern "C" void vtk_polyhedron_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); +extern "C" long long vtk_polyhedron_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); +extern "C" long long vtk_polyhedron_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); +extern "C" long long vtk_polyhedron_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); +extern "C" long long vtk_polyhedron_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); +extern "C" bool vtk_polyhedron_get_centroid(vtkNew sself, double centroid); +extern "C" double* vtk_polyhedron_get_parametric_coords(vtkNew sself); +extern "C" int vtk_polyhedron_get_cell_type(vtkNew sself); +extern "C" int vtk_polyhedron_requires_initialization(vtkNew sself); +extern "C" int vtk_polyhedron_get_number_of_edges(vtkNew sself); +extern "C" int vtk_polyhedron_get_number_of_faces(vtkNew sself); +extern "C" int vtk_polyhedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_polyhedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_polyhedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_polyhedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_polyhedron_get_parametric_center(vtkNew sself, double pcoords); +extern "C" int vtk_polyhedron_is_primary_cell(vtkNew sself); +extern "C" void vtk_polyhedron_interpolate_functions(vtkNew sself, const double x, double sf); +extern "C" void vtk_polyhedron_interpolate_derivs(vtkNew sself, const double x, double derivs); +extern "C" int vtk_polyhedron_requires_explicit_face_representation(vtkNew sself); +extern "C" int vtk_polyhedron_is_inside(vtkNew sself, const double x, double tolerance); +extern "C" bool vtk_polyhedron_is_convex(vtkNew sself); extern "C" vtkNew < vtkPyramid > vtkPyramid_new () ; extern "C" void vtkPyramid_destructor (vtkNew < vtkPyramid > sself) ; extern "C" void * vtkPyramid_get_ptr (vtkNew < vtkPyramid > sself) ; +extern "C" void vtk_pyramid_get_edge_points(vtkNew sself, long long edgeId, const long long pts); +extern "C" void vtk_pyramid_get_edge_points(vtkNew sself, int edgeId, int pts); +extern "C" long long vtk_pyramid_get_face_points(vtkNew sself, long long faceId, const long long pts); +extern "C" void vtk_pyramid_get_face_points(vtkNew sself, int faceId, int pts); +extern "C" void vtk_pyramid_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); +extern "C" long long vtk_pyramid_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); +extern "C" long long vtk_pyramid_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); +extern "C" long long vtk_pyramid_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); +extern "C" long long vtk_pyramid_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); +extern "C" bool vtk_pyramid_get_centroid(vtkNew sself, double centroid); +extern "C" int vtk_pyramid_get_cell_type(vtkNew sself); +extern "C" int vtk_pyramid_get_number_of_edges(vtkNew sself); +extern "C" int vtk_pyramid_get_number_of_faces(vtkNew sself); +extern "C" int vtk_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int* vtk_pyramid_get_triangle_cases(vtkNew sself, int caseId); +extern "C" int vtk_pyramid_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" int vtk_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); +extern "C" const long long* vtk_pyramid_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_pyramid_get_face_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_pyramid_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_pyramid_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_pyramid_get_point_to_incident_edges_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_pyramid_get_point_to_incident_faces_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_pyramid_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); extern "C" vtkNew < vtkQuad > vtkQuad_new () ; extern "C" void vtkQuad_destructor (vtkNew < vtkQuad > sself) ; extern "C" void * vtkQuad_get_ptr (vtkNew < vtkQuad > sself) ; +extern "C" int vtk_quad_get_cell_type(vtkNew sself); +extern "C" int vtk_quad_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quad_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quad_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_quad_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_quad_interpolation_functions(vtkNew sself, const double pcoords, double sf); +extern "C" void vtk_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_quad_interpolate_functions(vtkNew sself, const double pcoords, double sf); +extern "C" void vtk_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_quad_get_edge_array(vtkNew sself, long long edgeId); extern "C" vtkNew < vtkQuadraticEdge > vtkQuadraticEdge_new () ; extern "C" void vtkQuadraticEdge_destructor (vtkNew < vtkQuadraticEdge > sself) ; extern "C" void * vtkQuadraticEdge_get_ptr (vtkNew < vtkQuadraticEdge > sself) ; +extern "C" int vtk_quadratic_edge_get_cell_type(vtkNew sself); +extern "C" int vtk_quadratic_edge_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quadratic_edge_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quadratic_edge_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quadratic_edge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quadratic_edge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_quadratic_edge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_quadratic_edge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_quadratic_edge_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_quadratic_edge_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_edge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_quadratic_edge_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_edge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); extern "C" vtkNew < vtkQuadraticHexahedron > vtkQuadraticHexahedron_new () ; extern "C" void vtkQuadraticHexahedron_destructor (vtkNew < vtkQuadraticHexahedron > sself) ; extern "C" void * vtkQuadraticHexahedron_get_ptr (vtkNew < vtkQuadraticHexahedron > sself) ; +extern "C" int vtk_quadratic_hexahedron_get_cell_type(vtkNew sself); +extern "C" int vtk_quadratic_hexahedron_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quadratic_hexahedron_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quadratic_hexahedron_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId); +extern "C" void vtk_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkQuadraticLinearQuad > vtkQuadraticLinearQuad_new () ; extern "C" void vtkQuadraticLinearQuad_destructor (vtkNew < vtkQuadraticLinearQuad > sself) ; extern "C" void * vtkQuadraticLinearQuad_get_ptr (vtkNew < vtkQuadraticLinearQuad > sself) ; +extern "C" int vtk_quadratic_linear_quad_get_cell_type(vtkNew sself); +extern "C" int vtk_quadratic_linear_quad_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quadratic_linear_quad_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quadratic_linear_quad_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quadratic_linear_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quadratic_linear_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_quadratic_linear_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_quadratic_linear_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_quadratic_linear_quad_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_quadratic_linear_quad_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_linear_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_quadratic_linear_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_linear_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" int* vtk_quadratic_linear_quad_get_edge_array(vtkNew sself, long long edgeId); extern "C" vtkNew < vtkQuadraticLinearWedge > vtkQuadraticLinearWedge_new () ; extern "C" void vtkQuadraticLinearWedge_destructor (vtkNew < vtkQuadraticLinearWedge > sself) ; extern "C" void * vtkQuadraticLinearWedge_get_ptr (vtkNew < vtkQuadraticLinearWedge > sself) ; +extern "C" int vtk_quadratic_linear_wedge_get_cell_type(vtkNew sself); +extern "C" int vtk_quadratic_linear_wedge_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quadratic_linear_wedge_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quadratic_linear_wedge_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quadratic_linear_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quadratic_linear_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_quadratic_linear_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_quadratic_linear_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_quadratic_linear_wedge_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_quadratic_linear_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_linear_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_quadratic_linear_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_linear_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_quadratic_linear_wedge_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_quadratic_linear_wedge_get_face_array(vtkNew sself, long long faceId); +extern "C" void vtk_quadratic_linear_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkQuadraticPolygon > vtkQuadraticPolygon_new () ; extern "C" void vtkQuadraticPolygon_destructor (vtkNew < vtkQuadraticPolygon > sself) ; extern "C" void * vtkQuadraticPolygon_get_ptr (vtkNew < vtkQuadraticPolygon > sself) ; +extern "C" int vtk_quadratic_polygon_get_cell_type(vtkNew sself); +extern "C" int vtk_quadratic_polygon_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quadratic_polygon_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quadratic_polygon_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quadratic_polygon_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quadratic_polygon_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_quadratic_polygon_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_quadratic_polygon_interpolate_functions(vtkNew sself, const double x, double weights); +extern "C" int vtk_quadratic_polygon_parameterize_polygon(vtkNew sself, double p0, double p10, double l10, double p20, double l20, double n); +extern "C" int vtk_quadratic_polygon_point_in_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double n); +extern "C" double vtk_quadratic_polygon_distance_to_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double closest); +extern "C" int vtk_quadratic_polygon_intersect_polygon_with_polygon(vtkNew sself, int npts, double pts, double bounds, int npts2, double pts2, double bounds2, double tol, double x); +extern "C" void vtk_quadratic_polygon_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" bool vtk_quadratic_polygon_get_use_mvc_interpolation(vtkNew sself); +extern "C" void vtk_quadratic_polygon_set_use_mvc_interpolation(vtkNew sself, bool _arg); extern "C" vtkNew < vtkQuadraticPyramid > vtkQuadraticPyramid_new () ; extern "C" void vtkQuadraticPyramid_destructor (vtkNew < vtkQuadraticPyramid > sself) ; extern "C" void * vtkQuadraticPyramid_get_ptr (vtkNew < vtkQuadraticPyramid > sself) ; +extern "C" int vtk_quadratic_pyramid_get_cell_type(vtkNew sself); +extern "C" int vtk_quadratic_pyramid_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quadratic_pyramid_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quadratic_pyramid_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quadratic_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quadratic_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_quadratic_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_quadratic_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_quadratic_pyramid_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_quadratic_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_quadratic_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_quadratic_pyramid_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_quadratic_pyramid_get_face_array(vtkNew sself, long long faceId); +extern "C" void vtk_quadratic_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkQuadraticQuad > vtkQuadraticQuad_new () ; extern "C" void vtkQuadraticQuad_destructor (vtkNew < vtkQuadraticQuad > sself) ; extern "C" void * vtkQuadraticQuad_get_ptr (vtkNew < vtkQuadraticQuad > sself) ; +extern "C" int vtk_quadratic_quad_get_cell_type(vtkNew sself); +extern "C" int vtk_quadratic_quad_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quadratic_quad_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quadratic_quad_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quadratic_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quadratic_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_quadratic_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_quadratic_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_quadratic_quad_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_quadratic_quad_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_quadratic_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); extern "C" vtkNew < vtkQuadraticTetra > vtkQuadraticTetra_new () ; extern "C" void vtkQuadraticTetra_destructor (vtkNew < vtkQuadraticTetra > sself) ; extern "C" void * vtkQuadraticTetra_get_ptr (vtkNew < vtkQuadraticTetra > sself) ; +extern "C" int vtk_quadratic_tetra_get_cell_type(vtkNew sself); +extern "C" int vtk_quadratic_tetra_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quadratic_tetra_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quadratic_tetra_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quadratic_tetra_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quadratic_tetra_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_quadratic_tetra_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_quadratic_tetra_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_quadratic_tetra_get_parametric_center(vtkNew sself, double pcoords); +extern "C" double vtk_quadratic_tetra_get_parametric_distance(vtkNew sself, const double pcoords); +extern "C" void vtk_quadratic_tetra_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_tetra_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_quadratic_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_tetra_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_quadratic_tetra_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_quadratic_tetra_get_face_array(vtkNew sself, long long faceId); +extern "C" void vtk_quadratic_tetra_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkQuadraticTriangle > vtkQuadraticTriangle_new () ; extern "C" void vtkQuadraticTriangle_destructor (vtkNew < vtkQuadraticTriangle > sself) ; extern "C" void * vtkQuadraticTriangle_get_ptr (vtkNew < vtkQuadraticTriangle > sself) ; +extern "C" int vtk_quadratic_triangle_get_cell_type(vtkNew sself); +extern "C" int vtk_quadratic_triangle_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quadratic_triangle_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quadratic_triangle_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quadratic_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quadratic_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_quadratic_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_quadratic_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_quadratic_triangle_get_parametric_center(vtkNew sself, double pcoords); +extern "C" double vtk_quadratic_triangle_get_parametric_distance(vtkNew sself, const double pcoords); +extern "C" void vtk_quadratic_triangle_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_quadratic_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); extern "C" vtkNew < vtkQuadraticWedge > vtkQuadraticWedge_new () ; extern "C" void vtkQuadraticWedge_destructor (vtkNew < vtkQuadraticWedge > sself) ; extern "C" void * vtkQuadraticWedge_get_ptr (vtkNew < vtkQuadraticWedge > sself) ; +extern "C" int vtk_quadratic_wedge_get_cell_type(vtkNew sself); +extern "C" int vtk_quadratic_wedge_get_cell_dimension(vtkNew sself); +extern "C" int vtk_quadratic_wedge_get_number_of_edges(vtkNew sself); +extern "C" int vtk_quadratic_wedge_get_number_of_faces(vtkNew sself); +extern "C" int vtk_quadratic_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_quadratic_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_quadratic_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_quadratic_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_quadratic_wedge_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_quadratic_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_quadratic_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_quadratic_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_quadratic_wedge_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_quadratic_wedge_get_face_array(vtkNew sself, long long faceId); +extern "C" void vtk_quadratic_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkQuadratureSchemeDefinition > vtkQuadratureSchemeDefinition_new () ; extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkNew < vtkQuadratureSchemeDefinition > sself) ; extern "C" void * vtkQuadratureSchemeDefinition_get_ptr (vtkNew < vtkQuadratureSchemeDefinition > sself) ; +extern "C" void vtk_quadrature_scheme_definition_clear(vtkNew sself); +extern "C" void vtk_quadrature_scheme_definition_initialize(vtkNew sself, int cellType, int numberOfNodes, int numberOfQuadraturePoints, double shapeFunctionWeights); +extern "C" void vtk_quadrature_scheme_definition_initialize(vtkNew sself, int cellType, int numberOfNodes, int numberOfQuadraturePoints, double shapeFunctionWeights, double quadratureWeights); +extern "C" int vtk_quadrature_scheme_definition_get_cell_type(vtkNew sself); +extern "C" int vtk_quadrature_scheme_definition_get_quadrature_key(vtkNew sself); +extern "C" int vtk_quadrature_scheme_definition_get_number_of_nodes(vtkNew sself); +extern "C" int vtk_quadrature_scheme_definition_get_number_of_quadrature_points(vtkNew sself); +extern "C" const double* vtk_quadrature_scheme_definition_get_shape_function_weights(vtkNew sself); +extern "C" const double* vtk_quadrature_scheme_definition_get_shape_function_weights(vtkNew sself, int quadraturePointId); +extern "C" const double* vtk_quadrature_scheme_definition_get_quadrature_weights(vtkNew sself); extern "C" vtkNew < vtkQuadric > vtkQuadric_new () ; extern "C" void vtkQuadric_destructor (vtkNew < vtkQuadric > sself) ; extern "C" void * vtkQuadric_get_ptr (vtkNew < vtkQuadric > sself) ; +extern "C" double vtk_quadric_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_quadric_evaluate_gradient(vtkNew sself, double x, double g); +extern "C" void vtk_quadric_set_coefficients(vtkNew sself, double a); +extern "C" void vtk_quadric_set_coefficients(vtkNew sself, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9); +extern "C" double* vtk_quadric_get_coefficients(vtkNew sself); +extern "C" void vtk_quadric_get_coefficients(vtkNew sself, double data); extern "C" vtkNew < vtkRectilinearGrid > vtkRectilinearGrid_new () ; extern "C" void vtkRectilinearGrid_destructor (vtkNew < vtkRectilinearGrid > sself) ; extern "C" void * vtkRectilinearGrid_get_ptr (vtkNew < vtkRectilinearGrid > sself) ; +extern "C" int vtk_rectilinear_grid_get_data_object_type(vtkNew sself); +extern "C" void vtk_rectilinear_grid_initialize(vtkNew sself); +extern "C" long long vtk_rectilinear_grid_get_number_of_cells(vtkNew sself); +extern "C" long long vtk_rectilinear_grid_get_number_of_points(vtkNew sself); +extern "C" double* vtk_rectilinear_grid_get_point(vtkNew sself, long long ptId); +extern "C" long long vtk_rectilinear_grid_find_point(vtkNew sself, double x); +extern "C" int vtk_rectilinear_grid_get_cell_type(vtkNew sself, long long cellId); +extern "C" int vtk_rectilinear_grid_get_max_cell_size(vtkNew sself); +extern "C" unsigned char vtk_rectilinear_grid_is_point_visible(vtkNew sself, long long ptId); +extern "C" unsigned char vtk_rectilinear_grid_is_cell_visible(vtkNew sself, long long cellId); +extern "C" bool vtk_rectilinear_grid_has_any_blank_points(vtkNew sself); +extern "C" bool vtk_rectilinear_grid_has_any_blank_cells(vtkNew sself); +extern "C" void vtk_rectilinear_grid_get_cell_dims(vtkNew sself, int cellDims); +extern "C" void vtk_rectilinear_grid_set_dimensions(vtkNew sself, int i, int j, int k); +extern "C" void vtk_rectilinear_grid_set_dimensions(vtkNew sself, const int dim); +extern "C" int* vtk_rectilinear_grid_get_dimensions(vtkNew sself); +extern "C" void vtk_rectilinear_grid_get_dimensions(vtkNew sself, int data); +extern "C" int vtk_rectilinear_grid_get_data_dimension(vtkNew sself); +extern "C" int vtk_rectilinear_grid_compute_structured_coordinates(vtkNew sself, double x, int ijk, double pcoords); +extern "C" long long vtk_rectilinear_grid_compute_point_id(vtkNew sself, int ijk); +extern "C" long long vtk_rectilinear_grid_compute_cell_id(vtkNew sself, int ijk); +extern "C" void vtk_rectilinear_grid_get_point(vtkNew sself, const int i, const int j, const int k, double p); +extern "C" void vtk_rectilinear_grid_set_extent(vtkNew sself, int extent); +extern "C" void vtk_rectilinear_grid_set_extent(vtkNew sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax); +extern "C" int* vtk_rectilinear_grid_get_extent(vtkNew sself); +extern "C" void vtk_rectilinear_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_rectilinear_grid_get_extent(vtkNew sself, int _arg); +extern "C" int vtk_rectilinear_grid_get_extent_type(vtkNew sself); +extern "C" void vtk_rectilinear_grid_crop(vtkNew sself, const int updateExtent); +extern "C" int vtk_rectilinear_grid_get_scalar_type(vtkNew sself); +extern "C" const char* vtk_rectilinear_grid_get_scalar_type_as_string(vtkNew sself); +extern "C" int vtk_rectilinear_grid_get_number_of_scalar_components(vtkNew sself); extern "C" vtkNew < vtkReebGraph > vtkReebGraph_new () ; extern "C" void vtkReebGraph_destructor (vtkNew < vtkReebGraph > sself) ; extern "C" void * vtkReebGraph_get_ptr (vtkNew < vtkReebGraph > sself) ; +extern "C" int vtk_reeb_graph_stream_triangle(vtkNew sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2); +extern "C" int vtk_reeb_graph_stream_tetrahedron(vtkNew sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2, long long vertex3Id, double scalar3); +extern "C" void vtk_reeb_graph_close_stream(vtkNew sself); extern "C" vtkNew < vtkReebGraphSimplificationMetric > vtkReebGraphSimplificationMetric_new () ; extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkNew < vtkReebGraphSimplificationMetric > sself) ; extern "C" void * vtkReebGraphSimplificationMetric_get_ptr (vtkNew < vtkReebGraphSimplificationMetric > sself) ; +extern "C" void vtk_reeb_graph_simplification_metric_set_lower_bound(vtkNew sself, double _arg); +extern "C" double vtk_reeb_graph_simplification_metric_get_lower_bound(vtkNew sself); +extern "C" void vtk_reeb_graph_simplification_metric_set_upper_bound(vtkNew sself, double _arg); +extern "C" double vtk_reeb_graph_simplification_metric_get_upper_bound(vtkNew sself); extern "C" vtkNew < vtkSelection > vtkSelection_new () ; extern "C" void vtkSelection_destructor (vtkNew < vtkSelection > sself) ; extern "C" void * vtkSelection_get_ptr (vtkNew < vtkSelection > sself) ; +extern "C" int vtk_selection_get_data_object_type(vtkNew sself); +extern "C" unsigned int vtk_selection_get_number_of_nodes(vtkNew sself); +extern "C" const char* vtk_selection_get_node_name_at_index(vtkNew sself, unsigned int idx); +extern "C" void vtk_selection_remove_node(vtkNew sself, unsigned int idx); +extern "C" void vtk_selection_remove_node(vtkNew sself, const char* name); +extern "C" void vtk_selection_remove_all_nodes(vtkNew sself); +extern "C" void vtk_selection_set_expression(vtkNew sself, const char* _arg); +extern "C" const char* vtk_selection_get_expression(vtkNew sself); +extern "C" unsigned long vtk_selection_get_m_time(vtkNew sself); +extern "C" void vtk_selection_dump(vtkNew sself); extern "C" vtkNew < vtkSelectionNode > vtkSelectionNode_new () ; extern "C" void vtkSelectionNode_destructor (vtkNew < vtkSelectionNode > sself) ; extern "C" void * vtkSelectionNode_get_ptr (vtkNew < vtkSelectionNode > sself) ; +extern "C" void vtk_selection_node_initialize(vtkNew sself); +extern "C" unsigned long vtk_selection_node_get_m_time(vtkNew sself); +extern "C" void vtk_selection_node_set_content_type(vtkNew sself, int type); +extern "C" int vtk_selection_node_get_content_type(vtkNew sself); +extern "C" const char* vtk_selection_node_get_content_type_as_string(vtkNew sself, int type); +extern "C" void vtk_selection_node_set_field_type(vtkNew sself, int type); +extern "C" int vtk_selection_node_get_field_type(vtkNew sself); +extern "C" const char* vtk_selection_node_get_field_type_as_string(vtkNew sself, int type); +extern "C" int vtk_selection_node_get_field_type_from_string(vtkNew sself, const char type); +extern "C" int vtk_selection_node_convert_selection_field_to_attribute_type(vtkNew sself, int val); +extern "C" int vtk_selection_node_convert_attribute_type_to_selection_field(vtkNew sself, int val); +extern "C" void vtk_selection_node_set_query_string(vtkNew sself, const char _arg); +extern "C" char* vtk_selection_node_get_query_string(vtkNew sself); extern "C" vtkNew < vtkSimpleCellTessellator > vtkSimpleCellTessellator_new () ; extern "C" void vtkSimpleCellTessellator_destructor (vtkNew < vtkSimpleCellTessellator > sself) ; extern "C" void * vtkSimpleCellTessellator_get_ptr (vtkNew < vtkSimpleCellTessellator > sself) ; +extern "C" void vtk_simple_cell_tessellator_reset(vtkNew sself); +extern "C" int vtk_simple_cell_tessellator_get_fixed_subdivisions(vtkNew sself); +extern "C" int vtk_simple_cell_tessellator_get_max_subdivision_level(vtkNew sself); +extern "C" int vtk_simple_cell_tessellator_get_max_adaptive_subdivisions(vtkNew sself); +extern "C" void vtk_simple_cell_tessellator_set_fixed_subdivisions(vtkNew sself, int level); +extern "C" void vtk_simple_cell_tessellator_set_max_subdivision_level(vtkNew sself, int level); +extern "C" void vtk_simple_cell_tessellator_set_subdivision_levels(vtkNew sself, int fixed, int maxLevel); extern "C" vtkNew < vtkSmoothErrorMetric > vtkSmoothErrorMetric_new () ; extern "C" void vtkSmoothErrorMetric_destructor (vtkNew < vtkSmoothErrorMetric > sself) ; extern "C" void * vtkSmoothErrorMetric_get_ptr (vtkNew < vtkSmoothErrorMetric > sself) ; +extern "C" double vtk_smooth_error_metric_get_angle_tolerance(vtkNew sself); +extern "C" void vtk_smooth_error_metric_set_angle_tolerance(vtkNew sself, double value); +extern "C" int vtk_smooth_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); +extern "C" double vtk_smooth_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); extern "C" vtkNew < vtkSortFieldData > vtkSortFieldData_new () ; extern "C" void vtkSortFieldData_destructor (vtkNew < vtkSortFieldData > sself) ; extern "C" void * vtkSortFieldData_get_ptr (vtkNew < vtkSortFieldData > sself) ; extern "C" vtkNew < vtkSphere > vtkSphere_new () ; extern "C" void vtkSphere_destructor (vtkNew < vtkSphere > sself) ; extern "C" void * vtkSphere_get_ptr (vtkNew < vtkSphere > sself) ; +extern "C" double vtk_sphere_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_sphere_evaluate_gradient(vtkNew sself, double x, double n); +extern "C" void vtk_sphere_set_radius(vtkNew sself, double _arg); +extern "C" double vtk_sphere_get_radius(vtkNew sself); +extern "C" void vtk_sphere_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_sphere_set_center(vtkNew sself, const double _arg); +extern "C" double* vtk_sphere_get_center(vtkNew sself); +extern "C" void vtk_sphere_get_center(vtkNew sself, double data); +extern "C" double vtk_sphere_evaluate(vtkNew sself, double center, double R, double x); +extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, float pts, long long numPts, float sphere, long long hints); +extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, double pts, long long numPts, double sphere, long long hints); +extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, float spheres, long long numSpheres, float sphere, long long hints); +extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, double spheres, long long numSpheres, double sphere, long long hints); extern "C" vtkNew < vtkSpheres > vtkSpheres_new () ; extern "C" void vtkSpheres_destructor (vtkNew < vtkSpheres > sself) ; extern "C" void * vtkSpheres_get_ptr (vtkNew < vtkSpheres > sself) ; -extern "C" vtkNew < vtkSphericalPointIterator > vtkSphericalPointIterator_new () ; -extern "C" void vtkSphericalPointIterator_destructor (vtkNew < vtkSphericalPointIterator > sself) ; -extern "C" void * vtkSphericalPointIterator_get_ptr (vtkNew < vtkSphericalPointIterator > sself) ; +extern "C" double vtk_spheres_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_spheres_evaluate_gradient(vtkNew sself, double x, double n); +extern "C" int vtk_spheres_get_number_of_spheres(vtkNew sself); extern "C" vtkNew < vtkStaticCellLinks > vtkStaticCellLinks_new () ; extern "C" void vtkStaticCellLinks_destructor (vtkNew < vtkStaticCellLinks > sself) ; extern "C" void * vtkStaticCellLinks_get_ptr (vtkNew < vtkStaticCellLinks > sself) ; +extern "C" long long vtk_static_cell_links_get_number_of_cells(vtkNew sself, long long ptId); +extern "C" long long vtk_static_cell_links_get_ncells(vtkNew sself, long long ptId); +extern "C" long long* vtk_static_cell_links_get_cells(vtkNew sself, long long ptId); +extern "C" void vtk_static_cell_links_select_cells(vtkNew sself, long long minMaxDegree, unsigned char cellSelection); +extern "C" void vtk_static_cell_links_initialize(vtkNew sself); +extern "C" void vtk_static_cell_links_squeeze(vtkNew sself); +extern "C" void vtk_static_cell_links_reset(vtkNew sself); +extern "C" unsigned long vtk_static_cell_links_get_actual_memory_size(vtkNew sself); extern "C" vtkNew < vtkStaticCellLocator > vtkStaticCellLocator_new () ; extern "C" void vtkStaticCellLocator_destructor (vtkNew < vtkStaticCellLocator > sself) ; extern "C" void * vtkStaticCellLocator_get_ptr (vtkNew < vtkStaticCellLocator > sself) ; +extern "C" void vtk_static_cell_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3); +extern "C" void vtk_static_cell_locator_set_divisions(vtkNew sself, const int _arg); +extern "C" int* vtk_static_cell_locator_get_divisions(vtkNew sself); +extern "C" void vtk_static_cell_locator_get_divisions(vtkNew sself, int data); +extern "C" long long vtk_static_cell_locator_find_cell(vtkNew sself, double x); +extern "C" int vtk_static_cell_locator_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_static_cell_locator_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId, long long cellId); +extern "C" void vtk_static_cell_locator_free_search_structure(vtkNew sself); +extern "C" void vtk_static_cell_locator_build_locator(vtkNew sself); +extern "C" void vtk_static_cell_locator_set_max_number_of_buckets(vtkNew sself, long long _arg); +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_min_value(vtkNew sself); +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_max_value(vtkNew sself); +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets(vtkNew sself); +extern "C" bool vtk_static_cell_locator_get_large_ids(vtkNew sself); +extern "C" void vtk_static_cell_locator_set_use_diagonal_length_tolerance(vtkNew sself, bool _arg); +extern "C" bool vtk_static_cell_locator_get_use_diagonal_length_tolerance(vtkNew sself); +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_on(vtkNew sself); +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_off(vtkNew sself); extern "C" vtkNew < vtkStaticPointLocator > vtkStaticPointLocator_new () ; extern "C" void vtkStaticPointLocator_destructor (vtkNew < vtkStaticPointLocator > sself) ; extern "C" void * vtkStaticPointLocator_get_ptr (vtkNew < vtkStaticPointLocator > sself) ; +extern "C" void vtk_static_point_locator_set_number_of_points_per_bucket(vtkNew sself, int _arg); +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_min_value(vtkNew sself); +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_max_value(vtkNew sself); +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket(vtkNew sself); +extern "C" void vtk_static_point_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3); +extern "C" void vtk_static_point_locator_set_divisions(vtkNew sself, const int _arg); +extern "C" int* vtk_static_point_locator_get_divisions(vtkNew sself); +extern "C" void vtk_static_point_locator_get_divisions(vtkNew sself, int data); +extern "C" long long vtk_static_point_locator_find_closest_point(vtkNew sself, const double x); +extern "C" long long vtk_static_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); +extern "C" long long vtk_static_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2); +extern "C" int vtk_static_point_locator_intersect_with_line(vtkNew sself, double a0, double a1, double tol, double t, double lineX, double ptX, long long ptId); +extern "C" void vtk_static_point_locator_merge_points(vtkNew sself, double tol, long long mergeMap); +extern "C" void vtk_static_point_locator_initialize(vtkNew sself); +extern "C" void vtk_static_point_locator_free_search_structure(vtkNew sself); +extern "C" void vtk_static_point_locator_build_locator(vtkNew sself); +extern "C" void vtk_static_point_locator_build_locator(vtkNew sself, const double inBounds); +extern "C" long long vtk_static_point_locator_get_number_of_points_in_bucket(vtkNew sself, long long bNum); +extern "C" void vtk_static_point_locator_set_max_number_of_buckets(vtkNew sself, long long _arg); +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_min_value(vtkNew sself); +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_max_value(vtkNew sself); +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets(vtkNew sself); +extern "C" bool vtk_static_point_locator_get_large_ids(vtkNew sself); +extern "C" double* vtk_static_point_locator_get_spacing(vtkNew sself); +extern "C" void vtk_static_point_locator_get_spacing(vtkNew sself, double spacing); extern "C" vtkNew < vtkStaticPointLocator2D > vtkStaticPointLocator2D_new () ; extern "C" void vtkStaticPointLocator2D_destructor (vtkNew < vtkStaticPointLocator2D > sself) ; extern "C" void * vtkStaticPointLocator2D_get_ptr (vtkNew < vtkStaticPointLocator2D > sself) ; +extern "C" void vtk_static_point_locator_2_d_set_number_of_points_per_bucket(vtkNew sself, int _arg); +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value(vtkNew sself); +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value(vtkNew sself); +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket(vtkNew sself); +extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkNew sself, int _arg1, int _arg2); +extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkNew sself, const int _arg); +extern "C" int* vtk_static_point_locator_2_d_get_divisions(vtkNew sself); +extern "C" void vtk_static_point_locator_2_d_get_divisions(vtkNew sself, int data); +extern "C" long long vtk_static_point_locator_2_d_find_closest_point(vtkNew sself, const double x); +extern "C" long long vtk_static_point_locator_2_d_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); +extern "C" long long vtk_static_point_locator_2_d_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2); +extern "C" int vtk_static_point_locator_2_d_intersect_with_line(vtkNew sself, double a0, double a1, double tol, double t, double lineX, double ptX, long long ptId); +extern "C" void vtk_static_point_locator_2_d_merge_points(vtkNew sself, double tol, long long mergeMap); +extern "C" void vtk_static_point_locator_2_d_initialize(vtkNew sself); +extern "C" void vtk_static_point_locator_2_d_free_search_structure(vtkNew sself); +extern "C" void vtk_static_point_locator_2_d_build_locator(vtkNew sself); +extern "C" long long vtk_static_point_locator_2_d_get_number_of_points_in_bucket(vtkNew sself, long long bNum); +extern "C" void vtk_static_point_locator_2_d_set_max_number_of_buckets(vtkNew sself, long long _arg); +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(vtkNew sself); +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(vtkNew sself); +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets(vtkNew sself); +extern "C" bool vtk_static_point_locator_2_d_get_large_ids(vtkNew sself); +extern "C" void vtk_static_point_locator_2_d_get_bounds(vtkNew sself, double bounds); +extern "C" double* vtk_static_point_locator_2_d_get_spacing(vtkNew sself); +extern "C" void vtk_static_point_locator_2_d_get_spacing(vtkNew sself, double spacing); +extern "C" void vtk_static_point_locator_2_d_get_bucket_indices(vtkNew sself, const double x, int ij); +extern "C" long long vtk_static_point_locator_2_d_get_bucket_index(vtkNew sself, const double x); extern "C" vtkNew < vtkStructuredExtent > vtkStructuredExtent_new () ; extern "C" void vtkStructuredExtent_destructor (vtkNew < vtkStructuredExtent > sself) ; extern "C" void * vtkStructuredExtent_get_ptr (vtkNew < vtkStructuredExtent > sself) ; +extern "C" void vtk_structured_extent_clamp(vtkNew sself, int ext, const int wholeExt); +extern "C" bool vtk_structured_extent_strictly_smaller(vtkNew sself, const int ext, const int wholeExt); +extern "C" bool vtk_structured_extent_smaller(vtkNew sself, const int ext, const int wholeExt); +extern "C" void vtk_structured_extent_grow(vtkNew sself, int ext, int count); +extern "C" void vtk_structured_extent_grow(vtkNew sself, int ext, int count, int wholeExt); +extern "C" void vtk_structured_extent_transform(vtkNew sself, int ext, int wholeExt); +extern "C" void vtk_structured_extent_get_dimensions(vtkNew sself, const int ext, int dims); extern "C" vtkNew < vtkStructuredGrid > vtkStructuredGrid_new () ; extern "C" void vtkStructuredGrid_destructor (vtkNew < vtkStructuredGrid > sself) ; extern "C" void * vtkStructuredGrid_get_ptr (vtkNew < vtkStructuredGrid > sself) ; +extern "C" int vtk_structured_grid_get_data_object_type(vtkNew sself); +extern "C" long long vtk_structured_grid_get_number_of_points(vtkNew sself); +extern "C" void vtk_structured_grid_get_point(vtkNew sself, long long ptId, double p); +extern "C" int vtk_structured_grid_get_cell_type(vtkNew sself, long long cellId); +extern "C" void vtk_structured_grid_set_dimensions(vtkNew sself, int i, int j, int k); +extern "C" void vtk_structured_grid_set_dimensions(vtkNew sself, const int dim); +extern "C" int* vtk_structured_grid_get_dimensions(vtkNew sself); +extern "C" void vtk_structured_grid_get_dimensions(vtkNew sself, int dim); +extern "C" int vtk_structured_grid_get_data_dimension(vtkNew sself); +extern "C" void vtk_structured_grid_set_extent(vtkNew sself, int extent); +extern "C" void vtk_structured_grid_set_extent(vtkNew sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax); +extern "C" int* vtk_structured_grid_get_extent(vtkNew sself); +extern "C" void vtk_structured_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_structured_grid_get_extent(vtkNew sself, int _arg); +extern "C" int vtk_structured_grid_get_extent_type(vtkNew sself); +extern "C" void vtk_structured_grid_blank_point(vtkNew sself, long long ptId); +extern "C" void vtk_structured_grid_un_blank_point(vtkNew sself, long long ptId); +extern "C" void vtk_structured_grid_blank_cell(vtkNew sself, long long ptId); +extern "C" void vtk_structured_grid_un_blank_cell(vtkNew sself, long long ptId); +extern "C" unsigned char vtk_structured_grid_is_point_visible(vtkNew sself, long long ptId); +extern "C" unsigned char vtk_structured_grid_is_cell_visible(vtkNew sself, long long cellId); +extern "C" bool vtk_structured_grid_has_any_blank_points(vtkNew sself); +extern "C" bool vtk_structured_grid_has_any_blank_cells(vtkNew sself); +extern "C" void vtk_structured_grid_get_cell_dims(vtkNew sself, int cellDims); +extern "C" void vtk_structured_grid_crop(vtkNew sself, const int updateExtent); +extern "C" void vtk_structured_grid_get_point(vtkNew sself, int i, int j, int k, double p, bool adjustForExtent); extern "C" vtkNew < vtkStructuredPoints > vtkStructuredPoints_new () ; extern "C" void vtkStructuredPoints_destructor (vtkNew < vtkStructuredPoints > sself) ; extern "C" void * vtkStructuredPoints_get_ptr (vtkNew < vtkStructuredPoints > sself) ; +extern "C" int vtk_structured_points_get_data_object_type(vtkNew sself); extern "C" vtkNew < vtkStructuredPointsCollection > vtkStructuredPointsCollection_new () ; extern "C" void vtkStructuredPointsCollection_destructor (vtkNew < vtkStructuredPointsCollection > sself) ; extern "C" void * vtkStructuredPointsCollection_get_ptr (vtkNew < vtkStructuredPointsCollection > sself) ; extern "C" vtkNew < vtkSuperquadric > vtkSuperquadric_new () ; extern "C" void vtkSuperquadric_destructor (vtkNew < vtkSuperquadric > sself) ; extern "C" void * vtkSuperquadric_get_ptr (vtkNew < vtkSuperquadric > sself) ; +extern "C" double vtk_superquadric_evaluate_function(vtkNew sself, double x); +extern "C" void vtk_superquadric_evaluate_gradient(vtkNew sself, double x, double g); +extern "C" void vtk_superquadric_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_superquadric_set_center(vtkNew sself, const double _arg); +extern "C" double* vtk_superquadric_get_center(vtkNew sself); +extern "C" void vtk_superquadric_get_center(vtkNew sself, double data); +extern "C" void vtk_superquadric_set_scale(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_superquadric_set_scale(vtkNew sself, const double _arg); +extern "C" double* vtk_superquadric_get_scale(vtkNew sself); +extern "C" void vtk_superquadric_get_scale(vtkNew sself, double data); +extern "C" double vtk_superquadric_get_thickness(vtkNew sself); +extern "C" void vtk_superquadric_set_thickness(vtkNew sself, double _arg); +extern "C" double vtk_superquadric_get_thickness_min_value(vtkNew sself); +extern "C" double vtk_superquadric_get_thickness_max_value(vtkNew sself); +extern "C" double vtk_superquadric_get_phi_roundness(vtkNew sself); +extern "C" void vtk_superquadric_set_phi_roundness(vtkNew sself, double e); +extern "C" double vtk_superquadric_get_theta_roundness(vtkNew sself); +extern "C" void vtk_superquadric_set_theta_roundness(vtkNew sself, double e); +extern "C" void vtk_superquadric_set_size(vtkNew sself, double _arg); +extern "C" double vtk_superquadric_get_size(vtkNew sself); +extern "C" void vtk_superquadric_toroidal_on(vtkNew sself); +extern "C" void vtk_superquadric_toroidal_off(vtkNew sself); +extern "C" int vtk_superquadric_get_toroidal(vtkNew sself); +extern "C" void vtk_superquadric_set_toroidal(vtkNew sself, int _arg); extern "C" vtkNew < vtkTable > vtkTable_new () ; extern "C" void vtkTable_destructor (vtkNew < vtkTable > sself) ; extern "C" void * vtkTable_get_ptr (vtkNew < vtkTable > sself) ; +extern "C" void vtk_table_dump(vtkNew sself, unsigned int colWidth, int rowLimit); +extern "C" int vtk_table_get_data_object_type(vtkNew sself); +extern "C" long long vtk_table_get_number_of_rows(vtkNew sself); +extern "C" void vtk_table_set_number_of_rows(vtkNew sself, const long long p0); +extern "C" long long vtk_table_insert_next_blank_row(vtkNew sself, double default_num_val); +extern "C" void vtk_table_remove_row(vtkNew sself, long long row); +extern "C" long long vtk_table_get_number_of_columns(vtkNew sself); +extern "C" const char* vtk_table_get_column_name(vtkNew sself, long long col); +extern "C" void vtk_table_remove_column_by_name(vtkNew sself, const char name); +extern "C" void vtk_table_remove_column(vtkNew sself, long long col); +extern "C" void vtk_table_initialize(vtkNew sself); +extern "C" long long vtk_table_get_number_of_elements(vtkNew sself, int type); extern "C" vtkNew < vtkTetra > vtkTetra_new () ; extern "C" void vtkTetra_destructor (vtkNew < vtkTetra > sself) ; extern "C" void * vtkTetra_get_ptr (vtkNew < vtkTetra > sself) ; +extern "C" void vtk_tetra_get_edge_points(vtkNew sself, long long edgeId, const long long pts); +extern "C" void vtk_tetra_get_edge_points(vtkNew sself, int edgeId, int pts); +extern "C" long long vtk_tetra_get_face_points(vtkNew sself, long long faceId, const long long pts); +extern "C" void vtk_tetra_get_face_points(vtkNew sself, int faceId, int pts); +extern "C" void vtk_tetra_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); +extern "C" long long vtk_tetra_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); +extern "C" long long vtk_tetra_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); +extern "C" long long vtk_tetra_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); +extern "C" long long vtk_tetra_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); +extern "C" bool vtk_tetra_get_centroid(vtkNew sself, double centroid); +extern "C" int vtk_tetra_get_cell_type(vtkNew sself); +extern "C" int vtk_tetra_get_number_of_edges(vtkNew sself); +extern "C" int vtk_tetra_get_number_of_faces(vtkNew sself); +extern "C" int vtk_tetra_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_tetra_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_tetra_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_tetra_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int* vtk_tetra_get_triangle_cases(vtkNew sself, int caseId); +extern "C" int vtk_tetra_get_parametric_center(vtkNew sself, double pcoords); +extern "C" double vtk_tetra_get_parametric_distance(vtkNew sself, const double pcoords); +extern "C" void vtk_tetra_tetra_center(vtkNew sself, double p1, double p2, double p3, double p4, double center); +extern "C" double vtk_tetra_circumsphere(vtkNew sself, double x1, double x2, double x3, double x4, double center); +extern "C" double vtk_tetra_insphere(vtkNew sself, double p1, double p2, double p3, double p4, double center); +extern "C" int vtk_tetra_barycentric_coords(vtkNew sself, double x, double x1, double x2, double x3, double x4, double bcoords); +extern "C" double vtk_tetra_compute_volume(vtkNew sself, double p1, double p2, double p3, double p4); +extern "C" int vtk_tetra_jacobian_inverse(vtkNew sself, double inverse, double derivs); +extern "C" void vtk_tetra_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_tetra_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_tetra_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_tetra_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_tetra_get_face_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_tetra_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_tetra_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_tetra_get_point_to_incident_edges_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_tetra_get_point_to_incident_faces_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_tetra_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); extern "C" vtkNew < vtkTree > vtkTree_new () ; extern "C" void vtkTree_destructor (vtkNew < vtkTree > sself) ; extern "C" void * vtkTree_get_ptr (vtkNew < vtkTree > sself) ; +extern "C" long long vtk_tree_get_root(vtkNew sself); +extern "C" long long vtk_tree_get_number_of_children(vtkNew sself, long long v); +extern "C" long long vtk_tree_get_child(vtkNew sself, long long v, long long i); +extern "C" long long vtk_tree_get_parent(vtkNew sself, long long v); +extern "C" long long vtk_tree_get_level(vtkNew sself, long long v); +extern "C" bool vtk_tree_is_leaf(vtkNew sself, long long vertex); extern "C" vtkNew < vtkTreeBFSIterator > vtkTreeBFSIterator_new () ; extern "C" void vtkTreeBFSIterator_destructor (vtkNew < vtkTreeBFSIterator > sself) ; extern "C" void * vtkTreeBFSIterator_get_ptr (vtkNew < vtkTreeBFSIterator > sself) ; extern "C" vtkNew < vtkTreeDFSIterator > vtkTreeDFSIterator_new () ; extern "C" void vtkTreeDFSIterator_destructor (vtkNew < vtkTreeDFSIterator > sself) ; extern "C" void * vtkTreeDFSIterator_get_ptr (vtkNew < vtkTreeDFSIterator > sself) ; +extern "C" void vtk_tree_dfs_iterator_set_mode(vtkNew sself, int mode); +extern "C" int vtk_tree_dfs_iterator_get_mode(vtkNew sself); extern "C" vtkNew < vtkTriQuadraticHexahedron > vtkTriQuadraticHexahedron_new () ; extern "C" void vtkTriQuadraticHexahedron_destructor (vtkNew < vtkTriQuadraticHexahedron > sself) ; extern "C" void * vtkTriQuadraticHexahedron_get_ptr (vtkNew < vtkTriQuadraticHexahedron > sself) ; +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_type(vtkNew sself); +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_dimension(vtkNew sself); +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_edges(vtkNew sself); +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_faces(vtkNew sself); +extern "C" int vtk_tri_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_tri_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_tri_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_tri_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_tri_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_tri_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_tri_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_tri_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_tri_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_tri_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId); +extern "C" void vtk_tri_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); extern "C" vtkNew < vtkTriQuadraticPyramid > vtkTriQuadraticPyramid_new () ; extern "C" void vtkTriQuadraticPyramid_destructor (vtkNew < vtkTriQuadraticPyramid > sself) ; extern "C" void * vtkTriQuadraticPyramid_get_ptr (vtkNew < vtkTriQuadraticPyramid > sself) ; +extern "C" int vtk_tri_quadratic_pyramid_get_cell_type(vtkNew sself); +extern "C" int vtk_tri_quadratic_pyramid_get_cell_dimension(vtkNew sself); +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_edges(vtkNew sself); +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_faces(vtkNew sself); +extern "C" int vtk_tri_quadratic_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_tri_quadratic_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_tri_quadratic_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_tri_quadratic_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_tri_quadratic_pyramid_get_parametric_center(vtkNew sself, double pcoords); +extern "C" double vtk_tri_quadratic_pyramid_get_parametric_distance(vtkNew sself, const double pcoords); +extern "C" void vtk_tri_quadratic_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_tri_quadratic_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_tri_quadratic_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_tri_quadratic_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_tri_quadratic_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); +extern "C" const long long* vtk_tri_quadratic_pyramid_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_tri_quadratic_pyramid_get_face_array(vtkNew sself, long long faceId); extern "C" vtkNew < vtkTriangle > vtkTriangle_new () ; extern "C" void vtkTriangle_destructor (vtkNew < vtkTriangle > sself) ; extern "C" void * vtkTriangle_get_ptr (vtkNew < vtkTriangle > sself) ; +extern "C" int vtk_triangle_get_cell_type(vtkNew sself); +extern "C" int vtk_triangle_get_cell_dimension(vtkNew sself); +extern "C" int vtk_triangle_get_number_of_edges(vtkNew sself); +extern "C" int vtk_triangle_get_number_of_faces(vtkNew sself); +extern "C" int vtk_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" void vtk_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" double vtk_triangle_compute_area(vtkNew sself); +extern "C" void vtk_triangle_interpolation_functions(vtkNew sself, const double pcoords, double sf); +extern "C" void vtk_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_triangle_interpolate_functions(vtkNew sself, const double pcoords, double sf); +extern "C" void vtk_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" const long long* vtk_triangle_get_edge_array(vtkNew sself, long long edgeId); +extern "C" int vtk_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" int vtk_triangle_get_parametric_center(vtkNew sself, double pcoords); +extern "C" double vtk_triangle_get_parametric_distance(vtkNew sself, const double pcoords); +extern "C" void vtk_triangle_triangle_center(vtkNew sself, const double p1, const double p2, const double p3, double center); +extern "C" double vtk_triangle_triangle_area(vtkNew sself, const double p1, const double p2, const double p3); +extern "C" double vtk_triangle_circumcircle(vtkNew sself, const double p1, const double p2, const double p3, double center); +extern "C" int vtk_triangle_barycentric_coords(vtkNew sself, const double x, const double x1, const double x2, const double x3, double bcoords); +extern "C" int vtk_triangle_project_to_2_d(vtkNew sself, const double x1, const double x2, const double x3, double v1, double v2, double v3); +extern "C" void vtk_triangle_compute_normal(vtkNew sself, const double v1, const double v2, const double v3, double n); +extern "C" void vtk_triangle_compute_normal_direction(vtkNew sself, const double v1, const double v2, const double v3, double n); +extern "C" int vtk_triangle_triangles_intersect(vtkNew sself, const double p1, const double q1, const double r1, const double p2, const double q2, const double r2); +extern "C" int vtk_triangle_point_in_triangle(vtkNew sself, const double x, const double x1, const double x2, const double x3, const double tol2); +extern "C" void vtk_triangle_compute_quadric(vtkNew sself, const double x1, const double x2, const double x3, double quadric); extern "C" vtkNew < vtkTriangleStrip > vtkTriangleStrip_new () ; extern "C" void vtkTriangleStrip_destructor (vtkNew < vtkTriangleStrip > sself) ; extern "C" void * vtkTriangleStrip_get_ptr (vtkNew < vtkTriangleStrip > sself) ; +extern "C" int vtk_triangle_strip_get_cell_type(vtkNew sself); +extern "C" int vtk_triangle_strip_get_cell_dimension(vtkNew sself); +extern "C" int vtk_triangle_strip_get_number_of_edges(vtkNew sself); +extern "C" int vtk_triangle_strip_get_number_of_faces(vtkNew sself); +extern "C" int vtk_triangle_strip_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_triangle_strip_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_triangle_strip_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_triangle_strip_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_triangle_strip_get_parametric_center(vtkNew sself, double pcoords); extern "C" vtkNew < vtkUndirectedGraph > vtkUndirectedGraph_new () ; extern "C" void vtkUndirectedGraph_destructor (vtkNew < vtkUndirectedGraph > sself) ; extern "C" void * vtkUndirectedGraph_get_ptr (vtkNew < vtkUndirectedGraph > sself) ; +extern "C" long long vtk_undirected_graph_get_in_degree(vtkNew sself, long long v); extern "C" vtkNew < vtkUniformGrid > vtkUniformGrid_new () ; extern "C" void vtkUniformGrid_destructor (vtkNew < vtkUniformGrid > sself) ; extern "C" void * vtkUniformGrid_get_ptr (vtkNew < vtkUniformGrid > sself) ; +extern "C" int vtk_uniform_grid_get_grid_description(vtkNew sself); +extern "C" void vtk_uniform_grid_blank_point(vtkNew sself, long long ptId); +extern "C" void vtk_uniform_grid_un_blank_point(vtkNew sself, long long ptId); +extern "C" void vtk_uniform_grid_blank_point(vtkNew sself, const int i, const int j, const int k); +extern "C" void vtk_uniform_grid_un_blank_point(vtkNew sself, const int i, const int j, const int k); +extern "C" void vtk_uniform_grid_blank_cell(vtkNew sself, long long ptId); +extern "C" void vtk_uniform_grid_un_blank_cell(vtkNew sself, long long ptId); +extern "C" void vtk_uniform_grid_blank_cell(vtkNew sself, const int i, const int j, const int k); +extern "C" void vtk_uniform_grid_un_blank_cell(vtkNew sself, const int i, const int j, const int k); +extern "C" unsigned char vtk_uniform_grid_is_point_visible(vtkNew sself, long long pointId); +extern "C" unsigned char vtk_uniform_grid_is_cell_visible(vtkNew sself, long long cellId); extern "C" vtkNew < vtkUniformGridAMR > vtkUniformGridAMR_new () ; extern "C" void vtkUniformGridAMR_destructor (vtkNew < vtkUniformGridAMR > sself) ; extern "C" void * vtkUniformGridAMR_get_ptr (vtkNew < vtkUniformGridAMR > sself) ; +extern "C" int vtk_uniform_grid_amr_get_data_object_type(vtkNew sself); +extern "C" void vtk_uniform_grid_amr_initialize(vtkNew sself); +extern "C" void vtk_uniform_grid_amr_initialize(vtkNew sself, int numLevels, const int blocksPerLevel); +extern "C" void vtk_uniform_grid_amr_set_grid_description(vtkNew sself, int gridDescription); +extern "C" int vtk_uniform_grid_amr_get_grid_description(vtkNew sself); +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_levels(vtkNew sself); +extern "C" unsigned int vtk_uniform_grid_amr_get_total_number_of_blocks(vtkNew sself); +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_data_sets(vtkNew sself, const unsigned int level); +extern "C" void vtk_uniform_grid_amr_get_bounds(vtkNew sself, double bounds); +extern "C" const double* vtk_uniform_grid_amr_get_bounds(vtkNew sself); +extern "C" void vtk_uniform_grid_amr_get_min(vtkNew sself, double min); +extern "C" void vtk_uniform_grid_amr_get_max(vtkNew sself, double max); +extern "C" int vtk_uniform_grid_amr_get_composite_index(vtkNew sself, const unsigned int level, const unsigned int index); +extern "C" void vtk_uniform_grid_amr_get_level_and_index(vtkNew sself, const unsigned int compositeIdx, unsigned int level, unsigned int idx); extern "C" vtkNew < vtkUniformGridAMRDataIterator > vtkUniformGridAMRDataIterator_new () ; extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkNew < vtkUniformGridAMRDataIterator > sself) ; extern "C" void * vtkUniformGridAMRDataIterator_get_ptr (vtkNew < vtkUniformGridAMRDataIterator > sself) ; +extern "C" int vtk_uniform_grid_amr_data_iterator_has_current_meta_data(vtkNew sself); +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_flat_index(vtkNew sself); +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_level(vtkNew sself); +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_index(vtkNew sself); +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_first_item(vtkNew sself); +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_next_item(vtkNew sself); +extern "C" int vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(vtkNew sself); extern "C" vtkNew < vtkUniformHyperTreeGrid > vtkUniformHyperTreeGrid_new () ; extern "C" void vtkUniformHyperTreeGrid_destructor (vtkNew < vtkUniformHyperTreeGrid > sself) ; extern "C" void * vtkUniformHyperTreeGrid_get_ptr (vtkNew < vtkUniformHyperTreeGrid > sself) ; +extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkNew sself, const double _arg); +extern "C" double* vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself); +extern "C" void vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself, double _arg); +extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0, double p1, double p2); +extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0); +extern "C" double* vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself); +extern "C" void vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself, double _arg); +extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0); +extern "C" void vtk_uniform_hyper_tree_grid_get_level_zero_origin_from_index(vtkNew sself, long long p0, double p1); +extern "C" unsigned long vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(vtkNew sself); extern "C" vtkNew < vtkUnstructuredGrid > vtkUnstructuredGrid_new () ; extern "C" void vtkUnstructuredGrid_destructor (vtkNew < vtkUnstructuredGrid > sself) ; extern "C" void * vtkUnstructuredGrid_get_ptr (vtkNew < vtkUnstructuredGrid > sself) ; +extern "C" int vtk_unstructured_grid_get_data_object_type(vtkNew sself); +extern "C" bool vtk_unstructured_grid_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize); +extern "C" bool vtk_unstructured_grid_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize); +extern "C" void vtk_unstructured_grid_allocate(vtkNew sself, long long numCells, int extSize); +extern "C" void vtk_unstructured_grid_reset(vtkNew sself); +extern "C" int vtk_unstructured_grid_get_cell_type(vtkNew sself, long long cellId); +extern "C" void vtk_unstructured_grid_get_cell_points(vtkNew sself, long long cellId, long long npts, const long long pts); +extern "C" void vtk_unstructured_grid_get_point_cells(vtkNew sself, long long ptId, long long ncells, long long cells); +extern "C" void vtk_unstructured_grid_get_point_cells(vtkNew sself, long long ptId, unsigned short ncells, long long cells); +extern "C" void vtk_unstructured_grid_squeeze(vtkNew sself); +extern "C" void vtk_unstructured_grid_initialize(vtkNew sself); +extern "C" int vtk_unstructured_grid_get_max_cell_size(vtkNew sself); +extern "C" void vtk_unstructured_grid_build_links(vtkNew sself); +extern "C" void vtk_unstructured_grid_get_face_stream(vtkNew sself, long long cellId, long long nfaces, const long long ptIds); +extern "C" bool vtk_unstructured_grid_is_cell_boundary(vtkNew sself, long long cellId, long long npts, const long long ptIds); +extern "C" long long vtk_unstructured_grid_insert_next_linked_cell(vtkNew sself, int type, int npts, const long long pts); +extern "C" void vtk_unstructured_grid_remove_reference_to_cell(vtkNew sself, long long ptId, long long cellId); +extern "C" void vtk_unstructured_grid_add_reference_to_cell(vtkNew sself, long long ptId, long long cellId); +extern "C" void vtk_unstructured_grid_resize_cell_list(vtkNew sself, long long ptId, int size); +extern "C" int vtk_unstructured_grid_get_piece(vtkNew sself); +extern "C" int vtk_unstructured_grid_get_number_of_pieces(vtkNew sself); +extern "C" int vtk_unstructured_grid_get_ghost_level(vtkNew sself); +extern "C" int vtk_unstructured_grid_is_homogeneous(vtkNew sself); +extern "C" void vtk_unstructured_grid_remove_ghost_cells(vtkNew sself); +extern "C" long long* vtk_unstructured_grid_get_faces(vtkNew sself, long long cellId); +extern "C" int vtk_unstructured_grid_initialize_faces_representation(vtkNew sself, long long numPrevCells); +extern "C" unsigned long vtk_unstructured_grid_get_mesh_m_time(vtkNew sself); +extern "C" void vtk_unstructured_grid_convert_face_stream_point_ids(vtkNew sself, long long nfaces, long long faceStream, long long idMap); extern "C" vtkNew < vtkUnstructuredGridCellIterator > vtkUnstructuredGridCellIterator_new () ; extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkNew < vtkUnstructuredGridCellIterator > sself) ; extern "C" void * vtkUnstructuredGridCellIterator_get_ptr (vtkNew < vtkUnstructuredGridCellIterator > sself) ; +extern "C" bool vtk_unstructured_grid_cell_iterator_is_done_with_traversal(vtkNew sself); +extern "C" long long vtk_unstructured_grid_cell_iterator_get_cell_id(vtkNew sself); +extern "C" void vtk_unstructured_grid_cell_iterator_go_to_cell(vtkNew sself, long long cellId); extern "C" vtkNew < vtkVertex > vtkVertex_new () ; extern "C" void vtkVertex_destructor (vtkNew < vtkVertex > sself) ; extern "C" void * vtkVertex_get_ptr (vtkNew < vtkVertex > sself) ; +extern "C" int vtk_vertex_get_cell_type(vtkNew sself); +extern "C" int vtk_vertex_get_cell_dimension(vtkNew sself); +extern "C" int vtk_vertex_get_number_of_edges(vtkNew sself); +extern "C" int vtk_vertex_get_number_of_faces(vtkNew sself); +extern "C" int vtk_vertex_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_vertex_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_vertex_inflate(vtkNew sself, double p0); +extern "C" int vtk_vertex_get_parametric_center(vtkNew sself, double pcoords); +extern "C" int vtk_vertex_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_vertex_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" void vtk_vertex_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_vertex_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_vertex_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_vertex_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); extern "C" vtkNew < vtkVertexListIterator > vtkVertexListIterator_new () ; extern "C" void vtkVertexListIterator_destructor (vtkNew < vtkVertexListIterator > sself) ; extern "C" void * vtkVertexListIterator_get_ptr (vtkNew < vtkVertexListIterator > sself) ; +extern "C" long long vtk_vertex_list_iterator_next(vtkNew sself); +extern "C" bool vtk_vertex_list_iterator_has_next(vtkNew sself); extern "C" vtkNew < vtkVoxel > vtkVoxel_new () ; extern "C" void vtkVoxel_destructor (vtkNew < vtkVoxel > sself) ; extern "C" void * vtkVoxel_get_ptr (vtkNew < vtkVoxel > sself) ; +extern "C" void vtk_voxel_get_edge_points(vtkNew sself, long long edgeId, const long long pts); +extern "C" void vtk_voxel_get_edge_points(vtkNew sself, int edgeId, int pts); +extern "C" long long vtk_voxel_get_face_points(vtkNew sself, long long faceId, const long long pts); +extern "C" void vtk_voxel_get_face_points(vtkNew sself, int faceId, int pts); +extern "C" void vtk_voxel_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); +extern "C" long long vtk_voxel_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faces); +extern "C" long long vtk_voxel_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edges); +extern "C" long long vtk_voxel_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faces); +extern "C" long long vtk_voxel_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); +extern "C" bool vtk_voxel_get_centroid(vtkNew sself, double centroid); +extern "C" double vtk_voxel_compute_bounding_sphere(vtkNew sself, double center); +extern "C" int vtk_voxel_get_cell_type(vtkNew sself); +extern "C" int vtk_voxel_get_number_of_edges(vtkNew sself); +extern "C" int vtk_voxel_get_number_of_faces(vtkNew sself); +extern "C" int vtk_voxel_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_voxel_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_voxel_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_voxel_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int vtk_voxel_inflate(vtkNew sself, double dist); +extern "C" void vtk_voxel_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_voxel_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_voxel_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_voxel_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" int* vtk_voxel_get_triangle_cases(vtkNew sself, int caseId); +extern "C" const long long* vtk_voxel_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_voxel_get_face_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_voxel_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_voxel_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_voxel_get_point_to_incident_edges_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_voxel_get_point_to_incident_faces_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_voxel_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); extern "C" vtkNew < vtkWedge > vtkWedge_new () ; extern "C" void vtkWedge_destructor (vtkNew < vtkWedge > sself) ; extern "C" void * vtkWedge_get_ptr (vtkNew < vtkWedge > sself) ; +extern "C" void vtk_wedge_get_edge_points(vtkNew sself, long long edgeId, const long long pts); +extern "C" void vtk_wedge_get_edge_points(vtkNew sself, int edgeId, int pts); +extern "C" long long vtk_wedge_get_face_points(vtkNew sself, long long faceId, const long long pts); +extern "C" void vtk_wedge_get_face_points(vtkNew sself, int faceId, int pts); +extern "C" void vtk_wedge_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); +extern "C" long long vtk_wedge_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); +extern "C" long long vtk_wedge_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); +extern "C" long long vtk_wedge_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); +extern "C" long long vtk_wedge_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); +extern "C" bool vtk_wedge_get_centroid(vtkNew sself, double centroid); +extern "C" int vtk_wedge_get_cell_type(vtkNew sself); +extern "C" int vtk_wedge_get_number_of_edges(vtkNew sself); +extern "C" int vtk_wedge_get_number_of_faces(vtkNew sself); +extern "C" int vtk_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); +extern "C" void vtk_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); +extern "C" int vtk_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); +extern "C" void vtk_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); +extern "C" int* vtk_wedge_get_triangle_cases(vtkNew sself, int caseId); +extern "C" int vtk_wedge_get_parametric_center(vtkNew sself, double pcoords); +extern "C" void vtk_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" void vtk_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); +extern "C" void vtk_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); +extern "C" int vtk_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); +extern "C" const long long* vtk_wedge_get_edge_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_wedge_get_face_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_wedge_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); +extern "C" const long long* vtk_wedge_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); +extern "C" const long long* vtk_wedge_get_point_to_incident_edges_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_wedge_get_point_to_incident_faces_array(vtkNew sself, long long pointId); +extern "C" const long long* vtk_wedge_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); extern "C" vtkNew < vtkXMLDataElement > vtkXMLDataElement_new () ; extern "C" void vtkXMLDataElement_destructor (vtkNew < vtkXMLDataElement > sself) ; extern "C" void * vtkXMLDataElement_get_ptr (vtkNew < vtkXMLDataElement > sself) ; +extern "C" char* vtk_xml_data_element_get_name(vtkNew sself); +extern "C" void vtk_xml_data_element_set_name(vtkNew sself, const char _arg); +extern "C" char* vtk_xml_data_element_get_id(vtkNew sself); +extern "C" void vtk_xml_data_element_set_id(vtkNew sself, const char _arg); +extern "C" const char* vtk_xml_data_element_get_attribute(vtkNew sself, const char name); +extern "C" void vtk_xml_data_element_set_attribute(vtkNew sself, const char name, const char value); +extern "C" void vtk_xml_data_element_set_character_data(vtkNew sself, const char data, int length); +extern "C" void vtk_xml_data_element_add_character_data(vtkNew sself, const char c, size_t length); +extern "C" char* vtk_xml_data_element_get_character_data(vtkNew sself); +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, int value); +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, float value); +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, double value); +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, long value); +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, unsigned long value); +extern "C" void vtk_xml_data_element_set_int_attribute(vtkNew sself, const char name, int value); +extern "C" void vtk_xml_data_element_set_float_attribute(vtkNew sself, const char name, float value); +extern "C" void vtk_xml_data_element_set_double_attribute(vtkNew sself, const char name, double value); +extern "C" void vtk_xml_data_element_set_unsigned_long_attribute(vtkNew sself, const char name, unsigned long value); +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, int value); +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, float value); +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, double value); +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, long value); +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, unsigned long value); +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const int value); +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const float value); +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const double value); +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const unsigned long value); +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, long long value); +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, long long value); +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const long long value); +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, unsigned long long value); +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, unsigned long long value); +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const unsigned long long value); +extern "C" int vtk_xml_data_element_get_word_type_attribute(vtkNew sself, const char name, int value); +extern "C" int vtk_xml_data_element_get_number_of_attributes(vtkNew sself); +extern "C" const char* vtk_xml_data_element_get_attribute_name(vtkNew sself, int idx); +extern "C" const char* vtk_xml_data_element_get_attribute_value(vtkNew sself, int idx); +extern "C" void vtk_xml_data_element_remove_attribute(vtkNew sself, const char name); +extern "C" void vtk_xml_data_element_remove_all_attributes(vtkNew sself); +extern "C" int vtk_xml_data_element_get_number_of_nested_elements(vtkNew sself); +extern "C" void vtk_xml_data_element_remove_all_nested_elements(vtkNew sself); +extern "C" long long vtk_xml_data_element_get_xml_byte_index(vtkNew sself); +extern "C" void vtk_xml_data_element_set_xml_byte_index(vtkNew sself, long long _arg); +extern "C" void vtk_xml_data_element_set_attribute_encoding(vtkNew sself, int _arg); +extern "C" int vtk_xml_data_element_get_attribute_encoding_min_value(vtkNew sself); +extern "C" int vtk_xml_data_element_get_attribute_encoding_max_value(vtkNew sself); +extern "C" int vtk_xml_data_element_get_attribute_encoding(vtkNew sself); +extern "C" void vtk_xml_data_element_print_xml(vtkNew sself, const char fname); +extern "C" int vtk_xml_data_element_get_character_data_width(vtkNew sself); +extern "C" void vtk_xml_data_element_set_character_data_width(vtkNew sself, int _arg); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h index 4d4038e..813b96f 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h @@ -77,9 +77,61 @@ extern "C" vtkNew < vtkAlgorithm > vtkAlgorithm_new () ; extern "C" void vtkAlgorithm_destructor (vtkNew < vtkAlgorithm > sself) ; extern "C" void * vtkAlgorithm_get_ptr (vtkNew < vtkAlgorithm > sself) ; +extern "C" int vtk_algorithm_has_executive(vtkNew sself); +extern "C" int vtk_algorithm_get_number_of_input_ports(vtkNew sself); +extern "C" int vtk_algorithm_get_number_of_output_ports(vtkNew sself); +extern "C" void vtk_algorithm_set_abort_execute(vtkNew sself, int _arg); +extern "C" int vtk_algorithm_get_abort_execute(vtkNew sself); +extern "C" void vtk_algorithm_abort_execute_on(vtkNew sself); +extern "C" void vtk_algorithm_abort_execute_off(vtkNew sself); +extern "C" double vtk_algorithm_get_progress(vtkNew sself); +extern "C" void vtk_algorithm_set_progress(vtkNew sself, double p0); +extern "C" void vtk_algorithm_update_progress(vtkNew sself, double amount); +extern "C" void vtk_algorithm_set_progress_shift_scale(vtkNew sself, double shift, double scale); +extern "C" double vtk_algorithm_get_progress_shift(vtkNew sself); +extern "C" double vtk_algorithm_get_progress_scale(vtkNew sself); +extern "C" void vtk_algorithm_set_progress_text(vtkNew sself, const char ptext); +extern "C" char* vtk_algorithm_get_progress_text(vtkNew sself); +extern "C" unsigned long vtk_algorithm_get_error_code(vtkNew sself); +extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, int fieldAssociation, const char name); +extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, int fieldAssociation, int fieldAttributeType); +extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, const char fieldAssociation, const char attributeTypeorName); +extern "C" void vtk_algorithm_remove_all_inputs(vtkNew sself); +extern "C" void vtk_algorithm_remove_input_connection(vtkNew sself, int port, int idx); +extern "C" void vtk_algorithm_remove_all_input_connections(vtkNew sself, int port); +extern "C" int vtk_algorithm_get_number_of_input_connections(vtkNew sself, int port); +extern "C" int vtk_algorithm_get_total_number_of_input_connections(vtkNew sself); +extern "C" void vtk_algorithm_update(vtkNew sself, int port); +extern "C" void vtk_algorithm_update(vtkNew sself); +extern "C" int vtk_algorithm_update_piece(vtkNew sself, int piece, int numPieces, int ghostLevels, const int extents); +extern "C" int vtk_algorithm_update_extent(vtkNew sself, const int extents); +extern "C" int vtk_algorithm_update_time_step(vtkNew sself, double time, int piece, int numPieces, int ghostLevels, const int extents); +extern "C" void vtk_algorithm_update_information(vtkNew sself); +extern "C" void vtk_algorithm_update_data_object(vtkNew sself); +extern "C" void vtk_algorithm_propagate_update_extent(vtkNew sself); +extern "C" void vtk_algorithm_update_whole_extent(vtkNew sself); +extern "C" void vtk_algorithm_convert_total_input_to_port_connection(vtkNew sself, int ind, int port, int conn); +extern "C" void vtk_algorithm_set_release_data_flag(vtkNew sself, int p0); +extern "C" int vtk_algorithm_get_release_data_flag(vtkNew sself); +extern "C" void vtk_algorithm_release_data_flag_on(vtkNew sself); +extern "C" void vtk_algorithm_release_data_flag_off(vtkNew sself); +extern "C" int* vtk_algorithm_get_update_extent(vtkNew sself); +extern "C" int* vtk_algorithm_get_update_extent(vtkNew sself, int port); +extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int port, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int extent); +extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int port, int extent); +extern "C" int vtk_algorithm_get_update_piece(vtkNew sself); +extern "C" int vtk_algorithm_get_update_piece(vtkNew sself, int port); +extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkNew sself); +extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkNew sself, int port); +extern "C" int vtk_algorithm_get_update_ghost_level(vtkNew sself); +extern "C" int vtk_algorithm_get_update_ghost_level(vtkNew sself, int port); extern "C" vtkNew < vtkAlgorithmOutput > vtkAlgorithmOutput_new () ; extern "C" void vtkAlgorithmOutput_destructor (vtkNew < vtkAlgorithmOutput > sself) ; extern "C" void * vtkAlgorithmOutput_get_ptr (vtkNew < vtkAlgorithmOutput > sself) ; +extern "C" void vtk_algorithm_output_set_index(vtkNew sself, int index); +extern "C" int vtk_algorithm_output_get_index(vtkNew sself); extern "C" vtkNew < vtkAnnotationLayersAlgorithm > vtkAnnotationLayersAlgorithm_new () ; extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkNew < vtkAnnotationLayersAlgorithm > sself) ; extern "C" void * vtkAnnotationLayersAlgorithm_get_ptr (vtkNew < vtkAnnotationLayersAlgorithm > sself) ; @@ -89,6 +141,8 @@ extern "C" void * vtkArrayDataAlgorithm_get_ptr (vtkNew < vtkArrayDataAlgorithm extern "C" vtkNew < vtkCachedStreamingDemandDrivenPipeline > vtkCachedStreamingDemandDrivenPipeline_new () ; extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) ; extern "C" void * vtkCachedStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) ; +extern "C" void vtk_cached_streaming_demand_driven_pipeline_set_cache_size(vtkNew sself, int size); +extern "C" int vtk_cached_streaming_demand_driven_pipeline_get_cache_size(vtkNew sself); extern "C" vtkNew < vtkCastToConcrete > vtkCastToConcrete_new () ; extern "C" void vtkCastToConcrete_destructor (vtkNew < vtkCastToConcrete > sself) ; extern "C" void * vtkCastToConcrete_get_ptr (vtkNew < vtkCastToConcrete > sself) ; @@ -107,24 +161,86 @@ extern "C" void * vtkDataSetAlgorithm_get_ptr (vtkNew < vtkDataSetAlgorithm > ss extern "C" vtkNew < vtkDemandDrivenPipeline > vtkDemandDrivenPipeline_new () ; extern "C" void vtkDemandDrivenPipeline_destructor (vtkNew < vtkDemandDrivenPipeline > sself) ; extern "C" void * vtkDemandDrivenPipeline_get_ptr (vtkNew < vtkDemandDrivenPipeline > sself) ; +extern "C" unsigned long vtk_demand_driven_pipeline_get_pipeline_m_time(vtkNew sself); +extern "C" int vtk_demand_driven_pipeline_set_release_data_flag(vtkNew sself, int port, int n); +extern "C" int vtk_demand_driven_pipeline_get_release_data_flag(vtkNew sself, int port); +extern "C" int vtk_demand_driven_pipeline_update_pipeline_m_time(vtkNew sself); +extern "C" int vtk_demand_driven_pipeline_update_data_object(vtkNew sself); +extern "C" int vtk_demand_driven_pipeline_update_data(vtkNew sself, int outputPort); extern "C" vtkNew < vtkDirectedGraphAlgorithm > vtkDirectedGraphAlgorithm_new () ; extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkNew < vtkDirectedGraphAlgorithm > sself) ; extern "C" void * vtkDirectedGraphAlgorithm_get_ptr (vtkNew < vtkDirectedGraphAlgorithm > sself) ; extern "C" vtkNew < vtkEnsembleSource > vtkEnsembleSource_new () ; extern "C" void vtkEnsembleSource_destructor (vtkNew < vtkEnsembleSource > sself) ; extern "C" void * vtkEnsembleSource_get_ptr (vtkNew < vtkEnsembleSource > sself) ; +extern "C" void vtk_ensemble_source_remove_all_members(vtkNew sself); +extern "C" unsigned int vtk_ensemble_source_get_number_of_members(vtkNew sself); +extern "C" void vtk_ensemble_source_set_current_member(vtkNew sself, unsigned int _arg); +extern "C" unsigned int vtk_ensemble_source_get_current_member(vtkNew sself); extern "C" vtkNew < vtkExplicitStructuredGridAlgorithm > vtkExplicitStructuredGridAlgorithm_new () ; extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) ; extern "C" void * vtkExplicitStructuredGridAlgorithm_get_ptr (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) ; extern "C" vtkNew < vtkExtentRCBPartitioner > vtkExtentRCBPartitioner_new () ; extern "C" void vtkExtentRCBPartitioner_destructor (vtkNew < vtkExtentRCBPartitioner > sself) ; extern "C" void * vtkExtentRCBPartitioner_get_ptr (vtkNew < vtkExtentRCBPartitioner > sself) ; +extern "C" void vtk_extent_rcb_partitioner_set_number_of_partitions(vtkNew sself, const int N); +extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkNew sself, int imin, int imax, int jmin, int jmax, int kmin, int kmax); +extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkNew sself, int ext); +extern "C" void vtk_extent_rcb_partitioner_set_duplicate_nodes(vtkNew sself, int _arg); +extern "C" int vtk_extent_rcb_partitioner_get_duplicate_nodes(vtkNew sself); +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_on(vtkNew sself); +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_off(vtkNew sself); +extern "C" void vtk_extent_rcb_partitioner_set_number_of_ghost_layers(vtkNew sself, int _arg); +extern "C" int vtk_extent_rcb_partitioner_get_number_of_ghost_layers(vtkNew sself); +extern "C" int vtk_extent_rcb_partitioner_get_num_extents(vtkNew sself); +extern "C" void vtk_extent_rcb_partitioner_partition(vtkNew sself); +extern "C" void vtk_extent_rcb_partitioner_get_partition_extent(vtkNew sself, const int idx, int ext); extern "C" vtkNew < vtkExtentSplitter > vtkExtentSplitter_new () ; extern "C" void vtkExtentSplitter_destructor (vtkNew < vtkExtentSplitter > sself) ; extern "C" void * vtkExtentSplitter_get_ptr (vtkNew < vtkExtentSplitter > sself) ; +extern "C" void vtk_extent_splitter_add_extent_source(vtkNew sself, int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" void vtk_extent_splitter_add_extent_source(vtkNew sself, int id, int priority, int extent); +extern "C" void vtk_extent_splitter_remove_extent_source(vtkNew sself, int id); +extern "C" void vtk_extent_splitter_remove_all_extent_sources(vtkNew sself); +extern "C" void vtk_extent_splitter_add_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" void vtk_extent_splitter_add_extent(vtkNew sself, int extent); +extern "C" int vtk_extent_splitter_compute_sub_extents(vtkNew sself); +extern "C" int vtk_extent_splitter_get_number_of_sub_extents(vtkNew sself); +extern "C" int* vtk_extent_splitter_get_sub_extent(vtkNew sself, int index); +extern "C" void vtk_extent_splitter_get_sub_extent(vtkNew sself, int index, int extent); +extern "C" int vtk_extent_splitter_get_sub_extent_source(vtkNew sself, int index); +extern "C" int vtk_extent_splitter_get_point_mode(vtkNew sself); +extern "C" void vtk_extent_splitter_set_point_mode(vtkNew sself, int _arg); +extern "C" void vtk_extent_splitter_point_mode_on(vtkNew sself); +extern "C" void vtk_extent_splitter_point_mode_off(vtkNew sself); extern "C" vtkNew < vtkExtentTranslator > vtkExtentTranslator_new () ; extern "C" void vtkExtentTranslator_destructor (vtkNew < vtkExtentTranslator > sself) ; extern "C" void * vtkExtentTranslator_get_ptr (vtkNew < vtkExtentTranslator > sself) ; +extern "C" void vtk_extent_translator_set_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_extent_translator_set_whole_extent(vtkNew sself, const int _arg); +extern "C" int* vtk_extent_translator_get_whole_extent(vtkNew sself); +extern "C" void vtk_extent_translator_get_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_extent_translator_get_whole_extent(vtkNew sself, int _arg); +extern "C" void vtk_extent_translator_set_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_extent_translator_set_extent(vtkNew sself, const int _arg); +extern "C" int* vtk_extent_translator_get_extent(vtkNew sself); +extern "C" void vtk_extent_translator_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_extent_translator_get_extent(vtkNew sself, int _arg); +extern "C" void vtk_extent_translator_set_piece(vtkNew sself, int _arg); +extern "C" int vtk_extent_translator_get_piece(vtkNew sself); +extern "C" void vtk_extent_translator_set_number_of_pieces(vtkNew sself, int _arg); +extern "C" int vtk_extent_translator_get_number_of_pieces(vtkNew sself); +extern "C" void vtk_extent_translator_set_ghost_level(vtkNew sself, int _arg); +extern "C" int vtk_extent_translator_get_ghost_level(vtkNew sself); +extern "C" int vtk_extent_translator_piece_to_extent(vtkNew sself); +extern "C" int vtk_extent_translator_piece_to_extent_by_points(vtkNew sself); +extern "C" int vtk_extent_translator_piece_to_extent_thread_safe(vtkNew sself, int piece, int numPieces, int ghostLevel, int wholeExtent, int resultExtent, int splitMode, int byPoints); +extern "C" void vtk_extent_translator_set_split_mode_to_block(vtkNew sself); +extern "C" void vtk_extent_translator_set_split_mode_to_x_slab(vtkNew sself); +extern "C" void vtk_extent_translator_set_split_mode_to_y_slab(vtkNew sself); +extern "C" void vtk_extent_translator_set_split_mode_to_z_slab(vtkNew sself); +extern "C" int vtk_extent_translator_get_split_mode(vtkNew sself); +extern "C" void vtk_extent_translator_set_split_path(vtkNew sself, int len, int splitpath); extern "C" vtkNew < vtkGraphAlgorithm > vtkGraphAlgorithm_new () ; extern "C" void vtkGraphAlgorithm_destructor (vtkNew < vtkGraphAlgorithm > sself) ; extern "C" void * vtkGraphAlgorithm_get_ptr (vtkNew < vtkGraphAlgorithm > sself) ; @@ -161,6 +277,14 @@ extern "C" void * vtkPiecewiseFunctionAlgorithm_get_ptr (vtkNew < vtkPiecewiseFu extern "C" vtkNew < vtkPiecewiseFunctionShiftScale > vtkPiecewiseFunctionShiftScale_new () ; extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkNew < vtkPiecewiseFunctionShiftScale > sself) ; extern "C" void * vtkPiecewiseFunctionShiftScale_get_ptr (vtkNew < vtkPiecewiseFunctionShiftScale > sself) ; +extern "C" void vtk_piecewise_function_shift_scale_set_position_shift(vtkNew sself, double _arg); +extern "C" void vtk_piecewise_function_shift_scale_set_position_scale(vtkNew sself, double _arg); +extern "C" void vtk_piecewise_function_shift_scale_set_value_shift(vtkNew sself, double _arg); +extern "C" void vtk_piecewise_function_shift_scale_set_value_scale(vtkNew sself, double _arg); +extern "C" double vtk_piecewise_function_shift_scale_get_position_shift(vtkNew sself); +extern "C" double vtk_piecewise_function_shift_scale_get_position_scale(vtkNew sself); +extern "C" double vtk_piecewise_function_shift_scale_get_value_shift(vtkNew sself); +extern "C" double vtk_piecewise_function_shift_scale_get_value_scale(vtkNew sself); extern "C" vtkNew < vtkPointSetAlgorithm > vtkPointSetAlgorithm_new () ; extern "C" void vtkPointSetAlgorithm_destructor (vtkNew < vtkPointSetAlgorithm > sself) ; extern "C" void * vtkPointSetAlgorithm_get_ptr (vtkNew < vtkPointSetAlgorithm > sself) ; @@ -170,6 +294,8 @@ extern "C" void * vtkPolyDataAlgorithm_get_ptr (vtkNew < vtkPolyDataAlgorithm > extern "C" vtkNew < vtkProgressObserver > vtkProgressObserver_new () ; extern "C" void vtkProgressObserver_destructor (vtkNew < vtkProgressObserver > sself) ; extern "C" void * vtkProgressObserver_get_ptr (vtkNew < vtkProgressObserver > sself) ; +extern "C" void vtk_progress_observer_update_progress(vtkNew sself, double amount); +extern "C" double vtk_progress_observer_get_progress(vtkNew sself); extern "C" vtkNew < vtkReaderExecutive > vtkReaderExecutive_new () ; extern "C" void vtkReaderExecutive_destructor (vtkNew < vtkReaderExecutive > sself) ; extern "C" void * vtkReaderExecutive_get_ptr (vtkNew < vtkReaderExecutive > sself) ; @@ -179,21 +305,91 @@ extern "C" void * vtkRectilinearGridAlgorithm_get_ptr (vtkNew < vtkRectilinearGr extern "C" vtkNew < vtkSMPProgressObserver > vtkSMPProgressObserver_new () ; extern "C" void vtkSMPProgressObserver_destructor (vtkNew < vtkSMPProgressObserver > sself) ; extern "C" void * vtkSMPProgressObserver_get_ptr (vtkNew < vtkSMPProgressObserver > sself) ; +extern "C" void vtk_smp_progress_observer_update_progress(vtkNew sself, double progress); extern "C" vtkNew < vtkSelectionAlgorithm > vtkSelectionAlgorithm_new () ; extern "C" void vtkSelectionAlgorithm_destructor (vtkNew < vtkSelectionAlgorithm > sself) ; extern "C" void * vtkSelectionAlgorithm_get_ptr (vtkNew < vtkSelectionAlgorithm > sself) ; extern "C" vtkNew < vtkSimpleScalarTree > vtkSimpleScalarTree_new () ; extern "C" void vtkSimpleScalarTree_destructor (vtkNew < vtkSimpleScalarTree > sself) ; extern "C" void * vtkSimpleScalarTree_get_ptr (vtkNew < vtkSimpleScalarTree > sself) ; +extern "C" void vtk_simple_scalar_tree_set_branching_factor(vtkNew sself, int _arg); +extern "C" int vtk_simple_scalar_tree_get_branching_factor_min_value(vtkNew sself); +extern "C" int vtk_simple_scalar_tree_get_branching_factor_max_value(vtkNew sself); +extern "C" int vtk_simple_scalar_tree_get_branching_factor(vtkNew sself); +extern "C" int vtk_simple_scalar_tree_get_level(vtkNew sself); +extern "C" void vtk_simple_scalar_tree_set_max_level(vtkNew sself, int _arg); +extern "C" int vtk_simple_scalar_tree_get_max_level_min_value(vtkNew sself); +extern "C" int vtk_simple_scalar_tree_get_max_level_max_value(vtkNew sself); +extern "C" int vtk_simple_scalar_tree_get_max_level(vtkNew sself); +extern "C" void vtk_simple_scalar_tree_build_tree(vtkNew sself); +extern "C" void vtk_simple_scalar_tree_initialize(vtkNew sself); +extern "C" void vtk_simple_scalar_tree_init_traversal(vtkNew sself, double scalarValue); +extern "C" long long vtk_simple_scalar_tree_get_number_of_cell_batches(vtkNew sself, double scalarValue); +extern "C" const long long* vtk_simple_scalar_tree_get_cell_batch(vtkNew sself, long long batchNum, long long numCells); extern "C" vtkNew < vtkSpanSpace > vtkSpanSpace_new () ; extern "C" void vtkSpanSpace_destructor (vtkNew < vtkSpanSpace > sself) ; extern "C" void * vtkSpanSpace_get_ptr (vtkNew < vtkSpanSpace > sself) ; +extern "C" void vtk_span_space_set_scalar_range(vtkNew sself, double _arg1, double _arg2); +extern "C" void vtk_span_space_set_scalar_range(vtkNew sself, const double _arg); +extern "C" double* vtk_span_space_get_scalar_range(vtkNew sself); +extern "C" void vtk_span_space_get_scalar_range(vtkNew sself, double data); +extern "C" void vtk_span_space_set_compute_scalar_range(vtkNew sself, int _arg); +extern "C" int vtk_span_space_get_compute_scalar_range(vtkNew sself); +extern "C" void vtk_span_space_compute_scalar_range_on(vtkNew sself); +extern "C" void vtk_span_space_compute_scalar_range_off(vtkNew sself); +extern "C" void vtk_span_space_set_resolution(vtkNew sself, long long _arg); +extern "C" long long vtk_span_space_get_resolution_min_value(vtkNew sself); +extern "C" long long vtk_span_space_get_resolution_max_value(vtkNew sself); +extern "C" long long vtk_span_space_get_resolution(vtkNew sself); +extern "C" void vtk_span_space_set_compute_resolution(vtkNew sself, int _arg); +extern "C" int vtk_span_space_get_compute_resolution(vtkNew sself); +extern "C" void vtk_span_space_compute_resolution_on(vtkNew sself); +extern "C" void vtk_span_space_compute_resolution_off(vtkNew sself); +extern "C" void vtk_span_space_set_number_of_cells_per_bucket(vtkNew sself, int _arg); +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_min_value(vtkNew sself); +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_max_value(vtkNew sself); +extern "C" int vtk_span_space_get_number_of_cells_per_bucket(vtkNew sself); +extern "C" void vtk_span_space_initialize(vtkNew sself); +extern "C" void vtk_span_space_build_tree(vtkNew sself); +extern "C" void vtk_span_space_init_traversal(vtkNew sself, double scalarValue); +extern "C" long long vtk_span_space_get_number_of_cell_batches(vtkNew sself, double scalarValue); +extern "C" const long long* vtk_span_space_get_cell_batch(vtkNew sself, long long batchNum, long long numCells); +extern "C" void vtk_span_space_set_batch_size(vtkNew sself, long long _arg); +extern "C" long long vtk_span_space_get_batch_size_min_value(vtkNew sself); +extern "C" long long vtk_span_space_get_batch_size_max_value(vtkNew sself); +extern "C" long long vtk_span_space_get_batch_size(vtkNew sself); extern "C" vtkNew < vtkSphereTree > vtkSphereTree_new () ; extern "C" void vtkSphereTree_destructor (vtkNew < vtkSphereTree > sself) ; extern "C" void * vtkSphereTree_get_ptr (vtkNew < vtkSphereTree > sself) ; +extern "C" void vtk_sphere_tree_build(vtkNew sself); +extern "C" void vtk_sphere_tree_set_build_hierarchy(vtkNew sself, bool _arg); +extern "C" bool vtk_sphere_tree_get_build_hierarchy(vtkNew sself); +extern "C" void vtk_sphere_tree_build_hierarchy_on(vtkNew sself); +extern "C" void vtk_sphere_tree_build_hierarchy_off(vtkNew sself); +extern "C" const unsigned char* vtk_sphere_tree_select_point(vtkNew sself, double point, long long numSelected); +extern "C" const unsigned char* vtk_sphere_tree_select_line(vtkNew sself, double origin, double ray, long long numSelected); +extern "C" const unsigned char* vtk_sphere_tree_select_plane(vtkNew sself, double origin, double normal, long long numSelected); +extern "C" void vtk_sphere_tree_set_resolution(vtkNew sself, int _arg); +extern "C" int vtk_sphere_tree_get_resolution_min_value(vtkNew sself); +extern "C" int vtk_sphere_tree_get_resolution_max_value(vtkNew sself); +extern "C" int vtk_sphere_tree_get_resolution(vtkNew sself); +extern "C" void vtk_sphere_tree_set_max_level(vtkNew sself, int _arg); +extern "C" int vtk_sphere_tree_get_max_level_min_value(vtkNew sself); +extern "C" int vtk_sphere_tree_get_max_level_max_value(vtkNew sself); +extern "C" int vtk_sphere_tree_get_max_level(vtkNew sself); +extern "C" int vtk_sphere_tree_get_number_of_levels(vtkNew sself); +extern "C" const double* vtk_sphere_tree_get_cell_spheres(vtkNew sself); +extern "C" const double* vtk_sphere_tree_get_tree_spheres(vtkNew sself, int level, long long numSpheres); extern "C" vtkNew < vtkStreamingDemandDrivenPipeline > vtkStreamingDemandDrivenPipeline_new () ; extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkNew < vtkStreamingDemandDrivenPipeline > sself) ; extern "C" void * vtkStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkStreamingDemandDrivenPipeline > sself) ; +extern "C" int vtk_streaming_demand_driven_pipeline_update(vtkNew sself); +extern "C" int vtk_streaming_demand_driven_pipeline_update_whole_extent(vtkNew sself); +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_update_extent(vtkNew sself, int outputPort); +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_time(vtkNew sself, int outputPort); +extern "C" int vtk_streaming_demand_driven_pipeline_update_time_dependent_information(vtkNew sself, int outputPort); +extern "C" int vtk_streaming_demand_driven_pipeline_set_request_exact_extent(vtkNew sself, int port, int flag); +extern "C" int vtk_streaming_demand_driven_pipeline_get_request_exact_extent(vtkNew sself, int port); extern "C" vtkNew < vtkStructuredGridAlgorithm > vtkStructuredGridAlgorithm_new () ; extern "C" void vtkStructuredGridAlgorithm_destructor (vtkNew < vtkStructuredGridAlgorithm > sself) ; extern "C" void * vtkStructuredGridAlgorithm_get_ptr (vtkNew < vtkStructuredGridAlgorithm > sself) ; @@ -212,6 +408,12 @@ extern "C" void * vtkTrivialConsumer_get_ptr (vtkNew < vtkTrivialConsumer > ssel extern "C" vtkNew < vtkTrivialProducer > vtkTrivialProducer_new () ; extern "C" void vtkTrivialProducer_destructor (vtkNew < vtkTrivialProducer > sself) ; extern "C" void * vtkTrivialProducer_get_ptr (vtkNew < vtkTrivialProducer > sself) ; +extern "C" unsigned long vtk_trivial_producer_get_m_time(vtkNew sself); +extern "C" void vtk_trivial_producer_set_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_trivial_producer_set_whole_extent(vtkNew sself, const int _arg); +extern "C" int* vtk_trivial_producer_get_whole_extent(vtkNew sself); +extern "C" void vtk_trivial_producer_get_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_trivial_producer_get_whole_extent(vtkNew sself, int _arg); extern "C" vtkNew < vtkUndirectedGraphAlgorithm > vtkUndirectedGraphAlgorithm_new () ; extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkNew < vtkUndirectedGraphAlgorithm > sself) ; extern "C" void * vtkUndirectedGraphAlgorithm_get_ptr (vtkNew < vtkUndirectedGraphAlgorithm > sself) ; @@ -221,6 +423,14 @@ extern "C" void * vtkUniformGridAMRAlgorithm_get_ptr (vtkNew < vtkUniformGridAMR extern "C" vtkNew < vtkUniformGridPartitioner > vtkUniformGridPartitioner_new () ; extern "C" void vtkUniformGridPartitioner_destructor (vtkNew < vtkUniformGridPartitioner > sself) ; extern "C" void * vtkUniformGridPartitioner_get_ptr (vtkNew < vtkUniformGridPartitioner > sself) ; +extern "C" int vtk_uniform_grid_partitioner_get_number_of_partitions(vtkNew sself); +extern "C" void vtk_uniform_grid_partitioner_set_number_of_partitions(vtkNew sself, int _arg); +extern "C" int vtk_uniform_grid_partitioner_get_number_of_ghost_layers(vtkNew sself); +extern "C" void vtk_uniform_grid_partitioner_set_number_of_ghost_layers(vtkNew sself, int _arg); +extern "C" int vtk_uniform_grid_partitioner_get_duplicate_nodes(vtkNew sself); +extern "C" void vtk_uniform_grid_partitioner_set_duplicate_nodes(vtkNew sself, int _arg); +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_on(vtkNew sself); +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_off(vtkNew sself); extern "C" vtkNew < vtkUnstructuredGridAlgorithm > vtkUnstructuredGridAlgorithm_new () ; extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkNew < vtkUnstructuredGridAlgorithm > sself) ; extern "C" void * vtkUnstructuredGridAlgorithm_get_ptr (vtkNew < vtkUnstructuredGridAlgorithm > sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h index b1c918d..14cd942 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h @@ -23,27 +23,154 @@ extern "C" vtkNew < vtkAmoebaMinimizer > vtkAmoebaMinimizer_new () ; extern "C" void vtkAmoebaMinimizer_destructor (vtkNew < vtkAmoebaMinimizer > sself) ; extern "C" void * vtkAmoebaMinimizer_get_ptr (vtkNew < vtkAmoebaMinimizer > sself) ; +extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkNew sself, const char name, double value); +extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkNew sself, int i, double value); +extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkNew sself, const char name, double scale); +extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkNew sself, const char name); +extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkNew sself, int i, double scale); +extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkNew sself, int i); +extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkNew sself, const char name); +extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkNew sself, int i); +extern "C" const char* vtk_amoeba_minimizer_get_parameter_name(vtkNew sself, int i); +extern "C" int vtk_amoeba_minimizer_get_number_of_parameters(vtkNew sself); +extern "C" void vtk_amoeba_minimizer_initialize(vtkNew sself); +extern "C" void vtk_amoeba_minimizer_minimize(vtkNew sself); +extern "C" int vtk_amoeba_minimizer_iterate(vtkNew sself); +extern "C" void vtk_amoeba_minimizer_set_function_value(vtkNew sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_function_value(vtkNew sself); +extern "C" void vtk_amoeba_minimizer_set_contraction_ratio(vtkNew sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_min_value(vtkNew sself); +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_max_value(vtkNew sself); +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio(vtkNew sself); +extern "C" void vtk_amoeba_minimizer_set_expansion_ratio(vtkNew sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_min_value(vtkNew sself); +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_max_value(vtkNew sself); +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio(vtkNew sself); +extern "C" void vtk_amoeba_minimizer_set_tolerance(vtkNew sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_tolerance(vtkNew sself); +extern "C" void vtk_amoeba_minimizer_set_parameter_tolerance(vtkNew sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_parameter_tolerance(vtkNew sself); +extern "C" void vtk_amoeba_minimizer_set_max_iterations(vtkNew sself, int _arg); +extern "C" int vtk_amoeba_minimizer_get_max_iterations(vtkNew sself); +extern "C" int vtk_amoeba_minimizer_get_iterations(vtkNew sself); +extern "C" int vtk_amoeba_minimizer_get_function_evaluations(vtkNew sself); +extern "C" void vtk_amoeba_minimizer_evaluate_function(vtkNew sself); extern "C" vtkNew < vtkFFT > vtkFFT_new () ; extern "C" void vtkFFT_destructor (vtkNew < vtkFFT > sself) ; extern "C" void * vtkFFT_get_ptr (vtkNew < vtkFFT > sself) ; +extern "C" double vtk_fft_hanning_generator(vtkNew sself, const size_t x, const size_t size); +extern "C" double vtk_fft_bartlett_generator(vtkNew sself, const size_t x, const size_t size); +extern "C" double vtk_fft_sine_generator(vtkNew sself, const size_t x, const size_t size); +extern "C" double vtk_fft_blackman_generator(vtkNew sself, const size_t x, const size_t size); +extern "C" double vtk_fft_rectangular_generator(vtkNew sself, const size_t x, const size_t size); extern "C" vtkNew < vtkMatrix3x3 > vtkMatrix3x3_new () ; extern "C" void vtkMatrix3x3_destructor (vtkNew < vtkMatrix3x3 > sself) ; extern "C" void * vtkMatrix3x3_get_ptr (vtkNew < vtkMatrix3x3 > sself) ; +extern "C" void vtk_matrix_3_x_3_deep_copy(vtkNew sself, double elements, const double newElements); +extern "C" void vtk_matrix_3_x_3_deep_copy(vtkNew sself, const double elements); +extern "C" void vtk_matrix_3_x_3_zero(vtkNew sself); +extern "C" void vtk_matrix_3_x_3_zero(vtkNew sself, double elements); +extern "C" void vtk_matrix_3_x_3_identity(vtkNew sself); +extern "C" void vtk_matrix_3_x_3_identity(vtkNew sself, double elements); +extern "C" void vtk_matrix_3_x_3_invert(vtkNew sself); +extern "C" void vtk_matrix_3_x_3_invert(vtkNew sself, const double inElements, double outElements); +extern "C" void vtk_matrix_3_x_3_transpose(vtkNew sself); +extern "C" void vtk_matrix_3_x_3_transpose(vtkNew sself, const double inElements, double outElements); +extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const float in, float out); +extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double in, double out); +extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double elements, const float in, float out); +extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double elements, const double in, double out); +extern "C" void vtk_matrix_3_x_3_multiply_3_x_3(vtkNew sself, const double a, const double b, double c); +extern "C" void vtk_matrix_3_x_3_adjoint(vtkNew sself, const double inElements, double outElements); +extern "C" double vtk_matrix_3_x_3_determinant(vtkNew sself); +extern "C" double vtk_matrix_3_x_3_determinant(vtkNew sself, const double elements); +extern "C" void vtk_matrix_3_x_3_set_element(vtkNew sself, int i, int j, double value); +extern "C" double vtk_matrix_3_x_3_get_element(vtkNew sself, int i, int j); +extern "C" bool vtk_matrix_3_x_3_is_identity(vtkNew sself); +extern "C" double* vtk_matrix_3_x_3_get_data(vtkNew sself); +extern "C" const double* vtk_matrix_3_x_3_get_data(vtkNew sself); extern "C" vtkNew < vtkMatrix4x4 > vtkMatrix4x4_new () ; extern "C" void vtkMatrix4x4_destructor (vtkNew < vtkMatrix4x4 > sself) ; extern "C" void * vtkMatrix4x4_get_ptr (vtkNew < vtkMatrix4x4 > sself) ; +extern "C" void vtk_matrix_4_x_4_deep_copy(vtkNew sself, double destination, const double source); +extern "C" void vtk_matrix_4_x_4_deep_copy(vtkNew sself, const double elements); +extern "C" void vtk_matrix_4_x_4_zero(vtkNew sself); +extern "C" void vtk_matrix_4_x_4_zero(vtkNew sself, double elements); +extern "C" void vtk_matrix_4_x_4_identity(vtkNew sself); +extern "C" void vtk_matrix_4_x_4_identity(vtkNew sself, double elements); +extern "C" bool vtk_matrix_4_x_4_is_identity(vtkNew sself); +extern "C" void vtk_matrix_4_x_4_invert(vtkNew sself); +extern "C" void vtk_matrix_4_x_4_invert(vtkNew sself, const double inElements, double outElements); +extern "C" void vtk_matrix_4_x_4_transpose(vtkNew sself); +extern "C" void vtk_matrix_4_x_4_transpose(vtkNew sself, const double inElements, double outElements); +extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const float in, float out); +extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double in, double out); +extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double elements, const float in, float out); +extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double elements, const double in, double out); +extern "C" float* vtk_matrix_4_x_4_multiply_point(vtkNew sself, const float in); +extern "C" double* vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double in); +extern "C" float* vtk_matrix_4_x_4_multiply_float_point(vtkNew sself, const float in); +extern "C" double* vtk_matrix_4_x_4_multiply_double_point(vtkNew sself, const double in); +extern "C" void vtk_matrix_4_x_4_multiply_4_x_4(vtkNew sself, const double a, const double b, double c); +extern "C" void vtk_matrix_4_x_4_multiply_4_x_4(vtkNew sself, const double a, const double b, float c); +extern "C" void vtk_matrix_4_x_4_multiply_and_transpose_4_x_4(vtkNew sself, const double a, const double b, float c); +extern "C" void vtk_matrix_4_x_4_adjoint(vtkNew sself, const double inElements, double outElements); +extern "C" double vtk_matrix_4_x_4_determinant(vtkNew sself); +extern "C" double vtk_matrix_4_x_4_determinant(vtkNew sself, const double elements); +extern "C" void vtk_matrix_4_x_4_set_element(vtkNew sself, int i, int j, double value); +extern "C" double vtk_matrix_4_x_4_get_element(vtkNew sself, int i, int j); +extern "C" double* vtk_matrix_4_x_4_get_data(vtkNew sself); +extern "C" const double* vtk_matrix_4_x_4_get_data(vtkNew sself); extern "C" vtkNew < vtkPolynomialSolversUnivariate > vtkPolynomialSolversUnivariate_new () ; extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkNew < vtkPolynomialSolversUnivariate > sself) ; extern "C" void * vtkPolynomialSolversUnivariate_get_ptr (vtkNew < vtkPolynomialSolversUnivariate > sself) ; +extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol); +extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType); +extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType, bool divideGCD); +extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol); +extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType); +extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType, bool divideGCD); +extern "C" int vtk_polynomial_solvers_univariate_filter_roots(vtkNew sself, double P, int d, double upperBnds, int rootcount, double diameter); +extern "C" int vtk_polynomial_solvers_univariate_lin_bairstow_solve(vtkNew sself, double c, int d, double r, double tolerance); +extern "C" int vtk_polynomial_solvers_univariate_ferrari_solve(vtkNew sself, double c, double r, int m, double tol); +extern "C" int vtk_polynomial_solvers_univariate_tartaglia_cardan_solve(vtkNew sself, double c, double r, int m, double tol); +extern "C" double* vtk_polynomial_solvers_univariate_solve_cubic(vtkNew sself, double c0, double c1, double c2, double c3); +extern "C" double* vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c0, double c1, double c2); +extern "C" double* vtk_polynomial_solvers_univariate_solve_linear(vtkNew sself, double c0, double c1); +extern "C" int vtk_polynomial_solvers_univariate_solve_cubic(vtkNew sself, double c0, double c1, double c2, double c3, double r1, double r2, double r3, int num_roots); +extern "C" int vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c0, double c1, double c2, double r1, double r2, int num_roots); +extern "C" int vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c, double r, int m); +extern "C" int vtk_polynomial_solvers_univariate_solve_linear(vtkNew sself, double c0, double c1, double r1, int num_roots); +extern "C" void vtk_polynomial_solvers_univariate_set_division_tolerance(vtkNew sself, double tol); +extern "C" double vtk_polynomial_solvers_univariate_get_division_tolerance(vtkNew sself); extern "C" vtkNew < vtkQuaternionInterpolator > vtkQuaternionInterpolator_new () ; extern "C" void vtkQuaternionInterpolator_destructor (vtkNew < vtkQuaternionInterpolator > sself) ; extern "C" void * vtkQuaternionInterpolator_get_ptr (vtkNew < vtkQuaternionInterpolator > sself) ; +extern "C" int vtk_quaternion_interpolator_get_number_of_quaternions(vtkNew sself); +extern "C" double vtk_quaternion_interpolator_get_minimum_t(vtkNew sself); +extern "C" double vtk_quaternion_interpolator_get_maximum_t(vtkNew sself); +extern "C" void vtk_quaternion_interpolator_initialize(vtkNew sself); +extern "C" void vtk_quaternion_interpolator_add_quaternion(vtkNew sself, double t, double q); +extern "C" void vtk_quaternion_interpolator_remove_quaternion(vtkNew sself, double t); +extern "C" void vtk_quaternion_interpolator_interpolate_quaternion(vtkNew sself, double t, double q); +extern "C" int vtk_quaternion_interpolator_get_search_method(vtkNew sself); +extern "C" void vtk_quaternion_interpolator_set_search_method(vtkNew sself, int type); +extern "C" void vtk_quaternion_interpolator_set_interpolation_type(vtkNew sself, int _arg); +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_min_value(vtkNew sself); +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_max_value(vtkNew sself); +extern "C" int vtk_quaternion_interpolator_get_interpolation_type(vtkNew sself); +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_linear(vtkNew sself); +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_spline(vtkNew sself); extern "C" vtkNew < vtkRungeKutta2 > vtkRungeKutta2_new () ; extern "C" void vtkRungeKutta2_destructor (vtkNew < vtkRungeKutta2 > sself) ; extern "C" void * vtkRungeKutta2_get_ptr (vtkNew < vtkRungeKutta2 > sself) ; +extern "C" int vtk_runge_kutta_2_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData); extern "C" vtkNew < vtkRungeKutta4 > vtkRungeKutta4_new () ; extern "C" void vtkRungeKutta4_destructor (vtkNew < vtkRungeKutta4 > sself) ; extern "C" void * vtkRungeKutta4_get_ptr (vtkNew < vtkRungeKutta4 > sself) ; +extern "C" int vtk_runge_kutta_4_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData); extern "C" vtkNew < vtkRungeKutta45 > vtkRungeKutta45_new () ; extern "C" void vtkRungeKutta45_destructor (vtkNew < vtkRungeKutta45 > sself) ; extern "C" void * vtkRungeKutta45_get_ptr (vtkNew < vtkRungeKutta45 > sself) ; +extern "C" int vtk_runge_kutta_45_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData); +extern "C" int vtk_runge_kutta_45_compute_next_step(vtkNew sself, double xprev, double dxprev, double xnext, double t, double delT, double delTActual, double minStep, double maxStep, double maxError, double estErr, void userData); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h index 4b57245..c876a5c 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h @@ -15,15 +15,131 @@ extern "C" vtkNew < vtkContourValues > vtkContourValues_new () ; extern "C" void vtkContourValues_destructor (vtkNew < vtkContourValues > sself) ; extern "C" void * vtkContourValues_get_ptr (vtkNew < vtkContourValues > sself) ; +extern "C" void vtk_contour_values_set_value(vtkNew sself, int i, double value); +extern "C" double vtk_contour_values_get_value(vtkNew sself, int i); +extern "C" double* vtk_contour_values_get_values(vtkNew sself); +extern "C" void vtk_contour_values_get_values(vtkNew sself, double contourValues); +extern "C" void vtk_contour_values_set_number_of_contours(vtkNew sself, const int number); +extern "C" int vtk_contour_values_get_number_of_contours(vtkNew sself); +extern "C" void vtk_contour_values_generate_values(vtkNew sself, int numContours, double range); +extern "C" void vtk_contour_values_generate_values(vtkNew sself, int numContours, double rangeStart, double rangeEnd); extern "C" vtkNew < vtkExprTkFunctionParser > vtkExprTkFunctionParser_new () ; extern "C" void vtkExprTkFunctionParser_destructor (vtkNew < vtkExprTkFunctionParser > sself) ; extern "C" void * vtkExprTkFunctionParser_get_ptr (vtkNew < vtkExprTkFunctionParser > sself) ; +extern "C" unsigned long vtk_expr_tk_function_parser_get_m_time(vtkNew sself); +extern "C" void vtk_expr_tk_function_parser_set_function(vtkNew sself, const char function); +extern "C" const char* vtk_expr_tk_function_parser_get_function(vtkNew sself); +extern "C" int vtk_expr_tk_function_parser_is_scalar_result(vtkNew sself); +extern "C" int vtk_expr_tk_function_parser_is_vector_result(vtkNew sself); +extern "C" double vtk_expr_tk_function_parser_get_scalar_result(vtkNew sself); +extern "C" double* vtk_expr_tk_function_parser_get_vector_result(vtkNew sself); +extern "C" void vtk_expr_tk_function_parser_get_vector_result(vtkNew sself, double result); +extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkNew sself, const char* variableName, double value); +extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkNew sself, int i, double value); +extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkNew sself, const char* variableName); +extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkNew sself, int i); +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double xValue, double yValue, double zValue); +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double values); +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, int i, double xValue, double yValue, double zValue); +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, int i, double values); +extern "C" double* vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName); +extern "C" void vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName, double value); +extern "C" double* vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, int i); +extern "C" void vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, int i, double value); +extern "C" int vtk_expr_tk_function_parser_get_number_of_scalar_variables(vtkNew sself); +extern "C" int vtk_expr_tk_function_parser_get_scalar_variable_index(vtkNew sself, const char* name); +extern "C" int vtk_expr_tk_function_parser_get_number_of_vector_variables(vtkNew sself); +extern "C" int vtk_expr_tk_function_parser_get_vector_variable_index(vtkNew sself, const char* name); +extern "C" const char* vtk_expr_tk_function_parser_get_scalar_variable_name(vtkNew sself, int i); +extern "C" const char* vtk_expr_tk_function_parser_get_vector_variable_name(vtkNew sself, int i); +extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkNew sself, int i); +extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkNew sself, const char* variableName); +extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkNew sself, int i); +extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkNew sself, const char* variableName); +extern "C" void vtk_expr_tk_function_parser_remove_all_variables(vtkNew sself); +extern "C" void vtk_expr_tk_function_parser_remove_scalar_variables(vtkNew sself); +extern "C" void vtk_expr_tk_function_parser_remove_vector_variables(vtkNew sself); +extern "C" void vtk_expr_tk_function_parser_set_replace_invalid_values(vtkNew sself, int _arg); +extern "C" int vtk_expr_tk_function_parser_get_replace_invalid_values(vtkNew sself); +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_on(vtkNew sself); +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_off(vtkNew sself); +extern "C" void vtk_expr_tk_function_parser_set_replacement_value(vtkNew sself, double _arg); +extern "C" double vtk_expr_tk_function_parser_get_replacement_value(vtkNew sself); +extern "C" void vtk_expr_tk_function_parser_invalidate_function(vtkNew sself); +extern "C" const char* vtk_expr_tk_function_parser_sanitize_name(vtkNew sself, const char name); extern "C" vtkNew < vtkFunctionParser > vtkFunctionParser_new () ; extern "C" void vtkFunctionParser_destructor (vtkNew < vtkFunctionParser > sself) ; extern "C" void * vtkFunctionParser_get_ptr (vtkNew < vtkFunctionParser > sself) ; +extern "C" unsigned long vtk_function_parser_get_m_time(vtkNew sself); +extern "C" void vtk_function_parser_set_function(vtkNew sself, const char function); +extern "C" char* vtk_function_parser_get_function(vtkNew sself); +extern "C" int vtk_function_parser_is_scalar_result(vtkNew sself); +extern "C" int vtk_function_parser_is_vector_result(vtkNew sself); +extern "C" double vtk_function_parser_get_scalar_result(vtkNew sself); +extern "C" double* vtk_function_parser_get_vector_result(vtkNew sself); +extern "C" void vtk_function_parser_get_vector_result(vtkNew sself, double result); +extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, const char variableName, double value); +extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, const char* variableName, double value); +extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, int i, double value); +extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, const char variableName); +extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, const char* variableName); +extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, int i); +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char variableName, double xValue, double yValue, double zValue); +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double xValue, double yValue, double zValue); +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char variableName, const double values); +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, const double values); +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, int i, double xValue, double yValue, double zValue); +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, int i, const double values); +extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, const char variableName); +extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName); +extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, const char variableName, double value); +extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName, double value); +extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, int i); +extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, int i, double value); +extern "C" int vtk_function_parser_get_number_of_scalar_variables(vtkNew sself); +extern "C" int vtk_function_parser_get_scalar_variable_index(vtkNew sself, const char name); +extern "C" int vtk_function_parser_get_scalar_variable_index(vtkNew sself, const char* name); +extern "C" int vtk_function_parser_get_number_of_vector_variables(vtkNew sself); +extern "C" int vtk_function_parser_get_vector_variable_index(vtkNew sself, const char name); +extern "C" int vtk_function_parser_get_vector_variable_index(vtkNew sself, const char* name); +extern "C" const char* vtk_function_parser_get_scalar_variable_name(vtkNew sself, int i); +extern "C" const char* vtk_function_parser_get_vector_variable_name(vtkNew sself, int i); +extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, int i); +extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, const char variableName); +extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, const char* variableName); +extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, int i); +extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, const char variableName); +extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, const char* variableName); +extern "C" void vtk_function_parser_remove_all_variables(vtkNew sself); +extern "C" void vtk_function_parser_remove_scalar_variables(vtkNew sself); +extern "C" void vtk_function_parser_remove_vector_variables(vtkNew sself); +extern "C" void vtk_function_parser_set_replace_invalid_values(vtkNew sself, int _arg); +extern "C" int vtk_function_parser_get_replace_invalid_values(vtkNew sself); +extern "C" void vtk_function_parser_replace_invalid_values_on(vtkNew sself); +extern "C" void vtk_function_parser_replace_invalid_values_off(vtkNew sself); +extern "C" void vtk_function_parser_set_replacement_value(vtkNew sself, double _arg); +extern "C" double vtk_function_parser_get_replacement_value(vtkNew sself); +extern "C" void vtk_function_parser_check_expression(vtkNew sself, int pos, char error); +extern "C" void vtk_function_parser_invalidate_function(vtkNew sself); extern "C" vtkNew < vtkHeap > vtkHeap_new () ; extern "C" void vtkHeap_destructor (vtkNew < vtkHeap > sself) ; extern "C" void * vtkHeap_get_ptr (vtkNew < vtkHeap > sself) ; +extern "C" void* vtk_heap_allocate_memory(vtkNew sself, size_t n); +extern "C" void vtk_heap_set_block_size(vtkNew sself, size_t p0); +extern "C" size_t vtk_heap_get_block_size(vtkNew sself); +extern "C" int vtk_heap_get_number_of_blocks(vtkNew sself); +extern "C" int vtk_heap_get_number_of_allocations(vtkNew sself); +extern "C" void vtk_heap_reset(vtkNew sself); +extern "C" char* vtk_heap_string_dup(vtkNew sself, const char str); extern "C" vtkNew < vtkResourceFileLocator > vtkResourceFileLocator_new () ; extern "C" void vtkResourceFileLocator_destructor (vtkNew < vtkResourceFileLocator > sself) ; extern "C" void * vtkResourceFileLocator_get_ptr (vtkNew < vtkResourceFileLocator > sself) ; +extern "C" void vtk_resource_file_locator_set_print_debug_information(vtkNew sself, bool p0); +extern "C" bool vtk_resource_file_locator_get_print_debug_information(vtkNew sself); +extern "C" void vtk_resource_file_locator_print_debug_information_on(vtkNew sself); +extern "C" void vtk_resource_file_locator_print_debug_information_off(vtkNew sself); +extern "C" void vtk_resource_file_locator_set_log_verbosity(vtkNew sself, int _arg); +extern "C" int vtk_resource_file_locator_get_log_verbosity(vtkNew sself); +extern "C" const char* vtk_resource_file_locator_locate(vtkNew sself, const char* anchor, const char* landmark, const char* defaultDir); +extern "C" const char* vtk_resource_file_locator_get_library_path_for_symbol_unix(vtkNew sself, const char symbolname); +extern "C" const char* vtk_resource_file_locator_get_library_path_for_symbol_win_32(vtkNew sself, const void fptr); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h index 650c5b9..8c27e14 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h @@ -18,21 +18,73 @@ extern "C" vtkNew < vtkClientSocket > vtkClientSocket_new () ; extern "C" void vtkClientSocket_destructor (vtkNew < vtkClientSocket > sself) ; extern "C" void * vtkClientSocket_get_ptr (vtkNew < vtkClientSocket > sself) ; +extern "C" int vtk_client_socket_connect_to_server(vtkNew sself, const char hostname, int port); +extern "C" bool vtk_client_socket_get_connecting_side(vtkNew sself); extern "C" vtkNew < vtkDirectory > vtkDirectory_new () ; extern "C" void vtkDirectory_destructor (vtkNew < vtkDirectory > sself) ; extern "C" void * vtkDirectory_get_ptr (vtkNew < vtkDirectory > sself) ; +extern "C" int vtk_directory_open(vtkNew sself, const char dir); +extern "C" long long vtk_directory_get_number_of_files(vtkNew sself); +extern "C" const char* vtk_directory_get_file(vtkNew sself, long long index); +extern "C" int vtk_directory_file_is_directory(vtkNew sself, const char name); +extern "C" const char* vtk_directory_get_current_working_directory(vtkNew sself, char buf, unsigned int len); +extern "C" int vtk_directory_make_directory(vtkNew sself, const char dir); +extern "C" int vtk_directory_delete_directory(vtkNew sself, const char dir); +extern "C" int vtk_directory_rename(vtkNew sself, const char oldname, const char newname); extern "C" vtkNew < vtkExecutableRunner > vtkExecutableRunner_new () ; extern "C" void vtkExecutableRunner_destructor (vtkNew < vtkExecutableRunner > sself) ; extern "C" void * vtkExecutableRunner_get_ptr (vtkNew < vtkExecutableRunner > sself) ; +extern "C" void vtk_executable_runner_execute(vtkNew sself); +extern "C" void vtk_executable_runner_set_timeout(vtkNew sself, double _arg); +extern "C" double vtk_executable_runner_get_timeout(vtkNew sself); +extern "C" void vtk_executable_runner_set_right_trim_result(vtkNew sself, bool _arg); +extern "C" bool vtk_executable_runner_get_right_trim_result(vtkNew sself); +extern "C" void vtk_executable_runner_right_trim_result_on(vtkNew sself); +extern "C" void vtk_executable_runner_right_trim_result_off(vtkNew sself); +extern "C" const char* vtk_executable_runner_get_command(vtkNew sself); +extern "C" void vtk_executable_runner_set_command(vtkNew sself, const char arg); +extern "C" const char* vtk_executable_runner_get_std_out(vtkNew sself); +extern "C" const char* vtk_executable_runner_get_std_err(vtkNew sself); +extern "C" int vtk_executable_runner_get_return_value(vtkNew sself); extern "C" vtkNew < vtkServerSocket > vtkServerSocket_new () ; extern "C" void vtkServerSocket_destructor (vtkNew < vtkServerSocket > sself) ; extern "C" void * vtkServerSocket_get_ptr (vtkNew < vtkServerSocket > sself) ; +extern "C" int vtk_server_socket_create_server(vtkNew sself, int port); +extern "C" int vtk_server_socket_get_server_port(vtkNew sself); extern "C" vtkNew < vtkSocketCollection > vtkSocketCollection_new () ; extern "C" void vtkSocketCollection_destructor (vtkNew < vtkSocketCollection > sself) ; extern "C" void * vtkSocketCollection_get_ptr (vtkNew < vtkSocketCollection > sself) ; +extern "C" int vtk_socket_collection_select_sockets(vtkNew sself, unsigned long msec); extern "C" vtkNew < vtkThreadMessager > vtkThreadMessager_new () ; extern "C" void vtkThreadMessager_destructor (vtkNew < vtkThreadMessager > sself) ; extern "C" void * vtkThreadMessager_get_ptr (vtkNew < vtkThreadMessager > sself) ; +extern "C" void vtk_thread_messager_wait_for_message(vtkNew sself); +extern "C" void vtk_thread_messager_send_wake_message(vtkNew sself); +extern "C" void vtk_thread_messager_enable_wait_for_receiver(vtkNew sself); +extern "C" void vtk_thread_messager_disable_wait_for_receiver(vtkNew sself); +extern "C" void vtk_thread_messager_wait_for_receiver(vtkNew sself); extern "C" vtkNew < vtkTimerLog > vtkTimerLog_new () ; extern "C" void vtkTimerLog_destructor (vtkNew < vtkTimerLog > sself) ; extern "C" void * vtkTimerLog_get_ptr (vtkNew < vtkTimerLog > sself) ; +extern "C" void vtk_timer_log_set_logging(vtkNew sself, int v); +extern "C" int vtk_timer_log_get_logging(vtkNew sself); +extern "C" void vtk_timer_log_logging_on(vtkNew sself); +extern "C" void vtk_timer_log_logging_off(vtkNew sself); +extern "C" void vtk_timer_log_set_max_entries(vtkNew sself, int a); +extern "C" int vtk_timer_log_get_max_entries(vtkNew sself); +extern "C" void vtk_timer_log_dump_log(vtkNew sself, const char filename); +extern "C" void vtk_timer_log_mark_start_event(vtkNew sself, const char EventString); +extern "C" void vtk_timer_log_mark_end_event(vtkNew sself, const char EventString); +extern "C" void vtk_timer_log_insert_timed_event(vtkNew sself, const char EventString, double time, int cpuTicks); +extern "C" int vtk_timer_log_get_number_of_events(vtkNew sself); +extern "C" int vtk_timer_log_get_event_indent(vtkNew sself, int i); +extern "C" double vtk_timer_log_get_event_wall_time(vtkNew sself, int i); +extern "C" const char* vtk_timer_log_get_event_string(vtkNew sself, int i); +extern "C" void vtk_timer_log_mark_event(vtkNew sself, const char EventString); +extern "C" void vtk_timer_log_reset_log(vtkNew sself); +extern "C" void vtk_timer_log_cleanup_log(vtkNew sself); +extern "C" double vtk_timer_log_get_universal_time(vtkNew sself); +extern "C" double vtk_timer_log_get_cpu_time(vtkNew sself); +extern "C" void vtk_timer_log_start_timer(vtkNew sself); +extern "C" void vtk_timer_log_stop_timer(vtkNew sself); +extern "C" double vtk_timer_log_get_elapsed_time(vtkNew sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h index 9fd156d..b1dfc3e 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h @@ -30,33 +30,174 @@ extern "C" void * vtkCylindricalTransform_get_ptr (vtkNew < vtkCylindricalTransf extern "C" vtkNew < vtkGeneralTransform > vtkGeneralTransform_new () ; extern "C" void vtkGeneralTransform_destructor (vtkNew < vtkGeneralTransform > sself) ; extern "C" void * vtkGeneralTransform_get_ptr (vtkNew < vtkGeneralTransform > sself) ; +extern "C" void vtk_general_transform_identity(vtkNew sself); +extern "C" void vtk_general_transform_inverse(vtkNew sself); +extern "C" void vtk_general_transform_translate(vtkNew sself, double x, double y, double z); +extern "C" void vtk_general_transform_translate(vtkNew sself, const double x); +extern "C" void vtk_general_transform_translate(vtkNew sself, const float x); +extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z); +extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, const double axis); +extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, const float axis); +extern "C" void vtk_general_transform_rotate_x(vtkNew sself, double angle); +extern "C" void vtk_general_transform_rotate_y(vtkNew sself, double angle); +extern "C" void vtk_general_transform_rotate_z(vtkNew sself, double angle); +extern "C" void vtk_general_transform_scale(vtkNew sself, double x, double y, double z); +extern "C" void vtk_general_transform_scale(vtkNew sself, const double s); +extern "C" void vtk_general_transform_scale(vtkNew sself, const float s); +extern "C" void vtk_general_transform_concatenate(vtkNew sself, const double elements); +extern "C" void vtk_general_transform_pre_multiply(vtkNew sself); +extern "C" void vtk_general_transform_post_multiply(vtkNew sself); +extern "C" int vtk_general_transform_get_number_of_concatenated_transforms(vtkNew sself); +extern "C" int vtk_general_transform_get_inverse_flag(vtkNew sself); +extern "C" void vtk_general_transform_push(vtkNew sself); +extern "C" void vtk_general_transform_pop(vtkNew sself); +extern "C" void vtk_general_transform_internal_transform_point(vtkNew sself, const float in, float out); +extern "C" void vtk_general_transform_internal_transform_point(vtkNew sself, const double in, double out); +extern "C" void vtk_general_transform_internal_transform_derivative(vtkNew sself, const float in, float out, float derivative); +extern "C" void vtk_general_transform_internal_transform_derivative(vtkNew sself, const double in, double out, double derivative); +extern "C" unsigned long vtk_general_transform_get_m_time(vtkNew sself); extern "C" vtkNew < vtkIdentityTransform > vtkIdentityTransform_new () ; extern "C" void vtkIdentityTransform_destructor (vtkNew < vtkIdentityTransform > sself) ; extern "C" void * vtkIdentityTransform_get_ptr (vtkNew < vtkIdentityTransform > sself) ; +extern "C" void vtk_identity_transform_inverse(vtkNew sself); extern "C" vtkNew < vtkLandmarkTransform > vtkLandmarkTransform_new () ; extern "C" void vtkLandmarkTransform_destructor (vtkNew < vtkLandmarkTransform > sself) ; extern "C" void * vtkLandmarkTransform_get_ptr (vtkNew < vtkLandmarkTransform > sself) ; +extern "C" void vtk_landmark_transform_set_mode(vtkNew sself, int _arg); +extern "C" void vtk_landmark_transform_set_mode_to_rigid_body(vtkNew sself); +extern "C" void vtk_landmark_transform_set_mode_to_similarity(vtkNew sself); +extern "C" void vtk_landmark_transform_set_mode_to_affine(vtkNew sself); +extern "C" int vtk_landmark_transform_get_mode(vtkNew sself); +extern "C" const char* vtk_landmark_transform_get_mode_as_string(vtkNew sself); +extern "C" void vtk_landmark_transform_inverse(vtkNew sself); +extern "C" unsigned long vtk_landmark_transform_get_m_time(vtkNew sself); extern "C" vtkNew < vtkMatrixToHomogeneousTransform > vtkMatrixToHomogeneousTransform_new () ; extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkNew < vtkMatrixToHomogeneousTransform > sself) ; extern "C" void * vtkMatrixToHomogeneousTransform_get_ptr (vtkNew < vtkMatrixToHomogeneousTransform > sself) ; +extern "C" void vtk_matrix_to_homogeneous_transform_inverse(vtkNew sself); +extern "C" unsigned long vtk_matrix_to_homogeneous_transform_get_m_time(vtkNew sself); extern "C" vtkNew < vtkMatrixToLinearTransform > vtkMatrixToLinearTransform_new () ; extern "C" void vtkMatrixToLinearTransform_destructor (vtkNew < vtkMatrixToLinearTransform > sself) ; extern "C" void * vtkMatrixToLinearTransform_get_ptr (vtkNew < vtkMatrixToLinearTransform > sself) ; +extern "C" void vtk_matrix_to_linear_transform_inverse(vtkNew sself); +extern "C" unsigned long vtk_matrix_to_linear_transform_get_m_time(vtkNew sself); extern "C" vtkNew < vtkPerspectiveTransform > vtkPerspectiveTransform_new () ; extern "C" void vtkPerspectiveTransform_destructor (vtkNew < vtkPerspectiveTransform > sself) ; extern "C" void * vtkPerspectiveTransform_get_ptr (vtkNew < vtkPerspectiveTransform > sself) ; +extern "C" void vtk_perspective_transform_identity(vtkNew sself); +extern "C" void vtk_perspective_transform_inverse(vtkNew sself); +extern "C" void vtk_perspective_transform_adjust_viewport(vtkNew sself, double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax); +extern "C" void vtk_perspective_transform_adjust_z_buffer(vtkNew sself, double oldNearZ, double oldFarZ, double newNearZ, double newFarZ); +extern "C" void vtk_perspective_transform_ortho(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar); +extern "C" void vtk_perspective_transform_frustum(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar); +extern "C" void vtk_perspective_transform_perspective(vtkNew sself, double angle, double aspect, double znear, double zfar); +extern "C" void vtk_perspective_transform_shear(vtkNew sself, double dxdz, double dydz, double zplane); +extern "C" void vtk_perspective_transform_stereo(vtkNew sself, double angle, double focaldistance); +extern "C" void vtk_perspective_transform_setup_camera(vtkNew sself, const double position, const double focalpoint, const double viewup); +extern "C" void vtk_perspective_transform_setup_camera(vtkNew sself, double p0, double p1, double p2, double fp0, double fp1, double fp2, double vup0, double vup1, double vup2); +extern "C" void vtk_perspective_transform_translate(vtkNew sself, double x, double y, double z); +extern "C" void vtk_perspective_transform_translate(vtkNew sself, const double x); +extern "C" void vtk_perspective_transform_translate(vtkNew sself, const float x); +extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z); +extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, const double axis); +extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, const float axis); +extern "C" void vtk_perspective_transform_rotate_x(vtkNew sself, double angle); +extern "C" void vtk_perspective_transform_rotate_y(vtkNew sself, double angle); +extern "C" void vtk_perspective_transform_rotate_z(vtkNew sself, double angle); +extern "C" void vtk_perspective_transform_scale(vtkNew sself, double x, double y, double z); +extern "C" void vtk_perspective_transform_scale(vtkNew sself, const double s); +extern "C" void vtk_perspective_transform_scale(vtkNew sself, const float s); +extern "C" void vtk_perspective_transform_set_matrix(vtkNew sself, const double elements); +extern "C" void vtk_perspective_transform_concatenate(vtkNew sself, const double elements); +extern "C" void vtk_perspective_transform_pre_multiply(vtkNew sself); +extern "C" void vtk_perspective_transform_post_multiply(vtkNew sself); +extern "C" int vtk_perspective_transform_get_number_of_concatenated_transforms(vtkNew sself); +extern "C" int vtk_perspective_transform_get_inverse_flag(vtkNew sself); +extern "C" void vtk_perspective_transform_push(vtkNew sself); +extern "C" void vtk_perspective_transform_pop(vtkNew sself); +extern "C" unsigned long vtk_perspective_transform_get_m_time(vtkNew sself); extern "C" vtkNew < vtkSphericalTransform > vtkSphericalTransform_new () ; extern "C" void vtkSphericalTransform_destructor (vtkNew < vtkSphericalTransform > sself) ; extern "C" void * vtkSphericalTransform_get_ptr (vtkNew < vtkSphericalTransform > sself) ; extern "C" vtkNew < vtkThinPlateSplineTransform > vtkThinPlateSplineTransform_new () ; extern "C" void vtkThinPlateSplineTransform_destructor (vtkNew < vtkThinPlateSplineTransform > sself) ; extern "C" void * vtkThinPlateSplineTransform_get_ptr (vtkNew < vtkThinPlateSplineTransform > sself) ; +extern "C" double vtk_thin_plate_spline_transform_get_sigma(vtkNew sself); +extern "C" void vtk_thin_plate_spline_transform_set_sigma(vtkNew sself, double _arg); +extern "C" void vtk_thin_plate_spline_transform_set_basis(vtkNew sself, int basis); +extern "C" int vtk_thin_plate_spline_transform_get_basis(vtkNew sself); +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r(vtkNew sself); +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(vtkNew sself); +extern "C" const char* vtk_thin_plate_spline_transform_get_basis_as_string(vtkNew sself); +extern "C" unsigned long vtk_thin_plate_spline_transform_get_m_time(vtkNew sself); +extern "C" bool vtk_thin_plate_spline_transform_get_regularize_bulk_transform(vtkNew sself); +extern "C" void vtk_thin_plate_spline_transform_set_regularize_bulk_transform(vtkNew sself, bool _arg); +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_on(vtkNew sself); +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_off(vtkNew sself); extern "C" vtkNew < vtkTransform > vtkTransform_new () ; extern "C" void vtkTransform_destructor (vtkNew < vtkTransform > sself) ; extern "C" void * vtkTransform_get_ptr (vtkNew < vtkTransform > sself) ; +extern "C" void vtk_transform_identity(vtkNew sself); +extern "C" void vtk_transform_inverse(vtkNew sself); +extern "C" void vtk_transform_translate(vtkNew sself, double x, double y, double z); +extern "C" void vtk_transform_translate(vtkNew sself, const double x); +extern "C" void vtk_transform_translate(vtkNew sself, const float x); +extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z); +extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, const double axis); +extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, const float axis); +extern "C" void vtk_transform_rotate_x(vtkNew sself, double angle); +extern "C" void vtk_transform_rotate_y(vtkNew sself, double angle); +extern "C" void vtk_transform_rotate_z(vtkNew sself, double angle); +extern "C" void vtk_transform_scale(vtkNew sself, double x, double y, double z); +extern "C" void vtk_transform_scale(vtkNew sself, const double s); +extern "C" void vtk_transform_scale(vtkNew sself, const float s); +extern "C" void vtk_transform_set_matrix(vtkNew sself, const double elements); +extern "C" void vtk_transform_concatenate(vtkNew sself, const double elements); +extern "C" void vtk_transform_pre_multiply(vtkNew sself); +extern "C" void vtk_transform_post_multiply(vtkNew sself); +extern "C" int vtk_transform_get_number_of_concatenated_transforms(vtkNew sself); +extern "C" void vtk_transform_get_orientation(vtkNew sself, double orient); +extern "C" void vtk_transform_get_orientation(vtkNew sself, float orient); +extern "C" double* vtk_transform_get_orientation(vtkNew sself); +extern "C" void vtk_transform_get_orientation_wxyz(vtkNew sself, double wxyz); +extern "C" void vtk_transform_get_orientation_wxyz(vtkNew sself, float wxyz); +extern "C" double* vtk_transform_get_orientation_wxyz(vtkNew sself); +extern "C" void vtk_transform_get_position(vtkNew sself, double pos); +extern "C" void vtk_transform_get_position(vtkNew sself, float pos); +extern "C" double* vtk_transform_get_position(vtkNew sself); +extern "C" void vtk_transform_get_scale(vtkNew sself, double scale); +extern "C" void vtk_transform_get_scale(vtkNew sself, float scale); +extern "C" double* vtk_transform_get_scale(vtkNew sself); +extern "C" int vtk_transform_get_inverse_flag(vtkNew sself); +extern "C" void vtk_transform_push(vtkNew sself); +extern "C" void vtk_transform_pop(vtkNew sself); +extern "C" unsigned long vtk_transform_get_m_time(vtkNew sself); +extern "C" void vtk_transform_multiply_point(vtkNew sself, const float in, float out); +extern "C" void vtk_transform_multiply_point(vtkNew sself, const double in, double out); extern "C" vtkNew < vtkTransform2D > vtkTransform2D_new () ; extern "C" void vtkTransform2D_destructor (vtkNew < vtkTransform2D > sself) ; extern "C" void * vtkTransform2D_get_ptr (vtkNew < vtkTransform2D > sself) ; +extern "C" void vtk_transform_2_d_identity(vtkNew sself); +extern "C" void vtk_transform_2_d_inverse(vtkNew sself); +extern "C" void vtk_transform_2_d_translate(vtkNew sself, double x, double y); +extern "C" void vtk_transform_2_d_translate(vtkNew sself, const double x); +extern "C" void vtk_transform_2_d_translate(vtkNew sself, const float x); +extern "C" void vtk_transform_2_d_rotate(vtkNew sself, double angle); +extern "C" void vtk_transform_2_d_scale(vtkNew sself, double x, double y); +extern "C" void vtk_transform_2_d_scale(vtkNew sself, const double s); +extern "C" void vtk_transform_2_d_scale(vtkNew sself, const float s); +extern "C" void vtk_transform_2_d_set_matrix(vtkNew sself, const double elements); +extern "C" void vtk_transform_2_d_get_position(vtkNew sself, double pos); +extern "C" void vtk_transform_2_d_get_position(vtkNew sself, float pos); +extern "C" void vtk_transform_2_d_get_scale(vtkNew sself, double scale); +extern "C" void vtk_transform_2_d_get_scale(vtkNew sself, float pos); +extern "C" unsigned long vtk_transform_2_d_get_m_time(vtkNew sself); +extern "C" void vtk_transform_2_d_transform_points(vtkNew sself, const float inPts, float outPts, int n); +extern "C" void vtk_transform_2_d_transform_points(vtkNew sself, const double inPts, double outPts, int n); +extern "C" void vtk_transform_2_d_inverse_transform_points(vtkNew sself, const float inPts, float outPts, int n); +extern "C" void vtk_transform_2_d_inverse_transform_points(vtkNew sself, const double inPts, double outPts, int n); +extern "C" void vtk_transform_2_d_multiply_point(vtkNew sself, const float in, float out); +extern "C" void vtk_transform_2_d_multiply_point(vtkNew sself, const double in, double out); extern "C" vtkNew < vtkTransformCollection > vtkTransformCollection_new () ; extern "C" void vtkTransformCollection_destructor (vtkNew < vtkTransformCollection > sself) ; extern "C" void * vtkTransformCollection_get_ptr (vtkNew < vtkTransformCollection > sself) ; diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp index 9b219b4..2126370 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp @@ -13,6 +13,15 @@ extern "C" vtkNew < vtkColorSeries > vtkColorSeries_new () {return vtkNew < vtkColorSeries > () ;} extern "C" void vtkColorSeries_destructor (vtkNew < vtkColorSeries > sself) {sself . Reset () ; return ;} extern "C" void * vtkColorSeries_get_ptr (vtkNew < vtkColorSeries > sself) {return sself . GetPointer () ;} +extern "C" void vtk_color_series_set_color_scheme(vtkNew sself, int scheme) { sself->SetColorScheme(scheme); } +extern "C" int vtk_color_series_get_number_of_color_schemes(vtkNew sself) { return sself->GetNumberOfColorSchemes(); } +extern "C" int vtk_color_series_get_color_scheme(vtkNew sself) { return sself->GetColorScheme(); } +extern "C" int vtk_color_series_get_number_of_colors(vtkNew sself) { return sself->GetNumberOfColors(); } +extern "C" void vtk_color_series_set_number_of_colors(vtkNew sself, int numColors) { sself->SetNumberOfColors(numColors); } +extern "C" void vtk_color_series_remove_color(vtkNew sself, int index) { sself->RemoveColor(index); } +extern "C" void vtk_color_series_clear_colors(vtkNew sself) { sself->ClearColors(); } extern "C" vtkNew < vtkNamedColors > vtkNamedColors_new () {return vtkNew < vtkNamedColors > () ;} extern "C" void vtkNamedColors_destructor (vtkNew < vtkNamedColors > sself) {sself . Reset () ; return ;} extern "C" void * vtkNamedColors_get_ptr (vtkNew < vtkNamedColors > sself) {return sself . GetPointer () ;} +extern "C" int vtk_named_colors_get_number_of_colors(vtkNew sself) { return sself->GetNumberOfColors(); } +extern "C" void vtk_named_colors_reset_colors(vtkNew sself) { sself->ResetColors(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp index 9a6c9e7..86c6bdc 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp @@ -37,72 +37,256 @@ extern "C" vtkNew < vtkCardinalSpline > vtkCardinalSpline_new () {return vtkNew < vtkCardinalSpline > () ;} extern "C" void vtkCardinalSpline_destructor (vtkNew < vtkCardinalSpline > sself) {sself . Reset () ; return ;} extern "C" void * vtkCardinalSpline_get_ptr (vtkNew < vtkCardinalSpline > sself) {return sself . GetPointer () ;} +extern "C" void vtk_cardinal_spline_compute(vtkNew sself) { sself->Compute(); } +extern "C" double vtk_cardinal_spline_evaluate(vtkNew sself, double t) { return sself->Evaluate(t); } extern "C" vtkNew < vtkKochanekSpline > vtkKochanekSpline_new () {return vtkNew < vtkKochanekSpline > () ;} extern "C" void vtkKochanekSpline_destructor (vtkNew < vtkKochanekSpline > sself) {sself . Reset () ; return ;} extern "C" void * vtkKochanekSpline_get_ptr (vtkNew < vtkKochanekSpline > sself) {return sself . GetPointer () ;} +extern "C" void vtk_kochanek_spline_compute(vtkNew sself) { sself->Compute(); } +extern "C" double vtk_kochanek_spline_evaluate(vtkNew sself, double t) { return sself->Evaluate(t); } +extern "C" void vtk_kochanek_spline_set_default_bias(vtkNew sself, double _arg) { sself->SetDefaultBias(_arg); } +extern "C" double vtk_kochanek_spline_get_default_bias(vtkNew sself) { return sself->GetDefaultBias(); } +extern "C" void vtk_kochanek_spline_set_default_tension(vtkNew sself, double _arg) { sself->SetDefaultTension(_arg); } +extern "C" double vtk_kochanek_spline_get_default_tension(vtkNew sself) { return sself->GetDefaultTension(); } +extern "C" void vtk_kochanek_spline_set_default_continuity(vtkNew sself, double _arg) { sself->SetDefaultContinuity(_arg); } +extern "C" double vtk_kochanek_spline_get_default_continuity(vtkNew sself) { return sself->GetDefaultContinuity(); } extern "C" vtkNew < vtkParametricBohemianDome > vtkParametricBohemianDome_new () {return vtkNew < vtkParametricBohemianDome > () ;} extern "C" void vtkParametricBohemianDome_destructor (vtkNew < vtkParametricBohemianDome > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricBohemianDome_get_ptr (vtkNew < vtkParametricBohemianDome > sself) {return sself . GetPointer () ;} +extern "C" double vtk_parametric_bohemian_dome_get_a(vtkNew sself) { return sself->GetA(); } +extern "C" void vtk_parametric_bohemian_dome_set_a(vtkNew sself, double _arg) { sself->SetA(_arg); } +extern "C" double vtk_parametric_bohemian_dome_get_b(vtkNew sself) { return sself->GetB(); } +extern "C" void vtk_parametric_bohemian_dome_set_b(vtkNew sself, double _arg) { sself->SetB(_arg); } +extern "C" double vtk_parametric_bohemian_dome_get_c(vtkNew sself) { return sself->GetC(); } +extern "C" void vtk_parametric_bohemian_dome_set_c(vtkNew sself, double _arg) { sself->SetC(_arg); } +extern "C" int vtk_parametric_bohemian_dome_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_bohemian_dome_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_bohemian_dome_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricBour > vtkParametricBour_new () {return vtkNew < vtkParametricBour > () ;} extern "C" void vtkParametricBour_destructor (vtkNew < vtkParametricBour > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricBour_get_ptr (vtkNew < vtkParametricBour > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_bour_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_bour_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_bour_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricBoy > vtkParametricBoy_new () {return vtkNew < vtkParametricBoy > () ;} extern "C" void vtkParametricBoy_destructor (vtkNew < vtkParametricBoy > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricBoy_get_ptr (vtkNew < vtkParametricBoy > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_boy_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_boy_set_z_scale(vtkNew sself, double _arg) { sself->SetZScale(_arg); } +extern "C" double vtk_parametric_boy_get_z_scale(vtkNew sself) { return sself->GetZScale(); } +extern "C" void vtk_parametric_boy_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_boy_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricCatalanMinimal > vtkParametricCatalanMinimal_new () {return vtkNew < vtkParametricCatalanMinimal > () ;} extern "C" void vtkParametricCatalanMinimal_destructor (vtkNew < vtkParametricCatalanMinimal > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricCatalanMinimal_get_ptr (vtkNew < vtkParametricCatalanMinimal > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_catalan_minimal_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_catalan_minimal_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_catalan_minimal_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricConicSpiral > vtkParametricConicSpiral_new () {return vtkNew < vtkParametricConicSpiral > () ;} extern "C" void vtkParametricConicSpiral_destructor (vtkNew < vtkParametricConicSpiral > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricConicSpiral_get_ptr (vtkNew < vtkParametricConicSpiral > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_conic_spiral_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_conic_spiral_set_a(vtkNew sself, double _arg) { sself->SetA(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_a(vtkNew sself) { return sself->GetA(); } +extern "C" void vtk_parametric_conic_spiral_set_b(vtkNew sself, double _arg) { sself->SetB(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_b(vtkNew sself) { return sself->GetB(); } +extern "C" void vtk_parametric_conic_spiral_set_c(vtkNew sself, double _arg) { sself->SetC(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_c(vtkNew sself) { return sself->GetC(); } +extern "C" void vtk_parametric_conic_spiral_set_n(vtkNew sself, double _arg) { sself->SetN(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_n(vtkNew sself) { return sself->GetN(); } +extern "C" void vtk_parametric_conic_spiral_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_conic_spiral_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricCrossCap > vtkParametricCrossCap_new () {return vtkNew < vtkParametricCrossCap > () ;} extern "C" void vtkParametricCrossCap_destructor (vtkNew < vtkParametricCrossCap > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricCrossCap_get_ptr (vtkNew < vtkParametricCrossCap > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_cross_cap_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_cross_cap_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_cross_cap_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricDini > vtkParametricDini_new () {return vtkNew < vtkParametricDini > () ;} extern "C" void vtkParametricDini_destructor (vtkNew < vtkParametricDini > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricDini_get_ptr (vtkNew < vtkParametricDini > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_dini_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_dini_set_a(vtkNew sself, double _arg) { sself->SetA(_arg); } +extern "C" double vtk_parametric_dini_get_a(vtkNew sself) { return sself->GetA(); } +extern "C" void vtk_parametric_dini_set_b(vtkNew sself, double _arg) { sself->SetB(_arg); } +extern "C" double vtk_parametric_dini_get_b(vtkNew sself) { return sself->GetB(); } +extern "C" void vtk_parametric_dini_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_dini_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricEllipsoid > vtkParametricEllipsoid_new () {return vtkNew < vtkParametricEllipsoid > () ;} extern "C" void vtkParametricEllipsoid_destructor (vtkNew < vtkParametricEllipsoid > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricEllipsoid_get_ptr (vtkNew < vtkParametricEllipsoid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_ellipsoid_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_ellipsoid_set_x_radius(vtkNew sself, double _arg) { sself->SetXRadius(_arg); } +extern "C" double vtk_parametric_ellipsoid_get_x_radius(vtkNew sself) { return sself->GetXRadius(); } +extern "C" void vtk_parametric_ellipsoid_set_y_radius(vtkNew sself, double _arg) { sself->SetYRadius(_arg); } +extern "C" double vtk_parametric_ellipsoid_get_y_radius(vtkNew sself) { return sself->GetYRadius(); } +extern "C" void vtk_parametric_ellipsoid_set_z_radius(vtkNew sself, double _arg) { sself->SetZRadius(_arg); } +extern "C" double vtk_parametric_ellipsoid_get_z_radius(vtkNew sself) { return sself->GetZRadius(); } +extern "C" void vtk_parametric_ellipsoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_ellipsoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricEnneper > vtkParametricEnneper_new () {return vtkNew < vtkParametricEnneper > () ;} extern "C" void vtkParametricEnneper_destructor (vtkNew < vtkParametricEnneper > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricEnneper_get_ptr (vtkNew < vtkParametricEnneper > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_enneper_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_enneper_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_enneper_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricFigure8Klein > vtkParametricFigure8Klein_new () {return vtkNew < vtkParametricFigure8Klein > () ;} extern "C" void vtkParametricFigure8Klein_destructor (vtkNew < vtkParametricFigure8Klein > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricFigure8Klein_get_ptr (vtkNew < vtkParametricFigure8Klein > sself) {return sself . GetPointer () ;} +extern "C" void vtk_parametric_figure_8_klein_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_parametric_figure_8_klein_get_radius(vtkNew sself) { return sself->GetRadius(); } +extern "C" int vtk_parametric_figure_8_klein_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_figure_8_klein_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_figure_8_klein_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricHenneberg > vtkParametricHenneberg_new () {return vtkNew < vtkParametricHenneberg > () ;} extern "C" void vtkParametricHenneberg_destructor (vtkNew < vtkParametricHenneberg > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricHenneberg_get_ptr (vtkNew < vtkParametricHenneberg > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_henneberg_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_henneberg_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_henneberg_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricKlein > vtkParametricKlein_new () {return vtkNew < vtkParametricKlein > () ;} extern "C" void vtkParametricKlein_destructor (vtkNew < vtkParametricKlein > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricKlein_get_ptr (vtkNew < vtkParametricKlein > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_klein_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_klein_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_klein_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricKuen > vtkParametricKuen_new () {return vtkNew < vtkParametricKuen > () ;} extern "C" void vtkParametricKuen_destructor (vtkNew < vtkParametricKuen > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricKuen_get_ptr (vtkNew < vtkParametricKuen > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_kuen_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_kuen_set_delta_v_0(vtkNew sself, double _arg) { sself->SetDeltaV0(_arg); } +extern "C" double vtk_parametric_kuen_get_delta_v_0(vtkNew sself) { return sself->GetDeltaV0(); } +extern "C" void vtk_parametric_kuen_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_kuen_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricMobius > vtkParametricMobius_new () {return vtkNew < vtkParametricMobius > () ;} extern "C" void vtkParametricMobius_destructor (vtkNew < vtkParametricMobius > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricMobius_get_ptr (vtkNew < vtkParametricMobius > sself) {return sself . GetPointer () ;} +extern "C" void vtk_parametric_mobius_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_parametric_mobius_get_radius(vtkNew sself) { return sself->GetRadius(); } +extern "C" int vtk_parametric_mobius_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_mobius_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_mobius_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricPluckerConoid > vtkParametricPluckerConoid_new () {return vtkNew < vtkParametricPluckerConoid > () ;} extern "C" void vtkParametricPluckerConoid_destructor (vtkNew < vtkParametricPluckerConoid > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricPluckerConoid_get_ptr (vtkNew < vtkParametricPluckerConoid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_plucker_conoid_get_n(vtkNew sself) { return sself->GetN(); } +extern "C" void vtk_parametric_plucker_conoid_set_n(vtkNew sself, int _arg) { sself->SetN(_arg); } +extern "C" int vtk_parametric_plucker_conoid_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_plucker_conoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_plucker_conoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricPseudosphere > vtkParametricPseudosphere_new () {return vtkNew < vtkParametricPseudosphere > () ;} extern "C" void vtkParametricPseudosphere_destructor (vtkNew < vtkParametricPseudosphere > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricPseudosphere_get_ptr (vtkNew < vtkParametricPseudosphere > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_pseudosphere_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_pseudosphere_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_pseudosphere_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricRandomHills > vtkParametricRandomHills_new () {return vtkNew < vtkParametricRandomHills > () ;} extern "C" void vtkParametricRandomHills_destructor (vtkNew < vtkParametricRandomHills > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricRandomHills_get_ptr (vtkNew < vtkParametricRandomHills > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_random_hills_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_random_hills_set_number_of_hills(vtkNew sself, int _arg) { sself->SetNumberOfHills(_arg); } +extern "C" int vtk_parametric_random_hills_get_number_of_hills(vtkNew sself) { return sself->GetNumberOfHills(); } +extern "C" void vtk_parametric_random_hills_set_hill_x_variance(vtkNew sself, double _arg) { sself->SetHillXVariance(_arg); } +extern "C" double vtk_parametric_random_hills_get_hill_x_variance(vtkNew sself) { return sself->GetHillXVariance(); } +extern "C" void vtk_parametric_random_hills_set_hill_y_variance(vtkNew sself, double _arg) { sself->SetHillYVariance(_arg); } +extern "C" double vtk_parametric_random_hills_get_hill_y_variance(vtkNew sself) { return sself->GetHillYVariance(); } +extern "C" void vtk_parametric_random_hills_set_hill_amplitude(vtkNew sself, double _arg) { sself->SetHillAmplitude(_arg); } +extern "C" double vtk_parametric_random_hills_get_hill_amplitude(vtkNew sself) { return sself->GetHillAmplitude(); } +extern "C" void vtk_parametric_random_hills_set_random_seed(vtkNew sself, int _arg) { sself->SetRandomSeed(_arg); } +extern "C" int vtk_parametric_random_hills_get_random_seed(vtkNew sself) { return sself->GetRandomSeed(); } +extern "C" void vtk_parametric_random_hills_set_allow_random_generation(vtkNew sself, int _arg) { sself->SetAllowRandomGeneration(_arg); } +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_min_value(vtkNew sself) { return sself->GetAllowRandomGenerationMinValue(); } +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_max_value(vtkNew sself) { return sself->GetAllowRandomGenerationMaxValue(); } +extern "C" int vtk_parametric_random_hills_get_allow_random_generation(vtkNew sself) { return sself->GetAllowRandomGeneration(); } +extern "C" void vtk_parametric_random_hills_allow_random_generation_on(vtkNew sself) { sself->AllowRandomGenerationOn(); } +extern "C" void vtk_parametric_random_hills_allow_random_generation_off(vtkNew sself) { sself->AllowRandomGenerationOff(); } +extern "C" void vtk_parametric_random_hills_set_x_variance_scale_factor(vtkNew sself, double _arg) { sself->SetXVarianceScaleFactor(_arg); } +extern "C" double vtk_parametric_random_hills_get_x_variance_scale_factor(vtkNew sself) { return sself->GetXVarianceScaleFactor(); } +extern "C" void vtk_parametric_random_hills_set_y_variance_scale_factor(vtkNew sself, double _arg) { sself->SetYVarianceScaleFactor(_arg); } +extern "C" double vtk_parametric_random_hills_get_y_variance_scale_factor(vtkNew sself) { return sself->GetYVarianceScaleFactor(); } +extern "C" void vtk_parametric_random_hills_set_amplitude_scale_factor(vtkNew sself, double _arg) { sself->SetAmplitudeScaleFactor(_arg); } +extern "C" double vtk_parametric_random_hills_get_amplitude_scale_factor(vtkNew sself) { return sself->GetAmplitudeScaleFactor(); } +extern "C" void vtk_parametric_random_hills_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_random_hills_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricRoman > vtkParametricRoman_new () {return vtkNew < vtkParametricRoman > () ;} extern "C" void vtkParametricRoman_destructor (vtkNew < vtkParametricRoman > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricRoman_get_ptr (vtkNew < vtkParametricRoman > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_roman_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_roman_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_parametric_roman_get_radius(vtkNew sself) { return sself->GetRadius(); } +extern "C" void vtk_parametric_roman_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_roman_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricSpline > vtkParametricSpline_new () {return vtkNew < vtkParametricSpline > () ;} extern "C" void vtkParametricSpline_destructor (vtkNew < vtkParametricSpline > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricSpline_get_ptr (vtkNew < vtkParametricSpline > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_spline_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_spline_evaluate(vtkNew sself, double u, double Pt, double Du) { sself->Evaluate(u, Pt, Du); } +extern "C" double vtk_parametric_spline_evaluate_scalar(vtkNew sself, double u, double Pt, double Du) { return sself->EvaluateScalar(u, Pt, Du); } +extern "C" void vtk_parametric_spline_set_number_of_points(vtkNew sself, long long numPts) { sself->SetNumberOfPoints(numPts); } +extern "C" void vtk_parametric_spline_set_point(vtkNew sself, long long index, double x, double y, double z) { sself->SetPoint(index, x, y, z); } +extern "C" void vtk_parametric_spline_set_closed(vtkNew sself, int _arg) { sself->SetClosed(_arg); } +extern "C" int vtk_parametric_spline_get_closed(vtkNew sself) { return sself->GetClosed(); } +extern "C" void vtk_parametric_spline_closed_on(vtkNew sself) { sself->ClosedOn(); } +extern "C" void vtk_parametric_spline_closed_off(vtkNew sself) { sself->ClosedOff(); } +extern "C" void vtk_parametric_spline_set_parameterize_by_length(vtkNew sself, int _arg) { sself->SetParameterizeByLength(_arg); } +extern "C" int vtk_parametric_spline_get_parameterize_by_length(vtkNew sself) { return sself->GetParameterizeByLength(); } +extern "C" void vtk_parametric_spline_parameterize_by_length_on(vtkNew sself) { sself->ParameterizeByLengthOn(); } +extern "C" void vtk_parametric_spline_parameterize_by_length_off(vtkNew sself) { sself->ParameterizeByLengthOff(); } +extern "C" void vtk_parametric_spline_set_left_constraint(vtkNew sself, int _arg) { sself->SetLeftConstraint(_arg); } +extern "C" int vtk_parametric_spline_get_left_constraint_min_value(vtkNew sself) { return sself->GetLeftConstraintMinValue(); } +extern "C" int vtk_parametric_spline_get_left_constraint_max_value(vtkNew sself) { return sself->GetLeftConstraintMaxValue(); } +extern "C" int vtk_parametric_spline_get_left_constraint(vtkNew sself) { return sself->GetLeftConstraint(); } +extern "C" void vtk_parametric_spline_set_right_constraint(vtkNew sself, int _arg) { sself->SetRightConstraint(_arg); } +extern "C" int vtk_parametric_spline_get_right_constraint_min_value(vtkNew sself) { return sself->GetRightConstraintMinValue(); } +extern "C" int vtk_parametric_spline_get_right_constraint_max_value(vtkNew sself) { return sself->GetRightConstraintMaxValue(); } +extern "C" int vtk_parametric_spline_get_right_constraint(vtkNew sself) { return sself->GetRightConstraint(); } +extern "C" void vtk_parametric_spline_set_left_value(vtkNew sself, double _arg) { sself->SetLeftValue(_arg); } +extern "C" double vtk_parametric_spline_get_left_value(vtkNew sself) { return sself->GetLeftValue(); } +extern "C" void vtk_parametric_spline_set_right_value(vtkNew sself, double _arg) { sself->SetRightValue(_arg); } +extern "C" double vtk_parametric_spline_get_right_value(vtkNew sself) { return sself->GetRightValue(); } extern "C" vtkNew < vtkParametricSuperEllipsoid > vtkParametricSuperEllipsoid_new () {return vtkNew < vtkParametricSuperEllipsoid > () ;} extern "C" void vtkParametricSuperEllipsoid_destructor (vtkNew < vtkParametricSuperEllipsoid > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricSuperEllipsoid_get_ptr (vtkNew < vtkParametricSuperEllipsoid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_super_ellipsoid_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_super_ellipsoid_set_x_radius(vtkNew sself, double _arg) { sself->SetXRadius(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_x_radius(vtkNew sself) { return sself->GetXRadius(); } +extern "C" void vtk_parametric_super_ellipsoid_set_y_radius(vtkNew sself, double _arg) { sself->SetYRadius(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_y_radius(vtkNew sself) { return sself->GetYRadius(); } +extern "C" void vtk_parametric_super_ellipsoid_set_z_radius(vtkNew sself, double _arg) { sself->SetZRadius(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_z_radius(vtkNew sself) { return sself->GetZRadius(); } +extern "C" void vtk_parametric_super_ellipsoid_set_n_1(vtkNew sself, double _arg) { sself->SetN1(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_n_1(vtkNew sself) { return sself->GetN1(); } +extern "C" void vtk_parametric_super_ellipsoid_set_n_2(vtkNew sself, double _arg) { sself->SetN2(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_n_2(vtkNew sself) { return sself->GetN2(); } +extern "C" void vtk_parametric_super_ellipsoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_super_ellipsoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricSuperToroid > vtkParametricSuperToroid_new () {return vtkNew < vtkParametricSuperToroid > () ;} extern "C" void vtkParametricSuperToroid_destructor (vtkNew < vtkParametricSuperToroid > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricSuperToroid_get_ptr (vtkNew < vtkParametricSuperToroid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_parametric_super_toroid_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_super_toroid_set_ring_radius(vtkNew sself, double _arg) { sself->SetRingRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_ring_radius(vtkNew sself) { return sself->GetRingRadius(); } +extern "C" void vtk_parametric_super_toroid_set_cross_section_radius(vtkNew sself, double _arg) { sself->SetCrossSectionRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_cross_section_radius(vtkNew sself) { return sself->GetCrossSectionRadius(); } +extern "C" void vtk_parametric_super_toroid_set_x_radius(vtkNew sself, double _arg) { sself->SetXRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_x_radius(vtkNew sself) { return sself->GetXRadius(); } +extern "C" void vtk_parametric_super_toroid_set_y_radius(vtkNew sself, double _arg) { sself->SetYRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_y_radius(vtkNew sself) { return sself->GetYRadius(); } +extern "C" void vtk_parametric_super_toroid_set_z_radius(vtkNew sself, double _arg) { sself->SetZRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_z_radius(vtkNew sself) { return sself->GetZRadius(); } +extern "C" void vtk_parametric_super_toroid_set_n_1(vtkNew sself, double _arg) { sself->SetN1(_arg); } +extern "C" double vtk_parametric_super_toroid_get_n_1(vtkNew sself) { return sself->GetN1(); } +extern "C" void vtk_parametric_super_toroid_set_n_2(vtkNew sself, double _arg) { sself->SetN2(_arg); } +extern "C" double vtk_parametric_super_toroid_get_n_2(vtkNew sself) { return sself->GetN2(); } +extern "C" void vtk_parametric_super_toroid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_super_toroid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } extern "C" vtkNew < vtkParametricTorus > vtkParametricTorus_new () {return vtkNew < vtkParametricTorus > () ;} extern "C" void vtkParametricTorus_destructor (vtkNew < vtkParametricTorus > sself) {sself . Reset () ; return ;} extern "C" void * vtkParametricTorus_get_ptr (vtkNew < vtkParametricTorus > sself) {return sself . GetPointer () ;} +extern "C" void vtk_parametric_torus_set_ring_radius(vtkNew sself, double _arg) { sself->SetRingRadius(_arg); } +extern "C" double vtk_parametric_torus_get_ring_radius(vtkNew sself) { return sself->GetRingRadius(); } +extern "C" void vtk_parametric_torus_set_cross_section_radius(vtkNew sself, double _arg) { sself->SetCrossSectionRadius(_arg); } +extern "C" double vtk_parametric_torus_get_cross_section_radius(vtkNew sself) { return sself->GetCrossSectionRadius(); } +extern "C" int vtk_parametric_torus_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_torus_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } +extern "C" double vtk_parametric_torus_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp index b4da45f..82d43f2 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp @@ -19,7 +19,6 @@ #include #include #include -#include #include #include #include @@ -148,6 +147,8 @@ #include #include #include +#include +#include #include #include #include @@ -167,170 +168,1067 @@ extern "C" vtkNew < vtkAnimationCue > vtkAnimationCue_new () {return vtkNew < vtkAnimationCue > () ;} extern "C" void vtkAnimationCue_destructor (vtkNew < vtkAnimationCue > sself) {sself . Reset () ; return ;} extern "C" void * vtkAnimationCue_get_ptr (vtkNew < vtkAnimationCue > sself) {return sself . GetPointer () ;} +extern "C" void vtk_animation_cue_set_time_mode(vtkNew sself, int mode) { sself->SetTimeMode(mode); } +extern "C" int vtk_animation_cue_get_time_mode(vtkNew sself) { return sself->GetTimeMode(); } +extern "C" void vtk_animation_cue_set_time_mode_to_relative(vtkNew sself) { sself->SetTimeModeToRelative(); } +extern "C" void vtk_animation_cue_set_time_mode_to_normalized(vtkNew sself) { sself->SetTimeModeToNormalized(); } +extern "C" void vtk_animation_cue_set_start_time(vtkNew sself, double _arg) { sself->SetStartTime(_arg); } +extern "C" double vtk_animation_cue_get_start_time(vtkNew sself) { return sself->GetStartTime(); } +extern "C" void vtk_animation_cue_set_end_time(vtkNew sself, double _arg) { sself->SetEndTime(_arg); } +extern "C" double vtk_animation_cue_get_end_time(vtkNew sself) { return sself->GetEndTime(); } +extern "C" void vtk_animation_cue_tick(vtkNew sself, double currenttime, double deltatime, double clocktime) { sself->Tick(currenttime, deltatime, clocktime); } +extern "C" void vtk_animation_cue_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_animation_cue_finalize(vtkNew sself) { sself->Finalize(); } +extern "C" double vtk_animation_cue_get_animation_time(vtkNew sself) { return sself->GetAnimationTime(); } +extern "C" double vtk_animation_cue_get_delta_time(vtkNew sself) { return sself->GetDeltaTime(); } +extern "C" double vtk_animation_cue_get_clock_time(vtkNew sself) { return sself->GetClockTime(); } extern "C" vtkNew < vtkArchiver > vtkArchiver_new () {return vtkNew < vtkArchiver > () ;} extern "C" void vtkArchiver_destructor (vtkNew < vtkArchiver > sself) {sself . Reset () ; return ;} extern "C" void * vtkArchiver_get_ptr (vtkNew < vtkArchiver > sself) {return sself . GetPointer () ;} -extern "C" void vtkArchiver_set_archive_name (vtkNew < vtkArchiver > sself, const char * name) {sself->SetArchiveName(name);} -extern "C" const char * vtkArchiver_get_archive_name (vtkNew < vtkArchiver > sself) {return sself->GetArchiveName();} +extern "C" char* vtk_archiver_get_archive_name(vtkNew sself) { return sself->GetArchiveName(); } +extern "C" void vtk_archiver_set_archive_name(vtkNew sself, const char _arg) { sself->SetArchiveName(_arg); } +extern "C" void vtk_archiver_open_archive(vtkNew sself) { sself->OpenArchive(); } +extern "C" void vtk_archiver_close_archive(vtkNew sself) { sself->CloseArchive(); } +extern "C" void vtk_archiver_insert_into_archive(vtkNew sself, const char* relativePath, const char data, size_t size) { sself->InsertIntoArchive(relativePath, data, size); } +extern "C" bool vtk_archiver_contains(vtkNew sself, const char* relativePath) { return sself->Contains(relativePath); } extern "C" vtkNew < vtkBitArray > vtkBitArray_new () {return vtkNew < vtkBitArray > () ;} extern "C" void vtkBitArray_destructor (vtkNew < vtkBitArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkBitArray_get_ptr (vtkNew < vtkBitArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bit_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_bit_array_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_bit_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" int vtk_bit_array_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_bit_array_set_number_of_tuples(vtkNew sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" bool vtk_bit_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" double* vtk_bit_array_get_tuple(vtkNew sself, long long i) { return sself->GetTuple(i); } +extern "C" void vtk_bit_array_get_tuple(vtkNew sself, long long i, double tuple) { sself->GetTuple(i, tuple); } +extern "C" void vtk_bit_array_set_tuple(vtkNew sself, long long i, const float tuple) { sself->SetTuple(i, tuple); } +extern "C" void vtk_bit_array_set_tuple(vtkNew sself, long long i, const double tuple) { sself->SetTuple(i, tuple); } +extern "C" void vtk_bit_array_insert_tuple(vtkNew sself, long long i, const float tuple) { sself->InsertTuple(i, tuple); } +extern "C" void vtk_bit_array_insert_tuple(vtkNew sself, long long i, const double tuple) { sself->InsertTuple(i, tuple); } +extern "C" long long vtk_bit_array_insert_next_tuple(vtkNew sself, const float tuple) { return sself->InsertNextTuple(tuple); } +extern "C" long long vtk_bit_array_insert_next_tuple(vtkNew sself, const double tuple) { return sself->InsertNextTuple(tuple); } +extern "C" void vtk_bit_array_remove_tuple(vtkNew sself, long long id) { sself->RemoveTuple(id); } +extern "C" void vtk_bit_array_set_component(vtkNew sself, long long i, int j, double c) { sself->SetComponent(i, j, c); } +extern "C" void vtk_bit_array_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" int vtk_bit_array_resize(vtkNew sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" int vtk_bit_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_bit_array_set_value(vtkNew sself, long long id, int value) { sself->SetValue(id, value); } +extern "C" void vtk_bit_array_insert_value(vtkNew sself, long long id, int i) { sself->InsertValue(id, i); } +extern "C" long long vtk_bit_array_insert_next_value(vtkNew sself, int i) { return sself->InsertNextValue(i); } +extern "C" void vtk_bit_array_insert_component(vtkNew sself, long long i, int j, double c) { sself->InsertComponent(i, j, c); } +extern "C" unsigned char* vtk_bit_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" unsigned char* vtk_bit_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" void* vtk_bit_array_write_void_pointer(vtkNew sself, long long id, long long number) { return sself->WriteVoidPointer(id, number); } +extern "C" void* vtk_bit_array_get_void_pointer(vtkNew sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_bit_array_set_void_array(vtkNew sself, void array, long long size, int save) { sself->SetVoidArray(array, size, save); } +extern "C" long long vtk_bit_array_lookup_value(vtkNew sself, int value) { return sself->LookupValue(value); } +extern "C" void vtk_bit_array_data_changed(vtkNew sself) { sself->DataChanged(); } +extern "C" void vtk_bit_array_clear_lookup(vtkNew sself) { sself->ClearLookup(); } extern "C" vtkNew < vtkBitArrayIterator > vtkBitArrayIterator_new () {return vtkNew < vtkBitArrayIterator > () ;} extern "C" void vtkBitArrayIterator_destructor (vtkNew < vtkBitArrayIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkBitArrayIterator_get_ptr (vtkNew < vtkBitArrayIterator > sself) {return sself . GetPointer () ;} +extern "C" int* vtk_bit_array_iterator_get_tuple(vtkNew sself, long long id) { return sself->GetTuple(id); } +extern "C" int vtk_bit_array_iterator_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" long long vtk_bit_array_iterator_get_number_of_tuples(vtkNew sself) { return sself->GetNumberOfTuples(); } +extern "C" long long vtk_bit_array_iterator_get_number_of_values(vtkNew sself) { return sself->GetNumberOfValues(); } +extern "C" int vtk_bit_array_iterator_get_number_of_components(vtkNew sself) { return sself->GetNumberOfComponents(); } +extern "C" int vtk_bit_array_iterator_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" int vtk_bit_array_iterator_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_bit_array_iterator_set_value(vtkNew sself, long long id, int value) { sself->SetValue(id, value); } extern "C" vtkNew < vtkBoxMuellerRandomSequence > vtkBoxMuellerRandomSequence_new () {return vtkNew < vtkBoxMuellerRandomSequence > () ;} extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkNew < vtkBoxMuellerRandomSequence > sself) {sself . Reset () ; return ;} extern "C" void * vtkBoxMuellerRandomSequence_get_ptr (vtkNew < vtkBoxMuellerRandomSequence > sself) {return sself . GetPointer () ;} +extern "C" void vtk_box_mueller_random_sequence_initialize(vtkNew sself, unsigned int seed) { sself->Initialize(seed); } +extern "C" double vtk_box_mueller_random_sequence_get_value(vtkNew sself) { return sself->GetValue(); } +extern "C" void vtk_box_mueller_random_sequence_next(vtkNew sself) { sself->Next(); } extern "C" vtkNew < vtkByteSwap > vtkByteSwap_new () {return vtkNew < vtkByteSwap > () ;} extern "C" void vtkByteSwap_destructor (vtkNew < vtkByteSwap > sself) {sself . Reset () ; return ;} extern "C" void * vtkByteSwap_get_ptr (vtkNew < vtkByteSwap > sself) {return sself . GetPointer () ;} +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, float p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, float p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, float p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, float p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, double p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, double p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, double p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, double p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, char p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, char p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, char p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, char p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, short p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, short p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, short p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, short p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, int p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, int p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, int p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, int p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, long p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, long p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, long p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, long p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, long long p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, long long p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, long long p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, long long p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, char p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, char p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, char p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, char p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned char p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned char p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned char p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned char p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned short p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned short p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned short p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned short p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned int p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned int p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned int p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned int p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned long p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned long p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned long p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned long p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned long long p) { sself->SwapLE(p); } +extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned long long p) { sself->SwapBE(p); } +extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned long long p, size_t num) { sself->SwapLERange(p, num); } +extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned long long p, size_t num) { sself->SwapBERange(p, num); } +extern "C" void vtk_byte_swap_swap_2_le(vtkNew sself, void p) { sself->Swap2LE(p); } +extern "C" void vtk_byte_swap_swap_4_le(vtkNew sself, void p) { sself->Swap4LE(p); } +extern "C" void vtk_byte_swap_swap_8_le(vtkNew sself, void p) { sself->Swap8LE(p); } +extern "C" void vtk_byte_swap_swap_2_le_range(vtkNew sself, void p, size_t num) { sself->Swap2LERange(p, num); } +extern "C" void vtk_byte_swap_swap_4_le_range(vtkNew sself, void p, size_t num) { sself->Swap4LERange(p, num); } +extern "C" void vtk_byte_swap_swap_8_le_range(vtkNew sself, void p, size_t num) { sself->Swap8LERange(p, num); } +extern "C" void vtk_byte_swap_swap_2_be(vtkNew sself, void p) { sself->Swap2BE(p); } +extern "C" void vtk_byte_swap_swap_4_be(vtkNew sself, void p) { sself->Swap4BE(p); } +extern "C" void vtk_byte_swap_swap_8_be(vtkNew sself, void p) { sself->Swap8BE(p); } +extern "C" void vtk_byte_swap_swap_2_be_range(vtkNew sself, void p, size_t num) { sself->Swap2BERange(p, num); } +extern "C" void vtk_byte_swap_swap_4_be_range(vtkNew sself, void p, size_t num) { sself->Swap4BERange(p, num); } +extern "C" void vtk_byte_swap_swap_8_be_range(vtkNew sself, void p, size_t num) { sself->Swap8BERange(p, num); } +extern "C" void vtk_byte_swap_swap_void_range(vtkNew sself, void buffer, size_t numWords, size_t wordSize) { sself->SwapVoidRange(buffer, numWords, wordSize); } extern "C" vtkNew < vtkCallbackCommand > vtkCallbackCommand_new () {return vtkNew < vtkCallbackCommand > () ;} extern "C" void vtkCallbackCommand_destructor (vtkNew < vtkCallbackCommand > sself) {sself . Reset () ; return ;} extern "C" void * vtkCallbackCommand_get_ptr (vtkNew < vtkCallbackCommand > sself) {return sself . GetPointer () ;} +extern "C" void vtk_callback_command_set_client_data(vtkNew sself, void cd) { sself->SetClientData(cd); } +extern "C" void* vtk_callback_command_get_client_data(vtkNew sself) { return sself->GetClientData(); } +extern "C" void vtk_callback_command_set_abort_flag_on_execute(vtkNew sself, int f) { sself->SetAbortFlagOnExecute(f); } +extern "C" int vtk_callback_command_get_abort_flag_on_execute(vtkNew sself) { return sself->GetAbortFlagOnExecute(); } +extern "C" void vtk_callback_command_abort_flag_on_execute_on(vtkNew sself) { sself->AbortFlagOnExecuteOn(); } +extern "C" void vtk_callback_command_abort_flag_on_execute_off(vtkNew sself) { sself->AbortFlagOnExecuteOff(); } extern "C" vtkNew < vtkCharArray > vtkCharArray_new () {return vtkNew < vtkCharArray > () ;} extern "C" void vtkCharArray_destructor (vtkNew < vtkCharArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkCharArray_get_ptr (vtkNew < vtkCharArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_char_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_char_array_get_typed_tuple(vtkNew sself, long long i, char tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_char_array_set_typed_tuple(vtkNew sself, long long i, const char tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_char_array_insert_typed_tuple(vtkNew sself, long long i, const char tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_char_array_insert_next_typed_tuple(vtkNew sself, const char tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" char vtk_char_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_char_array_set_value(vtkNew sself, long long id, char value) { sself->SetValue(id, value); } +extern "C" bool vtk_char_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_char_array_insert_value(vtkNew sself, long long id, char f) { sself->InsertValue(id, f); } +extern "C" long long vtk_char_array_insert_next_value(vtkNew sself, char f) { return sself->InsertNextValue(f); } +extern "C" char* vtk_char_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" char* vtk_char_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" char* vtk_char_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" char* vtk_char_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_char_array_set_array(vtkNew sself, char array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_char_array_set_array(vtkNew sself, char array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" char vtk_char_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" char vtk_char_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkCollection > vtkCollection_new () {return vtkNew < vtkCollection > () ;} extern "C" void vtkCollection_destructor (vtkNew < vtkCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkCollection_get_ptr (vtkNew < vtkCollection > sself) {return sself . GetPointer () ;} +extern "C" void vtk_collection_remove_item(vtkNew sself, int i) { sself->RemoveItem(i); } +extern "C" void vtk_collection_remove_all_items(vtkNew sself) { sself->RemoveAllItems(); } +extern "C" int vtk_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } +extern "C" void vtk_collection_init_traversal(vtkNew sself) { sself->InitTraversal(); } +extern "C" void vtk_collection_init_traversal(vtkNew sself, void cookie) { sself->InitTraversal(cookie); } extern "C" vtkNew < vtkCollectionIterator > vtkCollectionIterator_new () {return vtkNew < vtkCollectionIterator > () ;} extern "C" void vtkCollectionIterator_destructor (vtkNew < vtkCollectionIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkCollectionIterator_get_ptr (vtkNew < vtkCollectionIterator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_collection_iterator_init_traversal(vtkNew sself) { sself->InitTraversal(); } +extern "C" void vtk_collection_iterator_go_to_first_item(vtkNew sself) { sself->GoToFirstItem(); } +extern "C" void vtk_collection_iterator_go_to_next_item(vtkNew sself) { sself->GoToNextItem(); } +extern "C" int vtk_collection_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } extern "C" vtkNew < vtkCriticalSection > vtkCriticalSection_new () {return vtkNew < vtkCriticalSection > () ;} extern "C" void vtkCriticalSection_destructor (vtkNew < vtkCriticalSection > sself) {sself . Reset () ; return ;} extern "C" void * vtkCriticalSection_get_ptr (vtkNew < vtkCriticalSection > sself) {return sself . GetPointer () ;} +extern "C" void vtk_critical_section_lock(vtkNew sself) { sself->Lock(); } +extern "C" void vtk_critical_section_unlock(vtkNew sself) { sself->Unlock(); } extern "C" vtkNew < vtkDataArrayCollection > vtkDataArrayCollection_new () {return vtkNew < vtkDataArrayCollection > () ;} extern "C" void vtkDataArrayCollection_destructor (vtkNew < vtkDataArrayCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataArrayCollection_get_ptr (vtkNew < vtkDataArrayCollection > sself) {return sself . GetPointer () ;} +extern "C" int vtk_data_array_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } extern "C" vtkNew < vtkDataArrayCollectionIterator > vtkDataArrayCollectionIterator_new () {return vtkNew < vtkDataArrayCollectionIterator > () ;} extern "C" void vtkDataArrayCollectionIterator_destructor (vtkNew < vtkDataArrayCollectionIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataArrayCollectionIterator_get_ptr (vtkNew < vtkDataArrayCollectionIterator > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkDataArraySelection > vtkDataArraySelection_new () {return vtkNew < vtkDataArraySelection > () ;} extern "C" void vtkDataArraySelection_destructor (vtkNew < vtkDataArraySelection > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataArraySelection_get_ptr (vtkNew < vtkDataArraySelection > sself) {return sself . GetPointer () ;} +extern "C" void vtk_data_array_selection_enable_array(vtkNew sself, const char name) { sself->EnableArray(name); } +extern "C" void vtk_data_array_selection_disable_array(vtkNew sself, const char name) { sself->DisableArray(name); } +extern "C" int vtk_data_array_selection_array_is_enabled(vtkNew sself, const char name) { return sself->ArrayIsEnabled(name); } +extern "C" int vtk_data_array_selection_array_exists(vtkNew sself, const char name) { return sself->ArrayExists(name); } +extern "C" void vtk_data_array_selection_enable_all_arrays(vtkNew sself) { sself->EnableAllArrays(); } +extern "C" void vtk_data_array_selection_disable_all_arrays(vtkNew sself) { sself->DisableAllArrays(); } +extern "C" int vtk_data_array_selection_get_number_of_arrays(vtkNew sself) { return sself->GetNumberOfArrays(); } +extern "C" int vtk_data_array_selection_get_number_of_arrays_enabled(vtkNew sself) { return sself->GetNumberOfArraysEnabled(); } +extern "C" const char* vtk_data_array_selection_get_array_name(vtkNew sself, int index) { return sself->GetArrayName(index); } +extern "C" int vtk_data_array_selection_get_array_index(vtkNew sself, const char name) { return sself->GetArrayIndex(name); } +extern "C" int vtk_data_array_selection_get_enabled_array_index(vtkNew sself, const char name) { return sself->GetEnabledArrayIndex(name); } +extern "C" int vtk_data_array_selection_get_array_setting(vtkNew sself, int index) { return sself->GetArraySetting(index); } +extern "C" int vtk_data_array_selection_get_array_setting(vtkNew sself, const char name) { return sself->GetArraySetting(name); } +extern "C" void vtk_data_array_selection_set_array_setting(vtkNew sself, const char name, int setting) { sself->SetArraySetting(name, setting); } +extern "C" void vtk_data_array_selection_remove_all_arrays(vtkNew sself) { sself->RemoveAllArrays(); } +extern "C" int vtk_data_array_selection_add_array(vtkNew sself, const char name, bool state) { return sself->AddArray(name, state); } +extern "C" void vtk_data_array_selection_remove_array_by_index(vtkNew sself, int index) { sself->RemoveArrayByIndex(index); } +extern "C" void vtk_data_array_selection_remove_array_by_name(vtkNew sself, const char name) { sself->RemoveArrayByName(name); } +extern "C" void vtk_data_array_selection_set_arrays(vtkNew sself, const char names, int numArrays) { sself->SetArrays(names, numArrays); } +extern "C" void vtk_data_array_selection_set_arrays_with_default(vtkNew sself, const char names, int numArrays, int defaultStatus) { sself->SetArraysWithDefault(names, numArrays, defaultStatus); } +extern "C" void vtk_data_array_selection_set_unknown_array_setting(vtkNew sself, int _arg) { sself->SetUnknownArraySetting(_arg); } +extern "C" int vtk_data_array_selection_get_unknown_array_setting(vtkNew sself) { return sself->GetUnknownArraySetting(); } extern "C" vtkNew < vtkDebugLeaks > vtkDebugLeaks_new () {return vtkNew < vtkDebugLeaks > () ;} extern "C" void vtkDebugLeaks_destructor (vtkNew < vtkDebugLeaks > sself) {sself . Reset () ; return ;} extern "C" void * vtkDebugLeaks_get_ptr (vtkNew < vtkDebugLeaks > sself) {return sself . GetPointer () ;} +extern "C" void vtk_debug_leaks_construct_class(vtkNew sself, const char className) { sself->ConstructClass(className); } +extern "C" void vtk_debug_leaks_destruct_class(vtkNew sself, const char className) { sself->DestructClass(className); } +extern "C" int vtk_debug_leaks_print_current_leaks(vtkNew sself) { return sself->PrintCurrentLeaks(); } +extern "C" int vtk_debug_leaks_get_exit_error(vtkNew sself) { return sself->GetExitError(); } +extern "C" void vtk_debug_leaks_set_exit_error(vtkNew sself, int p0) { sself->SetExitError(p0); } extern "C" vtkNew < vtkDoubleArray > vtkDoubleArray_new () {return vtkNew < vtkDoubleArray > () ;} extern "C" void vtkDoubleArray_destructor (vtkNew < vtkDoubleArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkDoubleArray_get_ptr (vtkNew < vtkDoubleArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_double_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_double_array_get_typed_tuple(vtkNew sself, long long i, double tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_double_array_set_typed_tuple(vtkNew sself, long long i, const double tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_double_array_insert_typed_tuple(vtkNew sself, long long i, const double tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_double_array_insert_next_typed_tuple(vtkNew sself, const double tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" double vtk_double_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_double_array_set_value(vtkNew sself, long long id, double value) { sself->SetValue(id, value); } +extern "C" bool vtk_double_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_double_array_insert_value(vtkNew sself, long long id, double f) { sself->InsertValue(id, f); } +extern "C" long long vtk_double_array_insert_next_value(vtkNew sself, double f) { return sself->InsertNextValue(f); } +extern "C" double* vtk_double_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" double* vtk_double_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" double* vtk_double_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" double* vtk_double_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_double_array_set_array(vtkNew sself, double array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_double_array_set_array(vtkNew sself, double array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" double vtk_double_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" double vtk_double_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkDynamicLoader > vtkDynamicLoader_new () {return vtkNew < vtkDynamicLoader > () ;} extern "C" void vtkDynamicLoader_destructor (vtkNew < vtkDynamicLoader > sself) {sself . Reset () ; return ;} extern "C" void * vtkDynamicLoader_get_ptr (vtkNew < vtkDynamicLoader > sself) {return sself . GetPointer () ;} +extern "C" const char* vtk_dynamic_loader_lib_prefix(vtkNew sself) { return sself->LibPrefix(); } +extern "C" const char* vtk_dynamic_loader_lib_extension(vtkNew sself) { return sself->LibExtension(); } +extern "C" const char* vtk_dynamic_loader_last_error(vtkNew sself) { return sself->LastError(); } extern "C" vtkNew < vtkEventDataDevice3D > vtkEventDataDevice3D_new () {return vtkNew < vtkEventDataDevice3D > () ;} extern "C" void vtkEventDataDevice3D_destructor (vtkNew < vtkEventDataDevice3D > sself) {sself . Reset () ; return ;} extern "C" void * vtkEventDataDevice3D_get_ptr (vtkNew < vtkEventDataDevice3D > sself) {return sself . GetPointer () ;} +extern "C" void vtk_event_data_device_3_d_get_world_position(vtkNew sself, double v) { sself->GetWorldPosition(v); } +extern "C" const double* vtk_event_data_device_3_d_get_world_position(vtkNew sself) { return sself->GetWorldPosition(); } +extern "C" void vtk_event_data_device_3_d_set_world_position(vtkNew sself, const double p) { sself->SetWorldPosition(p); } +extern "C" void vtk_event_data_device_3_d_get_world_direction(vtkNew sself, double v) { sself->GetWorldDirection(v); } +extern "C" const double* vtk_event_data_device_3_d_get_world_direction(vtkNew sself) { return sself->GetWorldDirection(); } +extern "C" void vtk_event_data_device_3_d_set_world_direction(vtkNew sself, const double p) { sself->SetWorldDirection(p); } +extern "C" void vtk_event_data_device_3_d_get_world_orientation(vtkNew sself, double v) { sself->GetWorldOrientation(v); } +extern "C" const double* vtk_event_data_device_3_d_get_world_orientation(vtkNew sself) { return sself->GetWorldOrientation(); } +extern "C" void vtk_event_data_device_3_d_set_world_orientation(vtkNew sself, const double p) { sself->SetWorldOrientation(p); } +extern "C" void vtk_event_data_device_3_d_get_track_pad_position(vtkNew sself, double v) { sself->GetTrackPadPosition(v); } +extern "C" const double* vtk_event_data_device_3_d_get_track_pad_position(vtkNew sself) { return sself->GetTrackPadPosition(); } +extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkNew sself, const double p) { sself->SetTrackPadPosition(p); } +extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkNew sself, double x, double y) { sself->SetTrackPadPosition(x, y); } extern "C" vtkNew < vtkEventDataForDevice > vtkEventDataForDevice_new () {return vtkNew < vtkEventDataForDevice > () ;} extern "C" void vtkEventDataForDevice_destructor (vtkNew < vtkEventDataForDevice > sself) {sself . Reset () ; return ;} extern "C" void * vtkEventDataForDevice_get_ptr (vtkNew < vtkEventDataForDevice > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkEventForwarderCommand > vtkEventForwarderCommand_new () {return vtkNew < vtkEventForwarderCommand > () ;} extern "C" void vtkEventForwarderCommand_destructor (vtkNew < vtkEventForwarderCommand > sself) {sself . Reset () ; return ;} extern "C" void * vtkEventForwarderCommand_get_ptr (vtkNew < vtkEventForwarderCommand > sself) {return sself . GetPointer () ;} +extern "C" void* vtk_event_forwarder_command_get_target(vtkNew sself) { return sself->GetTarget(); } extern "C" vtkNew < vtkFileOutputWindow > vtkFileOutputWindow_new () {return vtkNew < vtkFileOutputWindow > () ;} extern "C" void vtkFileOutputWindow_destructor (vtkNew < vtkFileOutputWindow > sself) {sself . Reset () ; return ;} extern "C" void * vtkFileOutputWindow_get_ptr (vtkNew < vtkFileOutputWindow > sself) {return sself . GetPointer () ;} +extern "C" void vtk_file_output_window_display_text(vtkNew sself, const char p0) { sself->DisplayText(p0); } +extern "C" void vtk_file_output_window_set_file_name(vtkNew sself, const char _arg) { sself->SetFileName(_arg); } +extern "C" char* vtk_file_output_window_get_file_name(vtkNew sself) { return sself->GetFileName(); } +extern "C" void vtk_file_output_window_set_flush(vtkNew sself, int _arg) { sself->SetFlush(_arg); } +extern "C" int vtk_file_output_window_get_flush(vtkNew sself) { return sself->GetFlush(); } +extern "C" void vtk_file_output_window_flush_on(vtkNew sself) { sself->FlushOn(); } +extern "C" void vtk_file_output_window_flush_off(vtkNew sself) { sself->FlushOff(); } +extern "C" void vtk_file_output_window_set_append(vtkNew sself, int _arg) { sself->SetAppend(_arg); } +extern "C" int vtk_file_output_window_get_append(vtkNew sself) { return sself->GetAppend(); } +extern "C" void vtk_file_output_window_append_on(vtkNew sself) { sself->AppendOn(); } +extern "C" void vtk_file_output_window_append_off(vtkNew sself) { sself->AppendOff(); } extern "C" vtkNew < vtkFloatArray > vtkFloatArray_new () {return vtkNew < vtkFloatArray > () ;} extern "C" void vtkFloatArray_destructor (vtkNew < vtkFloatArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkFloatArray_get_ptr (vtkNew < vtkFloatArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_float_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_float_array_get_typed_tuple(vtkNew sself, long long i, float tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_float_array_set_typed_tuple(vtkNew sself, long long i, const float tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_float_array_insert_typed_tuple(vtkNew sself, long long i, const float tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_float_array_insert_next_typed_tuple(vtkNew sself, const float tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" float vtk_float_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_float_array_set_value(vtkNew sself, long long id, float value) { sself->SetValue(id, value); } +extern "C" bool vtk_float_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_float_array_insert_value(vtkNew sself, long long id, float f) { sself->InsertValue(id, f); } +extern "C" long long vtk_float_array_insert_next_value(vtkNew sself, float f) { return sself->InsertNextValue(f); } +extern "C" float* vtk_float_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" float* vtk_float_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" float* vtk_float_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" float* vtk_float_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_float_array_set_array(vtkNew sself, float array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_float_array_set_array(vtkNew sself, float array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" float vtk_float_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" float vtk_float_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkGarbageCollector > vtkGarbageCollector_new () {return vtkNew < vtkGarbageCollector > () ;} extern "C" void vtkGarbageCollector_destructor (vtkNew < vtkGarbageCollector > sself) {sself . Reset () ; return ;} extern "C" void * vtkGarbageCollector_get_ptr (vtkNew < vtkGarbageCollector > sself) {return sself . GetPointer () ;} +extern "C" void vtk_garbage_collector_collect(vtkNew sself) { sself->Collect(); } +extern "C" void vtk_garbage_collector_deferred_collection_push(vtkNew sself) { sself->DeferredCollectionPush(); } +extern "C" void vtk_garbage_collector_deferred_collection_pop(vtkNew sself) { sself->DeferredCollectionPop(); } +extern "C" void vtk_garbage_collector_set_global_debug_flag(vtkNew sself, bool flag) { sself->SetGlobalDebugFlag(flag); } +extern "C" bool vtk_garbage_collector_get_global_debug_flag(vtkNew sself) { return sself->GetGlobalDebugFlag(); } extern "C" vtkNew < vtkIdList > vtkIdList_new () {return vtkNew < vtkIdList > () ;} extern "C" void vtkIdList_destructor (vtkNew < vtkIdList > sself) {sself . Reset () ; return ;} extern "C" void * vtkIdList_get_ptr (vtkNew < vtkIdList > sself) {return sself . GetPointer () ;} +extern "C" void vtk_id_list_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_id_list_allocate(vtkNew sself, const long long sz, const int strategy) { return sself->Allocate(sz, strategy); } +extern "C" long long vtk_id_list_get_number_of_ids(vtkNew sself) { return sself->GetNumberOfIds(); } +extern "C" long long vtk_id_list_get_id(vtkNew sself, const long long i) { return sself->GetId(i); } +extern "C" long long vtk_id_list_find_id_location(vtkNew sself, const long long id) { return sself->FindIdLocation(id); } +extern "C" void vtk_id_list_set_number_of_ids(vtkNew sself, const long long number) { sself->SetNumberOfIds(number); } +extern "C" void vtk_id_list_set_id(vtkNew sself, const long long i, const long long vtkid) { sself->SetId(i, vtkid); } +extern "C" void vtk_id_list_insert_id(vtkNew sself, const long long i, const long long vtkid) { sself->InsertId(i, vtkid); } +extern "C" long long vtk_id_list_insert_next_id(vtkNew sself, const long long vtkid) { return sself->InsertNextId(vtkid); } +extern "C" long long vtk_id_list_insert_unique_id(vtkNew sself, const long long vtkid) { return sself->InsertUniqueId(vtkid); } +extern "C" void vtk_id_list_sort(vtkNew sself) { sself->Sort(); } +extern "C" void vtk_id_list_fill(vtkNew sself, long long value) { sself->Fill(value); } +extern "C" long long* vtk_id_list_get_pointer(vtkNew sself, const long long i) { return sself->GetPointer(i); } +extern "C" long long* vtk_id_list_write_pointer(vtkNew sself, const long long i, const long long number) { return sself->WritePointer(i, number); } +extern "C" void vtk_id_list_set_array(vtkNew sself, long long array, long long size) { sself->SetArray(array, size); } +extern "C" void vtk_id_list_reset(vtkNew sself) { sself->Reset(); } +extern "C" void vtk_id_list_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" void vtk_id_list_delete_id(vtkNew sself, long long vtkid) { sself->DeleteId(vtkid); } +extern "C" long long vtk_id_list_is_id(vtkNew sself, long long vtkid) { return sself->IsId(vtkid); } +extern "C" long long* vtk_id_list_resize(vtkNew sself, const long long sz) { return sself->Resize(sz); } +extern "C" long long* vtk_id_list_begin(vtkNew sself) { return sself->begin(); } +extern "C" long long* vtk_id_list_end(vtkNew sself) { return sself->end(); } +extern "C" const long long* vtk_id_list_begin(vtkNew sself) { return sself->begin(); } +extern "C" const long long* vtk_id_list_end(vtkNew sself) { return sself->end(); } extern "C" vtkNew < vtkIdListCollection > vtkIdListCollection_new () {return vtkNew < vtkIdListCollection > () ;} extern "C" void vtkIdListCollection_destructor (vtkNew < vtkIdListCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkIdListCollection_get_ptr (vtkNew < vtkIdListCollection > sself) {return sself . GetPointer () ;} +extern "C" int vtk_id_list_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } extern "C" vtkNew < vtkIdTypeArray > vtkIdTypeArray_new () {return vtkNew < vtkIdTypeArray > () ;} extern "C" void vtkIdTypeArray_destructor (vtkNew < vtkIdTypeArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkIdTypeArray_get_ptr (vtkNew < vtkIdTypeArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_id_type_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_id_type_array_get_typed_tuple(vtkNew sself, long long i, long long tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_id_type_array_set_typed_tuple(vtkNew sself, long long i, const long long tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_id_type_array_insert_typed_tuple(vtkNew sself, long long i, const long long tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_id_type_array_insert_next_typed_tuple(vtkNew sself, const long long tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" long long vtk_id_type_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_id_type_array_set_value(vtkNew sself, long long id, long long value) { sself->SetValue(id, value); } +extern "C" bool vtk_id_type_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_id_type_array_insert_value(vtkNew sself, long long id, long long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_id_type_array_insert_next_value(vtkNew sself, long long f) { return sself->InsertNextValue(f); } +extern "C" long long* vtk_id_type_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" long long* vtk_id_type_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" long long* vtk_id_type_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" long long* vtk_id_type_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_id_type_array_set_array(vtkNew sself, long long array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_id_type_array_set_array(vtkNew sself, long long array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" long long vtk_id_type_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" long long vtk_id_type_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkInformation > vtkInformation_new () {return vtkNew < vtkInformation > () ;} extern "C" void vtkInformation_destructor (vtkNew < vtkInformation > sself) {sself . Reset () ; return ;} extern "C" void * vtkInformation_get_ptr (vtkNew < vtkInformation > sself) {return sself . GetPointer () ;} +extern "C" void vtk_information_modified(vtkNew sself) { sself->Modified(); } +extern "C" void vtk_information_clear(vtkNew sself) { sself->Clear(); } +extern "C" int vtk_information_get_number_of_keys(vtkNew sself) { return sself->GetNumberOfKeys(); } extern "C" vtkNew < vtkInformationIterator > vtkInformationIterator_new () {return vtkNew < vtkInformationIterator > () ;} extern "C" void vtkInformationIterator_destructor (vtkNew < vtkInformationIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkInformationIterator_get_ptr (vtkNew < vtkInformationIterator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_information_iterator_init_traversal(vtkNew sself) { sself->InitTraversal(); } +extern "C" void vtk_information_iterator_go_to_first_item(vtkNew sself) { sself->GoToFirstItem(); } +extern "C" void vtk_information_iterator_go_to_next_item(vtkNew sself) { sself->GoToNextItem(); } +extern "C" int vtk_information_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } extern "C" vtkNew < vtkInformationKeyLookup > vtkInformationKeyLookup_new () {return vtkNew < vtkInformationKeyLookup > () ;} extern "C" void vtkInformationKeyLookup_destructor (vtkNew < vtkInformationKeyLookup > sself) {sself . Reset () ; return ;} extern "C" void * vtkInformationKeyLookup_get_ptr (vtkNew < vtkInformationKeyLookup > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkInformationVector > vtkInformationVector_new () {return vtkNew < vtkInformationVector > () ;} extern "C" void vtkInformationVector_destructor (vtkNew < vtkInformationVector > sself) {sself . Reset () ; return ;} extern "C" void * vtkInformationVector_get_ptr (vtkNew < vtkInformationVector > sself) {return sself . GetPointer () ;} +extern "C" int vtk_information_vector_get_number_of_information_objects(vtkNew sself) { return sself->GetNumberOfInformationObjects(); } +extern "C" void vtk_information_vector_set_number_of_information_objects(vtkNew sself, int n) { sself->SetNumberOfInformationObjects(n); } +extern "C" void vtk_information_vector_remove(vtkNew sself, int idx) { sself->Remove(idx); } extern "C" vtkNew < vtkIntArray > vtkIntArray_new () {return vtkNew < vtkIntArray > () ;} extern "C" void vtkIntArray_destructor (vtkNew < vtkIntArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkIntArray_get_ptr (vtkNew < vtkIntArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_int_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_int_array_get_typed_tuple(vtkNew sself, long long i, int tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_int_array_set_typed_tuple(vtkNew sself, long long i, const int tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_int_array_insert_typed_tuple(vtkNew sself, long long i, const int tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_int_array_insert_next_typed_tuple(vtkNew sself, const int tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" int vtk_int_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_int_array_set_value(vtkNew sself, long long id, int value) { sself->SetValue(id, value); } +extern "C" bool vtk_int_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_int_array_insert_value(vtkNew sself, long long id, int f) { sself->InsertValue(id, f); } +extern "C" long long vtk_int_array_insert_next_value(vtkNew sself, int f) { return sself->InsertNextValue(f); } +extern "C" int* vtk_int_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" int* vtk_int_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" int* vtk_int_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" int* vtk_int_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_int_array_set_array(vtkNew sself, int array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_int_array_set_array(vtkNew sself, int array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" int vtk_int_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" int vtk_int_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkLongArray > vtkLongArray_new () {return vtkNew < vtkLongArray > () ;} extern "C" void vtkLongArray_destructor (vtkNew < vtkLongArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkLongArray_get_ptr (vtkNew < vtkLongArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_long_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_long_array_get_typed_tuple(vtkNew sself, long long i, long tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_long_array_set_typed_tuple(vtkNew sself, long long i, const long tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_long_array_insert_typed_tuple(vtkNew sself, long long i, const long tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_long_array_insert_next_typed_tuple(vtkNew sself, const long tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" long vtk_long_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_long_array_set_value(vtkNew sself, long long id, long value) { sself->SetValue(id, value); } +extern "C" bool vtk_long_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_long_array_insert_value(vtkNew sself, long long id, long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_long_array_insert_next_value(vtkNew sself, long f) { return sself->InsertNextValue(f); } +extern "C" long* vtk_long_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" long* vtk_long_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" long* vtk_long_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" long* vtk_long_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_long_array_set_array(vtkNew sself, long array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_long_array_set_array(vtkNew sself, long array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" long vtk_long_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" long vtk_long_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkLongLongArray > vtkLongLongArray_new () {return vtkNew < vtkLongLongArray > () ;} extern "C" void vtkLongLongArray_destructor (vtkNew < vtkLongLongArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkLongLongArray_get_ptr (vtkNew < vtkLongLongArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_long_long_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_long_long_array_get_typed_tuple(vtkNew sself, long long i, long long tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_long_long_array_set_typed_tuple(vtkNew sself, long long i, const long long tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_long_long_array_insert_typed_tuple(vtkNew sself, long long i, const long long tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_long_long_array_insert_next_typed_tuple(vtkNew sself, const long long tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" long long vtk_long_long_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_long_long_array_set_value(vtkNew sself, long long id, long long value) { sself->SetValue(id, value); } +extern "C" bool vtk_long_long_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_long_long_array_insert_value(vtkNew sself, long long id, long long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_long_long_array_insert_next_value(vtkNew sself, long long f) { return sself->InsertNextValue(f); } +extern "C" long long* vtk_long_long_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" long long* vtk_long_long_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" long long* vtk_long_long_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" long long* vtk_long_long_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_long_long_array_set_array(vtkNew sself, long long array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_long_long_array_set_array(vtkNew sself, long long array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" long long vtk_long_long_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" long long vtk_long_long_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkLookupTable > vtkLookupTable_new () {return vtkNew < vtkLookupTable > () ;} extern "C" void vtkLookupTable_destructor (vtkNew < vtkLookupTable > sself) {sself . Reset () ; return ;} extern "C" void * vtkLookupTable_get_ptr (vtkNew < vtkLookupTable > sself) {return sself . GetPointer () ;} +extern "C" int vtk_lookup_table_is_opaque(vtkNew sself) { return sself->IsOpaque(); } +extern "C" int vtk_lookup_table_allocate(vtkNew sself, int sz, int ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_lookup_table_build(vtkNew sself) { sself->Build(); } +extern "C" void vtk_lookup_table_force_build(vtkNew sself) { sself->ForceBuild(); } +extern "C" void vtk_lookup_table_build_special_colors(vtkNew sself) { sself->BuildSpecialColors(); } +extern "C" void vtk_lookup_table_set_ramp(vtkNew sself, int _arg) { sself->SetRamp(_arg); } +extern "C" void vtk_lookup_table_set_ramp_to_linear(vtkNew sself) { sself->SetRampToLinear(); } +extern "C" void vtk_lookup_table_set_ramp_to_s_curve(vtkNew sself) { sself->SetRampToSCurve(); } +extern "C" void vtk_lookup_table_set_ramp_to_sqrt(vtkNew sself) { sself->SetRampToSQRT(); } +extern "C" int vtk_lookup_table_get_ramp(vtkNew sself) { return sself->GetRamp(); } +extern "C" void vtk_lookup_table_set_scale(vtkNew sself, int scale) { sself->SetScale(scale); } +extern "C" void vtk_lookup_table_set_scale_to_linear(vtkNew sself) { sself->SetScaleToLinear(); } +extern "C" void vtk_lookup_table_set_scale_to_log_10(vtkNew sself) { sself->SetScaleToLog10(); } +extern "C" int vtk_lookup_table_get_scale(vtkNew sself) { return sself->GetScale(); } +extern "C" void vtk_lookup_table_set_table_range(vtkNew sself, const double r) { sself->SetTableRange(r); } +extern "C" void vtk_lookup_table_set_table_range(vtkNew sself, double min, double max) { sself->SetTableRange(min, max); } +extern "C" double* vtk_lookup_table_get_table_range(vtkNew sself) { return sself->GetTableRange(); } +extern "C" void vtk_lookup_table_get_table_range(vtkNew sself, double data) { sself->GetTableRange(data); } +extern "C" void vtk_lookup_table_set_hue_range(vtkNew sself, double _arg1, double _arg2) { sself->SetHueRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_hue_range(vtkNew sself, const double _arg) { sself->SetHueRange(_arg); } +extern "C" double* vtk_lookup_table_get_hue_range(vtkNew sself) { return sself->GetHueRange(); } +extern "C" void vtk_lookup_table_get_hue_range(vtkNew sself, double _arg1, double _arg2) { sself->GetHueRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_get_hue_range(vtkNew sself, double _arg) { sself->GetHueRange(_arg); } +extern "C" void vtk_lookup_table_set_saturation_range(vtkNew sself, double _arg1, double _arg2) { sself->SetSaturationRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_saturation_range(vtkNew sself, const double _arg) { sself->SetSaturationRange(_arg); } +extern "C" double* vtk_lookup_table_get_saturation_range(vtkNew sself) { return sself->GetSaturationRange(); } +extern "C" void vtk_lookup_table_get_saturation_range(vtkNew sself, double _arg1, double _arg2) { sself->GetSaturationRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_get_saturation_range(vtkNew sself, double _arg) { sself->GetSaturationRange(_arg); } +extern "C" void vtk_lookup_table_set_value_range(vtkNew sself, double _arg1, double _arg2) { sself->SetValueRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_value_range(vtkNew sself, const double _arg) { sself->SetValueRange(_arg); } +extern "C" double* vtk_lookup_table_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" void vtk_lookup_table_get_value_range(vtkNew sself, double _arg1, double _arg2) { sself->GetValueRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_get_value_range(vtkNew sself, double _arg) { sself->GetValueRange(_arg); } +extern "C" void vtk_lookup_table_set_alpha_range(vtkNew sself, double _arg1, double _arg2) { sself->SetAlphaRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_alpha_range(vtkNew sself, const double _arg) { sself->SetAlphaRange(_arg); } +extern "C" double* vtk_lookup_table_get_alpha_range(vtkNew sself) { return sself->GetAlphaRange(); } +extern "C" void vtk_lookup_table_get_alpha_range(vtkNew sself, double _arg1, double _arg2) { sself->GetAlphaRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_get_alpha_range(vtkNew sself, double _arg) { sself->GetAlphaRange(_arg); } +extern "C" void vtk_lookup_table_set_nan_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetNanColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_set_nan_color(vtkNew sself, const double _arg) { sself->SetNanColor(_arg); } +extern "C" double* vtk_lookup_table_get_nan_color(vtkNew sself) { return sself->GetNanColor(); } +extern "C" void vtk_lookup_table_get_nan_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->GetNanColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_get_nan_color(vtkNew sself, double _arg) { sself->GetNanColor(_arg); } +extern "C" unsigned char* vtk_lookup_table_get_nan_color_as_unsigned_chars(vtkNew sself) { return sself->GetNanColorAsUnsignedChars(); } +extern "C" void vtk_lookup_table_get_color_as_unsigned_chars(vtkNew sself, const double colorIn, unsigned char colorOut) { sself->GetColorAsUnsignedChars(colorIn, colorOut); } +extern "C" void vtk_lookup_table_set_below_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetBelowRangeColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_set_below_range_color(vtkNew sself, const double _arg) { sself->SetBelowRangeColor(_arg); } +extern "C" double* vtk_lookup_table_get_below_range_color(vtkNew sself) { return sself->GetBelowRangeColor(); } +extern "C" void vtk_lookup_table_get_below_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->GetBelowRangeColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_get_below_range_color(vtkNew sself, double _arg) { sself->GetBelowRangeColor(_arg); } +extern "C" void vtk_lookup_table_set_use_below_range_color(vtkNew sself, int _arg) { sself->SetUseBelowRangeColor(_arg); } +extern "C" int vtk_lookup_table_get_use_below_range_color(vtkNew sself) { return sself->GetUseBelowRangeColor(); } +extern "C" void vtk_lookup_table_use_below_range_color_on(vtkNew sself) { sself->UseBelowRangeColorOn(); } +extern "C" void vtk_lookup_table_use_below_range_color_off(vtkNew sself) { sself->UseBelowRangeColorOff(); } +extern "C" void vtk_lookup_table_set_above_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetAboveRangeColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_set_above_range_color(vtkNew sself, const double _arg) { sself->SetAboveRangeColor(_arg); } +extern "C" double* vtk_lookup_table_get_above_range_color(vtkNew sself) { return sself->GetAboveRangeColor(); } +extern "C" void vtk_lookup_table_get_above_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->GetAboveRangeColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_get_above_range_color(vtkNew sself, double _arg) { sself->GetAboveRangeColor(_arg); } +extern "C" void vtk_lookup_table_set_use_above_range_color(vtkNew sself, int _arg) { sself->SetUseAboveRangeColor(_arg); } +extern "C" int vtk_lookup_table_get_use_above_range_color(vtkNew sself) { return sself->GetUseAboveRangeColor(); } +extern "C" void vtk_lookup_table_use_above_range_color_on(vtkNew sself) { sself->UseAboveRangeColorOn(); } +extern "C" void vtk_lookup_table_use_above_range_color_off(vtkNew sself) { sself->UseAboveRangeColorOff(); } +extern "C" const unsigned char* vtk_lookup_table_map_value(vtkNew sself, double v) { return sself->MapValue(v); } +extern "C" void vtk_lookup_table_get_color(vtkNew sself, double v, double rgb) { sself->GetColor(v, rgb); } +extern "C" double vtk_lookup_table_get_opacity(vtkNew sself, double v) { return sself->GetOpacity(v); } +extern "C" long long vtk_lookup_table_get_index(vtkNew sself, double v) { return sself->GetIndex(v); } +extern "C" void vtk_lookup_table_set_number_of_table_values(vtkNew sself, long long number) { sself->SetNumberOfTableValues(number); } +extern "C" long long vtk_lookup_table_get_number_of_table_values(vtkNew sself) { return sself->GetNumberOfTableValues(); } +extern "C" void vtk_lookup_table_set_table_value(vtkNew sself, long long indx, const double rgba) { sself->SetTableValue(indx, rgba); } +extern "C" void vtk_lookup_table_set_table_value(vtkNew sself, long long indx, double r, double g, double b, double a) { sself->SetTableValue(indx, r, g, b, a); } +extern "C" double* vtk_lookup_table_get_table_value(vtkNew sself, long long indx) { return sself->GetTableValue(indx); } +extern "C" void vtk_lookup_table_get_table_value(vtkNew sself, long long indx, double rgba) { sself->GetTableValue(indx, rgba); } +extern "C" unsigned char* vtk_lookup_table_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" unsigned char* vtk_lookup_table_write_pointer(vtkNew sself, long long id, int number) { return sself->WritePointer(id, number); } +extern "C" double* vtk_lookup_table_get_range(vtkNew sself) { return sself->GetRange(); } +extern "C" void vtk_lookup_table_get_log_range(vtkNew sself, const double range, double log_range) { sself->GetLogRange(range, log_range); } +extern "C" double vtk_lookup_table_apply_log_scale(vtkNew sself, double v, const double range, const double log_range) { return sself->ApplyLogScale(v, range, log_range); } +extern "C" void vtk_lookup_table_set_number_of_colors(vtkNew sself, long long _arg) { sself->SetNumberOfColors(_arg); } +extern "C" long long vtk_lookup_table_get_number_of_colors_min_value(vtkNew sself) { return sself->GetNumberOfColorsMinValue(); } +extern "C" long long vtk_lookup_table_get_number_of_colors_max_value(vtkNew sself) { return sself->GetNumberOfColorsMaxValue(); } +extern "C" long long vtk_lookup_table_get_number_of_colors(vtkNew sself) { return sself->GetNumberOfColors(); } +extern "C" void vtk_lookup_table_map_scalars_through_table_2(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat) { sself->MapScalarsThroughTable2(input, output, inputDataType, numberOfValues, inputIncrement, outputFormat); } +extern "C" int vtk_lookup_table_using_log_scale(vtkNew sself) { return sself->UsingLogScale(); } +extern "C" void vtk_lookup_table_get_indexed_color(vtkNew sself, long long idx, double rgba) { sself->GetIndexedColor(idx, rgba); } extern "C" vtkNew < vtkMath > vtkMath_new () {return vtkNew < vtkMath > () ;} extern "C" void vtkMath_destructor (vtkNew < vtkMath > sself) {sself . Reset () ; return ;} extern "C" void * vtkMath_get_ptr (vtkNew < vtkMath > sself) {return sself . GetPointer () ;} +extern "C" double vtk_math_pi(vtkNew sself) { return sself->Pi(); } +extern "C" float vtk_math_radians_from_degrees(vtkNew sself, float degrees) { return sself->RadiansFromDegrees(degrees); } +extern "C" double vtk_math_radians_from_degrees(vtkNew sself, double degrees) { return sself->RadiansFromDegrees(degrees); } +extern "C" float vtk_math_degrees_from_radians(vtkNew sself, float radians) { return sself->DegreesFromRadians(radians); } +extern "C" double vtk_math_degrees_from_radians(vtkNew sself, double radians) { return sself->DegreesFromRadians(radians); } +extern "C" int vtk_math_round(vtkNew sself, float f) { return sself->Round(f); } +extern "C" int vtk_math_round(vtkNew sself, double f) { return sself->Round(f); } +extern "C" int vtk_math_floor(vtkNew sself, double x) { return sself->Floor(x); } +extern "C" int vtk_math_ceil(vtkNew sself, double x) { return sself->Ceil(x); } +extern "C" int vtk_math_ceil_log_2(vtkNew sself, unsigned long long x) { return sself->CeilLog2(x); } +extern "C" bool vtk_math_is_power_of_two(vtkNew sself, unsigned long long x) { return sself->IsPowerOfTwo(x); } +extern "C" int vtk_math_nearest_power_of_two(vtkNew sself, int x) { return sself->NearestPowerOfTwo(x); } +extern "C" long long vtk_math_factorial(vtkNew sself, int N) { return sself->Factorial(N); } +extern "C" long long vtk_math_binomial(vtkNew sself, int m, int n) { return sself->Binomial(m, n); } +extern "C" int* vtk_math_begin_combination(vtkNew sself, int m, int n) { return sself->BeginCombination(m, n); } +extern "C" int vtk_math_next_combination(vtkNew sself, int m, int n, int combination) { return sself->NextCombination(m, n, combination); } +extern "C" void vtk_math_free_combination(vtkNew sself, int combination) { sself->FreeCombination(combination); } +extern "C" void vtk_math_random_seed(vtkNew sself, int s) { sself->RandomSeed(s); } +extern "C" int vtk_math_get_seed(vtkNew sself) { return sself->GetSeed(); } +extern "C" double vtk_math_random(vtkNew sself) { return sself->Random(); } +extern "C" double vtk_math_random(vtkNew sself, double min, double max) { return sself->Random(min, max); } +extern "C" double vtk_math_gaussian(vtkNew sself) { return sself->Gaussian(); } +extern "C" double vtk_math_gaussian(vtkNew sself, double mean, double std) { return sself->Gaussian(mean, std); } +extern "C" void vtk_math_assign(vtkNew sself, const double a, double b) { sself->Assign(a, b); } +extern "C" void vtk_math_add(vtkNew sself, const float a, const float b, float c) { sself->Add(a, b, c); } +extern "C" void vtk_math_add(vtkNew sself, const double a, const double b, double c) { sself->Add(a, b, c); } +extern "C" void vtk_math_subtract(vtkNew sself, const float a, const float b, float c) { sself->Subtract(a, b, c); } +extern "C" void vtk_math_subtract(vtkNew sself, const double a, const double b, double c) { sself->Subtract(a, b, c); } +extern "C" void vtk_math_multiply_scalar(vtkNew sself, float a, float s) { sself->MultiplyScalar(a, s); } +extern "C" void vtk_math_multiply_scalar_2_d(vtkNew sself, float a, float s) { sself->MultiplyScalar2D(a, s); } +extern "C" void vtk_math_multiply_scalar(vtkNew sself, double a, double s) { sself->MultiplyScalar(a, s); } +extern "C" void vtk_math_multiply_scalar_2_d(vtkNew sself, double a, double s) { sself->MultiplyScalar2D(a, s); } +extern "C" float vtk_math_dot(vtkNew sself, const float a, const float b) { return sself->Dot(a, b); } +extern "C" double vtk_math_dot(vtkNew sself, const double a, const double b) { return sself->Dot(a, b); } +extern "C" void vtk_math_outer(vtkNew sself, const float a, const float b, float c) { sself->Outer(a, b, c); } +extern "C" void vtk_math_outer(vtkNew sself, const double a, const double b, double c) { sself->Outer(a, b, c); } +extern "C" void vtk_math_cross(vtkNew sself, const float a, const float b, float c) { sself->Cross(a, b, c); } +extern "C" void vtk_math_cross(vtkNew sself, const double a, const double b, double c) { sself->Cross(a, b, c); } +extern "C" float vtk_math_norm(vtkNew sself, const float x, int n) { return sself->Norm(x, n); } +extern "C" double vtk_math_norm(vtkNew sself, const double x, int n) { return sself->Norm(x, n); } +extern "C" float vtk_math_norm(vtkNew sself, const float v) { return sself->Norm(v); } +extern "C" double vtk_math_norm(vtkNew sself, const double v) { return sself->Norm(v); } +extern "C" float vtk_math_normalize(vtkNew sself, float v) { return sself->Normalize(v); } +extern "C" double vtk_math_normalize(vtkNew sself, double v) { return sself->Normalize(v); } +extern "C" void vtk_math_perpendiculars(vtkNew sself, const double v1, double v2, double v3, double theta) { sself->Perpendiculars(v1, v2, v3, theta); } +extern "C" void vtk_math_perpendiculars(vtkNew sself, const float v1, float v2, float v3, double theta) { sself->Perpendiculars(v1, v2, v3, theta); } +extern "C" bool vtk_math_project_vector(vtkNew sself, const float a, const float b, float projection) { return sself->ProjectVector(a, b, projection); } +extern "C" bool vtk_math_project_vector(vtkNew sself, const double a, const double b, double projection) { return sself->ProjectVector(a, b, projection); } +extern "C" bool vtk_math_project_vector_2_d(vtkNew sself, const float a, const float b, float projection) { return sself->ProjectVector2D(a, b, projection); } +extern "C" bool vtk_math_project_vector_2_d(vtkNew sself, const double a, const double b, double projection) { return sself->ProjectVector2D(a, b, projection); } +extern "C" float vtk_math_distance_2_between_points(vtkNew sself, const float p1, const float p2) { return sself->Distance2BetweenPoints(p1, p2); } +extern "C" double vtk_math_distance_2_between_points(vtkNew sself, const double p1, const double p2) { return sself->Distance2BetweenPoints(p1, p2); } +extern "C" double vtk_math_angle_between_vectors(vtkNew sself, const double v1, const double v2) { return sself->AngleBetweenVectors(v1, v2); } +extern "C" double vtk_math_signed_angle_between_vectors(vtkNew sself, const double v1, const double v2, const double vn) { return sself->SignedAngleBetweenVectors(v1, v2, vn); } +extern "C" double vtk_math_gaussian_amplitude(vtkNew sself, const double variance, const double distanceFromMean) { return sself->GaussianAmplitude(variance, distanceFromMean); } +extern "C" double vtk_math_gaussian_amplitude(vtkNew sself, const double mean, const double variance, const double position) { return sself->GaussianAmplitude(mean, variance, position); } +extern "C" double vtk_math_gaussian_weight(vtkNew sself, const double variance, const double distanceFromMean) { return sself->GaussianWeight(variance, distanceFromMean); } +extern "C" double vtk_math_gaussian_weight(vtkNew sself, const double mean, const double variance, const double position) { return sself->GaussianWeight(mean, variance, position); } +extern "C" float vtk_math_dot_2_d(vtkNew sself, const float x, const float y) { return sself->Dot2D(x, y); } +extern "C" double vtk_math_dot_2_d(vtkNew sself, const double x, const double y) { return sself->Dot2D(x, y); } +extern "C" void vtk_math_outer_2_d(vtkNew sself, const float x, const float y, float A) { sself->Outer2D(x, y, A); } +extern "C" void vtk_math_outer_2_d(vtkNew sself, const double x, const double y, double A) { sself->Outer2D(x, y, A); } +extern "C" float vtk_math_norm_2_d(vtkNew sself, const float x) { return sself->Norm2D(x); } +extern "C" double vtk_math_norm_2_d(vtkNew sself, const double x) { return sself->Norm2D(x); } +extern "C" float vtk_math_normalize_2_d(vtkNew sself, float v) { return sself->Normalize2D(v); } +extern "C" double vtk_math_normalize_2_d(vtkNew sself, double v) { return sself->Normalize2D(v); } +extern "C" float vtk_math_determinant_2_x_2(vtkNew sself, const float c1, const float c2) { return sself->Determinant2x2(c1, c2); } +extern "C" double vtk_math_determinant_2_x_2(vtkNew sself, double a, double b, double c, double d) { return sself->Determinant2x2(a, b, c, d); } +extern "C" double vtk_math_determinant_2_x_2(vtkNew sself, const double c1, const double c2) { return sself->Determinant2x2(c1, c2); } +extern "C" void vtk_math_lu_factor_3_x_3(vtkNew sself, float A, int index) { sself->LUFactor3x3(A, index); } +extern "C" void vtk_math_lu_factor_3_x_3(vtkNew sself, double A, int index) { sself->LUFactor3x3(A, index); } +extern "C" void vtk_math_lu_solve_3_x_3(vtkNew sself, const float A, const int index, float x) { sself->LUSolve3x3(A, index, x); } +extern "C" void vtk_math_lu_solve_3_x_3(vtkNew sself, const double A, const int index, double x) { sself->LUSolve3x3(A, index, x); } +extern "C" void vtk_math_linear_solve_3_x_3(vtkNew sself, const float A, const float x, float y) { sself->LinearSolve3x3(A, x, y); } +extern "C" void vtk_math_linear_solve_3_x_3(vtkNew sself, const double A, const double x, double y) { sself->LinearSolve3x3(A, x, y); } +extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const float A, const float v, float u) { sself->Multiply3x3(A, v, u); } +extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const double A, const double v, double u) { sself->Multiply3x3(A, v, u); } +extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const float A, const float B, float C) { sself->Multiply3x3(A, B, C); } +extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const double A, const double B, double C) { sself->Multiply3x3(A, B, C); } +extern "C" void vtk_math_multiply_matrix(vtkNew sself, const double A, const double B, unsigned int rowA, unsigned int colA, unsigned int rowB, unsigned int colB, double C) { sself->MultiplyMatrix(A, B, rowA, colA, rowB, colB, C); } +extern "C" void vtk_math_transpose_3_x_3(vtkNew sself, const float A, float AT) { sself->Transpose3x3(A, AT); } +extern "C" void vtk_math_transpose_3_x_3(vtkNew sself, const double A, double AT) { sself->Transpose3x3(A, AT); } +extern "C" void vtk_math_invert_3_x_3(vtkNew sself, const float A, float AI) { sself->Invert3x3(A, AI); } +extern "C" void vtk_math_invert_3_x_3(vtkNew sself, const double A, double AI) { sself->Invert3x3(A, AI); } +extern "C" void vtk_math_identity_3_x_3(vtkNew sself, float A) { sself->Identity3x3(A); } +extern "C" void vtk_math_identity_3_x_3(vtkNew sself, double A) { sself->Identity3x3(A); } +extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const float A) { return sself->Determinant3x3(A); } +extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const double A) { return sself->Determinant3x3(A); } +extern "C" float vtk_math_determinant_3_x_3(vtkNew sself, const float c1, const float c2, const float c3) { return sself->Determinant3x3(c1, c2, c3); } +extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const double c1, const double c2, const double c3) { return sself->Determinant3x3(c1, c2, c3); } +extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3) { return sself->Determinant3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3); } +extern "C" void vtk_math_quaternion_to_matrix_3_x_3(vtkNew sself, const float quat, float A) { sself->QuaternionToMatrix3x3(quat, A); } +extern "C" void vtk_math_quaternion_to_matrix_3_x_3(vtkNew sself, const double quat, double A) { sself->QuaternionToMatrix3x3(quat, A); } +extern "C" void vtk_math_matrix_3_x_3_to_quaternion(vtkNew sself, const float A, float quat) { sself->Matrix3x3ToQuaternion(A, quat); } +extern "C" void vtk_math_matrix_3_x_3_to_quaternion(vtkNew sself, const double A, double quat) { sself->Matrix3x3ToQuaternion(A, quat); } +extern "C" void vtk_math_multiply_quaternion(vtkNew sself, const float q1, const float q2, float q) { sself->MultiplyQuaternion(q1, q2, q); } +extern "C" void vtk_math_multiply_quaternion(vtkNew sself, const double q1, const double q2, double q) { sself->MultiplyQuaternion(q1, q2, q); } +extern "C" void vtk_math_rotate_vector_by_normalized_quaternion(vtkNew sself, const float v, const float q, float r) { sself->RotateVectorByNormalizedQuaternion(v, q, r); } +extern "C" void vtk_math_rotate_vector_by_normalized_quaternion(vtkNew sself, const double v, const double q, double r) { sself->RotateVectorByNormalizedQuaternion(v, q, r); } +extern "C" void vtk_math_rotate_vector_by_wxyz(vtkNew sself, const float v, const float q, float r) { sself->RotateVectorByWXYZ(v, q, r); } +extern "C" void vtk_math_rotate_vector_by_wxyz(vtkNew sself, const double v, const double q, double r) { sself->RotateVectorByWXYZ(v, q, r); } +extern "C" void vtk_math_orthogonalize_3_x_3(vtkNew sself, const float A, float B) { sself->Orthogonalize3x3(A, B); } +extern "C" void vtk_math_orthogonalize_3_x_3(vtkNew sself, const double A, double B) { sself->Orthogonalize3x3(A, B); } +extern "C" void vtk_math_diagonalize_3_x_3(vtkNew sself, const float A, float w, float V) { sself->Diagonalize3x3(A, w, V); } +extern "C" void vtk_math_diagonalize_3_x_3(vtkNew sself, const double A, double w, double V) { sself->Diagonalize3x3(A, w, V); } +extern "C" void vtk_math_singular_value_decomposition_3_x_3(vtkNew sself, const float A, float U, float w, float VT) { sself->SingularValueDecomposition3x3(A, U, w, VT); } +extern "C" void vtk_math_singular_value_decomposition_3_x_3(vtkNew sself, const double A, double U, double w, double VT) { sself->SingularValueDecomposition3x3(A, U, w, VT); } +extern "C" int vtk_math_solve_linear_system_gepp_2_x_2(vtkNew sself, double a00, double a01, double a10, double a11, double b0, double b1, double x0, double x1) { return sself->SolveLinearSystemGEPP2x2(a00, a01, a10, a11, b0, b1, x0, x1); } +extern "C" int vtk_math_solve_linear_system(vtkNew sself, double A, double x, int size) { return sself->SolveLinearSystem(A, x, size); } +extern "C" int vtk_math_invert_matrix(vtkNew sself, double A, double AI, int size) { return sself->InvertMatrix(A, AI, size); } +extern "C" int vtk_math_invert_matrix(vtkNew sself, double A, double AI, int size, int tmp1Size, double tmp2Size) { return sself->InvertMatrix(A, AI, size, tmp1Size, tmp2Size); } +extern "C" int vtk_math_lu_factor_linear_system(vtkNew sself, double A, int index, int size) { return sself->LUFactorLinearSystem(A, index, size); } +extern "C" int vtk_math_lu_factor_linear_system(vtkNew sself, double A, int index, int size, double tmpSize) { return sself->LUFactorLinearSystem(A, index, size, tmpSize); } +extern "C" void vtk_math_lu_solve_linear_system(vtkNew sself, double A, int index, double x, int size) { sself->LUSolveLinearSystem(A, index, x, size); } +extern "C" double vtk_math_estimate_matrix_condition(vtkNew sself, const double A, int size) { return sself->EstimateMatrixCondition(A, size); } +extern "C" int vtk_math_jacobi(vtkNew sself, float a, float w, float v) { return sself->Jacobi(a, w, v); } +extern "C" int vtk_math_jacobi(vtkNew sself, double a, double w, double v) { return sself->Jacobi(a, w, v); } +extern "C" int vtk_math_jacobi_n(vtkNew sself, float a, int n, float w, float v) { return sself->JacobiN(a, n, w, v); } +extern "C" int vtk_math_jacobi_n(vtkNew sself, double a, int n, double w, double v) { return sself->JacobiN(a, n, w, v); } +extern "C" int vtk_math_solve_homogeneous_least_squares(vtkNew sself, int numberOfSamples, double xt, int xOrder, double mt) { return sself->SolveHomogeneousLeastSquares(numberOfSamples, xt, xOrder, mt); } +extern "C" int vtk_math_solve_least_squares(vtkNew sself, int numberOfSamples, double xt, int xOrder, double yt, int yOrder, double mt, int checkHomogeneous) { return sself->SolveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt, checkHomogeneous); } +extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, const float rgb, float hsv) { sself->RGBToHSV(rgb, hsv); } +extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, float r, float g, float b, float h, float s, float v) { sself->RGBToHSV(r, g, b, h, s, v); } +extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, const double rgb, double hsv) { sself->RGBToHSV(rgb, hsv); } +extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, double r, double g, double b, double h, double s, double v) { sself->RGBToHSV(r, g, b, h, s, v); } +extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, const float hsv, float rgb) { sself->HSVToRGB(hsv, rgb); } +extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, float h, float s, float v, float r, float g, float b) { sself->HSVToRGB(h, s, v, r, g, b); } +extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, const double hsv, double rgb) { sself->HSVToRGB(hsv, rgb); } +extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, double h, double s, double v, double r, double g, double b) { sself->HSVToRGB(h, s, v, r, g, b); } +extern "C" void vtk_math_lab_to_xyz(vtkNew sself, const double lab, double xyz) { sself->LabToXYZ(lab, xyz); } +extern "C" void vtk_math_lab_to_xyz(vtkNew sself, double L, double a, double b, double x, double y, double z) { sself->LabToXYZ(L, a, b, x, y, z); } +extern "C" void vtk_math_xyz_to_lab(vtkNew sself, const double xyz, double lab) { sself->XYZToLab(xyz, lab); } +extern "C" void vtk_math_xyz_to_lab(vtkNew sself, double x, double y, double z, double L, double a, double b) { sself->XYZToLab(x, y, z, L, a, b); } +extern "C" void vtk_math_xyz_to_rgb(vtkNew sself, const double xyz, double rgb) { sself->XYZToRGB(xyz, rgb); } +extern "C" void vtk_math_xyz_to_rgb(vtkNew sself, double x, double y, double z, double r, double g, double b) { sself->XYZToRGB(x, y, z, r, g, b); } +extern "C" void vtk_math_rgb_to_xyz(vtkNew sself, const double rgb, double xyz) { sself->RGBToXYZ(rgb, xyz); } +extern "C" void vtk_math_rgb_to_xyz(vtkNew sself, double r, double g, double b, double x, double y, double z) { sself->RGBToXYZ(r, g, b, x, y, z); } +extern "C" void vtk_math_rgb_to_lab(vtkNew sself, const double rgb, double lab) { sself->RGBToLab(rgb, lab); } +extern "C" void vtk_math_rgb_to_lab(vtkNew sself, double red, double green, double blue, double L, double a, double b) { sself->RGBToLab(red, green, blue, L, a, b); } +extern "C" void vtk_math_lab_to_rgb(vtkNew sself, const double lab, double rgb) { sself->LabToRGB(lab, rgb); } +extern "C" void vtk_math_lab_to_rgb(vtkNew sself, double L, double a, double b, double red, double green, double blue) { sself->LabToRGB(L, a, b, red, green, blue); } +extern "C" void vtk_math_uninitialize_bounds(vtkNew sself, double bounds) { sself->UninitializeBounds(bounds); } +extern "C" int vtk_math_are_bounds_initialized(vtkNew sself, const double bounds) { return sself->AreBoundsInitialized(bounds); } +extern "C" void vtk_math_clamp_value(vtkNew sself, double value, const double range) { sself->ClampValue(value, range); } +extern "C" void vtk_math_clamp_value(vtkNew sself, double value, const double range, double clamped_value) { sself->ClampValue(value, range, clamped_value); } +extern "C" void vtk_math_clamp_values(vtkNew sself, double values, int nb_values, const double range) { sself->ClampValues(values, nb_values, range); } +extern "C" void vtk_math_clamp_values(vtkNew sself, const double values, int nb_values, const double range, double clamped_values) { sself->ClampValues(values, nb_values, range, clamped_values); } +extern "C" double vtk_math_clamp_and_normalize_value(vtkNew sself, double value, const double range) { return sself->ClampAndNormalizeValue(value, range); } +extern "C" int vtk_math_get_scalar_type_fitting_range(vtkNew sself, double range_min, double range_max, double scale, double shift) { return sself->GetScalarTypeFittingRange(range_min, range_max, scale, shift); } +extern "C" int vtk_math_extent_is_within_other_extent(vtkNew sself, const int extent1, const int extent2) { return sself->ExtentIsWithinOtherExtent(extent1, extent2); } +extern "C" int vtk_math_bounds_is_within_other_bounds(vtkNew sself, const double bounds1, const double bounds2, const double delta) { return sself->BoundsIsWithinOtherBounds(bounds1, bounds2, delta); } +extern "C" int vtk_math_point_is_within_bounds(vtkNew sself, const double point, const double bounds, const double delta) { return sself->PointIsWithinBounds(point, bounds, delta); } +extern "C" int vtk_math_plane_intersects_aabb(vtkNew sself, const double bounds, const double normal, const double point) { return sself->PlaneIntersectsAABB(bounds, normal, point); } +extern "C" double vtk_math_solve_3_point_circle(vtkNew sself, const double p1, const double p2, const double p3, double center) { return sself->Solve3PointCircle(p1, p2, p3, center); } +extern "C" double vtk_math_inf(vtkNew sself) { return sself->Inf(); } +extern "C" double vtk_math_neg_inf(vtkNew sself) { return sself->NegInf(); } +extern "C" double vtk_math_nan(vtkNew sself) { return sself->Nan(); } +extern "C" int vtk_math_is_inf(vtkNew sself, double x) { return sself->IsInf(x); } +extern "C" int vtk_math_is_nan(vtkNew sself, double x) { return sself->IsNan(x); } +extern "C" bool vtk_math_is_finite(vtkNew sself, double x) { return sself->IsFinite(x); } +extern "C" int vtk_math_quadratic_root(vtkNew sself, double a, double b, double c, double min, double max, double u) { return sself->QuadraticRoot(a, b, c, min, max, u); } extern "C" vtkNew < vtkMersenneTwister > vtkMersenneTwister_new () {return vtkNew < vtkMersenneTwister > () ;} extern "C" void vtkMersenneTwister_destructor (vtkNew < vtkMersenneTwister > sself) {sself . Reset () ; return ;} extern "C" void * vtkMersenneTwister_get_ptr (vtkNew < vtkMersenneTwister > sself) {return sself . GetPointer () ;} +extern "C" void vtk_mersenne_twister_initialize(vtkNew sself, unsigned int seed) { sself->Initialize(seed); } +extern "C" unsigned int vtk_mersenne_twister_initialize_new_sequence(vtkNew sself, unsigned int seed, int p) { return sself->InitializeNewSequence(seed, p); } +extern "C" void vtk_mersenne_twister_initialize_sequence(vtkNew sself, unsigned int id, unsigned int seed, int p) { sself->InitializeSequence(id, seed, p); } +extern "C" double vtk_mersenne_twister_get_value(vtkNew sself, unsigned int id) { return sself->GetValue(id); } +extern "C" double vtk_mersenne_twister_get_value(vtkNew sself) { return sself->GetValue(); } +extern "C" void vtk_mersenne_twister_next(vtkNew sself, unsigned int id) { sself->Next(id); } +extern "C" void vtk_mersenne_twister_next(vtkNew sself) { sself->Next(); } extern "C" vtkNew < vtkMinimalStandardRandomSequence > vtkMinimalStandardRandomSequence_new () {return vtkNew < vtkMinimalStandardRandomSequence > () ;} extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkNew < vtkMinimalStandardRandomSequence > sself) {sself . Reset () ; return ;} extern "C" void * vtkMinimalStandardRandomSequence_get_ptr (vtkNew < vtkMinimalStandardRandomSequence > sself) {return sself . GetPointer () ;} +extern "C" void vtk_minimal_standard_random_sequence_initialize(vtkNew sself, unsigned int seed) { sself->Initialize(seed); } +extern "C" void vtk_minimal_standard_random_sequence_set_seed(vtkNew sself, int value) { sself->SetSeed(value); } +extern "C" void vtk_minimal_standard_random_sequence_set_seed_only(vtkNew sself, int value) { sself->SetSeedOnly(value); } +extern "C" int vtk_minimal_standard_random_sequence_get_seed(vtkNew sself) { return sself->GetSeed(); } +extern "C" double vtk_minimal_standard_random_sequence_get_value(vtkNew sself) { return sself->GetValue(); } +extern "C" void vtk_minimal_standard_random_sequence_next(vtkNew sself) { sself->Next(); } +extern "C" double vtk_minimal_standard_random_sequence_get_range_value(vtkNew sself, double rangeMin, double rangeMax) { return sself->GetRangeValue(rangeMin, rangeMax); } +extern "C" double vtk_minimal_standard_random_sequence_get_next_range_value(vtkNew sself, double rangeMin, double rangeMax) { return sself->GetNextRangeValue(rangeMin, rangeMax); } extern "C" vtkNew < vtkMultiThreader > vtkMultiThreader_new () {return vtkNew < vtkMultiThreader > () ;} extern "C" void vtkMultiThreader_destructor (vtkNew < vtkMultiThreader > sself) {sself . Reset () ; return ;} extern "C" void * vtkMultiThreader_get_ptr (vtkNew < vtkMultiThreader > sself) {return sself . GetPointer () ;} +extern "C" void vtk_multi_threader_set_number_of_threads(vtkNew sself, int _arg) { sself->SetNumberOfThreads(_arg); } +extern "C" int vtk_multi_threader_get_number_of_threads_min_value(vtkNew sself) { return sself->GetNumberOfThreadsMinValue(); } +extern "C" int vtk_multi_threader_get_number_of_threads_max_value(vtkNew sself) { return sself->GetNumberOfThreadsMaxValue(); } +extern "C" int vtk_multi_threader_get_number_of_threads(vtkNew sself) { return sself->GetNumberOfThreads(); } +extern "C" int vtk_multi_threader_get_global_static_maximum_number_of_threads(vtkNew sself) { return sself->GetGlobalStaticMaximumNumberOfThreads(); } +extern "C" void vtk_multi_threader_set_global_maximum_number_of_threads(vtkNew sself, int val) { sself->SetGlobalMaximumNumberOfThreads(val); } +extern "C" int vtk_multi_threader_get_global_maximum_number_of_threads(vtkNew sself) { return sself->GetGlobalMaximumNumberOfThreads(); } +extern "C" void vtk_multi_threader_set_global_default_number_of_threads(vtkNew sself, int val) { sself->SetGlobalDefaultNumberOfThreads(val); } +extern "C" int vtk_multi_threader_get_global_default_number_of_threads(vtkNew sself) { return sself->GetGlobalDefaultNumberOfThreads(); } +extern "C" void vtk_multi_threader_single_method_execute(vtkNew sself) { sself->SingleMethodExecute(); } +extern "C" void vtk_multi_threader_multiple_method_execute(vtkNew sself) { sself->MultipleMethodExecute(); } +extern "C" void vtk_multi_threader_terminate_thread(vtkNew sself, int threadId) { sself->TerminateThread(threadId); } +extern "C" int vtk_multi_threader_is_thread_active(vtkNew sself, int threadId) { return sself->IsThreadActive(threadId); } extern "C" vtkNew < vtkObject > vtkObject_new () {return vtkNew < vtkObject > () ;} extern "C" void vtkObject_destructor (vtkNew < vtkObject > sself) {sself . Reset () ; return ;} extern "C" void * vtkObject_get_ptr (vtkNew < vtkObject > sself) {return sself . GetPointer () ;} +extern "C" int vtk_object_is_type_of(vtkNew sself, const char type) { return sself->IsTypeOf(type); } +extern "C" int vtk_object_is_a(vtkNew sself, const char type) { return sself->IsA(type); } +extern "C" long long vtk_object_get_number_of_generations_from_base_type(vtkNew sself, const char type) { return sself->GetNumberOfGenerationsFromBaseType(type); } +extern "C" long long vtk_object_get_number_of_generations_from_base(vtkNew sself, const char type) { return sself->GetNumberOfGenerationsFromBase(type); } +extern "C" void vtk_object_debug_on(vtkNew sself) { sself->DebugOn(); } +extern "C" void vtk_object_debug_off(vtkNew sself) { sself->DebugOff(); } +extern "C" bool vtk_object_get_debug(vtkNew sself) { return sself->GetDebug(); } +extern "C" void vtk_object_set_debug(vtkNew sself, bool debugFlag) { sself->SetDebug(debugFlag); } +extern "C" void vtk_object_break_on_error(vtkNew sself) { sself->BreakOnError(); } +extern "C" void vtk_object_modified(vtkNew sself) { sself->Modified(); } +extern "C" unsigned long vtk_object_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_object_set_global_warning_display(vtkNew sself, int val) { sself->SetGlobalWarningDisplay(val); } +extern "C" void vtk_object_global_warning_display_on(vtkNew sself) { sself->GlobalWarningDisplayOn(); } +extern "C" void vtk_object_global_warning_display_off(vtkNew sself) { sself->GlobalWarningDisplayOff(); } +extern "C" int vtk_object_get_global_warning_display(vtkNew sself) { return sself->GetGlobalWarningDisplay(); } +extern "C" void vtk_object_remove_observer(vtkNew sself, unsigned long tag) { sself->RemoveObserver(tag); } +extern "C" void vtk_object_remove_observers(vtkNew sself, unsigned long event) { sself->RemoveObservers(event); } +extern "C" void vtk_object_remove_observers(vtkNew sself, const char event) { sself->RemoveObservers(event); } +extern "C" void vtk_object_remove_all_observers(vtkNew sself) { sself->RemoveAllObservers(); } +extern "C" int vtk_object_has_observer(vtkNew sself, unsigned long event) { return sself->HasObserver(event); } +extern "C" int vtk_object_has_observer(vtkNew sself, const char event) { return sself->HasObserver(event); } +extern "C" int vtk_object_invoke_event(vtkNew sself, unsigned long event, void callData) { return sself->InvokeEvent(event, callData); } +extern "C" int vtk_object_invoke_event(vtkNew sself, const char event, void callData) { return sself->InvokeEvent(event, callData); } +extern "C" int vtk_object_invoke_event(vtkNew sself, unsigned long event) { return sself->InvokeEvent(event); } +extern "C" int vtk_object_invoke_event(vtkNew sself, const char event) { return sself->InvokeEvent(event); } extern "C" vtkNew < vtkObjectFactoryCollection > vtkObjectFactoryCollection_new () {return vtkNew < vtkObjectFactoryCollection > () ;} extern "C" void vtkObjectFactoryCollection_destructor (vtkNew < vtkObjectFactoryCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkObjectFactoryCollection_get_ptr (vtkNew < vtkObjectFactoryCollection > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkOldStyleCallbackCommand > vtkOldStyleCallbackCommand_new () {return vtkNew < vtkOldStyleCallbackCommand > () ;} extern "C" void vtkOldStyleCallbackCommand_destructor (vtkNew < vtkOldStyleCallbackCommand > sself) {sself . Reset () ; return ;} extern "C" void * vtkOldStyleCallbackCommand_get_ptr (vtkNew < vtkOldStyleCallbackCommand > sself) {return sself . GetPointer () ;} +extern "C" void vtk_old_style_callback_command_set_client_data(vtkNew sself, void cd) { sself->SetClientData(cd); } extern "C" vtkNew < vtkOutputWindow > vtkOutputWindow_new () {return vtkNew < vtkOutputWindow > () ;} extern "C" void vtkOutputWindow_destructor (vtkNew < vtkOutputWindow > sself) {sself . Reset () ; return ;} extern "C" void * vtkOutputWindow_get_ptr (vtkNew < vtkOutputWindow > sself) {return sself . GetPointer () ;} +extern "C" void vtk_output_window_display_text(vtkNew sself, const char p0) { sself->DisplayText(p0); } +extern "C" void vtk_output_window_display_error_text(vtkNew sself, const char p0) { sself->DisplayErrorText(p0); } +extern "C" void vtk_output_window_display_warning_text(vtkNew sself, const char p0) { sself->DisplayWarningText(p0); } +extern "C" void vtk_output_window_display_generic_warning_text(vtkNew sself, const char p0) { sself->DisplayGenericWarningText(p0); } +extern "C" void vtk_output_window_display_debug_text(vtkNew sself, const char p0) { sself->DisplayDebugText(p0); } +extern "C" void vtk_output_window_prompt_user_on(vtkNew sself) { sself->PromptUserOn(); } +extern "C" void vtk_output_window_prompt_user_off(vtkNew sself) { sself->PromptUserOff(); } +extern "C" void vtk_output_window_set_prompt_user(vtkNew sself, bool _arg) { sself->SetPromptUser(_arg); } +extern "C" void vtk_output_window_set_use_std_error_for_all_messages(vtkNew sself, bool p0) { sself->SetUseStdErrorForAllMessages(p0); } +extern "C" bool vtk_output_window_get_use_std_error_for_all_messages(vtkNew sself) { return sself->GetUseStdErrorForAllMessages(); } +extern "C" void vtk_output_window_use_std_error_for_all_messages_on(vtkNew sself) { sself->UseStdErrorForAllMessagesOn(); } +extern "C" void vtk_output_window_use_std_error_for_all_messages_off(vtkNew sself) { sself->UseStdErrorForAllMessagesOff(); } +extern "C" void vtk_output_window_set_display_mode(vtkNew sself, int _arg) { sself->SetDisplayMode(_arg); } +extern "C" int vtk_output_window_get_display_mode_min_value(vtkNew sself) { return sself->GetDisplayModeMinValue(); } +extern "C" int vtk_output_window_get_display_mode_max_value(vtkNew sself) { return sself->GetDisplayModeMaxValue(); } +extern "C" int vtk_output_window_get_display_mode(vtkNew sself) { return sself->GetDisplayMode(); } +extern "C" void vtk_output_window_set_display_mode_to_default(vtkNew sself) { sself->SetDisplayModeToDefault(); } +extern "C" void vtk_output_window_set_display_mode_to_never(vtkNew sself) { sself->SetDisplayModeToNever(); } +extern "C" void vtk_output_window_set_display_mode_to_always(vtkNew sself) { sself->SetDisplayModeToAlways(); } +extern "C" void vtk_output_window_set_display_mode_to_always_std_err(vtkNew sself) { sself->SetDisplayModeToAlwaysStdErr(); } extern "C" vtkNew < vtkOverrideInformationCollection > vtkOverrideInformationCollection_new () {return vtkNew < vtkOverrideInformationCollection > () ;} extern "C" void vtkOverrideInformationCollection_destructor (vtkNew < vtkOverrideInformationCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkOverrideInformationCollection_get_ptr (vtkNew < vtkOverrideInformationCollection > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkPoints > vtkPoints_new () {return vtkNew < vtkPoints > () ;} extern "C" void vtkPoints_destructor (vtkNew < vtkPoints > sself) {sself . Reset () ; return ;} extern "C" void * vtkPoints_get_ptr (vtkNew < vtkPoints > sself) {return sself . GetPointer () ;} +extern "C" int vtk_points_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_points_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_points_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_points_set_data_type(vtkNew sself, int dataType) { sself->SetDataType(dataType); } +extern "C" void vtk_points_set_data_type_to_bit(vtkNew sself) { sself->SetDataTypeToBit(); } +extern "C" void vtk_points_set_data_type_to_char(vtkNew sself) { sself->SetDataTypeToChar(); } +extern "C" void vtk_points_set_data_type_to_unsigned_char(vtkNew sself) { sself->SetDataTypeToUnsignedChar(); } +extern "C" void vtk_points_set_data_type_to_short(vtkNew sself) { sself->SetDataTypeToShort(); } +extern "C" void vtk_points_set_data_type_to_unsigned_short(vtkNew sself) { sself->SetDataTypeToUnsignedShort(); } +extern "C" void vtk_points_set_data_type_to_int(vtkNew sself) { sself->SetDataTypeToInt(); } +extern "C" void vtk_points_set_data_type_to_unsigned_int(vtkNew sself) { sself->SetDataTypeToUnsignedInt(); } +extern "C" void vtk_points_set_data_type_to_long(vtkNew sself) { sself->SetDataTypeToLong(); } +extern "C" void vtk_points_set_data_type_to_unsigned_long(vtkNew sself) { sself->SetDataTypeToUnsignedLong(); } +extern "C" void vtk_points_set_data_type_to_float(vtkNew sself) { sself->SetDataTypeToFloat(); } +extern "C" void vtk_points_set_data_type_to_double(vtkNew sself) { sself->SetDataTypeToDouble(); } +extern "C" void* vtk_points_get_void_pointer(vtkNew sself, const int id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_points_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" void vtk_points_reset(vtkNew sself) { sself->Reset(); } +extern "C" unsigned long vtk_points_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" long long vtk_points_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" double* vtk_points_get_point(vtkNew sself, long long id) { return sself->GetPoint(id); } +extern "C" void vtk_points_get_point(vtkNew sself, long long id, double x) { sself->GetPoint(id, x); } +extern "C" void vtk_points_set_point(vtkNew sself, long long id, const float x) { sself->SetPoint(id, x); } +extern "C" void vtk_points_set_point(vtkNew sself, long long id, const double x) { sself->SetPoint(id, x); } +extern "C" void vtk_points_set_point(vtkNew sself, long long id, double x, double y, double z) { sself->SetPoint(id, x, y, z); } +extern "C" void vtk_points_insert_point(vtkNew sself, long long id, const float x) { sself->InsertPoint(id, x); } +extern "C" void vtk_points_insert_point(vtkNew sself, long long id, const double x) { sself->InsertPoint(id, x); } +extern "C" void vtk_points_insert_point(vtkNew sself, long long id, double x, double y, double z) { sself->InsertPoint(id, x, y, z); } +extern "C" long long vtk_points_insert_next_point(vtkNew sself, const float x) { return sself->InsertNextPoint(x); } +extern "C" long long vtk_points_insert_next_point(vtkNew sself, const double x) { return sself->InsertNextPoint(x); } +extern "C" long long vtk_points_insert_next_point(vtkNew sself, double x, double y, double z) { return sself->InsertNextPoint(x, y, z); } +extern "C" void vtk_points_set_number_of_points(vtkNew sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } +extern "C" int vtk_points_resize(vtkNew sself, long long numPoints) { return sself->Resize(numPoints); } +extern "C" void vtk_points_compute_bounds(vtkNew sself) { sself->ComputeBounds(); } +extern "C" double* vtk_points_get_bounds(vtkNew sself) { return sself->GetBounds(); } +extern "C" void vtk_points_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" unsigned long vtk_points_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_points_modified(vtkNew sself) { sself->Modified(); } extern "C" vtkNew < vtkPoints2D > vtkPoints2D_new () {return vtkNew < vtkPoints2D > () ;} extern "C" void vtkPoints2D_destructor (vtkNew < vtkPoints2D > sself) {sself . Reset () ; return ;} extern "C" void * vtkPoints2D_get_ptr (vtkNew < vtkPoints2D > sself) {return sself . GetPointer () ;} +extern "C" int vtk_points_2_d_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_points_2_d_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_points_2_d_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_points_2_d_set_data_type(vtkNew sself, int dataType) { sself->SetDataType(dataType); } +extern "C" void vtk_points_2_d_set_data_type_to_bit(vtkNew sself) { sself->SetDataTypeToBit(); } +extern "C" void vtk_points_2_d_set_data_type_to_char(vtkNew sself) { sself->SetDataTypeToChar(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_char(vtkNew sself) { sself->SetDataTypeToUnsignedChar(); } +extern "C" void vtk_points_2_d_set_data_type_to_short(vtkNew sself) { sself->SetDataTypeToShort(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_short(vtkNew sself) { sself->SetDataTypeToUnsignedShort(); } +extern "C" void vtk_points_2_d_set_data_type_to_int(vtkNew sself) { sself->SetDataTypeToInt(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_int(vtkNew sself) { sself->SetDataTypeToUnsignedInt(); } +extern "C" void vtk_points_2_d_set_data_type_to_long(vtkNew sself) { sself->SetDataTypeToLong(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_long(vtkNew sself) { sself->SetDataTypeToUnsignedLong(); } +extern "C" void vtk_points_2_d_set_data_type_to_float(vtkNew sself) { sself->SetDataTypeToFloat(); } +extern "C" void vtk_points_2_d_set_data_type_to_double(vtkNew sself) { sself->SetDataTypeToDouble(); } +extern "C" void* vtk_points_2_d_get_void_pointer(vtkNew sself, const int id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_points_2_d_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" void vtk_points_2_d_reset(vtkNew sself) { sself->Reset(); } +extern "C" unsigned long vtk_points_2_d_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" long long vtk_points_2_d_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" double* vtk_points_2_d_get_point(vtkNew sself, long long id) { return sself->GetPoint(id); } +extern "C" void vtk_points_2_d_get_point(vtkNew sself, long long id, double x) { sself->GetPoint(id, x); } +extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, const float x) { sself->SetPoint(id, x); } +extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, const double x) { sself->SetPoint(id, x); } +extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, double x, double y) { sself->SetPoint(id, x, y); } +extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, const float x) { sself->InsertPoint(id, x); } +extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, const double x) { sself->InsertPoint(id, x); } +extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, double x, double y) { sself->InsertPoint(id, x, y); } +extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, const float x) { return sself->InsertNextPoint(x); } +extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, const double x) { return sself->InsertNextPoint(x); } +extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, double x, double y) { return sself->InsertNextPoint(x, y); } +extern "C" void vtk_points_2_d_remove_point(vtkNew sself, long long id) { sself->RemovePoint(id); } +extern "C" void vtk_points_2_d_set_number_of_points(vtkNew sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } +extern "C" int vtk_points_2_d_resize(vtkNew sself, long long numPoints) { return sself->Resize(numPoints); } +extern "C" void vtk_points_2_d_compute_bounds(vtkNew sself) { sself->ComputeBounds(); } +extern "C" double* vtk_points_2_d_get_bounds(vtkNew sself) { return sself->GetBounds(); } +extern "C" void vtk_points_2_d_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } extern "C" vtkNew < vtkPriorityQueue > vtkPriorityQueue_new () {return vtkNew < vtkPriorityQueue > () ;} extern "C" void vtkPriorityQueue_destructor (vtkNew < vtkPriorityQueue > sself) {sself . Reset () ; return ;} extern "C" void * vtkPriorityQueue_get_ptr (vtkNew < vtkPriorityQueue > sself) {return sself . GetPointer () ;} +extern "C" void vtk_priority_queue_allocate(vtkNew sself, long long sz, long long ext) { sself->Allocate(sz, ext); } +extern "C" void vtk_priority_queue_insert(vtkNew sself, double priority, long long id) { sself->Insert(priority, id); } +extern "C" long long vtk_priority_queue_pop(vtkNew sself, long long location, double priority) { return sself->Pop(location, priority); } +extern "C" long long vtk_priority_queue_pop(vtkNew sself, long long location) { return sself->Pop(location); } +extern "C" long long vtk_priority_queue_peek(vtkNew sself, long long location, double priority) { return sself->Peek(location, priority); } +extern "C" long long vtk_priority_queue_peek(vtkNew sself, long long location) { return sself->Peek(location); } +extern "C" double vtk_priority_queue_delete_id(vtkNew sself, long long id) { return sself->DeleteId(id); } +extern "C" double vtk_priority_queue_get_priority(vtkNew sself, long long id) { return sself->GetPriority(id); } +extern "C" long long vtk_priority_queue_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } +extern "C" void vtk_priority_queue_reset(vtkNew sself) { sself->Reset(); } extern "C" vtkNew < vtkRandomPool > vtkRandomPool_new () {return vtkNew < vtkRandomPool > () ;} extern "C" void vtkRandomPool_destructor (vtkNew < vtkRandomPool > sself) {sself . Reset () ; return ;} extern "C" void * vtkRandomPool_get_ptr (vtkNew < vtkRandomPool > sself) {return sself . GetPointer () ;} +extern "C" void vtk_random_pool_set_size(vtkNew sself, long long _arg) { sself->SetSize(_arg); } +extern "C" long long vtk_random_pool_get_size_min_value(vtkNew sself) { return sself->GetSizeMinValue(); } +extern "C" long long vtk_random_pool_get_size_max_value(vtkNew sself) { return sself->GetSizeMaxValue(); } +extern "C" long long vtk_random_pool_get_size(vtkNew sself) { return sself->GetSize(); } +extern "C" void vtk_random_pool_set_number_of_components(vtkNew sself, long long _arg) { sself->SetNumberOfComponents(_arg); } +extern "C" long long vtk_random_pool_get_number_of_components_min_value(vtkNew sself) { return sself->GetNumberOfComponentsMinValue(); } +extern "C" long long vtk_random_pool_get_number_of_components_max_value(vtkNew sself) { return sself->GetNumberOfComponentsMaxValue(); } +extern "C" long long vtk_random_pool_get_number_of_components(vtkNew sself) { return sself->GetNumberOfComponents(); } +extern "C" long long vtk_random_pool_get_total_size(vtkNew sself) { return sself->GetTotalSize(); } +extern "C" const double* vtk_random_pool_generate_pool(vtkNew sself) { return sself->GeneratePool(); } +extern "C" const double* vtk_random_pool_get_pool(vtkNew sself) { return sself->GetPool(); } +extern "C" double vtk_random_pool_get_value(vtkNew sself, long long i) { return sself->GetValue(i); } +extern "C" double vtk_random_pool_get_value(vtkNew sself, long long i, int compNum) { return sself->GetValue(i, compNum); } +extern "C" void vtk_random_pool_set_chunk_size(vtkNew sself, long long _arg) { sself->SetChunkSize(_arg); } +extern "C" long long vtk_random_pool_get_chunk_size_min_value(vtkNew sself) { return sself->GetChunkSizeMinValue(); } +extern "C" long long vtk_random_pool_get_chunk_size_max_value(vtkNew sself) { return sself->GetChunkSizeMaxValue(); } +extern "C" long long vtk_random_pool_get_chunk_size(vtkNew sself) { return sself->GetChunkSize(); } extern "C" vtkNew < vtkReferenceCount > vtkReferenceCount_new () {return vtkNew < vtkReferenceCount > () ;} extern "C" void vtkReferenceCount_destructor (vtkNew < vtkReferenceCount > sself) {sself . Reset () ; return ;} extern "C" void * vtkReferenceCount_get_ptr (vtkNew < vtkReferenceCount > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkScalarsToColors > vtkScalarsToColors_new () {return vtkNew < vtkScalarsToColors > () ;} extern "C" void vtkScalarsToColors_destructor (vtkNew < vtkScalarsToColors > sself) {sself . Reset () ; return ;} extern "C" void * vtkScalarsToColors_get_ptr (vtkNew < vtkScalarsToColors > sself) {return sself . GetPointer () ;} +extern "C" int vtk_scalars_to_colors_is_opaque(vtkNew sself) { return sself->IsOpaque(); } +extern "C" void vtk_scalars_to_colors_build(vtkNew sself) { sself->Build(); } +extern "C" double* vtk_scalars_to_colors_get_range(vtkNew sself) { return sself->GetRange(); } +extern "C" void vtk_scalars_to_colors_set_range(vtkNew sself, double min, double max) { sself->SetRange(min, max); } +extern "C" void vtk_scalars_to_colors_set_range(vtkNew sself, const double rng) { sself->SetRange(rng); } +extern "C" const unsigned char* vtk_scalars_to_colors_map_value(vtkNew sself, double v) { return sself->MapValue(v); } +extern "C" void vtk_scalars_to_colors_get_color(vtkNew sself, double v, double rgb) { sself->GetColor(v, rgb); } +extern "C" double* vtk_scalars_to_colors_get_color(vtkNew sself, double v) { return sself->GetColor(v); } +extern "C" double vtk_scalars_to_colors_get_opacity(vtkNew sself, double v) { return sself->GetOpacity(v); } +extern "C" double vtk_scalars_to_colors_get_luminance(vtkNew sself, double x) { return sself->GetLuminance(x); } +extern "C" void vtk_scalars_to_colors_set_alpha(vtkNew sself, double alpha) { sself->SetAlpha(alpha); } +extern "C" double vtk_scalars_to_colors_get_alpha(vtkNew sself) { return sself->GetAlpha(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode(vtkNew sself, int _arg) { sself->SetVectorMode(_arg); } +extern "C" int vtk_scalars_to_colors_get_vector_mode(vtkNew sself) { return sself->GetVectorMode(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_magnitude(vtkNew sself) { sself->SetVectorModeToMagnitude(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_component(vtkNew sself) { sself->SetVectorModeToComponent(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_rgb_colors(vtkNew sself) { sself->SetVectorModeToRGBColors(); } +extern "C" void vtk_scalars_to_colors_set_vector_component(vtkNew sself, int _arg) { sself->SetVectorComponent(_arg); } +extern "C" int vtk_scalars_to_colors_get_vector_component(vtkNew sself) { return sself->GetVectorComponent(); } +extern "C" void vtk_scalars_to_colors_set_vector_size(vtkNew sself, int _arg) { sself->SetVectorSize(_arg); } +extern "C" int vtk_scalars_to_colors_get_vector_size(vtkNew sself) { return sself->GetVectorSize(); } +extern "C" void vtk_scalars_to_colors_map_vectors_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat, int vectorComponent, int vectorSize) { sself->MapVectorsThroughTable(input, output, inputDataType, numberOfValues, inputIncrement, outputFormat, vectorComponent, vectorSize); } +extern "C" void vtk_scalars_to_colors_map_vectors_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat) { sself->MapVectorsThroughTable(input, output, inputDataType, numberOfValues, inputIncrement, outputFormat); } +extern "C" void vtk_scalars_to_colors_map_scalars_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat) { sself->MapScalarsThroughTable(input, output, inputDataType, numberOfValues, inputIncrement, outputFormat); } +extern "C" void vtk_scalars_to_colors_map_scalars_through_table_2(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat) { sself->MapScalarsThroughTable2(input, output, inputDataType, numberOfValues, inputIncrement, outputFormat); } +extern "C" int vtk_scalars_to_colors_using_log_scale(vtkNew sself) { return sself->UsingLogScale(); } +extern "C" long long vtk_scalars_to_colors_get_number_of_available_colors(vtkNew sself) { return sself->GetNumberOfAvailableColors(); } +extern "C" long long vtk_scalars_to_colors_get_number_of_annotated_values(vtkNew sself) { return sself->GetNumberOfAnnotatedValues(); } +extern "C" void vtk_scalars_to_colors_get_indexed_color(vtkNew sself, long long i, double rgba) { sself->GetIndexedColor(i, rgba); } +extern "C" void vtk_scalars_to_colors_reset_annotations(vtkNew sself) { sself->ResetAnnotations(); } +extern "C" void vtk_scalars_to_colors_set_indexed_lookup(vtkNew sself, int _arg) { sself->SetIndexedLookup(_arg); } +extern "C" int vtk_scalars_to_colors_get_indexed_lookup(vtkNew sself) { return sself->GetIndexedLookup(); } +extern "C" void vtk_scalars_to_colors_indexed_lookup_on(vtkNew sself) { sself->IndexedLookupOn(); } +extern "C" void vtk_scalars_to_colors_indexed_lookup_off(vtkNew sself) { sself->IndexedLookupOff(); } extern "C" vtkNew < vtkShortArray > vtkShortArray_new () {return vtkNew < vtkShortArray > () ;} extern "C" void vtkShortArray_destructor (vtkNew < vtkShortArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkShortArray_get_ptr (vtkNew < vtkShortArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_short_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_short_array_get_typed_tuple(vtkNew sself, long long i, short tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_short_array_set_typed_tuple(vtkNew sself, long long i, const short tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_short_array_insert_typed_tuple(vtkNew sself, long long i, const short tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_short_array_insert_next_typed_tuple(vtkNew sself, const short tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" short vtk_short_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_short_array_set_value(vtkNew sself, long long id, short value) { sself->SetValue(id, value); } +extern "C" bool vtk_short_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_short_array_insert_value(vtkNew sself, long long id, short f) { sself->InsertValue(id, f); } +extern "C" long long vtk_short_array_insert_next_value(vtkNew sself, short f) { return sself->InsertNextValue(f); } +extern "C" short* vtk_short_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" short* vtk_short_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" short* vtk_short_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" short* vtk_short_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_short_array_set_array(vtkNew sself, short array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_short_array_set_array(vtkNew sself, short array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" short vtk_short_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" short vtk_short_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkSignedCharArray > vtkSignedCharArray_new () {return vtkNew < vtkSignedCharArray > () ;} extern "C" void vtkSignedCharArray_destructor (vtkNew < vtkSignedCharArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkSignedCharArray_get_ptr (vtkNew < vtkSignedCharArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_signed_char_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_signed_char_array_get_typed_tuple(vtkNew sself, long long i, char tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_signed_char_array_set_typed_tuple(vtkNew sself, long long i, const char tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_signed_char_array_insert_typed_tuple(vtkNew sself, long long i, const char tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_signed_char_array_insert_next_typed_tuple(vtkNew sself, const char tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" char vtk_signed_char_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_signed_char_array_set_value(vtkNew sself, long long id, char value) { sself->SetValue(id, value); } +extern "C" bool vtk_signed_char_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_signed_char_array_insert_value(vtkNew sself, long long id, char f) { sself->InsertValue(id, f); } +extern "C" long long vtk_signed_char_array_insert_next_value(vtkNew sself, char f) { return sself->InsertNextValue(f); } +extern "C" char* vtk_signed_char_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" char* vtk_signed_char_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" char* vtk_signed_char_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" char* vtk_signed_char_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_signed_char_array_set_array(vtkNew sself, char array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_signed_char_array_set_array(vtkNew sself, char array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" char vtk_signed_char_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" char vtk_signed_char_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkSortDataArray > vtkSortDataArray_new () {return vtkNew < vtkSortDataArray > () ;} extern "C" void vtkSortDataArray_destructor (vtkNew < vtkSortDataArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkSortDataArray_get_ptr (vtkNew < vtkSortDataArray > sself) {return sself . GetPointer () ;} +extern "C" long long* vtk_sort_data_array_initialize_sort_indices(vtkNew sself, long long numKeys) { return sself->InitializeSortIndices(numKeys); } +extern "C" void vtk_sort_data_array_generate_sort_indices(vtkNew sself, int dataType, void dataIn, long long numKeys, int numComp, int k, long long idx) { sself->GenerateSortIndices(dataType, dataIn, numKeys, numComp, k, idx); } extern "C" vtkNew < vtkStringArray > vtkStringArray_new () {return vtkNew < vtkStringArray > () ;} extern "C" void vtkStringArray_destructor (vtkNew < vtkStringArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkStringArray_get_ptr (vtkNew < vtkStringArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_string_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" int vtk_string_array_is_numeric(vtkNew sself) { return sself->IsNumeric(); } +extern "C" void vtk_string_array_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_string_array_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_string_array_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" int vtk_string_array_resize(vtkNew sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" int vtk_string_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_string_array_set_value(vtkNew sself, long long id, const char value) { sself->SetValue(id, value); } +extern "C" void vtk_string_array_set_number_of_tuples(vtkNew sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" long long vtk_string_array_get_number_of_values(vtkNew sself) { return sself->GetNumberOfValues(); } +extern "C" int vtk_string_array_get_number_of_element_components(vtkNew sself) { return sself->GetNumberOfElementComponents(); } +extern "C" int vtk_string_array_get_element_component_size(vtkNew sself) { return sself->GetElementComponentSize(); } +extern "C" void vtk_string_array_insert_value(vtkNew sself, long long id, const char val) { sself->InsertValue(id, val); } +extern "C" long long vtk_string_array_insert_next_value(vtkNew sself, const char f) { return sself->InsertNextValue(f); } +extern "C" void* vtk_string_array_get_void_pointer(vtkNew sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_string_array_set_void_array(vtkNew sself, void array, long long size, int save) { sself->SetVoidArray(array, size, save); } +extern "C" unsigned long vtk_string_array_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" long long vtk_string_array_get_data_size(vtkNew sself) { return sself->GetDataSize(); } +extern "C" long long vtk_string_array_lookup_value(vtkNew sself, const char value) { return sself->LookupValue(value); } +extern "C" void vtk_string_array_data_changed(vtkNew sself) { sself->DataChanged(); } +extern "C" void vtk_string_array_data_element_changed(vtkNew sself, long long id) { sself->DataElementChanged(id); } +extern "C" void vtk_string_array_clear_lookup(vtkNew sself) { sself->ClearLookup(); } extern "C" vtkNew < vtkStringOutputWindow > vtkStringOutputWindow_new () {return vtkNew < vtkStringOutputWindow > () ;} extern "C" void vtkStringOutputWindow_destructor (vtkNew < vtkStringOutputWindow > sself) {sself . Reset () ; return ;} extern "C" void * vtkStringOutputWindow_get_ptr (vtkNew < vtkStringOutputWindow > sself) {return sself . GetPointer () ;} +extern "C" void vtk_string_output_window_display_text(vtkNew sself, const char p0) { sself->DisplayText(p0); } +extern "C" const char* vtk_string_output_window_get_output(vtkNew sself) { return sself->GetOutput(); } extern "C" vtkNew < vtkTimePointUtility > vtkTimePointUtility_new () {return vtkNew < vtkTimePointUtility > () ;} extern "C" void vtkTimePointUtility_destructor (vtkNew < vtkTimePointUtility > sself) {sself . Reset () ; return ;} extern "C" void * vtkTimePointUtility_get_ptr (vtkNew < vtkTimePointUtility > sself) {return sself . GetPointer () ;} +extern "C" unsigned long long vtk_time_point_utility_date_to_time_point(vtkNew sself, int year, int month, int day) { return sself->DateToTimePoint(year, month, day); } +extern "C" unsigned long long vtk_time_point_utility_time_to_time_point(vtkNew sself, int hour, int minute, int second, int millis) { return sself->TimeToTimePoint(hour, minute, second, millis); } +extern "C" unsigned long long vtk_time_point_utility_date_time_to_time_point(vtkNew sself, int year, int month, int day, int hour, int minute, int sec, int millis) { return sself->DateTimeToTimePoint(year, month, day, hour, minute, sec, millis); } +extern "C" void vtk_time_point_utility_get_date(vtkNew sself, unsigned long long time, int year, int month, int day) { sself->GetDate(time, year, month, day); } +extern "C" void vtk_time_point_utility_get_time(vtkNew sself, unsigned long long time, int hour, int minute, int second, int millis) { sself->GetTime(time, hour, minute, second, millis); } +extern "C" void vtk_time_point_utility_get_date_time(vtkNew sself, unsigned long long time, int year, int month, int day, int hour, int minute, int second, int millis) { sself->GetDateTime(time, year, month, day, hour, minute, second, millis); } +extern "C" int vtk_time_point_utility_get_year(vtkNew sself, unsigned long long time) { return sself->GetYear(time); } +extern "C" int vtk_time_point_utility_get_month(vtkNew sself, unsigned long long time) { return sself->GetMonth(time); } +extern "C" int vtk_time_point_utility_get_day(vtkNew sself, unsigned long long time) { return sself->GetDay(time); } +extern "C" int vtk_time_point_utility_get_hour(vtkNew sself, unsigned long long time) { return sself->GetHour(time); } +extern "C" int vtk_time_point_utility_get_minute(vtkNew sself, unsigned long long time) { return sself->GetMinute(time); } +extern "C" int vtk_time_point_utility_get_second(vtkNew sself, unsigned long long time) { return sself->GetSecond(time); } +extern "C" int vtk_time_point_utility_get_millisecond(vtkNew sself, unsigned long long time) { return sself->GetMillisecond(time); } +extern "C" unsigned long long vtk_time_point_utility_iso_8601_to_time_point(vtkNew sself, const char str, bool ok) { return sself->ISO8601ToTimePoint(str, ok); } +extern "C" const char* vtk_time_point_utility_time_point_to_iso_8601(vtkNew sself, unsigned long long p0, int format) { return sself->TimePointToISO8601(p0, format); } extern "C" vtkNew < vtkTypeFloat32Array > vtkTypeFloat32Array_new () {return vtkNew < vtkTypeFloat32Array > () ;} extern "C" void vtkTypeFloat32Array_destructor (vtkNew < vtkTypeFloat32Array > sself) {sself . Reset () ; return ;} extern "C" void * vtkTypeFloat32Array_get_ptr (vtkNew < vtkTypeFloat32Array > sself) {return sself . GetPointer () ;} @@ -361,33 +1259,182 @@ extern "C" void * vtkTypeUInt64Array_get_ptr (vtkNew < vtkTypeUInt64Array > ssel extern "C" vtkNew < vtkTypeUInt8Array > vtkTypeUInt8Array_new () {return vtkNew < vtkTypeUInt8Array > () ;} extern "C" void vtkTypeUInt8Array_destructor (vtkNew < vtkTypeUInt8Array > sself) {sself . Reset () ; return ;} extern "C" void * vtkTypeUInt8Array_get_ptr (vtkNew < vtkTypeUInt8Array > sself) {return sself . GetPointer () ;} +extern "C" vtkNew < vtkUnicodeStringArray > vtkUnicodeStringArray_new () {return vtkNew < vtkUnicodeStringArray > () ;} +extern "C" void vtkUnicodeStringArray_destructor (vtkNew < vtkUnicodeStringArray > sself) {sself . Reset () ; return ;} +extern "C" void * vtkUnicodeStringArray_get_ptr (vtkNew < vtkUnicodeStringArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_unicode_string_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_unicode_string_array_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_unicode_string_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" int vtk_unicode_string_array_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } +extern "C" int vtk_unicode_string_array_get_element_component_size(vtkNew sself) { return sself->GetElementComponentSize(); } +extern "C" void vtk_unicode_string_array_set_number_of_tuples(vtkNew sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" void* vtk_unicode_string_array_get_void_pointer(vtkNew sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_unicode_string_array_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" int vtk_unicode_string_array_resize(vtkNew sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" void vtk_unicode_string_array_set_void_array(vtkNew sself, void array, long long size, int save) { sself->SetVoidArray(array, size, save); } +extern "C" unsigned long vtk_unicode_string_array_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" int vtk_unicode_string_array_is_numeric(vtkNew sself) { return sself->IsNumeric(); } +extern "C" void vtk_unicode_string_array_data_changed(vtkNew sself) { sself->DataChanged(); } +extern "C" void vtk_unicode_string_array_clear_lookup(vtkNew sself) { sself->ClearLookup(); } +extern "C" void vtk_unicode_string_array_insert_next_utf_8_value(vtkNew sself, const char p0) { sself->InsertNextUTF8Value(p0); } +extern "C" void vtk_unicode_string_array_set_utf_8_value(vtkNew sself, long long i, const char p1) { sself->SetUTF8Value(i, p1); } +extern "C" const char* vtk_unicode_string_array_get_utf_8_value(vtkNew sself, long long i) { return sself->GetUTF8Value(i); } extern "C" vtkNew < vtkUnsignedCharArray > vtkUnsignedCharArray_new () {return vtkNew < vtkUnsignedCharArray > () ;} extern "C" void vtkUnsignedCharArray_destructor (vtkNew < vtkUnsignedCharArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkUnsignedCharArray_get_ptr (vtkNew < vtkUnsignedCharArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_unsigned_char_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_unsigned_char_array_get_typed_tuple(vtkNew sself, long long i, unsigned char tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_unsigned_char_array_set_typed_tuple(vtkNew sself, long long i, const unsigned char tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_unsigned_char_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned char tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_unsigned_char_array_insert_next_typed_tuple(vtkNew sself, const unsigned char tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" unsigned char vtk_unsigned_char_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_char_array_set_value(vtkNew sself, long long id, unsigned char value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_char_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_char_array_insert_value(vtkNew sself, long long id, unsigned char f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_char_array_insert_next_value(vtkNew sself, unsigned char f) { return sself->InsertNextValue(f); } +extern "C" unsigned char* vtk_unsigned_char_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" unsigned char* vtk_unsigned_char_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" unsigned char* vtk_unsigned_char_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" unsigned char* vtk_unsigned_char_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_unsigned_char_array_set_array(vtkNew sself, unsigned char array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_unsigned_char_array_set_array(vtkNew sself, unsigned char array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkUnsignedIntArray > vtkUnsignedIntArray_new () {return vtkNew < vtkUnsignedIntArray > () ;} extern "C" void vtkUnsignedIntArray_destructor (vtkNew < vtkUnsignedIntArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkUnsignedIntArray_get_ptr (vtkNew < vtkUnsignedIntArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_unsigned_int_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_unsigned_int_array_get_typed_tuple(vtkNew sself, long long i, unsigned int tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_unsigned_int_array_set_typed_tuple(vtkNew sself, long long i, const unsigned int tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_unsigned_int_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned int tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_unsigned_int_array_insert_next_typed_tuple(vtkNew sself, const unsigned int tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" unsigned int vtk_unsigned_int_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_int_array_set_value(vtkNew sself, long long id, unsigned int value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_int_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_int_array_insert_value(vtkNew sself, long long id, unsigned int f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_int_array_insert_next_value(vtkNew sself, unsigned int f) { return sself->InsertNextValue(f); } +extern "C" unsigned int* vtk_unsigned_int_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" unsigned int* vtk_unsigned_int_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" unsigned int* vtk_unsigned_int_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" unsigned int* vtk_unsigned_int_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_unsigned_int_array_set_array(vtkNew sself, unsigned int array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_unsigned_int_array_set_array(vtkNew sself, unsigned int array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkUnsignedLongArray > vtkUnsignedLongArray_new () {return vtkNew < vtkUnsignedLongArray > () ;} extern "C" void vtkUnsignedLongArray_destructor (vtkNew < vtkUnsignedLongArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkUnsignedLongArray_get_ptr (vtkNew < vtkUnsignedLongArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_unsigned_long_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_unsigned_long_array_get_typed_tuple(vtkNew sself, long long i, unsigned long tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_unsigned_long_array_set_typed_tuple(vtkNew sself, long long i, const unsigned long tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_unsigned_long_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned long tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_unsigned_long_array_insert_next_typed_tuple(vtkNew sself, const unsigned long tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" unsigned long vtk_unsigned_long_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_long_array_set_value(vtkNew sself, long long id, unsigned long value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_long_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_long_array_insert_value(vtkNew sself, long long id, unsigned long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_long_array_insert_next_value(vtkNew sself, unsigned long f) { return sself->InsertNextValue(f); } +extern "C" unsigned long* vtk_unsigned_long_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" unsigned long* vtk_unsigned_long_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" unsigned long* vtk_unsigned_long_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" unsigned long* vtk_unsigned_long_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_unsigned_long_array_set_array(vtkNew sself, unsigned long array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_unsigned_long_array_set_array(vtkNew sself, unsigned long array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkUnsignedLongLongArray > vtkUnsignedLongLongArray_new () {return vtkNew < vtkUnsignedLongLongArray > () ;} extern "C" void vtkUnsignedLongLongArray_destructor (vtkNew < vtkUnsignedLongLongArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkUnsignedLongLongArray_get_ptr (vtkNew < vtkUnsignedLongLongArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_unsigned_long_long_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_unsigned_long_long_array_get_typed_tuple(vtkNew sself, long long i, unsigned long long tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_unsigned_long_long_array_set_typed_tuple(vtkNew sself, long long i, const unsigned long long tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_unsigned_long_long_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned long long tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_unsigned_long_long_array_insert_next_typed_tuple(vtkNew sself, const unsigned long long tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" unsigned long long vtk_unsigned_long_long_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_long_long_array_set_value(vtkNew sself, long long id, unsigned long long value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_long_long_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_long_long_array_insert_value(vtkNew sself, long long id, unsigned long long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_long_long_array_insert_next_value(vtkNew sself, unsigned long long f) { return sself->InsertNextValue(f); } +extern "C" unsigned long long* vtk_unsigned_long_long_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" unsigned long long* vtk_unsigned_long_long_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" unsigned long long* vtk_unsigned_long_long_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" unsigned long long* vtk_unsigned_long_long_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_unsigned_long_long_array_set_array(vtkNew sself, unsigned long long array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_unsigned_long_long_array_set_array(vtkNew sself, unsigned long long array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkUnsignedShortArray > vtkUnsignedShortArray_new () {return vtkNew < vtkUnsignedShortArray > () ;} extern "C" void vtkUnsignedShortArray_destructor (vtkNew < vtkUnsignedShortArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkUnsignedShortArray_get_ptr (vtkNew < vtkUnsignedShortArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_unsigned_short_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" void vtk_unsigned_short_array_get_typed_tuple(vtkNew sself, long long i, unsigned short tuple) { sself->GetTypedTuple(i, tuple); } +extern "C" void vtk_unsigned_short_array_set_typed_tuple(vtkNew sself, long long i, const unsigned short tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_unsigned_short_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned short tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_unsigned_short_array_insert_next_typed_tuple(vtkNew sself, const unsigned short tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" unsigned short vtk_unsigned_short_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_short_array_set_value(vtkNew sself, long long id, unsigned short value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_short_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_short_array_insert_value(vtkNew sself, long long id, unsigned short f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_short_array_insert_next_value(vtkNew sself, unsigned short f) { return sself->InsertNextValue(f); } +extern "C" unsigned short* vtk_unsigned_short_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } +extern "C" unsigned short* vtk_unsigned_short_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } +extern "C" unsigned short* vtk_unsigned_short_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } +extern "C" unsigned short* vtk_unsigned_short_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void vtk_unsigned_short_array_set_array(vtkNew sself, unsigned short array, long long size, int save) { sself->SetArray(array, size, save); } +extern "C" void vtk_unsigned_short_array_set_array(vtkNew sself, unsigned short array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkNew < vtkVariantArray > vtkVariantArray_new () {return vtkNew < vtkVariantArray > () ;} extern "C" void vtkVariantArray_destructor (vtkNew < vtkVariantArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkVariantArray_get_ptr (vtkNew < vtkVariantArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_variant_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_variant_array_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_variant_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" int vtk_variant_array_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } +extern "C" int vtk_variant_array_get_element_component_size(vtkNew sself) { return sself->GetElementComponentSize(); } +extern "C" void vtk_variant_array_set_number_of_tuples(vtkNew sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" void* vtk_variant_array_get_void_pointer(vtkNew sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_variant_array_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" int vtk_variant_array_resize(vtkNew sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" void vtk_variant_array_set_void_array(vtkNew sself, void arr, long long size, int save) { sself->SetVoidArray(arr, size, save); } +extern "C" void vtk_variant_array_set_void_array(vtkNew sself, void arr, long long size, int save, int deleteM) { sself->SetVoidArray(arr, size, save, deleteM); } +extern "C" unsigned long vtk_variant_array_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" int vtk_variant_array_is_numeric(vtkNew sself) { return sself->IsNumeric(); } +extern "C" long long vtk_variant_array_get_number_of_values(vtkNew sself) { return sself->GetNumberOfValues(); } +extern "C" void vtk_variant_array_data_changed(vtkNew sself) { sself->DataChanged(); } +extern "C" void vtk_variant_array_data_element_changed(vtkNew sself, long long id) { sself->DataElementChanged(id); } +extern "C" void vtk_variant_array_clear_lookup(vtkNew sself) { sself->ClearLookup(); } extern "C" vtkNew < vtkVersion > vtkVersion_new () {return vtkNew < vtkVersion > () ;} extern "C" void vtkVersion_destructor (vtkNew < vtkVersion > sself) {sself . Reset () ; return ;} extern "C" void * vtkVersion_get_ptr (vtkNew < vtkVersion > sself) {return sself . GetPointer () ;} +extern "C" const char* vtk_version_get_vtk_version(vtkNew sself) { return sself->GetVTKVersion(); } +extern "C" const char* vtk_version_get_vtk_version_full(vtkNew sself) { return sself->GetVTKVersionFull(); } +extern "C" int vtk_version_get_vtk_major_version(vtkNew sself) { return sself->GetVTKMajorVersion(); } +extern "C" int vtk_version_get_vtk_minor_version(vtkNew sself) { return sself->GetVTKMinorVersion(); } +extern "C" int vtk_version_get_vtk_build_version(vtkNew sself) { return sself->GetVTKBuildVersion(); } +extern "C" const char* vtk_version_get_vtk_source_version(vtkNew sself) { return sself->GetVTKSourceVersion(); } extern "C" vtkNew < vtkVoidArray > vtkVoidArray_new () {return vtkNew < vtkVoidArray > () ;} extern "C" void vtkVoidArray_destructor (vtkNew < vtkVoidArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkVoidArray_get_ptr (vtkNew < vtkVoidArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_void_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_void_array_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_void_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } +extern "C" int vtk_void_array_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_void_array_set_number_of_pointers(vtkNew sself, long long number) { sself->SetNumberOfPointers(number); } +extern "C" long long vtk_void_array_get_number_of_pointers(vtkNew sself) { return sself->GetNumberOfPointers(); } +extern "C" void* vtk_void_array_get_void_pointer(vtkNew sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_void_array_set_void_pointer(vtkNew sself, long long id, void ptr) { sself->SetVoidPointer(id, ptr); } +extern "C" void vtk_void_array_insert_void_pointer(vtkNew sself, long long i, void ptr) { sself->InsertVoidPointer(i, ptr); } +extern "C" long long vtk_void_array_insert_next_void_pointer(vtkNew sself, void tuple) { return sself->InsertNextVoidPointer(tuple); } +extern "C" void vtk_void_array_reset(vtkNew sself) { sself->Reset(); } +extern "C" void vtk_void_array_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" void&* vtk_void_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } +extern "C" void&* vtk_void_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } extern "C" vtkNew < vtkWeakReference > vtkWeakReference_new () {return vtkNew < vtkWeakReference > () ;} extern "C" void vtkWeakReference_destructor (vtkNew < vtkWeakReference > sself) {sself . Reset () ; return ;} extern "C" void * vtkWeakReference_get_ptr (vtkNew < vtkWeakReference > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkXMLFileOutputWindow > vtkXMLFileOutputWindow_new () {return vtkNew < vtkXMLFileOutputWindow > () ;} extern "C" void vtkXMLFileOutputWindow_destructor (vtkNew < vtkXMLFileOutputWindow > sself) {sself . Reset () ; return ;} extern "C" void * vtkXMLFileOutputWindow_get_ptr (vtkNew < vtkXMLFileOutputWindow > sself) {return sself . GetPointer () ;} +extern "C" void vtk_xml_file_output_window_display_text(vtkNew sself, const char p0) { sself->DisplayText(p0); } +extern "C" void vtk_xml_file_output_window_display_tag(vtkNew sself, const char p0) { sself->DisplayTag(p0); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp index 73693be..6edbd39 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp @@ -47,7 +47,6 @@ #include #include #include -#include #include #include #include @@ -63,7 +62,6 @@ #include #include #include -#include #include #include #include @@ -233,7 +231,6 @@ #include #include #include -#include #include #include #include @@ -288,138 +285,597 @@ extern "C" vtkNew < vtkAMRDataInternals > vtkAMRDataInternals_new () {return vtkNew < vtkAMRDataInternals > () ;} extern "C" void vtkAMRDataInternals_destructor (vtkNew < vtkAMRDataInternals > sself) {sself . Reset () ; return ;} extern "C" void * vtkAMRDataInternals_get_ptr (vtkNew < vtkAMRDataInternals > sself) {return sself . GetPointer () ;} +extern "C" void vtk_amr_data_internals_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" bool vtk_amr_data_internals_empty(vtkNew sself) { return sself->Empty(); } +extern "C" unsigned int vtk_amr_data_internals_get_number_of_blocks(vtkNew sself) { return sself->GetNumberOfBlocks(); } extern "C" vtkNew < vtkAdjacentVertexIterator > vtkAdjacentVertexIterator_new () {return vtkNew < vtkAdjacentVertexIterator > () ;} extern "C" void vtkAdjacentVertexIterator_destructor (vtkNew < vtkAdjacentVertexIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkAdjacentVertexIterator_get_ptr (vtkNew < vtkAdjacentVertexIterator > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_adjacent_vertex_iterator_get_vertex(vtkNew sself) { return sself->GetVertex(); } +extern "C" long long vtk_adjacent_vertex_iterator_next(vtkNew sself) { return sself->Next(); } +extern "C" bool vtk_adjacent_vertex_iterator_has_next(vtkNew sself) { return sself->HasNext(); } extern "C" vtkNew < vtkAnimationScene > vtkAnimationScene_new () {return vtkNew < vtkAnimationScene > () ;} extern "C" void vtkAnimationScene_destructor (vtkNew < vtkAnimationScene > sself) {sself . Reset () ; return ;} extern "C" void * vtkAnimationScene_get_ptr (vtkNew < vtkAnimationScene > sself) {return sself . GetPointer () ;} +extern "C" void vtk_animation_scene_set_play_mode(vtkNew sself, int _arg) { sself->SetPlayMode(_arg); } +extern "C" void vtk_animation_scene_set_mode_to_sequence(vtkNew sself) { sself->SetModeToSequence(); } +extern "C" void vtk_animation_scene_set_mode_to_real_time(vtkNew sself) { sself->SetModeToRealTime(); } +extern "C" int vtk_animation_scene_get_play_mode(vtkNew sself) { return sself->GetPlayMode(); } +extern "C" void vtk_animation_scene_set_frame_rate(vtkNew sself, double _arg) { sself->SetFrameRate(_arg); } +extern "C" double vtk_animation_scene_get_frame_rate(vtkNew sself) { return sself->GetFrameRate(); } +extern "C" void vtk_animation_scene_remove_all_cues(vtkNew sself) { sself->RemoveAllCues(); } +extern "C" int vtk_animation_scene_get_number_of_cues(vtkNew sself) { return sself->GetNumberOfCues(); } +extern "C" void vtk_animation_scene_play(vtkNew sself) { sself->Play(); } +extern "C" void vtk_animation_scene_stop(vtkNew sself) { sself->Stop(); } +extern "C" void vtk_animation_scene_set_loop(vtkNew sself, int _arg) { sself->SetLoop(_arg); } +extern "C" int vtk_animation_scene_get_loop(vtkNew sself) { return sself->GetLoop(); } +extern "C" void vtk_animation_scene_set_animation_time(vtkNew sself, double time) { sself->SetAnimationTime(time); } +extern "C" void vtk_animation_scene_set_time_mode(vtkNew sself, int mode) { sself->SetTimeMode(mode); } +extern "C" int vtk_animation_scene_is_in_play(vtkNew sself) { return sself->IsInPlay(); } extern "C" vtkNew < vtkAnnotation > vtkAnnotation_new () {return vtkNew < vtkAnnotation > () ;} extern "C" void vtkAnnotation_destructor (vtkNew < vtkAnnotation > sself) {sself . Reset () ; return ;} extern "C" void * vtkAnnotation_get_ptr (vtkNew < vtkAnnotation > sself) {return sself . GetPointer () ;} +extern "C" int vtk_annotation_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_annotation_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" unsigned long vtk_annotation_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkAnnotationLayers > vtkAnnotationLayers_new () {return vtkNew < vtkAnnotationLayers > () ;} extern "C" void vtkAnnotationLayers_destructor (vtkNew < vtkAnnotationLayers > sself) {sself . Reset () ; return ;} extern "C" void * vtkAnnotationLayers_get_ptr (vtkNew < vtkAnnotationLayers > sself) {return sself . GetPointer () ;} +extern "C" int vtk_annotation_layers_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" unsigned int vtk_annotation_layers_get_number_of_annotations(vtkNew sself) { return sself->GetNumberOfAnnotations(); } +extern "C" void vtk_annotation_layers_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" unsigned long vtk_annotation_layers_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkArrayData > vtkArrayData_new () {return vtkNew < vtkArrayData > () ;} extern "C" void vtkArrayData_destructor (vtkNew < vtkArrayData > sself) {sself . Reset () ; return ;} extern "C" void * vtkArrayData_get_ptr (vtkNew < vtkArrayData > sself) {return sself . GetPointer () ;} +extern "C" void vtk_array_data_clear_arrays(vtkNew sself) { sself->ClearArrays(); } +extern "C" long long vtk_array_data_get_number_of_arrays(vtkNew sself) { return sself->GetNumberOfArrays(); } +extern "C" int vtk_array_data_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } extern "C" vtkNew < vtkAttributesErrorMetric > vtkAttributesErrorMetric_new () {return vtkNew < vtkAttributesErrorMetric > () ;} extern "C" void vtkAttributesErrorMetric_destructor (vtkNew < vtkAttributesErrorMetric > sself) {sself . Reset () ; return ;} extern "C" void * vtkAttributesErrorMetric_get_ptr (vtkNew < vtkAttributesErrorMetric > sself) {return sself . GetPointer () ;} +extern "C" double vtk_attributes_error_metric_get_absolute_attribute_tolerance(vtkNew sself) { return sself->GetAbsoluteAttributeTolerance(); } +extern "C" void vtk_attributes_error_metric_set_absolute_attribute_tolerance(vtkNew sself, double value) { sself->SetAbsoluteAttributeTolerance(value); } +extern "C" double vtk_attributes_error_metric_get_attribute_tolerance(vtkNew sself) { return sself->GetAttributeTolerance(); } +extern "C" void vtk_attributes_error_metric_set_attribute_tolerance(vtkNew sself, double value) { sself->SetAttributeTolerance(value); } +extern "C" int vtk_attributes_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->RequiresEdgeSubdivision(leftPoint, midPoint, rightPoint, alpha); } +extern "C" double vtk_attributes_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->GetError(leftPoint, midPoint, rightPoint, alpha); } extern "C" vtkNew < vtkBSPCuts > vtkBSPCuts_new () {return vtkNew < vtkBSPCuts > () ;} extern "C" void vtkBSPCuts_destructor (vtkNew < vtkBSPCuts > sself) {sself . Reset () ; return ;} extern "C" void * vtkBSPCuts_get_ptr (vtkNew < vtkBSPCuts > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bsp_cuts_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_bsp_cuts_create_cuts(vtkNew sself, double bounds, int ncuts, int dim, double coord, int lower, int upper, double lowerDataCoord, double upperDataCoord, int npoints) { sself->CreateCuts(bounds, ncuts, dim, coord, lower, upper, lowerDataCoord, upperDataCoord, npoints); } +extern "C" int vtk_bsp_cuts_get_number_of_cuts(vtkNew sself) { return sself->GetNumberOfCuts(); } +extern "C" int vtk_bsp_cuts_get_arrays(vtkNew sself, int len, int dim, double coord, int lower, int upper, double lowerDataCoord, double upperDataCoord, int npoints) { return sself->GetArrays(len, dim, coord, lower, upper, lowerDataCoord, upperDataCoord, npoints); } +extern "C" void vtk_bsp_cuts_print_tree(vtkNew sself) { sself->PrintTree(); } +extern "C" void vtk_bsp_cuts_print_arrays(vtkNew sself) { sself->PrintArrays(); } extern "C" vtkNew < vtkBSPIntersections > vtkBSPIntersections_new () {return vtkNew < vtkBSPIntersections > () ;} extern "C" void vtkBSPIntersections_destructor (vtkNew < vtkBSPIntersections > sself) {sself . Reset () ; return ;} extern "C" void * vtkBSPIntersections_get_ptr (vtkNew < vtkBSPIntersections > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bsp_intersections_get_bounds(vtkNew sself, double bounds) { return sself->GetBounds(bounds); } +extern "C" int vtk_bsp_intersections_get_number_of_regions(vtkNew sself) { return sself->GetNumberOfRegions(); } +extern "C" int vtk_bsp_intersections_get_region_bounds(vtkNew sself, int regionID, double bounds) { return sself->GetRegionBounds(regionID, bounds); } +extern "C" int vtk_bsp_intersections_get_region_data_bounds(vtkNew sself, int regionID, double bounds) { return sself->GetRegionDataBounds(regionID, bounds); } +extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int regionId, double x) { return sself->IntersectsBox(regionId, x); } +extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int regionId, double x0, double x1, double y0, double y1, double z0, double z1) { return sself->IntersectsBox(regionId, x0, x1, y0, y1, z0, z1); } +extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int ids, int len, double x) { return sself->IntersectsBox(ids, len, x); } +extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int ids, int len, double x0, double x1, double y0, double y1, double z0, double z1) { return sself->IntersectsBox(ids, len, x0, x1, y0, y1, z0, z1); } +extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkNew sself, int regionId, double x, double y, double z, double rSquared) { return sself->IntersectsSphere2(regionId, x, y, z, rSquared); } +extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkNew sself, int ids, int len, double x, double y, double z, double rSquared) { return sself->IntersectsSphere2(ids, len, x, y, z, rSquared); } +extern "C" int vtk_bsp_intersections_get_compute_intersections_using_data_bounds(vtkNew sself) { return sself->GetComputeIntersectionsUsingDataBounds(); } +extern "C" void vtk_bsp_intersections_set_compute_intersections_using_data_bounds(vtkNew sself, int c) { sself->SetComputeIntersectionsUsingDataBounds(c); } +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_on(vtkNew sself) { sself->ComputeIntersectionsUsingDataBoundsOn(); } +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_off(vtkNew sself) { sself->ComputeIntersectionsUsingDataBoundsOff(); } extern "C" vtkNew < vtkBezierCurve > vtkBezierCurve_new () {return vtkNew < vtkBezierCurve > () ;} extern "C" void vtkBezierCurve_destructor (vtkNew < vtkBezierCurve > sself) {sself . Reset () ; return ;} extern "C" void * vtkBezierCurve_get_ptr (vtkNew < vtkBezierCurve > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bezier_curve_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_bezier_curve_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } +extern "C" void vtk_bezier_curve_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkBezierHexahedron > vtkBezierHexahedron_new () {return vtkNew < vtkBezierHexahedron > () ;} extern "C" void vtkBezierHexahedron_destructor (vtkNew < vtkBezierHexahedron > sself) {sself . Reset () ; return ;} extern "C" void * vtkBezierHexahedron_get_ptr (vtkNew < vtkBezierHexahedron > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bezier_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_bezier_hexahedron_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } +extern "C" void vtk_bezier_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkBezierInterpolation > vtkBezierInterpolation_new () {return vtkNew < vtkBezierInterpolation > () ;} extern "C" void vtkBezierInterpolation_destructor (vtkNew < vtkBezierInterpolation > sself) {sself . Reset () ; return ;} extern "C" void * vtkBezierInterpolation_get_ptr (vtkNew < vtkBezierInterpolation > sself) {return sself . GetPointer () ;} +extern "C" void vtk_bezier_interpolation_de_casteljau_simplex(vtkNew sself, const int dim, const int deg, const double pcoords, double weights) { sself->deCasteljauSimplex(dim, deg, pcoords, weights); } +extern "C" void vtk_bezier_interpolation_de_casteljau_simplex(vtkNew sself, const int dim, const int deg, const double pcoords, double weights) { sself->DeCasteljauSimplex(dim, deg, pcoords, weights); } +extern "C" void vtk_bezier_interpolation_de_casteljau_simplex_deriv(vtkNew sself, const int dim, const int deg, const double pcoords, double weights) { sself->deCasteljauSimplexDeriv(dim, deg, pcoords, weights); } +extern "C" void vtk_bezier_interpolation_de_casteljau_simplex_deriv(vtkNew sself, const int dim, const int deg, const double pcoords, double weights) { sself->DeCasteljauSimplexDeriv(dim, deg, pcoords, weights); } +extern "C" void vtk_bezier_interpolation_evaluate_shape_functions(vtkNew sself, int order, double pcoord, double shape) { sself->EvaluateShapeFunctions(order, pcoord, shape); } +extern "C" void vtk_bezier_interpolation_evaluate_shape_and_gradient(vtkNew sself, int order, double pcoord, double shape, double grad) { sself->EvaluateShapeAndGradient(order, pcoord, shape, grad); } +extern "C" int vtk_bezier_interpolation_tensor_1_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor1ShapeFunctions(order, pcoords, shape); } +extern "C" int vtk_bezier_interpolation_tensor_1_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor1ShapeDerivatives(order, pcoords, derivs); } +extern "C" int vtk_bezier_interpolation_tensor_2_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor2ShapeFunctions(order, pcoords, shape); } +extern "C" int vtk_bezier_interpolation_tensor_2_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor2ShapeDerivatives(order, pcoords, derivs); } +extern "C" int vtk_bezier_interpolation_tensor_3_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor3ShapeFunctions(order, pcoords, shape); } +extern "C" int vtk_bezier_interpolation_tensor_3_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor3ShapeDerivatives(order, pcoords, derivs); } +extern "C" void vtk_bezier_interpolation_wedge_shape_functions(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double shape) { sself->WedgeShapeFunctions(order, numberOfPoints, pcoords, shape); } +extern "C" void vtk_bezier_interpolation_wedge_shape_derivatives(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double derivs) { sself->WedgeShapeDerivatives(order, numberOfPoints, pcoords, derivs); } +extern "C" void vtk_bezier_interpolation_wedge_evaluate(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double fieldVals, int fieldDim, double fieldAtPCoords) { sself->WedgeEvaluate(order, numberOfPoints, pcoords, fieldVals, fieldDim, fieldAtPCoords); } extern "C" vtkNew < vtkBezierQuadrilateral > vtkBezierQuadrilateral_new () {return vtkNew < vtkBezierQuadrilateral > () ;} extern "C" void vtkBezierQuadrilateral_destructor (vtkNew < vtkBezierQuadrilateral > sself) {sself . Reset () ; return ;} extern "C" void * vtkBezierQuadrilateral_get_ptr (vtkNew < vtkBezierQuadrilateral > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bezier_quadrilateral_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_bezier_quadrilateral_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } +extern "C" void vtk_bezier_quadrilateral_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkBezierTetra > vtkBezierTetra_new () {return vtkNew < vtkBezierTetra > () ;} extern "C" void vtkBezierTetra_destructor (vtkNew < vtkBezierTetra > sself) {sself . Reset () ; return ;} extern "C" void * vtkBezierTetra_get_ptr (vtkNew < vtkBezierTetra > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bezier_tetra_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_bezier_tetra_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } +extern "C" void vtk_bezier_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkBezierTriangle > vtkBezierTriangle_new () {return vtkNew < vtkBezierTriangle > () ;} extern "C" void vtkBezierTriangle_destructor (vtkNew < vtkBezierTriangle > sself) {sself . Reset () ; return ;} extern "C" void * vtkBezierTriangle_get_ptr (vtkNew < vtkBezierTriangle > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bezier_triangle_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_bezier_triangle_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } +extern "C" void vtk_bezier_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkBezierWedge > vtkBezierWedge_new () {return vtkNew < vtkBezierWedge > () ;} extern "C" void vtkBezierWedge_destructor (vtkNew < vtkBezierWedge > sself) {sself . Reset () ; return ;} extern "C" void * vtkBezierWedge_get_ptr (vtkNew < vtkBezierWedge > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bezier_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_bezier_wedge_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } +extern "C" void vtk_bezier_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkBiQuadraticQuad > vtkBiQuadraticQuad_new () {return vtkNew < vtkBiQuadraticQuad > () ;} extern "C" void vtkBiQuadraticQuad_destructor (vtkNew < vtkBiQuadraticQuad > sself) {sself . Reset () ; return ;} extern "C" void * vtkBiQuadraticQuad_get_ptr (vtkNew < vtkBiQuadraticQuad > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bi_quadratic_quad_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_quad_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_quad_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_quad_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_bi_quadratic_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_bi_quadratic_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_bi_quadratic_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_bi_quadratic_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_bi_quadratic_quad_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_bi_quadratic_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_bi_quadratic_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } extern "C" vtkNew < vtkBiQuadraticQuadraticHexahedron > vtkBiQuadraticQuadraticHexahedron_new () {return vtkNew < vtkBiQuadraticQuadraticHexahedron > () ;} extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) {sself . Reset () ; return ;} extern "C" void * vtkBiQuadraticQuadraticHexahedron_get_ptr (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_bi_quadratic_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_bi_quadratic_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" void vtk_bi_quadratic_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkBiQuadraticQuadraticWedge > vtkBiQuadraticQuadraticWedge_new () {return vtkNew < vtkBiQuadraticQuadraticWedge > () ;} extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkNew < vtkBiQuadraticQuadraticWedge > sself) {sself . Reset () ; return ;} extern "C" void * vtkBiQuadraticQuadraticWedge_get_ptr (vtkNew < vtkBiQuadraticQuadraticWedge > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_bi_quadratic_quadratic_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_bi_quadratic_quadratic_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_bi_quadratic_quadratic_wedge_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_bi_quadratic_quadratic_wedge_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" void vtk_bi_quadratic_quadratic_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkBiQuadraticTriangle > vtkBiQuadraticTriangle_new () {return vtkNew < vtkBiQuadraticTriangle > () ;} extern "C" void vtkBiQuadraticTriangle_destructor (vtkNew < vtkBiQuadraticTriangle > sself) {sself . Reset () ; return ;} extern "C" void * vtkBiQuadraticTriangle_get_ptr (vtkNew < vtkBiQuadraticTriangle > sself) {return sself . GetPointer () ;} +extern "C" int vtk_bi_quadratic_triangle_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_triangle_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_triangle_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_triangle_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_bi_quadratic_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_bi_quadratic_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_bi_quadratic_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_bi_quadratic_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_bi_quadratic_triangle_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" double vtk_bi_quadratic_triangle_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } +extern "C" void vtk_bi_quadratic_triangle_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_bi_quadratic_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_bi_quadratic_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_bi_quadratic_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } extern "C" vtkNew < vtkBox > vtkBox_new () {return vtkNew < vtkBox > () ;} extern "C" void vtkBox_destructor (vtkNew < vtkBox > sself) {sself . Reset () ; return ;} extern "C" void * vtkBox_get_ptr (vtkNew < vtkBox > sself) {return sself . GetPointer () ;} +extern "C" double vtk_box_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_box_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } +extern "C" void vtk_box_set_x_min(vtkNew sself, double p) { sself->SetXMin(p); } +extern "C" void vtk_box_set_x_min(vtkNew sself, double x, double y, double z) { sself->SetXMin(x, y, z); } +extern "C" void vtk_box_get_x_min(vtkNew sself, double p) { sself->GetXMin(p); } +extern "C" void vtk_box_get_x_min(vtkNew sself, double x, double y, double z) { sself->GetXMin(x, y, z); } +extern "C" void vtk_box_set_x_max(vtkNew sself, double p) { sself->SetXMax(p); } +extern "C" void vtk_box_set_x_max(vtkNew sself, double x, double y, double z) { sself->SetXMax(x, y, z); } +extern "C" void vtk_box_get_x_max(vtkNew sself, double p) { sself->GetXMax(p); } +extern "C" void vtk_box_get_x_max(vtkNew sself, double x, double y, double z) { sself->GetXMax(x, y, z); } +extern "C" void vtk_box_set_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" void vtk_box_set_bounds(vtkNew sself, const double bounds) { sself->SetBounds(bounds); } +extern "C" void vtk_box_get_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->GetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" void vtk_box_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" double* vtk_box_get_bounds(vtkNew sself) { return sself->GetBounds(); } +extern "C" void vtk_box_add_bounds(vtkNew sself, const double bounds) { sself->AddBounds(bounds); } +extern "C" char vtk_box_intersect_box(vtkNew sself, const double bounds, const double origin, const double dir, double coord, double t, const double tolerance) { return sself->IntersectBox(bounds, origin, dir, coord, t, tolerance); } +extern "C" int vtk_box_intersect_with_line(vtkNew sself, const double bounds, const double p1, const double p2, double t1, double t2, double x1, double x2, int plane1, int plane2) { return sself->IntersectWithLine(bounds, p1, p2, t1, t2, x1, x2, plane1, plane2); } +extern "C" bool vtk_box_intersect_with_infinite_line(vtkNew sself, const double bounds, const double p1, const double p2, double t1, double t2, double x1, double x2, int plane1, int plane2) { return sself->IntersectWithInfiniteLine(bounds, p1, p2, t1, t2, x1, x2, plane1, plane2); } +extern "C" int vtk_box_intersect_with_plane(vtkNew sself, double bounds, double origin, double normal) { return sself->IntersectWithPlane(bounds, origin, normal); } +extern "C" int vtk_box_intersect_with_plane(vtkNew sself, double bounds, double origin, double normal, double xout) { return sself->IntersectWithPlane(bounds, origin, normal, xout); } +extern "C" int vtk_box_is_box_in_frustum(vtkNew sself, double planes, double bounds) { return sself->IsBoxInFrustum(planes, bounds); } extern "C" vtkNew < vtkCellArray > vtkCellArray_new () {return vtkNew < vtkCellArray > () ;} extern "C" void vtkCellArray_destructor (vtkNew < vtkCellArray > sself) {sself . Reset () ; return ;} extern "C" void * vtkCellArray_get_ptr (vtkNew < vtkCellArray > sself) {return sself . GetPointer () ;} +extern "C" int vtk_cell_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" bool vtk_cell_array_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } +extern "C" bool vtk_cell_array_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } +extern "C" bool vtk_cell_array_resize_exact(vtkNew sself, long long numCells, long long connectivitySize) { return sself->ResizeExact(numCells, connectivitySize); } +extern "C" void vtk_cell_array_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_cell_array_reset(vtkNew sself) { sself->Reset(); } +extern "C" void vtk_cell_array_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" bool vtk_cell_array_is_valid(vtkNew sself) { return sself->IsValid(); } +extern "C" long long vtk_cell_array_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } +extern "C" long long vtk_cell_array_get_number_of_offsets(vtkNew sself) { return sself->GetNumberOfOffsets(); } +extern "C" long long vtk_cell_array_get_number_of_connectivity_ids(vtkNew sself) { return sself->GetNumberOfConnectivityIds(); } +extern "C" bool vtk_cell_array_is_storage_64_bit(vtkNew sself) { return sself->IsStorage64Bit(); } +extern "C" bool vtk_cell_array_is_storage_shareable(vtkNew sself) { return sself->IsStorageShareable(); } +extern "C" void vtk_cell_array_use_32_bit_storage(vtkNew sself) { sself->Use32BitStorage(); } +extern "C" void vtk_cell_array_use_64_bit_storage(vtkNew sself) { sself->Use64BitStorage(); } +extern "C" void vtk_cell_array_use_default_storage(vtkNew sself) { sself->UseDefaultStorage(); } +extern "C" bool vtk_cell_array_can_convert_to_32_bit_storage(vtkNew sself) { return sself->CanConvertTo32BitStorage(); } +extern "C" bool vtk_cell_array_can_convert_to_64_bit_storage(vtkNew sself) { return sself->CanConvertTo64BitStorage(); } +extern "C" bool vtk_cell_array_can_convert_to_default_storage(vtkNew sself) { return sself->CanConvertToDefaultStorage(); } +extern "C" bool vtk_cell_array_convert_to_32_bit_storage(vtkNew sself) { return sself->ConvertTo32BitStorage(); } +extern "C" bool vtk_cell_array_convert_to_64_bit_storage(vtkNew sself) { return sself->ConvertTo64BitStorage(); } +extern "C" bool vtk_cell_array_convert_to_default_storage(vtkNew sself) { return sself->ConvertToDefaultStorage(); } +extern "C" bool vtk_cell_array_convert_to_smallest_storage(vtkNew sself) { return sself->ConvertToSmallestStorage(); } +extern "C" long long vtk_cell_array_is_homogeneous(vtkNew sself) { return sself->IsHomogeneous(); } +extern "C" void vtk_cell_array_init_traversal(vtkNew sself) { sself->InitTraversal(); } +extern "C" int vtk_cell_array_get_next_cell(vtkNew sself, long long npts, const long long pts) { return sself->GetNextCell(npts, pts); } +extern "C" void vtk_cell_array_get_cell_at_id(vtkNew sself, long long cellId, long long cellSize, const long long cellPoints) { sself->GetCellAtId(cellId, cellSize, cellPoints); } +extern "C" long long vtk_cell_array_get_cell_size(vtkNew sself, const long long cellId) { return sself->GetCellSize(cellId); } +extern "C" long long vtk_cell_array_insert_next_cell(vtkNew sself, long long npts, const long long pts) { return sself->InsertNextCell(npts, pts); } +extern "C" long long vtk_cell_array_insert_next_cell(vtkNew sself, int npts) { return sself->InsertNextCell(npts); } +extern "C" void vtk_cell_array_insert_cell_point(vtkNew sself, long long id) { sself->InsertCellPoint(id); } +extern "C" void vtk_cell_array_update_cell_count(vtkNew sself, int npts) { sself->UpdateCellCount(npts); } +extern "C" long long vtk_cell_array_get_traversal_cell_id(vtkNew sself) { return sself->GetTraversalCellId(); } +extern "C" void vtk_cell_array_set_traversal_cell_id(vtkNew sself, long long cellId) { sself->SetTraversalCellId(cellId); } +extern "C" void vtk_cell_array_reverse_cell_at_id(vtkNew sself, long long cellId) { sself->ReverseCellAtId(cellId); } +extern "C" void vtk_cell_array_replace_cell_at_id(vtkNew sself, long long cellId, long long cellSize, const long long cellPoints) { sself->ReplaceCellAtId(cellId, cellSize, cellPoints); } +extern "C" int vtk_cell_array_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } +extern "C" void vtk_cell_array_import_legacy_format(vtkNew sself, const long long data, long long len) { sself->ImportLegacyFormat(data, len); } +extern "C" void vtk_cell_array_append_legacy_format(vtkNew sself, const long long data, long long len, long long ptOffset) { sself->AppendLegacyFormat(data, len, ptOffset); } +extern "C" unsigned long vtk_cell_array_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" void vtk_cell_array_set_number_of_cells(vtkNew sself, long long p0) { sself->SetNumberOfCells(p0); } +extern "C" long long vtk_cell_array_estimate_size(vtkNew sself, long long numCells, int maxPtsPerCell) { return sself->EstimateSize(numCells, maxPtsPerCell); } +extern "C" long long vtk_cell_array_get_size(vtkNew sself) { return sself->GetSize(); } +extern "C" long long vtk_cell_array_get_number_of_connectivity_entries(vtkNew sself) { return sself->GetNumberOfConnectivityEntries(); } +extern "C" void vtk_cell_array_get_cell(vtkNew sself, long long loc, long long npts, const long long pts) { sself->GetCell(loc, npts, pts); } +extern "C" long long vtk_cell_array_get_insert_location(vtkNew sself, int npts) { return sself->GetInsertLocation(npts); } +extern "C" long long vtk_cell_array_get_traversal_location(vtkNew sself) { return sself->GetTraversalLocation(); } +extern "C" long long vtk_cell_array_get_traversal_location(vtkNew sself, long long npts) { return sself->GetTraversalLocation(npts); } +extern "C" void vtk_cell_array_set_traversal_location(vtkNew sself, long long loc) { sself->SetTraversalLocation(loc); } +extern "C" void vtk_cell_array_reverse_cell(vtkNew sself, long long loc) { sself->ReverseCell(loc); } +extern "C" void vtk_cell_array_replace_cell(vtkNew sself, long long loc, int npts, const long long pts) { sself->ReplaceCell(loc, npts, pts); } extern "C" vtkNew < vtkCellArrayIterator > vtkCellArrayIterator_new () {return vtkNew < vtkCellArrayIterator > () ;} extern "C" void vtkCellArrayIterator_destructor (vtkNew < vtkCellArrayIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkCellArrayIterator_get_ptr (vtkNew < vtkCellArrayIterator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_cell_array_iterator_go_to_cell(vtkNew sself, long long cellId) { sself->GoToCell(cellId); } +extern "C" void vtk_cell_array_iterator_get_cell_at_id(vtkNew sself, long long cellId, long long numCellPts, const long long cellPts) { sself->GetCellAtId(cellId, numCellPts, cellPts); } +extern "C" void vtk_cell_array_iterator_go_to_first_cell(vtkNew sself) { sself->GoToFirstCell(); } +extern "C" void vtk_cell_array_iterator_go_to_next_cell(vtkNew sself) { sself->GoToNextCell(); } +extern "C" bool vtk_cell_array_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_cell_array_iterator_get_current_cell_id(vtkNew sself) { return sself->GetCurrentCellId(); } +extern "C" void vtk_cell_array_iterator_get_current_cell(vtkNew sself, long long cellSize, const long long cellPoints) { sself->GetCurrentCell(cellSize, cellPoints); } +extern "C" void vtk_cell_array_iterator_replace_current_cell(vtkNew sself, long long npts, const long long pts) { sself->ReplaceCurrentCell(npts, pts); } +extern "C" void vtk_cell_array_iterator_reverse_current_cell(vtkNew sself) { sself->ReverseCurrentCell(); } extern "C" vtkNew < vtkCellData > vtkCellData_new () {return vtkNew < vtkCellData > () ;} extern "C" void vtkCellData_destructor (vtkNew < vtkCellData > sself) {sself . Reset () ; return ;} extern "C" void * vtkCellData_get_ptr (vtkNew < vtkCellData > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkCellLinks > vtkCellLinks_new () {return vtkNew < vtkCellLinks > () ;} extern "C" void vtkCellLinks_destructor (vtkNew < vtkCellLinks > sself) {sself . Reset () ; return ;} extern "C" void * vtkCellLinks_get_ptr (vtkNew < vtkCellLinks > sself) {return sself . GetPointer () ;} +extern "C" void vtk_cell_links_allocate(vtkNew sself, long long numLinks, long long ext) { sself->Allocate(numLinks, ext); } +extern "C" void vtk_cell_links_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" long long vtk_cell_links_get_ncells(vtkNew sself, long long ptId) { return sself->GetNcells(ptId); } +extern "C" long long* vtk_cell_links_get_cells(vtkNew sself, long long ptId) { return sself->GetCells(ptId); } +extern "C" void vtk_cell_links_select_cells(vtkNew sself, long long minMaxDegree, unsigned char cellSelection) { sself->SelectCells(minMaxDegree, cellSelection); } +extern "C" long long vtk_cell_links_insert_next_point(vtkNew sself, int numLinks) { return sself->InsertNextPoint(numLinks); } +extern "C" void vtk_cell_links_insert_next_cell_reference(vtkNew sself, long long ptId, long long cellId) { sself->InsertNextCellReference(ptId, cellId); } +extern "C" void vtk_cell_links_delete_point(vtkNew sself, long long ptId) { sself->DeletePoint(ptId); } +extern "C" void vtk_cell_links_remove_cell_reference(vtkNew sself, long long cellId, long long ptId) { sself->RemoveCellReference(cellId, ptId); } +extern "C" void vtk_cell_links_add_cell_reference(vtkNew sself, long long cellId, long long ptId) { sself->AddCellReference(cellId, ptId); } +extern "C" void vtk_cell_links_resize_cell_list(vtkNew sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } +extern "C" void vtk_cell_links_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" void vtk_cell_links_reset(vtkNew sself) { sself->Reset(); } +extern "C" unsigned long vtk_cell_links_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } extern "C" vtkNew < vtkCellLocator > vtkCellLocator_new () {return vtkNew < vtkCellLocator > () ;} extern "C" void vtkCellLocator_destructor (vtkNew < vtkCellLocator > sself) {sself . Reset () ; return ;} extern "C" void * vtkCellLocator_get_ptr (vtkNew < vtkCellLocator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_cell_locator_set_number_of_cells_per_bucket(vtkNew sself, int N) { sself->SetNumberOfCellsPerBucket(N); } +extern "C" int vtk_cell_locator_get_number_of_cells_per_bucket(vtkNew sself) { return sself->GetNumberOfCellsPerBucket(); } +extern "C" int vtk_cell_locator_get_number_of_buckets(vtkNew sself) { return sself->GetNumberOfBuckets(); } +extern "C" void vtk_cell_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_cell_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } +extern "C" void vtk_cell_locator_build_locator_if_needed(vtkNew sself) { sself->BuildLocatorIfNeeded(); } +extern "C" void vtk_cell_locator_force_build_locator(vtkNew sself) { sself->ForceBuildLocator(); } +extern "C" void vtk_cell_locator_build_locator_internal(vtkNew sself) { sself->BuildLocatorInternal(); } extern "C" vtkNew < vtkCellLocatorStrategy > vtkCellLocatorStrategy_new () {return vtkNew < vtkCellLocatorStrategy > () ;} extern "C" void vtkCellLocatorStrategy_destructor (vtkNew < vtkCellLocatorStrategy > sself) {sself . Reset () ; return ;} extern "C" void * vtkCellLocatorStrategy_get_ptr (vtkNew < vtkCellLocatorStrategy > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellTreeLocator > vtkCellTreeLocator_new () {return vtkNew < vtkCellTreeLocator > () ;} -extern "C" void vtkCellTreeLocator_destructor (vtkNew < vtkCellTreeLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellTreeLocator_get_ptr (vtkNew < vtkCellTreeLocator > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkCellTypes > vtkCellTypes_new () {return vtkNew < vtkCellTypes > () ;} extern "C" void vtkCellTypes_destructor (vtkNew < vtkCellTypes > sself) {sself . Reset () ; return ;} extern "C" void * vtkCellTypes_get_ptr (vtkNew < vtkCellTypes > sself) {return sself . GetPointer () ;} +extern "C" int vtk_cell_types_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_cell_types_insert_cell(vtkNew sself, long long id, unsigned char type, long long loc) { sself->InsertCell(id, type, loc); } +extern "C" long long vtk_cell_types_insert_next_cell(vtkNew sself, unsigned char type, long long loc) { return sself->InsertNextCell(type, loc); } +extern "C" long long vtk_cell_types_get_cell_location(vtkNew sself, long long cellId) { return sself->GetCellLocation(cellId); } +extern "C" void vtk_cell_types_delete_cell(vtkNew sself, long long cellId) { sself->DeleteCell(cellId); } +extern "C" long long vtk_cell_types_get_number_of_types(vtkNew sself) { return sself->GetNumberOfTypes(); } +extern "C" int vtk_cell_types_is_type(vtkNew sself, unsigned char type) { return sself->IsType(type); } +extern "C" long long vtk_cell_types_insert_next_type(vtkNew sself, unsigned char type) { return sself->InsertNextType(type); } +extern "C" unsigned char vtk_cell_types_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_cell_types_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" void vtk_cell_types_reset(vtkNew sself) { sself->Reset(); } +extern "C" unsigned long vtk_cell_types_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" const char* vtk_cell_types_get_class_name_from_type_id(vtkNew sself, int typeId) { return sself->GetClassNameFromTypeId(typeId); } +extern "C" int vtk_cell_types_get_type_id_from_class_name(vtkNew sself, const char classname) { return sself->GetTypeIdFromClassName(classname); } +extern "C" int vtk_cell_types_is_linear(vtkNew sself, unsigned char type) { return sself->IsLinear(type); } extern "C" vtkNew < vtkClosestNPointsStrategy > vtkClosestNPointsStrategy_new () {return vtkNew < vtkClosestNPointsStrategy > () ;} extern "C" void vtkClosestNPointsStrategy_destructor (vtkNew < vtkClosestNPointsStrategy > sself) {sself . Reset () ; return ;} extern "C" void * vtkClosestNPointsStrategy_get_ptr (vtkNew < vtkClosestNPointsStrategy > sself) {return sself . GetPointer () ;} +extern "C" void vtk_closest_n_points_strategy_set_closest_n_points(vtkNew sself, int _arg) { sself->SetClosestNPoints(_arg); } +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_min_value(vtkNew sself) { return sself->GetClosestNPointsMinValue(); } +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_max_value(vtkNew sself) { return sself->GetClosestNPointsMaxValue(); } +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points(vtkNew sself) { return sself->GetClosestNPoints(); } extern "C" vtkNew < vtkClosestPointStrategy > vtkClosestPointStrategy_new () {return vtkNew < vtkClosestPointStrategy > () ;} extern "C" void vtkClosestPointStrategy_destructor (vtkNew < vtkClosestPointStrategy > sself) {sself . Reset () ; return ;} extern "C" void * vtkClosestPointStrategy_get_ptr (vtkNew < vtkClosestPointStrategy > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkCone > vtkCone_new () {return vtkNew < vtkCone > () ;} extern "C" void vtkCone_destructor (vtkNew < vtkCone > sself) {sself . Reset () ; return ;} extern "C" void * vtkCone_get_ptr (vtkNew < vtkCone > sself) {return sself . GetPointer () ;} +extern "C" double vtk_cone_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_cone_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } +extern "C" void vtk_cone_set_angle(vtkNew sself, double _arg) { sself->SetAngle(_arg); } +extern "C" double vtk_cone_get_angle_min_value(vtkNew sself) { return sself->GetAngleMinValue(); } +extern "C" double vtk_cone_get_angle_max_value(vtkNew sself) { return sself->GetAngleMaxValue(); } +extern "C" double vtk_cone_get_angle(vtkNew sself) { return sself->GetAngle(); } extern "C" vtkNew < vtkConvexPointSet > vtkConvexPointSet_new () {return vtkNew < vtkConvexPointSet > () ;} extern "C" void vtkConvexPointSet_destructor (vtkNew < vtkConvexPointSet > sself) {sself . Reset () ; return ;} extern "C" void * vtkConvexPointSet_get_ptr (vtkNew < vtkConvexPointSet > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCoordinateFrame > vtkCoordinateFrame_new () {return vtkNew < vtkCoordinateFrame > () ;} -extern "C" void vtkCoordinateFrame_destructor (vtkNew < vtkCoordinateFrame > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCoordinateFrame_get_ptr (vtkNew < vtkCoordinateFrame > sself) {return sself . GetPointer () ;} +extern "C" int vtk_convex_point_set_has_fixed_topology(vtkNew sself) { return sself->HasFixedTopology(); } +extern "C" void vtk_convex_point_set_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" void vtk_convex_point_set_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" long long vtk_convex_point_set_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_convex_point_set_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_convex_point_set_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } +extern "C" long long vtk_convex_point_set_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } +extern "C" long long vtk_convex_point_set_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } +extern "C" long long vtk_convex_point_set_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } +extern "C" long long vtk_convex_point_set_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } +extern "C" bool vtk_convex_point_set_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } +extern "C" double* vtk_convex_point_set_get_parametric_coords(vtkNew sself) { return sself->GetParametricCoords(); } +extern "C" int vtk_convex_point_set_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_convex_point_set_requires_initialization(vtkNew sself) { return sself->RequiresInitialization(); } +extern "C" int vtk_convex_point_set_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_convex_point_set_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_convex_point_set_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_convex_point_set_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_convex_point_set_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_convex_point_set_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_convex_point_set_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" int vtk_convex_point_set_is_primary_cell(vtkNew sself) { return sself->IsPrimaryCell(); } +extern "C" void vtk_convex_point_set_interpolate_functions(vtkNew sself, const double pcoords, double sf) { sself->InterpolateFunctions(pcoords, sf); } extern "C" vtkNew < vtkCubicLine > vtkCubicLine_new () {return vtkNew < vtkCubicLine > () ;} extern "C" void vtkCubicLine_destructor (vtkNew < vtkCubicLine > sself) {sself . Reset () ; return ;} extern "C" void * vtkCubicLine_get_ptr (vtkNew < vtkCubicLine > sself) {return sself . GetPointer () ;} +extern "C" int vtk_cubic_line_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_cubic_line_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_cubic_line_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_cubic_line_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_cubic_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_cubic_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_cubic_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" double vtk_cubic_line_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } +extern "C" int vtk_cubic_line_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" int vtk_cubic_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_cubic_line_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_cubic_line_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_cubic_line_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_cubic_line_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } extern "C" vtkNew < vtkCylinder > vtkCylinder_new () {return vtkNew < vtkCylinder > () ;} extern "C" void vtkCylinder_destructor (vtkNew < vtkCylinder > sself) {sself . Reset () ; return ;} extern "C" void * vtkCylinder_get_ptr (vtkNew < vtkCylinder > sself) {return sself . GetPointer () ;} +extern "C" double vtk_cylinder_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_cylinder_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } +extern "C" void vtk_cylinder_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_cylinder_get_radius(vtkNew sself) { return sself->GetRadius(); } +extern "C" void vtk_cylinder_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_cylinder_set_center(vtkNew sself, const double _arg) { sself->SetCenter(_arg); } +extern "C" double* vtk_cylinder_get_center(vtkNew sself) { return sself->GetCenter(); } +extern "C" void vtk_cylinder_get_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_cylinder_get_center(vtkNew sself, double _arg) { sself->GetCenter(_arg); } +extern "C" void vtk_cylinder_set_axis(vtkNew sself, double ax, double ay, double az) { sself->SetAxis(ax, ay, az); } +extern "C" void vtk_cylinder_set_axis(vtkNew sself, double a) { sself->SetAxis(a); } +extern "C" double* vtk_cylinder_get_axis(vtkNew sself) { return sself->GetAxis(); } +extern "C" void vtk_cylinder_get_axis(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetAxis(_arg1, _arg2, _arg3); } +extern "C" void vtk_cylinder_get_axis(vtkNew sself, double _arg) { sself->GetAxis(_arg); } extern "C" vtkNew < vtkDataAssembly > vtkDataAssembly_new () {return vtkNew < vtkDataAssembly > () ;} extern "C" void vtkDataAssembly_destructor (vtkNew < vtkDataAssembly > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataAssembly_get_ptr (vtkNew < vtkDataAssembly > sself) {return sself . GetPointer () ;} +extern "C" void vtk_data_assembly_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" bool vtk_data_assembly_initialize_from_xml(vtkNew sself, const char xmlcontents) { return sself->InitializeFromXML(xmlcontents); } +extern "C" int vtk_data_assembly_get_root_node(vtkNew sself) { return sself->GetRootNode(); } +extern "C" void vtk_data_assembly_set_root_node_name(vtkNew sself, const char name) { sself->SetRootNodeName(name); } +extern "C" const char* vtk_data_assembly_get_root_node_name(vtkNew sself) { return sself->GetRootNodeName(); } +extern "C" int vtk_data_assembly_add_node(vtkNew sself, const char name, int parent) { return sself->AddNode(name, parent); } +extern "C" bool vtk_data_assembly_remove_node(vtkNew sself, int id) { return sself->RemoveNode(id); } +extern "C" void vtk_data_assembly_set_node_name(vtkNew sself, int id, const char name) { sself->SetNodeName(id, name); } +extern "C" const char* vtk_data_assembly_get_node_name(vtkNew sself, int id) { return sself->GetNodeName(id); } +extern "C" const char* vtk_data_assembly_get_node_path(vtkNew sself, int id) { return sself->GetNodePath(id); } +extern "C" int vtk_data_assembly_get_first_node_by_path(vtkNew sself, const char path) { return sself->GetFirstNodeByPath(path); } +extern "C" bool vtk_data_assembly_add_data_set_index(vtkNew sself, int id, unsigned int dataset_index) { return sself->AddDataSetIndex(id, dataset_index); } +extern "C" bool vtk_data_assembly_add_data_set_index_range(vtkNew sself, int id, unsigned int index_start, int count) { return sself->AddDataSetIndexRange(id, index_start, count); } +extern "C" bool vtk_data_assembly_remove_data_set_index(vtkNew sself, int id, unsigned int dataset_index) { return sself->RemoveDataSetIndex(id, dataset_index); } +extern "C" bool vtk_data_assembly_remove_all_data_set_indices(vtkNew sself, int id, bool traverse_subtree) { return sself->RemoveAllDataSetIndices(id, traverse_subtree); } +extern "C" int vtk_data_assembly_find_first_node_with_name(vtkNew sself, const char name, int traversal_order) { return sself->FindFirstNodeWithName(name, traversal_order); } +extern "C" int vtk_data_assembly_get_number_of_children(vtkNew sself, int parent) { return sself->GetNumberOfChildren(parent); } +extern "C" int vtk_data_assembly_get_child(vtkNew sself, int parent, int index) { return sself->GetChild(parent, index); } +extern "C" int vtk_data_assembly_get_child_index(vtkNew sself, int parent, int child) { return sself->GetChildIndex(parent, child); } +extern "C" int vtk_data_assembly_get_parent(vtkNew sself, int id) { return sself->GetParent(id); } +extern "C" bool vtk_data_assembly_has_attribute(vtkNew sself, int id, const char name) { return sself->HasAttribute(id, name); } +extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, const char value) { sself->SetAttribute(id, name, value); } +extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, int value) { sself->SetAttribute(id, name, value); } +extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, unsigned int value) { sself->SetAttribute(id, name, value); } +extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, long long value) { sself->SetAttribute(id, name, value); } +extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, const char value) { return sself->GetAttribute(id, name, value); } +extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, int value) { return sself->GetAttribute(id, name, value); } +extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, unsigned int value) { return sself->GetAttribute(id, name, value); } +extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, long long value) { return sself->GetAttribute(id, name, value); } +extern "C" const char* vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, const char default_value) { return sself->GetAttributeOrDefault(id, name, default_value); } +extern "C" int vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, int default_value) { return sself->GetAttributeOrDefault(id, name, default_value); } +extern "C" unsigned int vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, unsigned int default_value) { return sself->GetAttributeOrDefault(id, name, default_value); } +extern "C" long long vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, long long default_value) { return sself->GetAttributeOrDefault(id, name, default_value); } +extern "C" bool vtk_data_assembly_is_node_name_valid(vtkNew sself, const char name) { return sself->IsNodeNameValid(name); } +extern "C" const char* vtk_data_assembly_make_valid_node_name(vtkNew sself, const char name) { return sself->MakeValidNodeName(name); } +extern "C" bool vtk_data_assembly_is_node_name_reserved(vtkNew sself, const char name) { return sself->IsNodeNameReserved(name); } extern "C" vtkNew < vtkDataAssemblyUtilities > vtkDataAssemblyUtilities_new () {return vtkNew < vtkDataAssemblyUtilities > () ;} extern "C" void vtkDataAssemblyUtilities_destructor (vtkNew < vtkDataAssemblyUtilities > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataAssemblyUtilities_get_ptr (vtkNew < vtkDataAssemblyUtilities > sself) {return sself . GetPointer () ;} +extern "C" const char* vtk_data_assembly_utilities_hierarchy_name(vtkNew sself) { return sself->HierarchyName(); } extern "C" vtkNew < vtkDataObject > vtkDataObject_new () {return vtkNew < vtkDataObject > () ;} extern "C" void vtkDataObject_destructor (vtkNew < vtkDataObject > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataObject_get_ptr (vtkNew < vtkDataObject > sself) {return sself . GetPointer () ;} +extern "C" unsigned long vtk_data_object_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_data_object_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_data_object_release_data(vtkNew sself) { sself->ReleaseData(); } +extern "C" int vtk_data_object_get_data_released(vtkNew sself) { return sself->GetDataReleased(); } +extern "C" void vtk_data_object_set_global_release_data_flag(vtkNew sself, int val) { sself->SetGlobalReleaseDataFlag(val); } +extern "C" void vtk_data_object_global_release_data_flag_on(vtkNew sself) { sself->GlobalReleaseDataFlagOn(); } +extern "C" void vtk_data_object_global_release_data_flag_off(vtkNew sself) { sself->GlobalReleaseDataFlagOff(); } +extern "C" int vtk_data_object_get_global_release_data_flag(vtkNew sself) { return sself->GetGlobalReleaseDataFlag(); } +extern "C" int vtk_data_object_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" unsigned long vtk_data_object_get_update_time(vtkNew sself) { return sself->GetUpdateTime(); } +extern "C" unsigned long vtk_data_object_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" void vtk_data_object_data_has_been_generated(vtkNew sself) { sself->DataHasBeenGenerated(); } +extern "C" void vtk_data_object_prepare_for_new_data(vtkNew sself) { sself->PrepareForNewData(); } +extern "C" int vtk_data_object_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } +extern "C" void vtk_data_object_crop(vtkNew sself, const int updateExtent) { sself->Crop(updateExtent); } +extern "C" long long vtk_data_object_get_number_of_elements(vtkNew sself, int type) { return sself->GetNumberOfElements(type); } +extern "C" const char* vtk_data_object_get_association_type_as_string(vtkNew sself, int associationType) { return sself->GetAssociationTypeAsString(associationType); } +extern "C" int vtk_data_object_get_association_type_from_string(vtkNew sself, const char associationName) { return sself->GetAssociationTypeFromString(associationName); } extern "C" vtkNew < vtkDataObjectCollection > vtkDataObjectCollection_new () {return vtkNew < vtkDataObjectCollection > () ;} extern "C" void vtkDataObjectCollection_destructor (vtkNew < vtkDataObjectCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataObjectCollection_get_ptr (vtkNew < vtkDataObjectCollection > sself) {return sself . GetPointer () ;} +extern "C" int vtk_data_object_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } extern "C" vtkNew < vtkDataObjectTreeIterator > vtkDataObjectTreeIterator_new () {return vtkNew < vtkDataObjectTreeIterator > () ;} extern "C" void vtkDataObjectTreeIterator_destructor (vtkNew < vtkDataObjectTreeIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataObjectTreeIterator_get_ptr (vtkNew < vtkDataObjectTreeIterator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_data_object_tree_iterator_go_to_first_item(vtkNew sself) { sself->GoToFirstItem(); } +extern "C" void vtk_data_object_tree_iterator_go_to_next_item(vtkNew sself) { sself->GoToNextItem(); } +extern "C" int vtk_data_object_tree_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } +extern "C" int vtk_data_object_tree_iterator_has_current_meta_data(vtkNew sself) { return sself->HasCurrentMetaData(); } +extern "C" unsigned int vtk_data_object_tree_iterator_get_current_flat_index(vtkNew sself) { return sself->GetCurrentFlatIndex(); } +extern "C" void vtk_data_object_tree_iterator_set_visit_only_leaves(vtkNew sself, int _arg) { sself->SetVisitOnlyLeaves(_arg); } +extern "C" int vtk_data_object_tree_iterator_get_visit_only_leaves(vtkNew sself) { return sself->GetVisitOnlyLeaves(); } +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_on(vtkNew sself) { sself->VisitOnlyLeavesOn(); } +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_off(vtkNew sself) { sself->VisitOnlyLeavesOff(); } +extern "C" void vtk_data_object_tree_iterator_set_traverse_sub_tree(vtkNew sself, int _arg) { sself->SetTraverseSubTree(_arg); } +extern "C" int vtk_data_object_tree_iterator_get_traverse_sub_tree(vtkNew sself) { return sself->GetTraverseSubTree(); } +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_on(vtkNew sself) { sself->TraverseSubTreeOn(); } +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_off(vtkNew sself) { sself->TraverseSubTreeOff(); } extern "C" vtkNew < vtkDataObjectTypes > vtkDataObjectTypes_new () {return vtkNew < vtkDataObjectTypes > () ;} extern "C" void vtkDataObjectTypes_destructor (vtkNew < vtkDataObjectTypes > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataObjectTypes_get_ptr (vtkNew < vtkDataObjectTypes > sself) {return sself . GetPointer () ;} +extern "C" const char* vtk_data_object_types_get_class_name_from_type_id(vtkNew sself, int typeId) { return sself->GetClassNameFromTypeId(typeId); } +extern "C" int vtk_data_object_types_get_type_id_from_class_name(vtkNew sself, const char classname) { return sself->GetTypeIdFromClassName(classname); } +extern "C" bool vtk_data_object_types_type_id_is_a(vtkNew sself, int typeId, int targetTypeId) { return sself->TypeIdIsA(typeId, targetTypeId); } +extern "C" int vtk_data_object_types_get_common_base_type_id(vtkNew sself, int typeA, int typeB) { return sself->GetCommonBaseTypeId(typeA, typeB); } extern "C" vtkNew < vtkDataSetAttributes > vtkDataSetAttributes_new () {return vtkNew < vtkDataSetAttributes > () ;} extern "C" void vtkDataSetAttributes_destructor (vtkNew < vtkDataSetAttributes > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataSetAttributes_get_ptr (vtkNew < vtkDataSetAttributes > sself) {return sself . GetPointer () ;} +extern "C" void vtk_data_set_attributes_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_data_set_attributes_update(vtkNew sself) { sself->Update(); } +extern "C" const char* vtk_data_set_attributes_ghost_array_name(vtkNew sself) { return sself->GhostArrayName(); } +extern "C" int vtk_data_set_attributes_set_active_scalars(vtkNew sself, const char name) { return sself->SetActiveScalars(name); } +extern "C" int vtk_data_set_attributes_set_active_vectors(vtkNew sself, const char name) { return sself->SetActiveVectors(name); } +extern "C" int vtk_data_set_attributes_set_active_normals(vtkNew sself, const char name) { return sself->SetActiveNormals(name); } +extern "C" int vtk_data_set_attributes_set_active_tangents(vtkNew sself, const char name) { return sself->SetActiveTangents(name); } +extern "C" int vtk_data_set_attributes_set_active_t_coords(vtkNew sself, const char name) { return sself->SetActiveTCoords(name); } +extern "C" int vtk_data_set_attributes_set_active_tensors(vtkNew sself, const char name) { return sself->SetActiveTensors(name); } +extern "C" int vtk_data_set_attributes_set_active_global_ids(vtkNew sself, const char name) { return sself->SetActiveGlobalIds(name); } +extern "C" int vtk_data_set_attributes_set_active_pedigree_ids(vtkNew sself, const char name) { return sself->SetActivePedigreeIds(name); } +extern "C" int vtk_data_set_attributes_set_active_rational_weights(vtkNew sself, const char name) { return sself->SetActiveRationalWeights(name); } +extern "C" int vtk_data_set_attributes_set_active_higher_order_degrees(vtkNew sself, const char name) { return sself->SetActiveHigherOrderDegrees(name); } +extern "C" int vtk_data_set_attributes_set_active_attribute(vtkNew sself, const char name, int attributeType) { return sself->SetActiveAttribute(name, attributeType); } +extern "C" int vtk_data_set_attributes_set_active_attribute(vtkNew sself, int index, int attributeType) { return sself->SetActiveAttribute(index, attributeType); } +extern "C" void vtk_data_set_attributes_get_attribute_indices(vtkNew sself, int indexArray) { sself->GetAttributeIndices(indexArray); } +extern "C" int vtk_data_set_attributes_is_array_an_attribute(vtkNew sself, int idx) { return sself->IsArrayAnAttribute(idx); } +extern "C" const char* vtk_data_set_attributes_get_attribute_type_as_string(vtkNew sself, int attributeType) { return sself->GetAttributeTypeAsString(attributeType); } +extern "C" const char* vtk_data_set_attributes_get_long_attribute_type_as_string(vtkNew sself, int attributeType) { return sself->GetLongAttributeTypeAsString(attributeType); } +extern "C" void vtk_data_set_attributes_set_copy_attribute(vtkNew sself, int index, int value, int ctype) { sself->SetCopyAttribute(index, value, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_attribute(vtkNew sself, int index, int ctype) { return sself->GetCopyAttribute(index, ctype); } +extern "C" void vtk_data_set_attributes_set_copy_scalars(vtkNew sself, int i, int ctype) { sself->SetCopyScalars(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_scalars(vtkNew sself, int ctype) { return sself->GetCopyScalars(ctype); } +extern "C" void vtk_data_set_attributes_copy_scalars_on(vtkNew sself) { sself->CopyScalarsOn(); } +extern "C" void vtk_data_set_attributes_copy_scalars_off(vtkNew sself) { sself->CopyScalarsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_vectors(vtkNew sself, int i, int ctype) { sself->SetCopyVectors(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_vectors(vtkNew sself, int ctype) { return sself->GetCopyVectors(ctype); } +extern "C" void vtk_data_set_attributes_copy_vectors_on(vtkNew sself) { sself->CopyVectorsOn(); } +extern "C" void vtk_data_set_attributes_copy_vectors_off(vtkNew sself) { sself->CopyVectorsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_normals(vtkNew sself, int i, int ctype) { sself->SetCopyNormals(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_normals(vtkNew sself, int ctype) { return sself->GetCopyNormals(ctype); } +extern "C" void vtk_data_set_attributes_copy_normals_on(vtkNew sself) { sself->CopyNormalsOn(); } +extern "C" void vtk_data_set_attributes_copy_normals_off(vtkNew sself) { sself->CopyNormalsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_tangents(vtkNew sself, int i, int ctype) { sself->SetCopyTangents(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_tangents(vtkNew sself, int ctype) { return sself->GetCopyTangents(ctype); } +extern "C" void vtk_data_set_attributes_copy_tangents_on(vtkNew sself) { sself->CopyTangentsOn(); } +extern "C" void vtk_data_set_attributes_copy_tangents_off(vtkNew sself) { sself->CopyTangentsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_t_coords(vtkNew sself, int i, int ctype) { sself->SetCopyTCoords(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_t_coords(vtkNew sself, int ctype) { return sself->GetCopyTCoords(ctype); } +extern "C" void vtk_data_set_attributes_copy_t_coords_on(vtkNew sself) { sself->CopyTCoordsOn(); } +extern "C" void vtk_data_set_attributes_copy_t_coords_off(vtkNew sself) { sself->CopyTCoordsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_tensors(vtkNew sself, int i, int ctype) { sself->SetCopyTensors(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_tensors(vtkNew sself, int ctype) { return sself->GetCopyTensors(ctype); } +extern "C" void vtk_data_set_attributes_copy_tensors_on(vtkNew sself) { sself->CopyTensorsOn(); } +extern "C" void vtk_data_set_attributes_copy_tensors_off(vtkNew sself) { sself->CopyTensorsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_global_ids(vtkNew sself, int i, int ctype) { sself->SetCopyGlobalIds(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_global_ids(vtkNew sself, int ctype) { return sself->GetCopyGlobalIds(ctype); } +extern "C" void vtk_data_set_attributes_copy_global_ids_on(vtkNew sself) { sself->CopyGlobalIdsOn(); } +extern "C" void vtk_data_set_attributes_copy_global_ids_off(vtkNew sself) { sself->CopyGlobalIdsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_pedigree_ids(vtkNew sself, int i, int ctype) { sself->SetCopyPedigreeIds(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_pedigree_ids(vtkNew sself, int ctype) { return sself->GetCopyPedigreeIds(ctype); } +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_on(vtkNew sself) { sself->CopyPedigreeIdsOn(); } +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_off(vtkNew sself) { sself->CopyPedigreeIdsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_rational_weights(vtkNew sself, int i, int ctype) { sself->SetCopyRationalWeights(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_rational_weights(vtkNew sself, int ctype) { return sself->GetCopyRationalWeights(ctype); } +extern "C" void vtk_data_set_attributes_copy_rational_weights_on(vtkNew sself) { sself->CopyRationalWeightsOn(); } +extern "C" void vtk_data_set_attributes_copy_rational_weights_off(vtkNew sself) { sself->CopyRationalWeightsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_higher_order_degrees(vtkNew sself, int i, int ctype) { sself->SetCopyHigherOrderDegrees(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_higher_order_degrees(vtkNew sself, int ctype) { return sself->GetCopyHigherOrderDegrees(ctype); } +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_on(vtkNew sself) { sself->CopyHigherOrderDegreesOn(); } +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_off(vtkNew sself) { sself->CopyHigherOrderDegreesOff(); } +extern "C" void vtk_data_set_attributes_copy_all_on(vtkNew sself, int ctype) { sself->CopyAllOn(ctype); } +extern "C" void vtk_data_set_attributes_copy_all_off(vtkNew sself, int ctype) { sself->CopyAllOff(ctype); } extern "C" vtkNew < vtkDataSetCellIterator > vtkDataSetCellIterator_new () {return vtkNew < vtkDataSetCellIterator > () ;} extern "C" void vtkDataSetCellIterator_destructor (vtkNew < vtkDataSetCellIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataSetCellIterator_get_ptr (vtkNew < vtkDataSetCellIterator > sself) {return sself . GetPointer () ;} +extern "C" bool vtk_data_set_cell_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_data_set_cell_iterator_get_cell_id(vtkNew sself) { return sself->GetCellId(); } extern "C" vtkNew < vtkDataSetCollection > vtkDataSetCollection_new () {return vtkNew < vtkDataSetCollection > () ;} extern "C" void vtkDataSetCollection_destructor (vtkNew < vtkDataSetCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkDataSetCollection_get_ptr (vtkNew < vtkDataSetCollection > sself) {return sself . GetPointer () ;} +extern "C" int vtk_data_set_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } extern "C" vtkNew < vtkDirectedAcyclicGraph > vtkDirectedAcyclicGraph_new () {return vtkNew < vtkDirectedAcyclicGraph > () ;} extern "C" void vtkDirectedAcyclicGraph_destructor (vtkNew < vtkDirectedAcyclicGraph > sself) {sself . Reset () ; return ;} extern "C" void * vtkDirectedAcyclicGraph_get_ptr (vtkNew < vtkDirectedAcyclicGraph > sself) {return sself . GetPointer () ;} @@ -429,48 +885,312 @@ extern "C" void * vtkDirectedGraph_get_ptr (vtkNew < vtkDirectedGraph > sself) { extern "C" vtkNew < vtkEdgeListIterator > vtkEdgeListIterator_new () {return vtkNew < vtkEdgeListIterator > () ;} extern "C" void vtkEdgeListIterator_destructor (vtkNew < vtkEdgeListIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkEdgeListIterator_get_ptr (vtkNew < vtkEdgeListIterator > sself) {return sself . GetPointer () ;} +extern "C" bool vtk_edge_list_iterator_has_next(vtkNew sself) { return sself->HasNext(); } extern "C" vtkNew < vtkEdgeTable > vtkEdgeTable_new () {return vtkNew < vtkEdgeTable > () ;} extern "C" void vtkEdgeTable_destructor (vtkNew < vtkEdgeTable > sself) {sself . Reset () ; return ;} extern "C" void * vtkEdgeTable_get_ptr (vtkNew < vtkEdgeTable > sself) {return sself . GetPointer () ;} +extern "C" void vtk_edge_table_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_edge_table_init_edge_insertion(vtkNew sself, long long numPoints, int storeAttributes) { return sself->InitEdgeInsertion(numPoints, storeAttributes); } +extern "C" long long vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2) { return sself->InsertEdge(p1, p2); } +extern "C" void vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2, long long attributeId) { sself->InsertEdge(p1, p2, attributeId); } +extern "C" void vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2, void ptr) { sself->InsertEdge(p1, p2, ptr); } +extern "C" long long vtk_edge_table_is_edge(vtkNew sself, long long p1, long long p2) { return sself->IsEdge(p1, p2); } +extern "C" void vtk_edge_table_is_edge(vtkNew sself, long long p1, long long p2, void ptr) { sself->IsEdge(p1, p2, ptr); } +extern "C" int vtk_edge_table_insert_unique_point(vtkNew sself, long long p1, long long p2, double x, long long ptId) { return sself->InsertUniquePoint(p1, p2, x, ptId); } +extern "C" long long vtk_edge_table_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" void vtk_edge_table_init_traversal(vtkNew sself) { sself->InitTraversal(); } +extern "C" long long vtk_edge_table_get_next_edge(vtkNew sself, long long p1, long long p2) { return sself->GetNextEdge(p1, p2); } +extern "C" int vtk_edge_table_get_next_edge(vtkNew sself, long long p1, long long p2, void ptr) { return sself->GetNextEdge(p1, p2, ptr); } +extern "C" void vtk_edge_table_reset(vtkNew sself) { sself->Reset(); } extern "C" vtkNew < vtkEmptyCell > vtkEmptyCell_new () {return vtkNew < vtkEmptyCell > () ;} extern "C" void vtkEmptyCell_destructor (vtkNew < vtkEmptyCell > sself) {sself . Reset () ; return ;} extern "C" void * vtkEmptyCell_get_ptr (vtkNew < vtkEmptyCell > sself) {return sself . GetPointer () ;} +extern "C" int vtk_empty_cell_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_empty_cell_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_empty_cell_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_empty_cell_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_empty_cell_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_empty_cell_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_empty_cell_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_empty_cell_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } extern "C" vtkNew < vtkExplicitStructuredGrid > vtkExplicitStructuredGrid_new () {return vtkNew < vtkExplicitStructuredGrid > () ;} extern "C" void vtkExplicitStructuredGrid_destructor (vtkNew < vtkExplicitStructuredGrid > sself) {sself . Reset () ; return ;} extern "C" void * vtkExplicitStructuredGrid_get_ptr (vtkNew < vtkExplicitStructuredGrid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_explicit_structured_grid_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_explicit_structured_grid_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_explicit_structured_grid_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" int vtk_explicit_structured_grid_get_data_dimension(vtkNew sself) { return sself->GetDataDimension(); } +extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkNew sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkNew sself, int dim) { sself->SetDimensions(dim); } +extern "C" void vtk_explicit_structured_grid_get_dimensions(vtkNew sself, int dim) { sself->GetDimensions(dim); } +extern "C" void vtk_explicit_structured_grid_get_cell_dims(vtkNew sself, int cellDims) { sself->GetCellDims(cellDims); } +extern "C" int vtk_explicit_structured_grid_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } +extern "C" void vtk_explicit_structured_grid_set_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1) { sself->SetExtent(x0, x1, y0, y1, z0, z1); } +extern "C" void vtk_explicit_structured_grid_set_extent(vtkNew sself, int extent) { sself->SetExtent(extent); } +extern "C" int* vtk_explicit_structured_grid_get_extent(vtkNew sself) { return sself->GetExtent(); } +extern "C" void vtk_explicit_structured_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_explicit_structured_grid_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } +extern "C" void vtk_explicit_structured_grid_build_links(vtkNew sself) { sself->BuildLinks(); } +extern "C" long long* vtk_explicit_structured_grid_get_cell_points(vtkNew sself, long long cellId) { return sself->GetCellPoints(cellId); } +extern "C" void vtk_explicit_structured_grid_get_cell_points(vtkNew sself, long long cellId, long long npts, long long pts) { sself->GetCellPoints(cellId, npts, pts); } +extern "C" void vtk_explicit_structured_grid_get_cell_neighbors(vtkNew sself, long long cellId, long long neighbors, int wholeExtent) { sself->GetCellNeighbors(cellId, neighbors, wholeExtent); } +extern "C" void vtk_explicit_structured_grid_compute_cell_structured_coords(vtkNew sself, long long cellId, int i, int j, int k, bool adjustForExtent) { sself->ComputeCellStructuredCoords(cellId, i, j, k, adjustForExtent); } +extern "C" long long vtk_explicit_structured_grid_compute_cell_id(vtkNew sself, int i, int j, int k, bool adjustForExtent) { return sself->ComputeCellId(i, j, k, adjustForExtent); } +extern "C" void vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(vtkNew sself) { sself->ComputeFacesConnectivityFlagsArray(); } +extern "C" void vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name(vtkNew sself, const char _arg) { sself->SetFacesConnectivityFlagsArrayName(_arg); } +extern "C" char* vtk_explicit_structured_grid_get_faces_connectivity_flags_array_name(vtkNew sself) { return sself->GetFacesConnectivityFlagsArrayName(); } +extern "C" void vtk_explicit_structured_grid_blank_cell(vtkNew sself, long long cellId) { sself->BlankCell(cellId); } +extern "C" void vtk_explicit_structured_grid_un_blank_cell(vtkNew sself, long long cellId) { sself->UnBlankCell(cellId); } +extern "C" bool vtk_explicit_structured_grid_has_any_blank_cells(vtkNew sself) { return sself->HasAnyBlankCells(); } +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_visible(vtkNew sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_ghost(vtkNew sself, long long cellId) { return sself->IsCellGhost(cellId); } +extern "C" bool vtk_explicit_structured_grid_has_any_ghost_cells(vtkNew sself) { return sself->HasAnyGhostCells(); } +extern "C" void vtk_explicit_structured_grid_crop(vtkNew sself, const int updateExtent) { sself->Crop(updateExtent); } +extern "C" unsigned long vtk_explicit_structured_grid_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" void vtk_explicit_structured_grid_check_and_reorder_faces(vtkNew sself) { sself->CheckAndReorderFaces(); } extern "C" vtkNew < vtkExtractStructuredGridHelper > vtkExtractStructuredGridHelper_new () {return vtkNew < vtkExtractStructuredGridHelper > () ;} extern "C" void vtkExtractStructuredGridHelper_destructor (vtkNew < vtkExtractStructuredGridHelper > sself) {sself . Reset () ; return ;} extern "C" void * vtkExtractStructuredGridHelper_get_ptr (vtkNew < vtkExtractStructuredGridHelper > sself) {return sself . GetPointer () ;} +extern "C" int* vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself) { return sself->GetOutputWholeExtent(); } +extern "C" void vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetOutputWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself, int _arg) { sself->GetOutputWholeExtent(_arg); } +extern "C" void vtk_extract_structured_grid_helper_initialize(vtkNew sself, int voi, int wholeExt, int sampleRate, bool includeBoundary) { sself->Initialize(voi, wholeExt, sampleRate, includeBoundary); } +extern "C" bool vtk_extract_structured_grid_helper_is_valid(vtkNew sself) { return sself->IsValid(); } +extern "C" int vtk_extract_structured_grid_helper_get_size(vtkNew sself, const int dim) { return sself->GetSize(dim); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index(vtkNew sself, int dim, int outIdx) { return sself->GetMappedIndex(dim, outIdx); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value(vtkNew sself, int dim, int outExtVal) { return sself->GetMappedIndexFromExtentValue(dim, outExtVal); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value(vtkNew sself, int dim, int outExtVal) { return sself->GetMappedExtentValue(dim, outExtVal); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index(vtkNew sself, int dim, int outIdx) { return sself->GetMappedExtentValueFromIndex(dim, outIdx); } +extern "C" void vtk_extract_structured_grid_helper_compute_begin_and_end(vtkNew sself, int inExt, int voi, int begin, int end) { sself->ComputeBeginAndEnd(inExt, voi, begin, end); } +extern "C" void vtk_extract_structured_grid_helper_get_partitioned_voi(vtkNew sself, const int globalVOI, const int partitionedExtent, const int sampleRate, bool includeBoundary, int partitionedVOI) { sself->GetPartitionedVOI(globalVOI, partitionedExtent, sampleRate, includeBoundary, partitionedVOI); } +extern "C" void vtk_extract_structured_grid_helper_get_partitioned_output_extent(vtkNew sself, const int globalVOI, const int partitionedVOI, const int outputWholeExtent, const int sampleRate, bool includeBoundary, int partitionedOutputExtent) { sself->GetPartitionedOutputExtent(globalVOI, partitionedVOI, outputWholeExtent, sampleRate, includeBoundary, partitionedOutputExtent); } extern "C" vtkNew < vtkFieldData > vtkFieldData_new () {return vtkNew < vtkFieldData > () ;} extern "C" void vtkFieldData_destructor (vtkNew < vtkFieldData > sself) {sself . Reset () ; return ;} extern "C" void * vtkFieldData_get_ptr (vtkNew < vtkFieldData > sself) {return sself . GetPointer () ;} +extern "C" void vtk_field_data_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_field_data_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_field_data_allocate_arrays(vtkNew sself, int num) { sself->AllocateArrays(num); } +extern "C" int vtk_field_data_get_number_of_arrays(vtkNew sself) { return sself->GetNumberOfArrays(); } +extern "C" void vtk_field_data_null_data(vtkNew sself, long long id) { sself->NullData(id); } +extern "C" void vtk_field_data_remove_array(vtkNew sself, const char name) { sself->RemoveArray(name); } +extern "C" void vtk_field_data_remove_array(vtkNew sself, int index) { sself->RemoveArray(index); } +extern "C" int vtk_field_data_has_array(vtkNew sself, const char name) { return sself->HasArray(name); } +extern "C" const char* vtk_field_data_get_array_name(vtkNew sself, int i) { return sself->GetArrayName(i); } +extern "C" void vtk_field_data_copy_field_on(vtkNew sself, const char name) { sself->CopyFieldOn(name); } +extern "C" void vtk_field_data_copy_field_off(vtkNew sself, const char name) { sself->CopyFieldOff(name); } +extern "C" void vtk_field_data_copy_all_on(vtkNew sself, int unused) { sself->CopyAllOn(unused); } +extern "C" void vtk_field_data_copy_all_off(vtkNew sself, int unused) { sself->CopyAllOff(unused); } +extern "C" void vtk_field_data_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" void vtk_field_data_reset(vtkNew sself) { sself->Reset(); } +extern "C" unsigned long vtk_field_data_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" unsigned long vtk_field_data_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" int vtk_field_data_get_array_containing_component(vtkNew sself, int i, int arrayComp) { return sself->GetArrayContainingComponent(i, arrayComp); } +extern "C" int vtk_field_data_get_number_of_components(vtkNew sself) { return sself->GetNumberOfComponents(); } +extern "C" long long vtk_field_data_get_number_of_tuples(vtkNew sself) { return sself->GetNumberOfTuples(); } +extern "C" void vtk_field_data_set_number_of_tuples(vtkNew sself, const long long number) { sself->SetNumberOfTuples(number); } extern "C" vtkNew < vtkGenericAttributeCollection > vtkGenericAttributeCollection_new () {return vtkNew < vtkGenericAttributeCollection > () ;} extern "C" void vtkGenericAttributeCollection_destructor (vtkNew < vtkGenericAttributeCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkGenericAttributeCollection_get_ptr (vtkNew < vtkGenericAttributeCollection > sself) {return sself . GetPointer () ;} +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes(vtkNew sself) { return sself->GetNumberOfAttributes(); } +extern "C" int vtk_generic_attribute_collection_get_number_of_components(vtkNew sself) { return sself->GetNumberOfComponents(); } +extern "C" int vtk_generic_attribute_collection_get_number_of_point_centered_components(vtkNew sself) { return sself->GetNumberOfPointCenteredComponents(); } +extern "C" int vtk_generic_attribute_collection_get_max_number_of_components(vtkNew sself) { return sself->GetMaxNumberOfComponents(); } +extern "C" unsigned long vtk_generic_attribute_collection_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" int vtk_generic_attribute_collection_is_empty(vtkNew sself) { return sself->IsEmpty(); } +extern "C" int vtk_generic_attribute_collection_find_attribute(vtkNew sself, const char name) { return sself->FindAttribute(name); } +extern "C" int vtk_generic_attribute_collection_get_attribute_index(vtkNew sself, int i) { return sself->GetAttributeIndex(i); } +extern "C" void vtk_generic_attribute_collection_remove_attribute(vtkNew sself, int i) { sself->RemoveAttribute(i); } +extern "C" void vtk_generic_attribute_collection_reset(vtkNew sself) { sself->Reset(); } +extern "C" unsigned long vtk_generic_attribute_collection_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" int vtk_generic_attribute_collection_get_active_attribute(vtkNew sself) { return sself->GetActiveAttribute(); } +extern "C" int vtk_generic_attribute_collection_get_active_component(vtkNew sself) { return sself->GetActiveComponent(); } +extern "C" void vtk_generic_attribute_collection_set_active_attribute(vtkNew sself, int attribute, int component) { sself->SetActiveAttribute(attribute, component); } +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate(vtkNew sself) { return sself->GetNumberOfAttributesToInterpolate(); } +extern "C" int* vtk_generic_attribute_collection_get_attributes_to_interpolate(vtkNew sself) { return sself->GetAttributesToInterpolate(); } +extern "C" int vtk_generic_attribute_collection_has_attribute(vtkNew sself, int size, int attributes, int attribute) { return sself->HasAttribute(size, attributes, attribute); } +extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate(vtkNew sself, int size, int attributes) { sself->SetAttributesToInterpolate(size, attributes); } +extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(vtkNew sself) { sself->SetAttributesToInterpolateToAll(); } extern "C" vtkNew < vtkGenericCell > vtkGenericCell_new () {return vtkNew < vtkGenericCell > () ;} extern "C" void vtkGenericCell_destructor (vtkNew < vtkGenericCell > sself) {sself . Reset () ; return ;} extern "C" void * vtkGenericCell_get_ptr (vtkNew < vtkGenericCell > sself) {return sself . GetPointer () ;} +extern "C" int vtk_generic_cell_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_generic_cell_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_generic_cell_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_generic_cell_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_generic_cell_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_generic_cell_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_generic_cell_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_generic_cell_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" void vtk_generic_cell_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_generic_cell_set_cell_type(vtkNew sself, int cellType) { sself->SetCellType(cellType); } +extern "C" void vtk_generic_cell_set_cell_type_to_empty_cell(vtkNew sself) { sself->SetCellTypeToEmptyCell(); } +extern "C" void vtk_generic_cell_set_cell_type_to_vertex(vtkNew sself) { sself->SetCellTypeToVertex(); } +extern "C" void vtk_generic_cell_set_cell_type_to_poly_vertex(vtkNew sself) { sself->SetCellTypeToPolyVertex(); } +extern "C" void vtk_generic_cell_set_cell_type_to_line(vtkNew sself) { sself->SetCellTypeToLine(); } +extern "C" void vtk_generic_cell_set_cell_type_to_poly_line(vtkNew sself) { sself->SetCellTypeToPolyLine(); } +extern "C" void vtk_generic_cell_set_cell_type_to_triangle(vtkNew sself) { sself->SetCellTypeToTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_triangle_strip(vtkNew sself) { sself->SetCellTypeToTriangleStrip(); } +extern "C" void vtk_generic_cell_set_cell_type_to_polygon(vtkNew sself) { sself->SetCellTypeToPolygon(); } +extern "C" void vtk_generic_cell_set_cell_type_to_pixel(vtkNew sself) { sself->SetCellTypeToPixel(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quad(vtkNew sself) { sself->SetCellTypeToQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_tetra(vtkNew sself) { sself->SetCellTypeToTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_voxel(vtkNew sself) { sself->SetCellTypeToVoxel(); } +extern "C" void vtk_generic_cell_set_cell_type_to_hexahedron(vtkNew sself) { sself->SetCellTypeToHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_wedge(vtkNew sself) { sself->SetCellTypeToWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_pyramid(vtkNew sself) { sself->SetCellTypeToPyramid(); } +extern "C" void vtk_generic_cell_set_cell_type_to_pentagonal_prism(vtkNew sself) { sself->SetCellTypeToPentagonalPrism(); } +extern "C" void vtk_generic_cell_set_cell_type_to_hexagonal_prism(vtkNew sself) { sself->SetCellTypeToHexagonalPrism(); } +extern "C" void vtk_generic_cell_set_cell_type_to_polyhedron(vtkNew sself) { sself->SetCellTypeToPolyhedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_convex_point_set(vtkNew sself) { sself->SetCellTypeToConvexPointSet(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_edge(vtkNew sself) { sself->SetCellTypeToQuadraticEdge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_cubic_line(vtkNew sself) { sself->SetCellTypeToCubicLine(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_triangle(vtkNew sself) { sself->SetCellTypeToQuadraticTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle(vtkNew sself) { sself->SetCellTypeToBiQuadraticTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_quad(vtkNew sself) { sself->SetCellTypeToQuadraticQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_polygon(vtkNew sself) { sself->SetCellTypeToQuadraticPolygon(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_tetra(vtkNew sself) { sself->SetCellTypeToQuadraticTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_hexahedron(vtkNew sself) { sself->SetCellTypeToQuadraticHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_wedge(vtkNew sself) { sself->SetCellTypeToQuadraticWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_pyramid(vtkNew sself) { sself->SetCellTypeToQuadraticPyramid(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_quad(vtkNew sself) { sself->SetCellTypeToQuadraticLinearQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quad(vtkNew sself) { sself->SetCellTypeToBiQuadraticQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge(vtkNew sself) { sself->SetCellTypeToQuadraticLinearWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge(vtkNew sself) { sself->SetCellTypeToBiQuadraticQuadraticWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron(vtkNew sself) { sself->SetCellTypeToTriQuadraticHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid(vtkNew sself) { sself->SetCellTypeToTriQuadraticPyramid(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron(vtkNew sself) { sself->SetCellTypeToBiQuadraticQuadraticHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_triangle(vtkNew sself) { sself->SetCellTypeToLagrangeTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_tetra(vtkNew sself) { sself->SetCellTypeToLagrangeTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_curve(vtkNew sself) { sself->SetCellTypeToLagrangeCurve(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral(vtkNew sself) { sself->SetCellTypeToLagrangeQuadrilateral(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_hexahedron(vtkNew sself) { sself->SetCellTypeToLagrangeHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_wedge(vtkNew sself) { sself->SetCellTypeToLagrangeWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_triangle(vtkNew sself) { sself->SetCellTypeToBezierTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_tetra(vtkNew sself) { sself->SetCellTypeToBezierTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_curve(vtkNew sself) { sself->SetCellTypeToBezierCurve(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_quadrilateral(vtkNew sself) { sself->SetCellTypeToBezierQuadrilateral(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_hexahedron(vtkNew sself) { sself->SetCellTypeToBezierHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_wedge(vtkNew sself) { sself->SetCellTypeToBezierWedge(); } extern "C" vtkNew < vtkGenericEdgeTable > vtkGenericEdgeTable_new () {return vtkNew < vtkGenericEdgeTable > () ;} extern "C" void vtkGenericEdgeTable_destructor (vtkNew < vtkGenericEdgeTable > sself) {sself . Reset () ; return ;} extern "C" void * vtkGenericEdgeTable_get_ptr (vtkNew < vtkGenericEdgeTable > sself) {return sself . GetPointer () ;} +extern "C" void vtk_generic_edge_table_insert_edge(vtkNew sself, long long e1, long long e2, long long cellId, int ref, long long ptId) { sself->InsertEdge(e1, e2, cellId, ref, ptId); } +extern "C" void vtk_generic_edge_table_insert_edge(vtkNew sself, long long e1, long long e2, long long cellId, int ref) { sself->InsertEdge(e1, e2, cellId, ref); } +extern "C" int vtk_generic_edge_table_remove_edge(vtkNew sself, long long e1, long long e2) { return sself->RemoveEdge(e1, e2); } +extern "C" int vtk_generic_edge_table_check_edge(vtkNew sself, long long e1, long long e2, long long ptId) { return sself->CheckEdge(e1, e2, ptId); } +extern "C" int vtk_generic_edge_table_increment_edge_reference_count(vtkNew sself, long long e1, long long e2, long long cellId) { return sself->IncrementEdgeReferenceCount(e1, e2, cellId); } +extern "C" int vtk_generic_edge_table_check_edge_reference_count(vtkNew sself, long long e1, long long e2) { return sself->CheckEdgeReferenceCount(e1, e2); } +extern "C" void vtk_generic_edge_table_initialize(vtkNew sself, long long start) { sself->Initialize(start); } +extern "C" int vtk_generic_edge_table_get_number_of_components(vtkNew sself) { return sself->GetNumberOfComponents(); } +extern "C" void vtk_generic_edge_table_set_number_of_components(vtkNew sself, int count) { sself->SetNumberOfComponents(count); } +extern "C" int vtk_generic_edge_table_check_point(vtkNew sself, long long ptId) { return sself->CheckPoint(ptId); } +extern "C" int vtk_generic_edge_table_check_point(vtkNew sself, long long ptId, double point, double scalar) { return sself->CheckPoint(ptId, point, scalar); } +extern "C" void vtk_generic_edge_table_insert_point(vtkNew sself, long long ptId, double point) { sself->InsertPoint(ptId, point); } +extern "C" void vtk_generic_edge_table_insert_point_and_scalar(vtkNew sself, long long ptId, double pt, double s) { sself->InsertPointAndScalar(ptId, pt, s); } +extern "C" void vtk_generic_edge_table_remove_point(vtkNew sself, long long ptId) { sself->RemovePoint(ptId); } +extern "C" void vtk_generic_edge_table_increment_point_reference_count(vtkNew sself, long long ptId) { sself->IncrementPointReferenceCount(ptId); } +extern "C" void vtk_generic_edge_table_dump_table(vtkNew sself) { sself->DumpTable(); } +extern "C" void vtk_generic_edge_table_load_factor(vtkNew sself) { sself->LoadFactor(); } extern "C" vtkNew < vtkGenericInterpolatedVelocityField > vtkGenericInterpolatedVelocityField_new () {return vtkNew < vtkGenericInterpolatedVelocityField > () ;} extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkNew < vtkGenericInterpolatedVelocityField > sself) {sself . Reset () ; return ;} extern "C" void * vtkGenericInterpolatedVelocityField_get_ptr (vtkNew < vtkGenericInterpolatedVelocityField > sself) {return sself . GetPointer () ;} +extern "C" int vtk_generic_interpolated_velocity_field_function_values(vtkNew sself, double x, double f) { return sself->FunctionValues(x, f); } +extern "C" void vtk_generic_interpolated_velocity_field_clear_last_cell(vtkNew sself) { sself->ClearLastCell(); } +extern "C" int vtk_generic_interpolated_velocity_field_get_last_local_coordinates(vtkNew sself, double pcoords) { return sself->GetLastLocalCoordinates(pcoords); } +extern "C" int vtk_generic_interpolated_velocity_field_get_caching(vtkNew sself) { return sself->GetCaching(); } +extern "C" void vtk_generic_interpolated_velocity_field_set_caching(vtkNew sself, int _arg) { sself->SetCaching(_arg); } +extern "C" void vtk_generic_interpolated_velocity_field_caching_on(vtkNew sself) { sself->CachingOn(); } +extern "C" void vtk_generic_interpolated_velocity_field_caching_off(vtkNew sself) { sself->CachingOff(); } +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_hit(vtkNew sself) { return sself->GetCacheHit(); } +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_miss(vtkNew sself) { return sself->GetCacheMiss(); } +extern "C" char* vtk_generic_interpolated_velocity_field_get_vectors_selection(vtkNew sself) { return sself->GetVectorsSelection(); } +extern "C" void vtk_generic_interpolated_velocity_field_select_vectors(vtkNew sself, const char fieldName) { sself->SelectVectors(fieldName); } extern "C" vtkNew < vtkGeometricErrorMetric > vtkGeometricErrorMetric_new () {return vtkNew < vtkGeometricErrorMetric > () ;} extern "C" void vtkGeometricErrorMetric_destructor (vtkNew < vtkGeometricErrorMetric > sself) {sself . Reset () ; return ;} extern "C" void * vtkGeometricErrorMetric_get_ptr (vtkNew < vtkGeometricErrorMetric > sself) {return sself . GetPointer () ;} +extern "C" double vtk_geometric_error_metric_get_absolute_geometric_tolerance(vtkNew sself) { return sself->GetAbsoluteGeometricTolerance(); } +extern "C" void vtk_geometric_error_metric_set_absolute_geometric_tolerance(vtkNew sself, double value) { sself->SetAbsoluteGeometricTolerance(value); } +extern "C" int vtk_geometric_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->RequiresEdgeSubdivision(leftPoint, midPoint, rightPoint, alpha); } +extern "C" double vtk_geometric_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->GetError(leftPoint, midPoint, rightPoint, alpha); } +extern "C" int vtk_geometric_error_metric_get_relative(vtkNew sself) { return sself->GetRelative(); } extern "C" vtkNew < vtkGraphEdge > vtkGraphEdge_new () {return vtkNew < vtkGraphEdge > () ;} extern "C" void vtkGraphEdge_destructor (vtkNew < vtkGraphEdge > sself) {sself . Reset () ; return ;} extern "C" void * vtkGraphEdge_get_ptr (vtkNew < vtkGraphEdge > sself) {return sself . GetPointer () ;} +extern "C" void vtk_graph_edge_set_source(vtkNew sself, long long _arg) { sself->SetSource(_arg); } +extern "C" long long vtk_graph_edge_get_source(vtkNew sself) { return sself->GetSource(); } +extern "C" void vtk_graph_edge_set_target(vtkNew sself, long long _arg) { sself->SetTarget(_arg); } +extern "C" long long vtk_graph_edge_get_target(vtkNew sself) { return sself->GetTarget(); } +extern "C" void vtk_graph_edge_set_id(vtkNew sself, long long _arg) { sself->SetId(_arg); } +extern "C" long long vtk_graph_edge_get_id(vtkNew sself) { return sself->GetId(); } extern "C" vtkNew < vtkGraphInternals > vtkGraphInternals_new () {return vtkNew < vtkGraphInternals > () ;} extern "C" void vtkGraphInternals_destructor (vtkNew < vtkGraphInternals > sself) {sself . Reset () ; return ;} extern "C" void * vtkGraphInternals_get_ptr (vtkNew < vtkGraphInternals > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkHexagonalPrism > vtkHexagonalPrism_new () {return vtkNew < vtkHexagonalPrism > () ;} extern "C" void vtkHexagonalPrism_destructor (vtkNew < vtkHexagonalPrism > sself) {sself . Reset () ; return ;} extern "C" void * vtkHexagonalPrism_get_ptr (vtkNew < vtkHexagonalPrism > sself) {return sself . GetPointer () ;} +extern "C" void vtk_hexagonal_prism_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" void vtk_hexagonal_prism_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" long long vtk_hexagonal_prism_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_hexagonal_prism_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_hexagonal_prism_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } +extern "C" long long vtk_hexagonal_prism_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } +extern "C" long long vtk_hexagonal_prism_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } +extern "C" long long vtk_hexagonal_prism_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } +extern "C" long long vtk_hexagonal_prism_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } +extern "C" bool vtk_hexagonal_prism_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } +extern "C" int vtk_hexagonal_prism_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_hexagonal_prism_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_hexagonal_prism_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_hexagonal_prism_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_hexagonal_prism_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_hexagonal_prism_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_hexagonal_prism_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_hexagonal_prism_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_hexagonal_prism_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_hexagonal_prism_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_hexagonal_prism_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_hexagonal_prism_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_hexagonal_prism_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_hexagonal_prism_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" const long long* vtk_hexagonal_prism_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } +extern "C" const long long* vtk_hexagonal_prism_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } +extern "C" const long long* vtk_hexagonal_prism_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } +extern "C" const long long* vtk_hexagonal_prism_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } +extern "C" const long long* vtk_hexagonal_prism_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } +extern "C" void vtk_hexagonal_prism_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkHexahedron > vtkHexahedron_new () {return vtkNew < vtkHexahedron > () ;} extern "C" void vtkHexahedron_destructor (vtkNew < vtkHexahedron > sself) {sself . Reset () ; return ;} extern "C" void * vtkHexahedron_get_ptr (vtkNew < vtkHexahedron > sself) {return sself . GetPointer () ;} +extern "C" void vtk_hexahedron_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" void vtk_hexahedron_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" long long vtk_hexahedron_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_hexahedron_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_hexahedron_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } +extern "C" long long vtk_hexahedron_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } +extern "C" long long vtk_hexahedron_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } +extern "C" long long vtk_hexahedron_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } +extern "C" long long vtk_hexahedron_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } +extern "C" bool vtk_hexahedron_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } +extern "C" int vtk_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_hexahedron_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_hexahedron_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int* vtk_hexahedron_get_triangle_cases(vtkNew sself, int caseId) { return sself->GetTriangleCases(caseId); } +extern "C" void vtk_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_hexahedron_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_hexahedron_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" const long long* vtk_hexahedron_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } +extern "C" const long long* vtk_hexahedron_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } +extern "C" const long long* vtk_hexahedron_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } +extern "C" const long long* vtk_hexahedron_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } +extern "C" const long long* vtk_hexahedron_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } +extern "C" void vtk_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkHierarchicalBoxDataIterator > vtkHierarchicalBoxDataIterator_new () {return vtkNew < vtkHierarchicalBoxDataIterator > () ;} extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkNew < vtkHierarchicalBoxDataIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkHierarchicalBoxDataIterator_get_ptr (vtkNew < vtkHierarchicalBoxDataIterator > sself) {return sself . GetPointer () ;} @@ -480,12 +1200,119 @@ extern "C" void * vtkHierarchicalBoxDataSet_get_ptr (vtkNew < vtkHierarchicalBox extern "C" vtkNew < vtkHyperTreeGrid > vtkHyperTreeGrid_new () {return vtkNew < vtkHyperTreeGrid > () ;} extern "C" void vtkHyperTreeGrid_destructor (vtkNew < vtkHyperTreeGrid > sself) {sself . Reset () ; return ;} extern "C" void * vtkHyperTreeGrid_get_ptr (vtkNew < vtkHyperTreeGrid > sself) {return sself . GetPointer () ;} +extern "C" void vtk_hyper_tree_grid_set_mode_squeeze(vtkNew sself, const char _arg) { sself->SetModeSqueeze(_arg); } +extern "C" char* vtk_hyper_tree_grid_get_mode_squeeze(vtkNew sself) { return sself->GetModeSqueeze(); } +extern "C" void vtk_hyper_tree_grid_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" int vtk_hyper_tree_grid_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, const unsigned int dims) { sself->SetDimensions(dims); } +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, const int dims) { sself->SetDimensions(dims); } +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, unsigned int i, unsigned int j, unsigned int k) { sself->SetDimensions(i, j, k); } +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" const unsigned int* vtk_hyper_tree_grid_get_dimensions(vtkNew sself) { return sself->GetDimensions(); } +extern "C" void vtk_hyper_tree_grid_get_dimensions(vtkNew sself, int dim) { sself->GetDimensions(dim); } +extern "C" void vtk_hyper_tree_grid_get_dimensions(vtkNew sself, unsigned int dim) { sself->GetDimensions(dim); } +extern "C" void vtk_hyper_tree_grid_set_extent(vtkNew sself, const int extent) { sself->SetExtent(extent); } +extern "C" void vtk_hyper_tree_grid_set_extent(vtkNew sself, int x1, int x2, int y1, int y2, int z1, int z2) { sself->SetExtent(x1, x2, y1, y2, z1, z2); } +extern "C" int* vtk_hyper_tree_grid_get_extent(vtkNew sself) { return sself->GetExtent(); } +extern "C" void vtk_hyper_tree_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_hyper_tree_grid_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } +extern "C" const unsigned int* vtk_hyper_tree_grid_get_cell_dims(vtkNew sself) { return sself->GetCellDims(); } +extern "C" void vtk_hyper_tree_grid_get_cell_dims(vtkNew sself, int cellDims) { sself->GetCellDims(cellDims); } +extern "C" void vtk_hyper_tree_grid_get_cell_dims(vtkNew sself, unsigned int cellDims) { sself->GetCellDims(cellDims); } +extern "C" unsigned int vtk_hyper_tree_grid_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" void vtk_hyper_tree_grid_get_1_d_axis(vtkNew sself, unsigned int axis) { sself->Get1DAxis(axis); } +extern "C" void vtk_hyper_tree_grid_get_2_d_axes(vtkNew sself, unsigned int axis1, unsigned int axis2) { sself->Get2DAxes(axis1, axis2); } +extern "C" const unsigned int* vtk_hyper_tree_grid_get_axes(vtkNew sself) { return sself->GetAxes(); } +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_children(vtkNew sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_set_transposed_root_indexing(vtkNew sself, bool _arg) { sself->SetTransposedRootIndexing(_arg); } +extern "C" bool vtk_hyper_tree_grid_get_transposed_root_indexing(vtkNew sself) { return sself->GetTransposedRootIndexing(); } +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_kji(vtkNew sself) { sself->SetIndexingModeToKJI(); } +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_ijk(vtkNew sself) { sself->SetIndexingModeToIJK(); } +extern "C" unsigned int vtk_hyper_tree_grid_get_orientation(vtkNew sself) { return sself->GetOrientation(); } +extern "C" bool vtk_hyper_tree_grid_get_freeze_state(vtkNew sself) { return sself->GetFreezeState(); } +extern "C" void vtk_hyper_tree_grid_set_branch_factor(vtkNew sself, unsigned int p0) { sself->SetBranchFactor(p0); } +extern "C" unsigned int vtk_hyper_tree_grid_get_branch_factor(vtkNew sself) { return sself->GetBranchFactor(); } +extern "C" long long vtk_hyper_tree_grid_get_max_number_of_trees(vtkNew sself) { return sself->GetMaxNumberOfTrees(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_vertices(vtkNew sself) { return sself->GetNumberOfVertices(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_non_empty_trees(vtkNew sself) { return sself->GetNumberOfNonEmptyTrees(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_leaves(vtkNew sself) { return sself->GetNumberOfLeaves(); } +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkNew sself, long long p0) { return sself->GetNumberOfLevels(p0); } +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkNew sself) { return sself->GetNumberOfLevels(); } +extern "C" void vtk_hyper_tree_grid_set_fixed_coordinates(vtkNew sself, unsigned int axis, double value) { sself->SetFixedCoordinates(axis, value); } +extern "C" bool vtk_hyper_tree_grid_has_mask(vtkNew sself) { return sself->HasMask(); } +extern "C" void vtk_hyper_tree_grid_set_has_interface(vtkNew sself, bool _arg) { sself->SetHasInterface(_arg); } +extern "C" bool vtk_hyper_tree_grid_get_has_interface(vtkNew sself) { return sself->GetHasInterface(); } +extern "C" void vtk_hyper_tree_grid_has_interface_on(vtkNew sself) { sself->HasInterfaceOn(); } +extern "C" void vtk_hyper_tree_grid_has_interface_off(vtkNew sself) { sself->HasInterfaceOff(); } +extern "C" void vtk_hyper_tree_grid_set_interface_normals_name(vtkNew sself, const char _arg) { sself->SetInterfaceNormalsName(_arg); } +extern "C" char* vtk_hyper_tree_grid_get_interface_normals_name(vtkNew sself) { return sself->GetInterfaceNormalsName(); } +extern "C" void vtk_hyper_tree_grid_set_interface_intercepts_name(vtkNew sself, const char _arg) { sself->SetInterfaceInterceptsName(_arg); } +extern "C" char* vtk_hyper_tree_grid_get_interface_intercepts_name(vtkNew sself) { return sself->GetInterfaceInterceptsName(); } +extern "C" void vtk_hyper_tree_grid_set_depth_limiter(vtkNew sself, unsigned int _arg) { sself->SetDepthLimiter(_arg); } +extern "C" unsigned int vtk_hyper_tree_grid_get_depth_limiter(vtkNew sself) { return sself->GetDepthLimiter(); } +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_x(vtkNew sself, double value) { return sself->FindDichotomicX(value); } +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_y(vtkNew sself, double value) { return sself->FindDichotomicY(value); } +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_z(vtkNew sself, double value) { return sself->FindDichotomicZ(value); } +extern "C" void vtk_hyper_tree_grid_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_hyper_tree_grid_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size_bytes(vtkNew sself) { return sself->GetActualMemorySizeBytes(); } +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } +extern "C" unsigned int vtk_hyper_tree_grid_get_child_mask(vtkNew sself, unsigned int p0) { return sself->GetChildMask(p0); } +extern "C" void vtk_hyper_tree_grid_get_index_from_level_zero_coordinates(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3) { sself->GetIndexFromLevelZeroCoordinates(p0, p1, p2, p3); } +extern "C" long long vtk_hyper_tree_grid_get_shifted_level_zero_index(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3) { return sself->GetShiftedLevelZeroIndex(p0, p1, p2, p3); } +extern "C" void vtk_hyper_tree_grid_get_level_zero_coordinates_from_index(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3) { sself->GetLevelZeroCoordinatesFromIndex(p0, p1, p2, p3); } +extern "C" void vtk_hyper_tree_grid_get_level_zero_origin_and_size_from_index(vtkNew sself, long long p0, double p1, double p2) { sself->GetLevelZeroOriginAndSizeFromIndex(p0, p1, p2); } +extern "C" void vtk_hyper_tree_grid_get_level_zero_origin_from_index(vtkNew sself, long long p0, double p1) { sself->GetLevelZeroOriginFromIndex(p0, p1); } +extern "C" long long vtk_hyper_tree_grid_get_global_node_index_max(vtkNew sself) { return sself->GetGlobalNodeIndexMax(); } +extern "C" void vtk_hyper_tree_grid_initialize_local_index_node(vtkNew sself) { sself->InitializeLocalIndexNode(); } +extern "C" bool vtk_hyper_tree_grid_has_any_ghost_cells(vtkNew sself) { return sself->HasAnyGhostCells(); } +extern "C" double* vtk_hyper_tree_grid_get_bounds(vtkNew sself) { return sself->GetBounds(); } +extern "C" void vtk_hyper_tree_grid_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" double* vtk_hyper_tree_grid_get_center(vtkNew sself) { return sself->GetCenter(); } +extern "C" void vtk_hyper_tree_grid_get_center(vtkNew sself, double center) { sself->GetCenter(center); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_elements(vtkNew sself, int type) { return sself->GetNumberOfElements(type); } extern "C" vtkNew < vtkHyperTreeGridNonOrientedCursor > vtkHyperTreeGridNonOrientedCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedCursor > () ;} extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) {sself . Reset () ; return ;} extern "C" void * vtkHyperTreeGridNonOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) {return sself . GetPointer () ;} +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_has_tree(vtkNew sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(vtkNew sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(vtkNew sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(vtkNew sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(vtkNew sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local(vtkNew sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_mask(vtkNew sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_masked(vtkNew sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_leaf(vtkNew sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf(vtkNew sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_root(vtkNew sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_cursor_get_level(vtkNew sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_child(vtkNew sself, unsigned char ichild) { sself->ToChild(ichild); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_root(vtkNew sself) { sself->ToRoot(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_parent(vtkNew sself) { sself->ToParent(); } extern "C" vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > vtkHyperTreeGridNonOrientedGeometryCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > () ;} extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) {sself . Reset () ; return ;} extern "C" void * vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) {return sself . GetPointer () ;} +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(vtkNew sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(vtkNew sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index(vtkNew sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children(vtkNew sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start(vtkNew sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local(vtkNew sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" double* vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_origin(vtkNew sself) { return sself->GetOrigin(); } +extern "C" double* vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_size(vtkNew sself) { return sself->GetSize(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_point(vtkNew sself, double point) { sself->GetPoint(point); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask(vtkNew sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked(vtkNew sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf(vtkNew sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf(vtkNew sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root(vtkNew sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level(vtkNew sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child(vtkNew sself, unsigned char ichild) { sself->ToChild(ichild); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(vtkNew sself) { sself->ToRoot(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(vtkNew sself) { sself->ToParent(); } extern "C" vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > vtkHyperTreeGridNonOrientedMooreSuperCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > () ;} extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) {sself . Reset () ; return ;} extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) {return sself . GetPointer () ;} @@ -501,357 +1328,1976 @@ extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr extern "C" vtkNew < vtkHyperTreeGridOrientedCursor > vtkHyperTreeGridOrientedCursor_new () {return vtkNew < vtkHyperTreeGridOrientedCursor > () ;} extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkNew < vtkHyperTreeGridOrientedCursor > sself) {sself . Reset () ; return ;} extern "C" void * vtkHyperTreeGridOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedCursor > sself) {return sself . GetPointer () ;} +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_has_tree(vtkNew sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(vtkNew sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(vtkNew sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(vtkNew sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(vtkNew sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local(vtkNew sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_mask(vtkNew sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_masked(vtkNew sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_leaf(vtkNew sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf(vtkNew sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_root(vtkNew sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_oriented_cursor_get_level(vtkNew sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_to_child(vtkNew sself, unsigned char ichild) { sself->ToChild(ichild); } extern "C" vtkNew < vtkHyperTreeGridOrientedGeometryCursor > vtkHyperTreeGridOrientedGeometryCursor_new () {return vtkNew < vtkHyperTreeGridOrientedGeometryCursor > () ;} extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) {sself . Reset () ; return ;} extern "C" void * vtkHyperTreeGridOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) {return sself . GetPointer () ;} +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(vtkNew sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(vtkNew sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(vtkNew sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension(vtkNew sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(vtkNew sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start(vtkNew sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local(vtkNew sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" double* vtk_hyper_tree_grid_oriented_geometry_cursor_get_origin(vtkNew sself) { return sself->GetOrigin(); } +extern "C" double* vtk_hyper_tree_grid_oriented_geometry_cursor_get_size(vtkNew sself) { return sself->GetSize(); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_get_point(vtkNew sself, double point) { sself->GetPoint(point); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask(vtkNew sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked(vtkNew sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf(vtkNew sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf(vtkNew sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_root(vtkNew sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(vtkNew sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(vtkNew sself, unsigned char ichild) { sself->ToChild(ichild); } extern "C" vtkNew < vtkImageData > vtkImageData_new () {return vtkNew < vtkImageData > () ;} extern "C" void vtkImageData_destructor (vtkNew < vtkImageData > sself) {sself . Reset () ; return ;} extern "C" void * vtkImageData_get_ptr (vtkNew < vtkImageData > sself) {return sself . GetPointer () ;} +extern "C" int vtk_image_data_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_image_data_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } +extern "C" long long vtk_image_data_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" double* vtk_image_data_get_point(vtkNew sself, long long ptId) { return sself->GetPoint(ptId); } +extern "C" long long vtk_image_data_find_point(vtkNew sself, double x, double y, double z) { return sself->FindPoint(x, y, z); } +extern "C" long long vtk_image_data_find_point(vtkNew sself, double x) { return sself->FindPoint(x); } +extern "C" int vtk_image_data_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" int vtk_image_data_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } +extern "C" void vtk_image_data_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" unsigned char vtk_image_data_is_point_visible(vtkNew sself, long long ptId) { return sself->IsPointVisible(ptId); } +extern "C" unsigned char vtk_image_data_is_cell_visible(vtkNew sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" bool vtk_image_data_has_any_blank_points(vtkNew sself) { return sself->HasAnyBlankPoints(); } +extern "C" bool vtk_image_data_has_any_blank_cells(vtkNew sself) { return sself->HasAnyBlankCells(); } +extern "C" void vtk_image_data_get_cell_dims(vtkNew sself, int cellDims) { sself->GetCellDims(cellDims); } +extern "C" void vtk_image_data_set_dimensions(vtkNew sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" void vtk_image_data_set_dimensions(vtkNew sself, const int dims) { sself->SetDimensions(dims); } +extern "C" int* vtk_image_data_get_dimensions(vtkNew sself) { return sself->GetDimensions(); } +extern "C" void vtk_image_data_get_dimensions(vtkNew sself, int dims) { sself->GetDimensions(dims); } +extern "C" void vtk_image_data_get_dimensions(vtkNew sself, long long dims) { sself->GetDimensions(dims); } +extern "C" int vtk_image_data_compute_structured_coordinates(vtkNew sself, const double x, int ijk, double pcoords) { return sself->ComputeStructuredCoordinates(x, ijk, pcoords); } +extern "C" int vtk_image_data_get_data_dimension(vtkNew sself) { return sself->GetDataDimension(); } +extern "C" long long vtk_image_data_compute_point_id(vtkNew sself, int ijk) { return sself->ComputePointId(ijk); } +extern "C" long long vtk_image_data_compute_cell_id(vtkNew sself, int ijk) { return sself->ComputeCellId(ijk); } +extern "C" void vtk_image_data_set_axis_update_extent(vtkNew sself, int axis, int min, int max, const int updateExtent, int axisUpdateExtent) { sself->SetAxisUpdateExtent(axis, min, max, updateExtent, axisUpdateExtent); } +extern "C" void vtk_image_data_get_axis_update_extent(vtkNew sself, int axis, int min, int max, const int updateExtent) { sself->GetAxisUpdateExtent(axis, min, max, updateExtent); } +extern "C" void vtk_image_data_set_extent(vtkNew sself, int extent) { sself->SetExtent(extent); } +extern "C" void vtk_image_data_set_extent(vtkNew sself, int x1, int x2, int y1, int y2, int z1, int z2) { sself->SetExtent(x1, x2, y1, y2, z1, z2); } +extern "C" int* vtk_image_data_get_extent(vtkNew sself) { return sself->GetExtent(); } +extern "C" void vtk_image_data_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_image_data_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } +extern "C" double vtk_image_data_get_scalar_type_min(vtkNew sself) { return sself->GetScalarTypeMin(); } +extern "C" double vtk_image_data_get_scalar_type_max(vtkNew sself) { return sself->GetScalarTypeMax(); } +extern "C" int vtk_image_data_get_scalar_size(vtkNew sself) { return sself->GetScalarSize(); } +extern "C" long long* vtk_image_data_get_increments(vtkNew sself) { return sself->GetIncrements(); } +extern "C" void vtk_image_data_get_increments(vtkNew sself, long long incX, long long incY, long long incZ) { sself->GetIncrements(incX, incY, incZ); } +extern "C" void vtk_image_data_get_increments(vtkNew sself, long long inc) { sself->GetIncrements(inc); } +extern "C" void vtk_image_data_get_continuous_increments(vtkNew sself, int extent, long long incX, long long incY, long long incZ) { sself->GetContinuousIncrements(extent, incX, incY, incZ); } +extern "C" void* vtk_image_data_get_scalar_pointer_for_extent(vtkNew sself, int extent) { return sself->GetScalarPointerForExtent(extent); } +extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself, int coordinates) { return sself->GetScalarPointer(coordinates); } +extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself, int x, int y, int z) { return sself->GetScalarPointer(x, y, z); } +extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself) { return sself->GetScalarPointer(); } +extern "C" long long vtk_image_data_get_scalar_index_for_extent(vtkNew sself, int extent) { return sself->GetScalarIndexForExtent(extent); } +extern "C" long long vtk_image_data_get_scalar_index(vtkNew sself, int coordinates) { return sself->GetScalarIndex(coordinates); } +extern "C" long long vtk_image_data_get_scalar_index(vtkNew sself, int x, int y, int z) { return sself->GetScalarIndex(x, y, z); } +extern "C" float vtk_image_data_get_scalar_component_as_float(vtkNew sself, int x, int y, int z, int component) { return sself->GetScalarComponentAsFloat(x, y, z, component); } +extern "C" void vtk_image_data_set_scalar_component_from_float(vtkNew sself, int x, int y, int z, int component, float v) { sself->SetScalarComponentFromFloat(x, y, z, component, v); } +extern "C" double vtk_image_data_get_scalar_component_as_double(vtkNew sself, int x, int y, int z, int component) { return sself->GetScalarComponentAsDouble(x, y, z, component); } +extern "C" void vtk_image_data_set_scalar_component_from_double(vtkNew sself, int x, int y, int z, int component, double v) { sself->SetScalarComponentFromDouble(x, y, z, component, v); } +extern "C" void vtk_image_data_allocate_scalars(vtkNew sself, int dataType, int numComponents) { sself->AllocateScalars(dataType, numComponents); } +extern "C" void vtk_image_data_crop(vtkNew sself, const int updateExtent) { sself->Crop(updateExtent); } +extern "C" double* vtk_image_data_get_spacing(vtkNew sself) { return sself->GetSpacing(); } +extern "C" void vtk_image_data_get_spacing(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetSpacing(_arg1, _arg2, _arg3); } +extern "C" void vtk_image_data_get_spacing(vtkNew sself, double _arg) { sself->GetSpacing(_arg); } +extern "C" void vtk_image_data_set_spacing(vtkNew sself, double i, double j, double k) { sself->SetSpacing(i, j, k); } +extern "C" void vtk_image_data_set_spacing(vtkNew sself, const double ijk) { sself->SetSpacing(ijk); } +extern "C" double* vtk_image_data_get_origin(vtkNew sself) { return sself->GetOrigin(); } +extern "C" void vtk_image_data_get_origin(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_image_data_get_origin(vtkNew sself, double _arg) { sself->GetOrigin(_arg); } +extern "C" void vtk_image_data_set_origin(vtkNew sself, double i, double j, double k) { sself->SetOrigin(i, j, k); } +extern "C" void vtk_image_data_set_origin(vtkNew sself, const double ijk) { sself->SetOrigin(ijk); } +extern "C" void vtk_image_data_set_direction_matrix(vtkNew sself, const double elements) { sself->SetDirectionMatrix(elements); } +extern "C" void vtk_image_data_set_direction_matrix(vtkNew sself, double e00, double e01, double e02, double e10, double e11, double e12, double e20, double e21, double e22) { sself->SetDirectionMatrix(e00, e01, e02, e10, e11, e12, e20, e21, e22); } +extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, double i, double j, double k, double xyz) { sself->TransformContinuousIndexToPhysicalPoint(i, j, k, xyz); } +extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, const double ijk, double xyz) { sself->TransformContinuousIndexToPhysicalPoint(ijk, xyz); } +extern "C" void vtk_image_data_transform_index_to_physical_point(vtkNew sself, int i, int j, int k, double xyz) { sself->TransformIndexToPhysicalPoint(i, j, k, xyz); } +extern "C" void vtk_image_data_transform_index_to_physical_point(vtkNew sself, const int ijk, double xyz) { sself->TransformIndexToPhysicalPoint(ijk, xyz); } +extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, double i, double j, double k, const double origin, const double spacing, const double direction, double xyz) { sself->TransformContinuousIndexToPhysicalPoint(i, j, k, origin, spacing, direction, xyz); } +extern "C" void vtk_image_data_transform_physical_point_to_continuous_index(vtkNew sself, double x, double y, double z, double ijk) { sself->TransformPhysicalPointToContinuousIndex(x, y, z, ijk); } +extern "C" void vtk_image_data_transform_physical_point_to_continuous_index(vtkNew sself, const double xyz, double ijk) { sself->TransformPhysicalPointToContinuousIndex(xyz, ijk); } +extern "C" void vtk_image_data_compute_index_to_physical_matrix(vtkNew sself, const double origin, const double spacing, const double direction, double result) { sself->ComputeIndexToPhysicalMatrix(origin, spacing, direction, result); } +extern "C" void vtk_image_data_transform_physical_normal_to_continuous_index(vtkNew sself, const double xyz, double ijk) { sself->TransformPhysicalNormalToContinuousIndex(xyz, ijk); } +extern "C" void vtk_image_data_transform_physical_plane_to_continuous_index(vtkNew sself, const double pplane, double iplane) { sself->TransformPhysicalPlaneToContinuousIndex(pplane, iplane); } +extern "C" int vtk_image_data_get_scalar_type(vtkNew sself) { return sself->GetScalarType(); } +extern "C" const char* vtk_image_data_get_scalar_type_as_string(vtkNew sself) { return sself->GetScalarTypeAsString(); } +extern "C" int vtk_image_data_get_number_of_scalar_components(vtkNew sself) { return sself->GetNumberOfScalarComponents(); } +extern "C" void vtk_image_data_prepare_for_new_data(vtkNew sself) { sself->PrepareForNewData(); } +extern "C" void vtk_image_data_compute_internal_extent(vtkNew sself, int intExt, int tgtExt, int bnds) { sself->ComputeInternalExtent(intExt, tgtExt, bnds); } +extern "C" int vtk_image_data_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } extern "C" vtkNew < vtkImageTransform > vtkImageTransform_new () {return vtkNew < vtkImageTransform > () ;} extern "C" void vtkImageTransform_destructor (vtkNew < vtkImageTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkImageTransform_get_ptr (vtkNew < vtkImageTransform > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkImplicitBoolean > vtkImplicitBoolean_new () {return vtkNew < vtkImplicitBoolean > () ;} extern "C" void vtkImplicitBoolean_destructor (vtkNew < vtkImplicitBoolean > sself) {sself . Reset () ; return ;} extern "C" void * vtkImplicitBoolean_get_ptr (vtkNew < vtkImplicitBoolean > sself) {return sself . GetPointer () ;} +extern "C" double vtk_implicit_boolean_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_implicit_boolean_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } +extern "C" unsigned long vtk_implicit_boolean_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_implicit_boolean_set_operation_type(vtkNew sself, int _arg) { sself->SetOperationType(_arg); } +extern "C" int vtk_implicit_boolean_get_operation_type_min_value(vtkNew sself) { return sself->GetOperationTypeMinValue(); } +extern "C" int vtk_implicit_boolean_get_operation_type_max_value(vtkNew sself) { return sself->GetOperationTypeMaxValue(); } +extern "C" int vtk_implicit_boolean_get_operation_type(vtkNew sself) { return sself->GetOperationType(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_union(vtkNew sself) { sself->SetOperationTypeToUnion(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_intersection(vtkNew sself) { sself->SetOperationTypeToIntersection(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_difference(vtkNew sself) { sself->SetOperationTypeToDifference(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(vtkNew sself) { sself->SetOperationTypeToUnionOfMagnitudes(); } +extern "C" const char* vtk_implicit_boolean_get_operation_type_as_string(vtkNew sself) { return sself->GetOperationTypeAsString(); } extern "C" vtkNew < vtkImplicitDataSet > vtkImplicitDataSet_new () {return vtkNew < vtkImplicitDataSet > () ;} extern "C" void vtkImplicitDataSet_destructor (vtkNew < vtkImplicitDataSet > sself) {sself . Reset () ; return ;} extern "C" void * vtkImplicitDataSet_get_ptr (vtkNew < vtkImplicitDataSet > sself) {return sself . GetPointer () ;} +extern "C" unsigned long vtk_implicit_data_set_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" double vtk_implicit_data_set_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_implicit_data_set_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } +extern "C" void vtk_implicit_data_set_set_out_value(vtkNew sself, double _arg) { sself->SetOutValue(_arg); } +extern "C" double vtk_implicit_data_set_get_out_value(vtkNew sself) { return sself->GetOutValue(); } +extern "C" void vtk_implicit_data_set_set_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetOutGradient(_arg1, _arg2, _arg3); } +extern "C" void vtk_implicit_data_set_set_out_gradient(vtkNew sself, const double _arg) { sself->SetOutGradient(_arg); } +extern "C" double* vtk_implicit_data_set_get_out_gradient(vtkNew sself) { return sself->GetOutGradient(); } +extern "C" void vtk_implicit_data_set_get_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetOutGradient(_arg1, _arg2, _arg3); } +extern "C" void vtk_implicit_data_set_get_out_gradient(vtkNew sself, double _arg) { sself->GetOutGradient(_arg); } extern "C" vtkNew < vtkImplicitFunctionCollection > vtkImplicitFunctionCollection_new () {return vtkNew < vtkImplicitFunctionCollection > () ;} extern "C" void vtkImplicitFunctionCollection_destructor (vtkNew < vtkImplicitFunctionCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkImplicitFunctionCollection_get_ptr (vtkNew < vtkImplicitFunctionCollection > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkImplicitHalo > vtkImplicitHalo_new () {return vtkNew < vtkImplicitHalo > () ;} extern "C" void vtkImplicitHalo_destructor (vtkNew < vtkImplicitHalo > sself) {sself . Reset () ; return ;} extern "C" void * vtkImplicitHalo_get_ptr (vtkNew < vtkImplicitHalo > sself) {return sself . GetPointer () ;} +extern "C" double vtk_implicit_halo_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_implicit_halo_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } +extern "C" void vtk_implicit_halo_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_implicit_halo_get_radius(vtkNew sself) { return sself->GetRadius(); } +extern "C" void vtk_implicit_halo_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_implicit_halo_set_center(vtkNew sself, const double _arg) { sself->SetCenter(_arg); } +extern "C" double* vtk_implicit_halo_get_center(vtkNew sself) { return sself->GetCenter(); } +extern "C" void vtk_implicit_halo_get_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_implicit_halo_get_center(vtkNew sself, double _arg) { sself->GetCenter(_arg); } +extern "C" void vtk_implicit_halo_set_fade_out(vtkNew sself, double _arg) { sself->SetFadeOut(_arg); } +extern "C" double vtk_implicit_halo_get_fade_out(vtkNew sself) { return sself->GetFadeOut(); } extern "C" vtkNew < vtkImplicitSelectionLoop > vtkImplicitSelectionLoop_new () {return vtkNew < vtkImplicitSelectionLoop > () ;} extern "C" void vtkImplicitSelectionLoop_destructor (vtkNew < vtkImplicitSelectionLoop > sself) {sself . Reset () ; return ;} extern "C" void * vtkImplicitSelectionLoop_get_ptr (vtkNew < vtkImplicitSelectionLoop > sself) {return sself . GetPointer () ;} +extern "C" double vtk_implicit_selection_loop_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_implicit_selection_loop_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } +extern "C" void vtk_implicit_selection_loop_set_automatic_normal_generation(vtkNew sself, int _arg) { sself->SetAutomaticNormalGeneration(_arg); } +extern "C" int vtk_implicit_selection_loop_get_automatic_normal_generation(vtkNew sself) { return sself->GetAutomaticNormalGeneration(); } +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_on(vtkNew sself) { sself->AutomaticNormalGenerationOn(); } +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_off(vtkNew sself) { sself->AutomaticNormalGenerationOff(); } +extern "C" void vtk_implicit_selection_loop_set_normal(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" void vtk_implicit_selection_loop_set_normal(vtkNew sself, const double _arg) { sself->SetNormal(_arg); } +extern "C" double* vtk_implicit_selection_loop_get_normal(vtkNew sself) { return sself->GetNormal(); } +extern "C" void vtk_implicit_selection_loop_get_normal(vtkNew sself, double data) { sself->GetNormal(data); } +extern "C" unsigned long vtk_implicit_selection_loop_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkImplicitSum > vtkImplicitSum_new () {return vtkNew < vtkImplicitSum > () ;} extern "C" void vtkImplicitSum_destructor (vtkNew < vtkImplicitSum > sself) {sself . Reset () ; return ;} extern "C" void * vtkImplicitSum_get_ptr (vtkNew < vtkImplicitSum > sself) {return sself . GetPointer () ;} +extern "C" double vtk_implicit_sum_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_implicit_sum_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } +extern "C" unsigned long vtk_implicit_sum_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_implicit_sum_remove_all_functions(vtkNew sself) { sself->RemoveAllFunctions(); } +extern "C" void vtk_implicit_sum_set_normalize_by_weight(vtkNew sself, int _arg) { sself->SetNormalizeByWeight(_arg); } +extern "C" int vtk_implicit_sum_get_normalize_by_weight(vtkNew sself) { return sself->GetNormalizeByWeight(); } +extern "C" void vtk_implicit_sum_normalize_by_weight_on(vtkNew sself) { sself->NormalizeByWeightOn(); } +extern "C" void vtk_implicit_sum_normalize_by_weight_off(vtkNew sself) { sself->NormalizeByWeightOff(); } extern "C" vtkNew < vtkImplicitVolume > vtkImplicitVolume_new () {return vtkNew < vtkImplicitVolume > () ;} extern "C" void vtkImplicitVolume_destructor (vtkNew < vtkImplicitVolume > sself) {sself . Reset () ; return ;} extern "C" void * vtkImplicitVolume_get_ptr (vtkNew < vtkImplicitVolume > sself) {return sself . GetPointer () ;} +extern "C" unsigned long vtk_implicit_volume_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" double vtk_implicit_volume_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_implicit_volume_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } +extern "C" void vtk_implicit_volume_set_out_value(vtkNew sself, double _arg) { sself->SetOutValue(_arg); } +extern "C" double vtk_implicit_volume_get_out_value(vtkNew sself) { return sself->GetOutValue(); } +extern "C" void vtk_implicit_volume_set_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetOutGradient(_arg1, _arg2, _arg3); } +extern "C" void vtk_implicit_volume_set_out_gradient(vtkNew sself, const double _arg) { sself->SetOutGradient(_arg); } +extern "C" double* vtk_implicit_volume_get_out_gradient(vtkNew sself) { return sself->GetOutGradient(); } +extern "C" void vtk_implicit_volume_get_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetOutGradient(_arg1, _arg2, _arg3); } +extern "C" void vtk_implicit_volume_get_out_gradient(vtkNew sself, double _arg) { sself->GetOutGradient(_arg); } extern "C" vtkNew < vtkImplicitWindowFunction > vtkImplicitWindowFunction_new () {return vtkNew < vtkImplicitWindowFunction > () ;} extern "C" void vtkImplicitWindowFunction_destructor (vtkNew < vtkImplicitWindowFunction > sself) {sself . Reset () ; return ;} extern "C" void * vtkImplicitWindowFunction_get_ptr (vtkNew < vtkImplicitWindowFunction > sself) {return sself . GetPointer () ;} +extern "C" double vtk_implicit_window_function_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_implicit_window_function_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } +extern "C" void vtk_implicit_window_function_set_window_range(vtkNew sself, double _arg1, double _arg2) { sself->SetWindowRange(_arg1, _arg2); } +extern "C" void vtk_implicit_window_function_set_window_range(vtkNew sself, const double _arg) { sself->SetWindowRange(_arg); } +extern "C" double* vtk_implicit_window_function_get_window_range(vtkNew sself) { return sself->GetWindowRange(); } +extern "C" void vtk_implicit_window_function_get_window_range(vtkNew sself, double data) { sself->GetWindowRange(data); } +extern "C" void vtk_implicit_window_function_set_window_values(vtkNew sself, double _arg1, double _arg2) { sself->SetWindowValues(_arg1, _arg2); } +extern "C" void vtk_implicit_window_function_set_window_values(vtkNew sself, const double _arg) { sself->SetWindowValues(_arg); } +extern "C" double* vtk_implicit_window_function_get_window_values(vtkNew sself) { return sself->GetWindowValues(); } +extern "C" void vtk_implicit_window_function_get_window_values(vtkNew sself, double data) { sself->GetWindowValues(data); } +extern "C" unsigned long vtk_implicit_window_function_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkInEdgeIterator > vtkInEdgeIterator_new () {return vtkNew < vtkInEdgeIterator > () ;} extern "C" void vtkInEdgeIterator_destructor (vtkNew < vtkInEdgeIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkInEdgeIterator_get_ptr (vtkNew < vtkInEdgeIterator > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_in_edge_iterator_get_vertex(vtkNew sself) { return sself->GetVertex(); } +extern "C" bool vtk_in_edge_iterator_has_next(vtkNew sself) { return sself->HasNext(); } extern "C" vtkNew < vtkIncrementalOctreeNode > vtkIncrementalOctreeNode_new () {return vtkNew < vtkIncrementalOctreeNode > () ;} extern "C" void vtkIncrementalOctreeNode_destructor (vtkNew < vtkIncrementalOctreeNode > sself) {sself . Reset () ; return ;} extern "C" void * vtkIncrementalOctreeNode_get_ptr (vtkNew < vtkIncrementalOctreeNode > sself) {return sself . GetPointer () ;} +extern "C" int vtk_incremental_octree_node_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_incremental_octree_node_delete_child_nodes(vtkNew sself) { sself->DeleteChildNodes(); } +extern "C" void vtk_incremental_octree_node_set_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetBounds(x1, x2, y1, y2, z1, z2); } +extern "C" void vtk_incremental_octree_node_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" double* vtk_incremental_octree_node_get_min_bounds(vtkNew sself) { return sself->GetMinBounds(); } +extern "C" void vtk_incremental_octree_node_get_min_bounds(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetMinBounds(_arg1, _arg2, _arg3); } +extern "C" void vtk_incremental_octree_node_get_min_bounds(vtkNew sself, double _arg) { sself->GetMinBounds(_arg); } +extern "C" double* vtk_incremental_octree_node_get_max_bounds(vtkNew sself) { return sself->GetMaxBounds(); } +extern "C" void vtk_incremental_octree_node_get_max_bounds(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetMaxBounds(_arg1, _arg2, _arg3); } +extern "C" void vtk_incremental_octree_node_get_max_bounds(vtkNew sself, double _arg) { sself->GetMaxBounds(_arg); } +extern "C" double* vtk_incremental_octree_node_get_min_data_bounds(vtkNew sself) { return sself->GetMinDataBounds(); } +extern "C" double* vtk_incremental_octree_node_get_max_data_bounds(vtkNew sself) { return sself->GetMaxDataBounds(); } +extern "C" int vtk_incremental_octree_node_is_leaf(vtkNew sself) { return sself->IsLeaf(); } +extern "C" int vtk_incremental_octree_node_get_child_index(vtkNew sself, const double point) { return sself->GetChildIndex(point); } +extern "C" int vtk_incremental_octree_node_contains_point(vtkNew sself, const double pnt) { return sself->ContainsPoint(pnt); } +extern "C" int vtk_incremental_octree_node_contains_point_by_data(vtkNew sself, const double pnt) { return sself->ContainsPointByData(pnt); } +extern "C" int vtk_incremental_octree_node_get_number_of_levels(vtkNew sself) { return sself->GetNumberOfLevels(); } +extern "C" int vtk_incremental_octree_node_get_id(vtkNew sself) { return sself->GetID(); } extern "C" vtkNew < vtkIncrementalOctreePointLocator > vtkIncrementalOctreePointLocator_new () {return vtkNew < vtkIncrementalOctreePointLocator > () ;} extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkNew < vtkIncrementalOctreePointLocator > sself) {sself . Reset () ; return ;} extern "C" void * vtkIncrementalOctreePointLocator_get_ptr (vtkNew < vtkIncrementalOctreePointLocator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_incremental_octree_point_locator_set_max_points_per_leaf(vtkNew sself, int _arg) { sself->SetMaxPointsPerLeaf(_arg); } +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value(vtkNew sself) { return sself->GetMaxPointsPerLeafMinValue(); } +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value(vtkNew sself) { return sself->GetMaxPointsPerLeafMaxValue(); } +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf(vtkNew sself) { return sself->GetMaxPointsPerLeaf(); } +extern "C" void vtk_incremental_octree_point_locator_set_build_cubic_octree(vtkNew sself, int _arg) { sself->SetBuildCubicOctree(_arg); } +extern "C" int vtk_incremental_octree_point_locator_get_build_cubic_octree(vtkNew sself) { return sself->GetBuildCubicOctree(); } +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_on(vtkNew sself) { sself->BuildCubicOctreeOn(); } +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_off(vtkNew sself) { sself->BuildCubicOctreeOff(); } +extern "C" void vtk_incremental_octree_point_locator_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_incremental_octree_point_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_incremental_octree_point_locator_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" double* vtk_incremental_octree_point_locator_get_bounds(vtkNew sself) { return sself->GetBounds(); } +extern "C" int vtk_incremental_octree_point_locator_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" int vtk_incremental_octree_point_locator_get_number_of_nodes(vtkNew sself) { return sself->GetNumberOfNodes(); } +extern "C" long long vtk_incremental_octree_point_locator_find_closest_inserted_point(vtkNew sself, const double x) { return sself->FindClosestInsertedPoint(x); } +extern "C" void vtk_incremental_octree_point_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z) { return sself->FindClosestPoint(x, y, z); } +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, const double x, double miniDist2) { return sself->FindClosestPoint(x, miniDist2); } +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z, double miniDist2) { return sself->FindClosestPoint(x, y, z, miniDist2); } +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point_within_squared_radius(vtkNew sself, double radius2, const double x, double dist2) { return sself->FindClosestPointWithinSquaredRadius(radius2, x, dist2); } +extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkNew sself, const double x) { return sself->IsInsertedPoint(x); } +extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkNew sself, double x, double y, double z) { return sself->IsInsertedPoint(x, y, z); } +extern "C" int vtk_incremental_octree_point_locator_insert_unique_point(vtkNew sself, const double point, long long pntId) { return sself->InsertUniquePoint(point, pntId); } +extern "C" void vtk_incremental_octree_point_locator_insert_point(vtkNew sself, long long ptId, const double x) { sself->InsertPoint(ptId, x); } +extern "C" long long vtk_incremental_octree_point_locator_insert_next_point(vtkNew sself, const double x) { return sself->InsertNextPoint(x); } +extern "C" void vtk_incremental_octree_point_locator_insert_point_without_checking(vtkNew sself, const double point, long long pntId, int insert) { sself->InsertPointWithoutChecking(point, pntId, insert); } +extern "C" int vtk_incremental_octree_point_locator_get_number_of_levels(vtkNew sself) { return sself->GetNumberOfLevels(); } extern "C" vtkNew < vtkIterativeClosestPointTransform > vtkIterativeClosestPointTransform_new () {return vtkNew < vtkIterativeClosestPointTransform > () ;} extern "C" void vtkIterativeClosestPointTransform_destructor (vtkNew < vtkIterativeClosestPointTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkIterativeClosestPointTransform_get_ptr (vtkNew < vtkIterativeClosestPointTransform > sself) {return sself . GetPointer () ;} +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_iterations(vtkNew sself, int _arg) { sself->SetMaximumNumberOfIterations(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_iterations(vtkNew sself) { return sself->GetMaximumNumberOfIterations(); } +extern "C" int vtk_iterative_closest_point_transform_get_number_of_iterations(vtkNew sself) { return sself->GetNumberOfIterations(); } +extern "C" void vtk_iterative_closest_point_transform_set_check_mean_distance(vtkNew sself, int _arg) { sself->SetCheckMeanDistance(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_check_mean_distance(vtkNew sself) { return sself->GetCheckMeanDistance(); } +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_on(vtkNew sself) { sself->CheckMeanDistanceOn(); } +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_off(vtkNew sself) { sself->CheckMeanDistanceOff(); } +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode(vtkNew sself, int _arg) { sself->SetMeanDistanceMode(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value(vtkNew sself) { return sself->GetMeanDistanceModeMinValue(); } +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value(vtkNew sself) { return sself->GetMeanDistanceModeMaxValue(); } +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode(vtkNew sself) { return sself->GetMeanDistanceMode(); } +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms(vtkNew sself) { sself->SetMeanDistanceModeToRMS(); } +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value(vtkNew sself) { sself->SetMeanDistanceModeToAbsoluteValue(); } +extern "C" const char* vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string(vtkNew sself) { return sself->GetMeanDistanceModeAsString(); } +extern "C" void vtk_iterative_closest_point_transform_set_maximum_mean_distance(vtkNew sself, double _arg) { sself->SetMaximumMeanDistance(_arg); } +extern "C" double vtk_iterative_closest_point_transform_get_maximum_mean_distance(vtkNew sself) { return sself->GetMaximumMeanDistance(); } +extern "C" double vtk_iterative_closest_point_transform_get_mean_distance(vtkNew sself) { return sself->GetMeanDistance(); } +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks(vtkNew sself, int _arg) { sself->SetMaximumNumberOfLandmarks(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks(vtkNew sself) { return sself->GetMaximumNumberOfLandmarks(); } +extern "C" void vtk_iterative_closest_point_transform_set_start_by_matching_centroids(vtkNew sself, int _arg) { sself->SetStartByMatchingCentroids(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_start_by_matching_centroids(vtkNew sself) { return sself->GetStartByMatchingCentroids(); } +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_on(vtkNew sself) { sself->StartByMatchingCentroidsOn(); } +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_off(vtkNew sself) { sself->StartByMatchingCentroidsOff(); } +extern "C" void vtk_iterative_closest_point_transform_inverse(vtkNew sself) { sself->Inverse(); } extern "C" vtkNew < vtkKdNode > vtkKdNode_new () {return vtkNew < vtkKdNode > () ;} extern "C" void vtkKdNode_destructor (vtkNew < vtkKdNode > sself) {sself . Reset () ; return ;} extern "C" void * vtkKdNode_get_ptr (vtkNew < vtkKdNode > sself) {return sself . GetPointer () ;} +extern "C" void vtk_kd_node_set_dim(vtkNew sself, int _arg) { sself->SetDim(_arg); } +extern "C" int vtk_kd_node_get_dim(vtkNew sself) { return sself->GetDim(); } +extern "C" double vtk_kd_node_get_division_position(vtkNew sself) { return sself->GetDivisionPosition(); } +extern "C" void vtk_kd_node_set_number_of_points(vtkNew sself, int _arg) { sself->SetNumberOfPoints(_arg); } +extern "C" int vtk_kd_node_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_kd_node_set_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetBounds(x1, x2, y1, y2, z1, z2); } +extern "C" void vtk_kd_node_set_bounds(vtkNew sself, const double b) { sself->SetBounds(b); } +extern "C" void vtk_kd_node_get_bounds(vtkNew sself, double b) { sself->GetBounds(b); } +extern "C" void vtk_kd_node_set_data_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetDataBounds(x1, x2, y1, y2, z1, z2); } +extern "C" void vtk_kd_node_get_data_bounds(vtkNew sself, double b) { sself->GetDataBounds(b); } +extern "C" void vtk_kd_node_set_data_bounds(vtkNew sself, float v) { sself->SetDataBounds(v); } +extern "C" double* vtk_kd_node_get_min_bounds(vtkNew sself) { return sself->GetMinBounds(); } +extern "C" double* vtk_kd_node_get_max_bounds(vtkNew sself) { return sself->GetMaxBounds(); } +extern "C" void vtk_kd_node_set_min_bounds(vtkNew sself, const double mb) { sself->SetMinBounds(mb); } +extern "C" void vtk_kd_node_set_max_bounds(vtkNew sself, const double mb) { sself->SetMaxBounds(mb); } +extern "C" double* vtk_kd_node_get_min_data_bounds(vtkNew sself) { return sself->GetMinDataBounds(); } +extern "C" double* vtk_kd_node_get_max_data_bounds(vtkNew sself) { return sself->GetMaxDataBounds(); } +extern "C" void vtk_kd_node_set_min_data_bounds(vtkNew sself, const double mb) { sself->SetMinDataBounds(mb); } +extern "C" void vtk_kd_node_set_max_data_bounds(vtkNew sself, const double mb) { sself->SetMaxDataBounds(mb); } +extern "C" void vtk_kd_node_set_id(vtkNew sself, int _arg) { sself->SetID(_arg); } +extern "C" int vtk_kd_node_get_id(vtkNew sself) { return sself->GetID(); } +extern "C" int vtk_kd_node_get_min_id(vtkNew sself) { return sself->GetMinID(); } +extern "C" int vtk_kd_node_get_max_id(vtkNew sself) { return sself->GetMaxID(); } +extern "C" void vtk_kd_node_set_min_id(vtkNew sself, int _arg) { sself->SetMinID(_arg); } +extern "C" void vtk_kd_node_set_max_id(vtkNew sself, int _arg) { sself->SetMaxID(_arg); } +extern "C" void vtk_kd_node_delete_child_nodes(vtkNew sself) { sself->DeleteChildNodes(); } +extern "C" int vtk_kd_node_intersects_box(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds) { return sself->IntersectsBox(x1, x2, y1, y2, z1, z2, useDataBounds); } +extern "C" int vtk_kd_node_intersects_sphere_2(vtkNew sself, double x, double y, double z, double rSquared, int useDataBounds) { return sself->IntersectsSphere2(x, y, z, rSquared, useDataBounds); } +extern "C" int vtk_kd_node_contains_box(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds) { return sself->ContainsBox(x1, x2, y1, y2, z1, z2, useDataBounds); } +extern "C" int vtk_kd_node_contains_point(vtkNew sself, double x, double y, double z, int useDataBounds) { return sself->ContainsPoint(x, y, z, useDataBounds); } +extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkNew sself, double x, double y, double z, int useDataBounds) { return sself->GetDistance2ToBoundary(x, y, z, useDataBounds); } +extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkNew sself, double x, double y, double z, double boundaryPt, int useDataBounds) { return sself->GetDistance2ToBoundary(x, y, z, boundaryPt, useDataBounds); } +extern "C" double vtk_kd_node_get_distance_2_to_inner_boundary(vtkNew sself, double x, double y, double z) { return sself->GetDistance2ToInnerBoundary(x, y, z); } +extern "C" void vtk_kd_node_print_node(vtkNew sself, int depth) { sself->PrintNode(depth); } +extern "C" void vtk_kd_node_print_verbose_node(vtkNew sself, int depth) { sself->PrintVerboseNode(depth); } extern "C" vtkNew < vtkKdTree > vtkKdTree_new () {return vtkNew < vtkKdTree > () ;} extern "C" void vtkKdTree_destructor (vtkNew < vtkKdTree > sself) {sself . Reset () ; return ;} extern "C" void * vtkKdTree_get_ptr (vtkNew < vtkKdTree > sself) {return sself . GetPointer () ;} +extern "C" void vtk_kd_tree_timing_on(vtkNew sself) { sself->TimingOn(); } +extern "C" void vtk_kd_tree_timing_off(vtkNew sself) { sself->TimingOff(); } +extern "C" void vtk_kd_tree_set_timing(vtkNew sself, int _arg) { sself->SetTiming(_arg); } +extern "C" int vtk_kd_tree_get_timing(vtkNew sself) { return sself->GetTiming(); } +extern "C" void vtk_kd_tree_set_min_cells(vtkNew sself, int _arg) { sself->SetMinCells(_arg); } +extern "C" int vtk_kd_tree_get_min_cells(vtkNew sself) { return sself->GetMinCells(); } +extern "C" int vtk_kd_tree_get_number_of_regions_or_less(vtkNew sself) { return sself->GetNumberOfRegionsOrLess(); } +extern "C" void vtk_kd_tree_set_number_of_regions_or_less(vtkNew sself, int _arg) { sself->SetNumberOfRegionsOrLess(_arg); } +extern "C" int vtk_kd_tree_get_number_of_regions_or_more(vtkNew sself) { return sself->GetNumberOfRegionsOrMore(); } +extern "C" void vtk_kd_tree_set_number_of_regions_or_more(vtkNew sself, int _arg) { sself->SetNumberOfRegionsOrMore(_arg); } +extern "C" double vtk_kd_tree_get_fudge_factor(vtkNew sself) { return sself->GetFudgeFactor(); } +extern "C" void vtk_kd_tree_set_fudge_factor(vtkNew sself, double _arg) { sself->SetFudgeFactor(_arg); } +extern "C" void vtk_kd_tree_omit_x_partitioning(vtkNew sself) { sself->OmitXPartitioning(); } +extern "C" void vtk_kd_tree_omit_y_partitioning(vtkNew sself) { sself->OmitYPartitioning(); } +extern "C" void vtk_kd_tree_omit_z_partitioning(vtkNew sself) { sself->OmitZPartitioning(); } +extern "C" void vtk_kd_tree_omit_xy_partitioning(vtkNew sself) { sself->OmitXYPartitioning(); } +extern "C" void vtk_kd_tree_omit_yz_partitioning(vtkNew sself) { sself->OmitYZPartitioning(); } +extern "C" void vtk_kd_tree_omit_zx_partitioning(vtkNew sself) { sself->OmitZXPartitioning(); } +extern "C" void vtk_kd_tree_omit_no_partitioning(vtkNew sself) { sself->OmitNoPartitioning(); } +extern "C" void vtk_kd_tree_remove_data_set(vtkNew sself, int index) { sself->RemoveDataSet(index); } +extern "C" void vtk_kd_tree_remove_all_data_sets(vtkNew sself) { sself->RemoveAllDataSets(); } +extern "C" int vtk_kd_tree_get_number_of_data_sets(vtkNew sself) { return sself->GetNumberOfDataSets(); } +extern "C" void vtk_kd_tree_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" void vtk_kd_tree_set_new_bounds(vtkNew sself, double bounds) { sself->SetNewBounds(bounds); } +extern "C" int vtk_kd_tree_get_number_of_regions(vtkNew sself) { return sself->GetNumberOfRegions(); } +extern "C" void vtk_kd_tree_get_region_bounds(vtkNew sself, int regionID, double bounds) { sself->GetRegionBounds(regionID, bounds); } +extern "C" void vtk_kd_tree_get_region_data_bounds(vtkNew sself, int regionID, double bounds) { sself->GetRegionDataBounds(regionID, bounds); } +extern "C" void vtk_kd_tree_print_tree(vtkNew sself) { sself->PrintTree(); } +extern "C" void vtk_kd_tree_print_verbose_tree(vtkNew sself) { sself->PrintVerboseTree(); } +extern "C" void vtk_kd_tree_print_region(vtkNew sself, int id) { sself->PrintRegion(id); } +extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself, int dataSetIndex, int regionReqList, int reqListSize) { sself->CreateCellLists(dataSetIndex, regionReqList, reqListSize); } +extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself, int regionReqList, int listSize) { sself->CreateCellLists(regionReqList, listSize); } +extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself) { sself->CreateCellLists(); } +extern "C" void vtk_kd_tree_set_include_region_boundary_cells(vtkNew sself, int _arg) { sself->SetIncludeRegionBoundaryCells(_arg); } +extern "C" int vtk_kd_tree_get_include_region_boundary_cells(vtkNew sself) { return sself->GetIncludeRegionBoundaryCells(); } +extern "C" void vtk_kd_tree_include_region_boundary_cells_on(vtkNew sself) { sself->IncludeRegionBoundaryCellsOn(); } +extern "C" void vtk_kd_tree_include_region_boundary_cells_off(vtkNew sself) { sself->IncludeRegionBoundaryCellsOff(); } +extern "C" void vtk_kd_tree_delete_cell_lists(vtkNew sself) { sself->DeleteCellLists(); } +extern "C" int vtk_kd_tree_get_region_containing_cell(vtkNew sself, int set, long long cellID) { return sself->GetRegionContainingCell(set, cellID); } +extern "C" int vtk_kd_tree_get_region_containing_cell(vtkNew sself, long long cellID) { return sself->GetRegionContainingCell(cellID); } +extern "C" int* vtk_kd_tree_all_get_region_containing_cell(vtkNew sself) { return sself->AllGetRegionContainingCell(); } +extern "C" int vtk_kd_tree_get_region_containing_point(vtkNew sself, double x, double y, double z) { return sself->GetRegionContainingPoint(x, y, z); } +extern "C" void vtk_kd_tree_build_locator(vtkNew sself) { sself->BuildLocator(); } +extern "C" long long vtk_kd_tree_find_point(vtkNew sself, double x) { return sself->FindPoint(x); } +extern "C" long long vtk_kd_tree_find_point(vtkNew sself, double x, double y, double z) { return sself->FindPoint(x, y, z); } +extern "C" long long vtk_kd_tree_find_closest_point(vtkNew sself, double x, double dist2) { return sself->FindClosestPoint(x, dist2); } +extern "C" long long vtk_kd_tree_find_closest_point(vtkNew sself, double x, double y, double z, double dist2) { return sself->FindClosestPoint(x, y, z, dist2); } +extern "C" long long vtk_kd_tree_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } +extern "C" long long vtk_kd_tree_find_closest_point_in_region(vtkNew sself, int regionId, double x, double dist2) { return sself->FindClosestPointInRegion(regionId, x, dist2); } +extern "C" long long vtk_kd_tree_find_closest_point_in_region(vtkNew sself, int regionId, double x, double y, double z, double dist2) { return sself->FindClosestPointInRegion(regionId, x, y, z, dist2); } +extern "C" void vtk_kd_tree_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_on(vtkNew sself) { sself->GenerateRepresentationUsingDataBoundsOn(); } +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_off(vtkNew sself) { sself->GenerateRepresentationUsingDataBoundsOff(); } +extern "C" void vtk_kd_tree_set_generate_representation_using_data_bounds(vtkNew sself, int _arg) { sself->SetGenerateRepresentationUsingDataBounds(_arg); } +extern "C" int vtk_kd_tree_get_generate_representation_using_data_bounds(vtkNew sself) { return sself->GetGenerateRepresentationUsingDataBounds(); } +extern "C" int vtk_kd_tree_new_geometry(vtkNew sself) { return sself->NewGeometry(); } +extern "C" void vtk_kd_tree_invalidate_geometry(vtkNew sself) { sself->InvalidateGeometry(); } extern "C" vtkNew < vtkKdTreePointLocator > vtkKdTreePointLocator_new () {return vtkNew < vtkKdTreePointLocator > () ;} extern "C" void vtkKdTreePointLocator_destructor (vtkNew < vtkKdTreePointLocator > sself) {sself . Reset () ; return ;} extern "C" void * vtkKdTreePointLocator_get_ptr (vtkNew < vtkKdTreePointLocator > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_kd_tree_point_locator_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } +extern "C" long long vtk_kd_tree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } +extern "C" void vtk_kd_tree_point_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_kd_tree_point_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } extern "C" vtkNew < vtkLagrangeCurve > vtkLagrangeCurve_new () {return vtkNew < vtkLagrangeCurve > () ;} extern "C" void vtkLagrangeCurve_destructor (vtkNew < vtkLagrangeCurve > sself) {sself . Reset () ; return ;} extern "C" void * vtkLagrangeCurve_get_ptr (vtkNew < vtkLagrangeCurve > sself) {return sself . GetPointer () ;} +extern "C" int vtk_lagrange_curve_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_lagrange_curve_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkLagrangeHexahedron > vtkLagrangeHexahedron_new () {return vtkNew < vtkLagrangeHexahedron > () ;} extern "C" void vtkLagrangeHexahedron_destructor (vtkNew < vtkLagrangeHexahedron > sself) {sself . Reset () ; return ;} extern "C" void * vtkLagrangeHexahedron_get_ptr (vtkNew < vtkLagrangeHexahedron > sself) {return sself . GetPointer () ;} +extern "C" int vtk_lagrange_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_lagrange_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkLagrangeInterpolation > vtkLagrangeInterpolation_new () {return vtkNew < vtkLagrangeInterpolation > () ;} extern "C" void vtkLagrangeInterpolation_destructor (vtkNew < vtkLagrangeInterpolation > sself) {sself . Reset () ; return ;} extern "C" void * vtkLagrangeInterpolation_get_ptr (vtkNew < vtkLagrangeInterpolation > sself) {return sself . GetPointer () ;} +extern "C" void vtk_lagrange_interpolation_evaluate_shape_functions(vtkNew sself, const int order, const double pcoord, double shape) { sself->EvaluateShapeFunctions(order, pcoord, shape); } +extern "C" void vtk_lagrange_interpolation_evaluate_shape_and_gradient(vtkNew sself, const int order, const double pcoord, double shape, double grad) { sself->EvaluateShapeAndGradient(order, pcoord, shape, grad); } +extern "C" int vtk_lagrange_interpolation_tensor_1_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor1ShapeFunctions(order, pcoords, shape); } +extern "C" int vtk_lagrange_interpolation_tensor_1_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor1ShapeDerivatives(order, pcoords, derivs); } +extern "C" int vtk_lagrange_interpolation_tensor_2_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor2ShapeFunctions(order, pcoords, shape); } +extern "C" int vtk_lagrange_interpolation_tensor_2_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor2ShapeDerivatives(order, pcoords, derivs); } +extern "C" int vtk_lagrange_interpolation_tensor_3_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor3ShapeFunctions(order, pcoords, shape); } +extern "C" int vtk_lagrange_interpolation_tensor_3_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor3ShapeDerivatives(order, pcoords, derivs); } +extern "C" void vtk_lagrange_interpolation_wedge_shape_functions(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double shape) { sself->WedgeShapeFunctions(order, numberOfPoints, pcoords, shape); } +extern "C" void vtk_lagrange_interpolation_wedge_shape_derivatives(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double derivs) { sself->WedgeShapeDerivatives(order, numberOfPoints, pcoords, derivs); } +extern "C" void vtk_lagrange_interpolation_wedge_evaluate(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double fieldVals, int fieldDim, double fieldAtPCoords) { sself->WedgeEvaluate(order, numberOfPoints, pcoords, fieldVals, fieldDim, fieldAtPCoords); } extern "C" vtkNew < vtkLagrangeQuadrilateral > vtkLagrangeQuadrilateral_new () {return vtkNew < vtkLagrangeQuadrilateral > () ;} extern "C" void vtkLagrangeQuadrilateral_destructor (vtkNew < vtkLagrangeQuadrilateral > sself) {sself . Reset () ; return ;} extern "C" void * vtkLagrangeQuadrilateral_get_ptr (vtkNew < vtkLagrangeQuadrilateral > sself) {return sself . GetPointer () ;} +extern "C" int vtk_lagrange_quadrilateral_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_lagrange_quadrilateral_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkLagrangeTetra > vtkLagrangeTetra_new () {return vtkNew < vtkLagrangeTetra > () ;} extern "C" void vtkLagrangeTetra_destructor (vtkNew < vtkLagrangeTetra > sself) {sself . Reset () ; return ;} extern "C" void * vtkLagrangeTetra_get_ptr (vtkNew < vtkLagrangeTetra > sself) {return sself . GetPointer () ;} +extern "C" int vtk_lagrange_tetra_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_lagrange_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkLagrangeTriangle > vtkLagrangeTriangle_new () {return vtkNew < vtkLagrangeTriangle > () ;} extern "C" void vtkLagrangeTriangle_destructor (vtkNew < vtkLagrangeTriangle > sself) {sself . Reset () ; return ;} extern "C" void * vtkLagrangeTriangle_get_ptr (vtkNew < vtkLagrangeTriangle > sself) {return sself . GetPointer () ;} +extern "C" int vtk_lagrange_triangle_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_lagrange_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkLagrangeWedge > vtkLagrangeWedge_new () {return vtkNew < vtkLagrangeWedge > () ;} extern "C" void vtkLagrangeWedge_destructor (vtkNew < vtkLagrangeWedge > sself) {sself . Reset () ; return ;} extern "C" void * vtkLagrangeWedge_get_ptr (vtkNew < vtkLagrangeWedge > sself) {return sself . GetPointer () ;} +extern "C" int vtk_lagrange_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" void vtk_lagrange_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } extern "C" vtkNew < vtkLine > vtkLine_new () {return vtkNew < vtkLine > () ;} extern "C" void vtkLine_destructor (vtkNew < vtkLine > sself) {sself . Reset () ; return ;} extern "C" void * vtkLine_get_ptr (vtkNew < vtkLine > sself) {return sself . GetPointer () ;} +extern "C" int vtk_line_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_line_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_line_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_line_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_line_inflate(vtkNew sself, double dist) { return sself->Inflate(dist); } +extern "C" int vtk_line_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" int vtk_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_line_intersection(vtkNew sself, const double p1, const double p2, const double x1, const double x2, double u, double v, const double tolerance, int toleranceType) { return sself->Intersection(p1, p2, x1, x2, u, v, tolerance, toleranceType); } +extern "C" int vtk_line_intersection_3_d(vtkNew sself, double p1, double p2, double x1, double x2, double u, double v, const double tolerance) { return sself->Intersection3D(p1, p2, x1, x2, u, v, tolerance); } +extern "C" double vtk_line_distance_to_line(vtkNew sself, const double x, const double p1, const double p2, double t, double closestPoint) { return sself->DistanceToLine(x, p1, p2, t, closestPoint); } +extern "C" double vtk_line_distance_to_line(vtkNew sself, const double x, const double p1, const double p2) { return sself->DistanceToLine(x, p1, p2); } +extern "C" double vtk_line_distance_between_lines(vtkNew sself, double l0, double l1, double m0, double m1, double closestPt1, double closestPt2, double t1, double t2) { return sself->DistanceBetweenLines(l0, l1, m0, m1, closestPt1, closestPt2, t1, t2); } +extern "C" double vtk_line_distance_between_line_segments(vtkNew sself, double l0, double l1, double m0, double m1, double closestPt1, double closestPt2, double t1, double t2) { return sself->DistanceBetweenLineSegments(l0, l1, m0, m1, closestPt1, closestPt2, t1, t2); } +extern "C" void vtk_line_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_line_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_line_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_line_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } extern "C" vtkNew < vtkMeanValueCoordinatesInterpolator > vtkMeanValueCoordinatesInterpolator_new () {return vtkNew < vtkMeanValueCoordinatesInterpolator > () ;} extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) {sself . Reset () ; return ;} extern "C" void * vtkMeanValueCoordinatesInterpolator_get_ptr (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkMergePoints > vtkMergePoints_new () {return vtkNew < vtkMergePoints > () ;} extern "C" void vtkMergePoints_destructor (vtkNew < vtkMergePoints > sself) {sself . Reset () ; return ;} extern "C" void * vtkMergePoints_get_ptr (vtkNew < vtkMergePoints > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_merge_points_is_inserted_point(vtkNew sself, const double x) { return sself->IsInsertedPoint(x); } +extern "C" int vtk_merge_points_insert_unique_point(vtkNew sself, const double x, long long ptId) { return sself->InsertUniquePoint(x, ptId); } extern "C" vtkNew < vtkMolecule > vtkMolecule_new () {return vtkNew < vtkMolecule > () ;} extern "C" void vtkMolecule_destructor (vtkNew < vtkMolecule > sself) {sself . Reset () ; return ;} extern "C" void * vtkMolecule_get_ptr (vtkNew < vtkMolecule > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_molecule_get_number_of_atoms(vtkNew sself) { return sself->GetNumberOfAtoms(); } +extern "C" long long vtk_molecule_get_number_of_bonds(vtkNew sself) { return sself->GetNumberOfBonds(); } +extern "C" unsigned short vtk_molecule_get_atom_atomic_number(vtkNew sself, long long atomId) { return sself->GetAtomAtomicNumber(atomId); } +extern "C" void vtk_molecule_set_atom_atomic_number(vtkNew sself, long long atomId, unsigned short atomicNum) { sself->SetAtomAtomicNumber(atomId, atomicNum); } +extern "C" void vtk_molecule_set_atom_position(vtkNew sself, long long atomId, double x, double y, double z) { sself->SetAtomPosition(atomId, x, y, z); } +extern "C" void vtk_molecule_set_atom_position(vtkNew sself, long long atomId, double pos) { sself->SetAtomPosition(atomId, pos); } +extern "C" void vtk_molecule_get_atom_position(vtkNew sself, long long atomId, float pos) { sself->GetAtomPosition(atomId, pos); } +extern "C" void vtk_molecule_get_atom_position(vtkNew sself, long long atomId, double pos) { sself->GetAtomPosition(atomId, pos); } +extern "C" void vtk_molecule_set_bond_order(vtkNew sself, long long bondId, unsigned short order) { sself->SetBondOrder(bondId, order); } +extern "C" unsigned short vtk_molecule_get_bond_order(vtkNew sself, long long bondId) { return sself->GetBondOrder(bondId); } +extern "C" double vtk_molecule_get_bond_length(vtkNew sself, long long bondId) { return sself->GetBondLength(bondId); } +extern "C" bool vtk_molecule_has_lattice(vtkNew sself) { return sself->HasLattice(); } +extern "C" void vtk_molecule_clear_lattice(vtkNew sself) { sself->ClearLattice(); } +extern "C" void vtk_molecule_allocate_atom_ghost_array(vtkNew sself) { sself->AllocateAtomGhostArray(); } +extern "C" void vtk_molecule_allocate_bond_ghost_array(vtkNew sself) { sself->AllocateBondGhostArray(); } +extern "C" long long vtk_molecule_get_bond_id(vtkNew sself, long long a, long long b) { return sself->GetBondId(a, b); } +extern "C" void vtk_molecule_set_atomic_number_array_name(vtkNew sself, const char _arg) { sself->SetAtomicNumberArrayName(_arg); } +extern "C" char* vtk_molecule_get_atomic_number_array_name(vtkNew sself) { return sself->GetAtomicNumberArrayName(); } +extern "C" void vtk_molecule_set_bond_orders_array_name(vtkNew sself, const char _arg) { sself->SetBondOrdersArrayName(_arg); } +extern "C" char* vtk_molecule_get_bond_orders_array_name(vtkNew sself) { return sself->GetBondOrdersArrayName(); } extern "C" vtkNew < vtkMultiBlockDataSet > vtkMultiBlockDataSet_new () {return vtkNew < vtkMultiBlockDataSet > () ;} extern "C" void vtkMultiBlockDataSet_destructor (vtkNew < vtkMultiBlockDataSet > sself) {sself . Reset () ; return ;} extern "C" void * vtkMultiBlockDataSet_get_ptr (vtkNew < vtkMultiBlockDataSet > sself) {return sself . GetPointer () ;} +extern "C" void vtk_multi_block_data_set_set_number_of_blocks(vtkNew sself, unsigned int numBlocks) { sself->SetNumberOfBlocks(numBlocks); } +extern "C" unsigned int vtk_multi_block_data_set_get_number_of_blocks(vtkNew sself) { return sself->GetNumberOfBlocks(); } +extern "C" void vtk_multi_block_data_set_remove_block(vtkNew sself, unsigned int blockno) { sself->RemoveBlock(blockno); } +extern "C" int vtk_multi_block_data_set_has_meta_data(vtkNew sself, unsigned int blockno) { return sself->HasMetaData(blockno); } extern "C" vtkNew < vtkMultiPieceDataSet > vtkMultiPieceDataSet_new () {return vtkNew < vtkMultiPieceDataSet > () ;} extern "C" void vtkMultiPieceDataSet_destructor (vtkNew < vtkMultiPieceDataSet > sself) {sself . Reset () ; return ;} extern "C" void * vtkMultiPieceDataSet_get_ptr (vtkNew < vtkMultiPieceDataSet > sself) {return sself . GetPointer () ;} +extern "C" void vtk_multi_piece_data_set_set_number_of_pieces(vtkNew sself, unsigned int numpieces) { sself->SetNumberOfPieces(numpieces); } +extern "C" unsigned int vtk_multi_piece_data_set_get_number_of_pieces(vtkNew sself) { return sself->GetNumberOfPieces(); } extern "C" vtkNew < vtkMutableDirectedGraph > vtkMutableDirectedGraph_new () {return vtkNew < vtkMutableDirectedGraph > () ;} extern "C" void vtkMutableDirectedGraph_destructor (vtkNew < vtkMutableDirectedGraph > sself) {sself . Reset () ; return ;} extern "C" void * vtkMutableDirectedGraph_get_ptr (vtkNew < vtkMutableDirectedGraph > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_mutable_directed_graph_set_number_of_vertices(vtkNew sself, long long numVerts) { return sself->SetNumberOfVertices(numVerts); } +extern "C" long long vtk_mutable_directed_graph_add_vertex(vtkNew sself) { return sself->AddVertex(); } +extern "C" void vtk_mutable_directed_graph_lazy_add_vertex(vtkNew sself) { sself->LazyAddVertex(); } +extern "C" long long vtk_mutable_directed_graph_add_child(vtkNew sself, long long parent) { return sself->AddChild(parent); } +extern "C" void vtk_mutable_directed_graph_remove_vertex(vtkNew sself, long long v) { sself->RemoveVertex(v); } +extern "C" void vtk_mutable_directed_graph_remove_edge(vtkNew sself, long long e) { sself->RemoveEdge(e); } extern "C" vtkNew < vtkMutableUndirectedGraph > vtkMutableUndirectedGraph_new () {return vtkNew < vtkMutableUndirectedGraph > () ;} extern "C" void vtkMutableUndirectedGraph_destructor (vtkNew < vtkMutableUndirectedGraph > sself) {sself . Reset () ; return ;} extern "C" void * vtkMutableUndirectedGraph_get_ptr (vtkNew < vtkMutableUndirectedGraph > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_mutable_undirected_graph_set_number_of_vertices(vtkNew sself, long long numVerts) { return sself->SetNumberOfVertices(numVerts); } +extern "C" long long vtk_mutable_undirected_graph_add_vertex(vtkNew sself) { return sself->AddVertex(); } +extern "C" void vtk_mutable_undirected_graph_lazy_add_vertex(vtkNew sself) { sself->LazyAddVertex(); } +extern "C" void vtk_mutable_undirected_graph_lazy_add_edge(vtkNew sself, long long u, long long v) { sself->LazyAddEdge(u, v); } +extern "C" void vtk_mutable_undirected_graph_remove_vertex(vtkNew sself, long long v) { sself->RemoveVertex(v); } +extern "C" void vtk_mutable_undirected_graph_remove_edge(vtkNew sself, long long e) { sself->RemoveEdge(e); } extern "C" vtkNew < vtkNonMergingPointLocator > vtkNonMergingPointLocator_new () {return vtkNew < vtkNonMergingPointLocator > () ;} extern "C" void vtkNonMergingPointLocator_destructor (vtkNew < vtkNonMergingPointLocator > sself) {sself . Reset () ; return ;} extern "C" void * vtkNonMergingPointLocator_get_ptr (vtkNew < vtkNonMergingPointLocator > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNew sself, const double p0) { return sself->IsInsertedPoint(p0); } +extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNew sself, double p0, double p1, double p2) { return sself->IsInsertedPoint(p0, p1, p2); } +extern "C" int vtk_non_merging_point_locator_insert_unique_point(vtkNew sself, const double x, long long ptId) { return sself->InsertUniquePoint(x, ptId); } extern "C" vtkNew < vtkNonOverlappingAMR > vtkNonOverlappingAMR_new () {return vtkNew < vtkNonOverlappingAMR > () ;} extern "C" void vtkNonOverlappingAMR_destructor (vtkNew < vtkNonOverlappingAMR > sself) {sself . Reset () ; return ;} extern "C" void * vtkNonOverlappingAMR_get_ptr (vtkNew < vtkNonOverlappingAMR > sself) {return sself . GetPointer () ;} +extern "C" int vtk_non_overlapping_amr_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } extern "C" vtkNew < vtkOctreePointLocator > vtkOctreePointLocator_new () {return vtkNew < vtkOctreePointLocator > () ;} extern "C" void vtkOctreePointLocator_destructor (vtkNew < vtkOctreePointLocator > sself) {sself . Reset () ; return ;} extern "C" void * vtkOctreePointLocator_get_ptr (vtkNew < vtkOctreePointLocator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_octree_point_locator_set_maximum_points_per_region(vtkNew sself, int _arg) { sself->SetMaximumPointsPerRegion(_arg); } +extern "C" int vtk_octree_point_locator_get_maximum_points_per_region(vtkNew sself) { return sself->GetMaximumPointsPerRegion(); } +extern "C" void vtk_octree_point_locator_set_create_cubic_octants(vtkNew sself, int _arg) { sself->SetCreateCubicOctants(_arg); } +extern "C" int vtk_octree_point_locator_get_create_cubic_octants(vtkNew sself) { return sself->GetCreateCubicOctants(); } +extern "C" double vtk_octree_point_locator_get_fudge_factor(vtkNew sself) { return sself->GetFudgeFactor(); } +extern "C" void vtk_octree_point_locator_set_fudge_factor(vtkNew sself, double _arg) { sself->SetFudgeFactor(_arg); } +extern "C" double* vtk_octree_point_locator_get_bounds(vtkNew sself) { return sself->GetBounds(); } +extern "C" void vtk_octree_point_locator_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" int vtk_octree_point_locator_get_number_of_leaf_nodes(vtkNew sself) { return sself->GetNumberOfLeafNodes(); } +extern "C" void vtk_octree_point_locator_get_region_bounds(vtkNew sself, int regionID, double bounds) { sself->GetRegionBounds(regionID, bounds); } +extern "C" void vtk_octree_point_locator_get_region_data_bounds(vtkNew sself, int leafNodeID, double bounds) { sself->GetRegionDataBounds(leafNodeID, bounds); } +extern "C" int vtk_octree_point_locator_get_region_containing_point(vtkNew sself, double x, double y, double z) { return sself->GetRegionContainingPoint(x, y, z); } +extern "C" void vtk_octree_point_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } +extern "C" long long vtk_octree_point_locator_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } +extern "C" long long vtk_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z, double dist2) { return sself->FindClosestPoint(x, y, z, dist2); } +extern "C" long long vtk_octree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } +extern "C" long long vtk_octree_point_locator_find_closest_point_in_region(vtkNew sself, int regionId, double x, double dist2) { return sself->FindClosestPointInRegion(regionId, x, dist2); } +extern "C" long long vtk_octree_point_locator_find_closest_point_in_region(vtkNew sself, int regionId, double x, double y, double z, double dist2) { return sself->FindClosestPointInRegion(regionId, x, y, z, dist2); } +extern "C" void vtk_octree_point_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } extern "C" vtkNew < vtkOctreePointLocatorNode > vtkOctreePointLocatorNode_new () {return vtkNew < vtkOctreePointLocatorNode > () ;} extern "C" void vtkOctreePointLocatorNode_destructor (vtkNew < vtkOctreePointLocatorNode > sself) {sself . Reset () ; return ;} extern "C" void * vtkOctreePointLocatorNode_get_ptr (vtkNew < vtkOctreePointLocatorNode > sself) {return sself . GetPointer () ;} +extern "C" void vtk_octree_point_locator_node_set_number_of_points(vtkNew sself, int numberOfPoints) { sself->SetNumberOfPoints(numberOfPoints); } +extern "C" int vtk_octree_point_locator_node_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_octree_point_locator_node_set_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" void vtk_octree_point_locator_node_set_bounds(vtkNew sself, const double b) { sself->SetBounds(b); } +extern "C" void vtk_octree_point_locator_node_get_bounds(vtkNew sself, double b) { sself->GetBounds(b); } +extern "C" void vtk_octree_point_locator_node_set_data_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetDataBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" void vtk_octree_point_locator_node_get_data_bounds(vtkNew sself, double b) { sself->GetDataBounds(b); } +extern "C" double* vtk_octree_point_locator_node_get_min_bounds(vtkNew sself) { return sself->GetMinBounds(); } +extern "C" double* vtk_octree_point_locator_node_get_max_bounds(vtkNew sself) { return sself->GetMaxBounds(); } +extern "C" void vtk_octree_point_locator_node_set_min_bounds(vtkNew sself, double minBounds) { sself->SetMinBounds(minBounds); } +extern "C" void vtk_octree_point_locator_node_set_max_bounds(vtkNew sself, double maxBounds) { sself->SetMaxBounds(maxBounds); } +extern "C" double* vtk_octree_point_locator_node_get_min_data_bounds(vtkNew sself) { return sself->GetMinDataBounds(); } +extern "C" double* vtk_octree_point_locator_node_get_max_data_bounds(vtkNew sself) { return sself->GetMaxDataBounds(); } +extern "C" void vtk_octree_point_locator_node_set_min_data_bounds(vtkNew sself, double minDataBounds) { sself->SetMinDataBounds(minDataBounds); } +extern "C" void vtk_octree_point_locator_node_set_max_data_bounds(vtkNew sself, double maxDataBounds) { sself->SetMaxDataBounds(maxDataBounds); } +extern "C" int vtk_octree_point_locator_node_get_id(vtkNew sself) { return sself->GetID(); } +extern "C" int vtk_octree_point_locator_node_get_min_id(vtkNew sself) { return sself->GetMinID(); } +extern "C" void vtk_octree_point_locator_node_create_child_nodes(vtkNew sself) { sself->CreateChildNodes(); } +extern "C" void vtk_octree_point_locator_node_delete_child_nodes(vtkNew sself) { sself->DeleteChildNodes(); } +extern "C" int vtk_octree_point_locator_node_contains_point(vtkNew sself, double x, double y, double z, int useDataBounds) { return sself->ContainsPoint(x, y, z, useDataBounds); } +extern "C" int vtk_octree_point_locator_node_get_sub_octant_index(vtkNew sself, double point, int CheckContainment) { return sself->GetSubOctantIndex(point, CheckContainment); } extern "C" vtkNew < vtkOrderedTriangulator > vtkOrderedTriangulator_new () {return vtkNew < vtkOrderedTriangulator > () ;} extern "C" void vtkOrderedTriangulator_destructor (vtkNew < vtkOrderedTriangulator > sself) {sself . Reset () ; return ;} extern "C" void * vtkOrderedTriangulator_get_ptr (vtkNew < vtkOrderedTriangulator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_ordered_triangulator_init_triangulation(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts) { sself->InitTriangulation(xmin, xmax, ymin, ymax, zmin, zmax, numPts); } +extern "C" void vtk_ordered_triangulator_init_triangulation(vtkNew sself, double bounds, int numPts) { sself->InitTriangulation(bounds, numPts); } +extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, double x, double p, int type) { return sself->InsertPoint(id, x, p, type); } +extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, long long sortid, double x, double p, int type) { return sself->InsertPoint(id, sortid, x, p, type); } +extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, long long sortid, long long sortid2, double x, double p, int type) { return sself->InsertPoint(id, sortid, sortid2, x, p, type); } +extern "C" void vtk_ordered_triangulator_triangulate(vtkNew sself) { sself->Triangulate(); } +extern "C" void vtk_ordered_triangulator_template_triangulate(vtkNew sself, int cellType, int numPts, int numEdges) { sself->TemplateTriangulate(cellType, numPts, numEdges); } +extern "C" void vtk_ordered_triangulator_update_point_type(vtkNew sself, long long internalId, int type) { sself->UpdatePointType(internalId, type); } +extern "C" double* vtk_ordered_triangulator_get_point_position(vtkNew sself, long long internalId) { return sself->GetPointPosition(internalId); } +extern "C" double* vtk_ordered_triangulator_get_point_location(vtkNew sself, long long internalId) { return sself->GetPointLocation(internalId); } +extern "C" long long vtk_ordered_triangulator_get_point_id(vtkNew sself, long long internalId) { return sself->GetPointId(internalId); } +extern "C" int vtk_ordered_triangulator_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_ordered_triangulator_set_use_templates(vtkNew sself, int _arg) { sself->SetUseTemplates(_arg); } +extern "C" int vtk_ordered_triangulator_get_use_templates(vtkNew sself) { return sself->GetUseTemplates(); } +extern "C" void vtk_ordered_triangulator_use_templates_on(vtkNew sself) { sself->UseTemplatesOn(); } +extern "C" void vtk_ordered_triangulator_use_templates_off(vtkNew sself) { sself->UseTemplatesOff(); } +extern "C" void vtk_ordered_triangulator_set_pre_sorted(vtkNew sself, int _arg) { sself->SetPreSorted(_arg); } +extern "C" int vtk_ordered_triangulator_get_pre_sorted(vtkNew sself) { return sself->GetPreSorted(); } +extern "C" void vtk_ordered_triangulator_pre_sorted_on(vtkNew sself) { sself->PreSortedOn(); } +extern "C" void vtk_ordered_triangulator_pre_sorted_off(vtkNew sself) { sself->PreSortedOff(); } +extern "C" void vtk_ordered_triangulator_set_use_two_sort_ids(vtkNew sself, int _arg) { sself->SetUseTwoSortIds(_arg); } +extern "C" int vtk_ordered_triangulator_get_use_two_sort_ids(vtkNew sself) { return sself->GetUseTwoSortIds(); } +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_on(vtkNew sself) { sself->UseTwoSortIdsOn(); } +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_off(vtkNew sself) { sself->UseTwoSortIdsOff(); } +extern "C" void vtk_ordered_triangulator_init_tetra_traversal(vtkNew sself) { sself->InitTetraTraversal(); } extern "C" vtkNew < vtkOutEdgeIterator > vtkOutEdgeIterator_new () {return vtkNew < vtkOutEdgeIterator > () ;} extern "C" void vtkOutEdgeIterator_destructor (vtkNew < vtkOutEdgeIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkOutEdgeIterator_get_ptr (vtkNew < vtkOutEdgeIterator > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_out_edge_iterator_get_vertex(vtkNew sself) { return sself->GetVertex(); } +extern "C" bool vtk_out_edge_iterator_has_next(vtkNew sself) { return sself->HasNext(); } extern "C" vtkNew < vtkOverlappingAMR > vtkOverlappingAMR_new () {return vtkNew < vtkOverlappingAMR > () ;} extern "C" void vtkOverlappingAMR_destructor (vtkNew < vtkOverlappingAMR > sself) {sself . Reset () ; return ;} extern "C" void * vtkOverlappingAMR_get_ptr (vtkNew < vtkOverlappingAMR > sself) {return sself . GetPointer () ;} +extern "C" void vtk_overlapping_amr_set_origin(vtkNew sself, const double origin) { sself->SetOrigin(origin); } +extern "C" double* vtk_overlapping_amr_get_origin(vtkNew sself) { return sself->GetOrigin(); } +extern "C" void vtk_overlapping_amr_set_spacing(vtkNew sself, unsigned int level, const double spacing) { sself->SetSpacing(level, spacing); } +extern "C" void vtk_overlapping_amr_get_spacing(vtkNew sself, unsigned int level, double spacing) { sself->GetSpacing(level, spacing); } +extern "C" void vtk_overlapping_amr_get_bounds(vtkNew sself, unsigned int level, unsigned int id, double bb) { sself->GetBounds(level, id, bb); } +extern "C" void vtk_overlapping_amr_get_origin(vtkNew sself, unsigned int level, unsigned int id, double origin) { sself->GetOrigin(level, id, origin); } +extern "C" void vtk_overlapping_amr_set_refinement_ratio(vtkNew sself, unsigned int level, int refRatio) { sself->SetRefinementRatio(level, refRatio); } +extern "C" int vtk_overlapping_amr_get_refinement_ratio(vtkNew sself, unsigned int level) { return sself->GetRefinementRatio(level); } +extern "C" void vtk_overlapping_amr_set_amr_block_source_index(vtkNew sself, unsigned int level, unsigned int id, int sourceId) { sself->SetAMRBlockSourceIndex(level, id, sourceId); } +extern "C" int vtk_overlapping_amr_get_amr_block_source_index(vtkNew sself, unsigned int level, unsigned int id) { return sself->GetAMRBlockSourceIndex(level, id); } +extern "C" bool vtk_overlapping_amr_has_children_information(vtkNew sself) { return sself->HasChildrenInformation(); } +extern "C" void vtk_overlapping_amr_generate_parent_child_information(vtkNew sself) { sself->GenerateParentChildInformation(); } +extern "C" unsigned int* vtk_overlapping_amr_get_parents(vtkNew sself, unsigned int level, unsigned int index, unsigned int numParents) { return sself->GetParents(level, index, numParents); } +extern "C" unsigned int* vtk_overlapping_amr_get_children(vtkNew sself, unsigned int level, unsigned int index, unsigned int numChildren) { return sself->GetChildren(level, index, numChildren); } +extern "C" void vtk_overlapping_amr_print_parent_child_info(vtkNew sself, unsigned int level, unsigned int index) { sself->PrintParentChildInfo(level, index); } +extern "C" void vtk_overlapping_amr_get_bounds(vtkNew sself, double b) { sself->GetBounds(b); } +extern "C" bool vtk_overlapping_amr_find_grid(vtkNew sself, double q, unsigned int level, unsigned int gridId) { return sself->FindGrid(q, level, gridId); } +extern "C" void vtk_overlapping_amr_audit(vtkNew sself) { sself->Audit(); } extern "C" vtkNew < vtkPartitionedDataSet > vtkPartitionedDataSet_new () {return vtkNew < vtkPartitionedDataSet > () ;} extern "C" void vtkPartitionedDataSet_destructor (vtkNew < vtkPartitionedDataSet > sself) {sself . Reset () ; return ;} extern "C" void * vtkPartitionedDataSet_get_ptr (vtkNew < vtkPartitionedDataSet > sself) {return sself . GetPointer () ;} +extern "C" void vtk_partitioned_data_set_set_number_of_partitions(vtkNew sself, unsigned int numPartitions) { sself->SetNumberOfPartitions(numPartitions); } +extern "C" unsigned int vtk_partitioned_data_set_get_number_of_partitions(vtkNew sself) { return sself->GetNumberOfPartitions(); } +extern "C" int vtk_partitioned_data_set_has_meta_data(vtkNew sself, unsigned int idx) { return sself->HasMetaData(idx); } +extern "C" void vtk_partitioned_data_set_remove_null_partitions(vtkNew sself) { sself->RemoveNullPartitions(); } extern "C" vtkNew < vtkPartitionedDataSetCollection > vtkPartitionedDataSetCollection_new () {return vtkNew < vtkPartitionedDataSetCollection > () ;} extern "C" void vtkPartitionedDataSetCollection_destructor (vtkNew < vtkPartitionedDataSetCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkPartitionedDataSetCollection_get_ptr (vtkNew < vtkPartitionedDataSetCollection > sself) {return sself . GetPointer () ;} +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets(vtkNew sself, unsigned int numDataSets) { sself->SetNumberOfPartitionedDataSets(numDataSets); } +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets(vtkNew sself) { return sself->GetNumberOfPartitionedDataSets(); } +extern "C" void vtk_partitioned_data_set_collection_remove_partitioned_data_set(vtkNew sself, unsigned int idx) { sself->RemovePartitionedDataSet(idx); } +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitions(vtkNew sself, unsigned int idx) { return sself->GetNumberOfPartitions(idx); } +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitions(vtkNew sself, unsigned int idx, unsigned int numPartitions) { sself->SetNumberOfPartitions(idx, numPartitions); } +extern "C" int vtk_partitioned_data_set_collection_has_meta_data(vtkNew sself, unsigned int idx) { return sself->HasMetaData(idx); } +extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkNew sself, unsigned int idx) { return sself->GetCompositeIndex(idx); } +extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkNew sself, unsigned int idx, unsigned int partition) { return sself->GetCompositeIndex(idx, partition); } +extern "C" unsigned long vtk_partitioned_data_set_collection_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkPath > vtkPath_new () {return vtkNew < vtkPath > () ;} extern "C" void vtkPath_destructor (vtkNew < vtkPath > sself) {sself . Reset () ; return ;} extern "C" void * vtkPath_get_ptr (vtkNew < vtkPath > sself) {return sself . GetPointer () ;} +extern "C" int vtk_path_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_path_insert_next_point(vtkNew sself, float pts, int code) { sself->InsertNextPoint(pts, code); } +extern "C" void vtk_path_insert_next_point(vtkNew sself, double pts, int code) { sself->InsertNextPoint(pts, code); } +extern "C" void vtk_path_insert_next_point(vtkNew sself, double x, double y, double z, int code) { sself->InsertNextPoint(x, y, z, code); } +extern "C" long long vtk_path_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } +extern "C" int vtk_path_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } +extern "C" void vtk_path_allocate(vtkNew sself, long long size, int extSize) { sself->Allocate(size, extSize); } +extern "C" void vtk_path_reset(vtkNew sself) { sself->Reset(); } extern "C" vtkNew < vtkPentagonalPrism > vtkPentagonalPrism_new () {return vtkNew < vtkPentagonalPrism > () ;} extern "C" void vtkPentagonalPrism_destructor (vtkNew < vtkPentagonalPrism > sself) {sself . Reset () ; return ;} extern "C" void * vtkPentagonalPrism_get_ptr (vtkNew < vtkPentagonalPrism > sself) {return sself . GetPointer () ;} +extern "C" void vtk_pentagonal_prism_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" void vtk_pentagonal_prism_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" long long vtk_pentagonal_prism_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_pentagonal_prism_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_pentagonal_prism_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } +extern "C" long long vtk_pentagonal_prism_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } +extern "C" long long vtk_pentagonal_prism_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } +extern "C" long long vtk_pentagonal_prism_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } +extern "C" long long vtk_pentagonal_prism_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } +extern "C" bool vtk_pentagonal_prism_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } +extern "C" int vtk_pentagonal_prism_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_pentagonal_prism_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_pentagonal_prism_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_pentagonal_prism_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_pentagonal_prism_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_pentagonal_prism_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_pentagonal_prism_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_pentagonal_prism_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_pentagonal_prism_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_pentagonal_prism_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_pentagonal_prism_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_pentagonal_prism_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_pentagonal_prism_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_pentagonal_prism_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" const long long* vtk_pentagonal_prism_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } +extern "C" const long long* vtk_pentagonal_prism_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } +extern "C" const long long* vtk_pentagonal_prism_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } +extern "C" const long long* vtk_pentagonal_prism_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } +extern "C" const long long* vtk_pentagonal_prism_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } +extern "C" void vtk_pentagonal_prism_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkPerlinNoise > vtkPerlinNoise_new () {return vtkNew < vtkPerlinNoise > () ;} extern "C" void vtkPerlinNoise_destructor (vtkNew < vtkPerlinNoise > sself) {sself . Reset () ; return ;} extern "C" void * vtkPerlinNoise_get_ptr (vtkNew < vtkPerlinNoise > sself) {return sself . GetPointer () ;} +extern "C" double vtk_perlin_noise_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_perlin_noise_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } +extern "C" void vtk_perlin_noise_set_frequency(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetFrequency(_arg1, _arg2, _arg3); } +extern "C" void vtk_perlin_noise_set_frequency(vtkNew sself, const double _arg) { sself->SetFrequency(_arg); } +extern "C" double* vtk_perlin_noise_get_frequency(vtkNew sself) { return sself->GetFrequency(); } +extern "C" void vtk_perlin_noise_get_frequency(vtkNew sself, double data) { sself->GetFrequency(data); } +extern "C" void vtk_perlin_noise_set_phase(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetPhase(_arg1, _arg2, _arg3); } +extern "C" void vtk_perlin_noise_set_phase(vtkNew sself, const double _arg) { sself->SetPhase(_arg); } +extern "C" double* vtk_perlin_noise_get_phase(vtkNew sself) { return sself->GetPhase(); } +extern "C" void vtk_perlin_noise_get_phase(vtkNew sself, double data) { sself->GetPhase(data); } +extern "C" void vtk_perlin_noise_set_amplitude(vtkNew sself, double _arg) { sself->SetAmplitude(_arg); } +extern "C" double vtk_perlin_noise_get_amplitude(vtkNew sself) { return sself->GetAmplitude(); } extern "C" vtkNew < vtkPiecewiseFunction > vtkPiecewiseFunction_new () {return vtkNew < vtkPiecewiseFunction > () ;} extern "C" void vtkPiecewiseFunction_destructor (vtkNew < vtkPiecewiseFunction > sself) {sself . Reset () ; return ;} extern "C" void * vtkPiecewiseFunction_get_ptr (vtkNew < vtkPiecewiseFunction > sself) {return sself . GetPointer () ;} +extern "C" int vtk_piecewise_function_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" int vtk_piecewise_function_get_size(vtkNew sself) { return sself->GetSize(); } +extern "C" int vtk_piecewise_function_add_point(vtkNew sself, double x, double y) { return sself->AddPoint(x, y); } +extern "C" int vtk_piecewise_function_add_point(vtkNew sself, double x, double y, double midpoint, double sharpness) { return sself->AddPoint(x, y, midpoint, sharpness); } +extern "C" bool vtk_piecewise_function_remove_point_by_index(vtkNew sself, size_t id) { return sself->RemovePointByIndex(id); } +extern "C" int vtk_piecewise_function_remove_point(vtkNew sself, double x) { return sself->RemovePoint(x); } +extern "C" int vtk_piecewise_function_remove_point(vtkNew sself, double x, double y) { return sself->RemovePoint(x, y); } +extern "C" void vtk_piecewise_function_remove_all_points(vtkNew sself) { sself->RemoveAllPoints(); } +extern "C" void vtk_piecewise_function_add_segment(vtkNew sself, double x1, double y1, double x2, double y2) { sself->AddSegment(x1, y1, x2, y2); } +extern "C" double vtk_piecewise_function_get_value(vtkNew sself, double x) { return sself->GetValue(x); } +extern "C" int vtk_piecewise_function_get_node_value(vtkNew sself, int index, double val) { return sself->GetNodeValue(index, val); } +extern "C" int vtk_piecewise_function_set_node_value(vtkNew sself, int index, double val) { return sself->SetNodeValue(index, val); } +extern "C" double* vtk_piecewise_function_get_data_pointer(vtkNew sself) { return sself->GetDataPointer(); } +extern "C" void vtk_piecewise_function_fill_from_data_pointer(vtkNew sself, int p0, double p1) { sself->FillFromDataPointer(p0, p1); } +extern "C" double* vtk_piecewise_function_get_range(vtkNew sself) { return sself->GetRange(); } +extern "C" void vtk_piecewise_function_get_range(vtkNew sself, double _arg1, double _arg2) { sself->GetRange(_arg1, _arg2); } +extern "C" void vtk_piecewise_function_get_range(vtkNew sself, double _arg) { sself->GetRange(_arg); } +extern "C" int vtk_piecewise_function_adjust_range(vtkNew sself, double range) { return sself->AdjustRange(range); } +extern "C" void vtk_piecewise_function_get_table(vtkNew sself, double x1, double x2, int size, float table, int stride, int logIncrements) { sself->GetTable(x1, x2, size, table, stride, logIncrements); } +extern "C" void vtk_piecewise_function_get_table(vtkNew sself, double x1, double x2, int size, double table, int stride, int logIncrements) { sself->GetTable(x1, x2, size, table, stride, logIncrements); } +extern "C" void vtk_piecewise_function_build_function_from_table(vtkNew sself, double x1, double x2, int size, double table, int stride) { sself->BuildFunctionFromTable(x1, x2, size, table, stride); } +extern "C" void vtk_piecewise_function_set_clamping(vtkNew sself, int _arg) { sself->SetClamping(_arg); } +extern "C" int vtk_piecewise_function_get_clamping(vtkNew sself) { return sself->GetClamping(); } +extern "C" void vtk_piecewise_function_clamping_on(vtkNew sself) { sself->ClampingOn(); } +extern "C" void vtk_piecewise_function_clamping_off(vtkNew sself) { sself->ClampingOff(); } +extern "C" void vtk_piecewise_function_set_use_log_scale(vtkNew sself, bool _arg) { sself->SetUseLogScale(_arg); } +extern "C" bool vtk_piecewise_function_get_use_log_scale(vtkNew sself) { return sself->GetUseLogScale(); } +extern "C" void vtk_piecewise_function_use_log_scale_on(vtkNew sself) { sself->UseLogScaleOn(); } +extern "C" void vtk_piecewise_function_use_log_scale_off(vtkNew sself) { sself->UseLogScaleOff(); } +extern "C" const char* vtk_piecewise_function_get_type(vtkNew sself) { return sself->GetType(); } +extern "C" double vtk_piecewise_function_get_first_non_zero_value(vtkNew sself) { return sself->GetFirstNonZeroValue(); } +extern "C" void vtk_piecewise_function_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_piecewise_function_set_allow_duplicate_scalars(vtkNew sself, int _arg) { sself->SetAllowDuplicateScalars(_arg); } +extern "C" int vtk_piecewise_function_get_allow_duplicate_scalars(vtkNew sself) { return sself->GetAllowDuplicateScalars(); } +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_on(vtkNew sself) { sself->AllowDuplicateScalarsOn(); } +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_off(vtkNew sself) { sself->AllowDuplicateScalarsOff(); } +extern "C" int vtk_piecewise_function_estimate_min_number_of_samples(vtkNew sself, const double x1, const double x2) { return sself->EstimateMinNumberOfSamples(x1, x2); } extern "C" vtkNew < vtkPixel > vtkPixel_new () {return vtkNew < vtkPixel > () ;} extern "C" void vtkPixel_destructor (vtkNew < vtkPixel > sself) {sself . Reset () ; return ;} extern "C" void * vtkPixel_get_ptr (vtkNew < vtkPixel > sself) {return sself . GetPointer () ;} +extern "C" int vtk_pixel_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_pixel_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_pixel_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_pixel_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_pixel_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_pixel_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_pixel_inflate(vtkNew sself, double dist) { return sself->Inflate(dist); } +extern "C" double vtk_pixel_compute_bounding_sphere(vtkNew sself, double center) { return sself->ComputeBoundingSphere(center); } +extern "C" int vtk_pixel_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" int vtk_pixel_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_pixel_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" void vtk_pixel_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_pixel_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_pixel_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_pixel_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" int vtk_pixel_compute_normal(vtkNew sself, double n) { return sself->ComputeNormal(n); } extern "C" vtkNew < vtkPlane > vtkPlane_new () {return vtkNew < vtkPlane > () ;} extern "C" void vtkPlane_destructor (vtkNew < vtkPlane > sself) {sself . Reset () ; return ;} extern "C" void * vtkPlane_get_ptr (vtkNew < vtkPlane > sself) {return sself . GetPointer () ;} +extern "C" double vtk_plane_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_plane_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } +extern "C" void vtk_plane_set_normal(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" void vtk_plane_set_normal(vtkNew sself, const double _arg) { sself->SetNormal(_arg); } +extern "C" double* vtk_plane_get_normal(vtkNew sself) { return sself->GetNormal(); } +extern "C" void vtk_plane_get_normal(vtkNew sself, double data) { sself->GetNormal(data); } +extern "C" void vtk_plane_set_origin(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_plane_set_origin(vtkNew sself, const double _arg) { sself->SetOrigin(_arg); } +extern "C" double* vtk_plane_get_origin(vtkNew sself) { return sself->GetOrigin(); } +extern "C" void vtk_plane_get_origin(vtkNew sself, double data) { sself->GetOrigin(data); } +extern "C" void vtk_plane_push(vtkNew sself, double distance) { sself->Push(distance); } +extern "C" void vtk_plane_project_point(vtkNew sself, const double x, const double origin, const double normal, double xproj) { sself->ProjectPoint(x, origin, normal, xproj); } +extern "C" void vtk_plane_project_point(vtkNew sself, const double x, double xproj) { sself->ProjectPoint(x, xproj); } +extern "C" void vtk_plane_project_vector(vtkNew sself, const double v, const double origin, const double normal, double vproj) { sself->ProjectVector(v, origin, normal, vproj); } +extern "C" void vtk_plane_project_vector(vtkNew sself, const double v, double vproj) { sself->ProjectVector(v, vproj); } +extern "C" void vtk_plane_generalized_project_point(vtkNew sself, const double x, const double origin, const double normal, double xproj) { sself->GeneralizedProjectPoint(x, origin, normal, xproj); } +extern "C" void vtk_plane_generalized_project_point(vtkNew sself, const double x, double xproj) { sself->GeneralizedProjectPoint(x, xproj); } +extern "C" double vtk_plane_evaluate(vtkNew sself, double normal, double origin, double x) { return sself->Evaluate(normal, origin, x); } +extern "C" double vtk_plane_distance_to_plane(vtkNew sself, double x, double n, double p0) { return sself->DistanceToPlane(x, n, p0); } +extern "C" double vtk_plane_distance_to_plane(vtkNew sself, double x) { return sself->DistanceToPlane(x); } +extern "C" int vtk_plane_intersect_with_line(vtkNew sself, const double p1, const double p2, double n, double p0, double t, double x) { return sself->IntersectWithLine(p1, p2, n, p0, t, x); } +extern "C" int vtk_plane_intersect_with_line(vtkNew sself, const double p1, const double p2, double t, double x) { return sself->IntersectWithLine(p1, p2, t, x); } +extern "C" int vtk_plane_intersect_with_finite_plane(vtkNew sself, double n, double o, double pOrigin, double px, double py, double x0, double x1) { return sself->IntersectWithFinitePlane(n, o, pOrigin, px, py, x0, x1); } +extern "C" int vtk_plane_intersect_with_finite_plane(vtkNew sself, double pOrigin, double px, double py, double x0, double x1) { return sself->IntersectWithFinitePlane(pOrigin, px, py, x0, x1); } extern "C" vtkNew < vtkPlaneCollection > vtkPlaneCollection_new () {return vtkNew < vtkPlaneCollection > () ;} extern "C" void vtkPlaneCollection_destructor (vtkNew < vtkPlaneCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkPlaneCollection_get_ptr (vtkNew < vtkPlaneCollection > sself) {return sself . GetPointer () ;} +extern "C" int vtk_plane_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } extern "C" vtkNew < vtkPlanes > vtkPlanes_new () {return vtkNew < vtkPlanes > () ;} extern "C" void vtkPlanes_destructor (vtkNew < vtkPlanes > sself) {sself . Reset () ; return ;} extern "C" void * vtkPlanes_get_ptr (vtkNew < vtkPlanes > sself) {return sself . GetPointer () ;} +extern "C" double vtk_planes_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_planes_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } +extern "C" void vtk_planes_set_frustum_planes(vtkNew sself, double planes) { sself->SetFrustumPlanes(planes); } +extern "C" void vtk_planes_set_bounds(vtkNew sself, const double bounds) { sself->SetBounds(bounds); } +extern "C" void vtk_planes_set_bounds(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) { sself->SetBounds(xmin, xmax, ymin, ymax, zmin, zmax); } +extern "C" int vtk_planes_get_number_of_planes(vtkNew sself) { return sself->GetNumberOfPlanes(); } extern "C" vtkNew < vtkPlanesIntersection > vtkPlanesIntersection_new () {return vtkNew < vtkPlanesIntersection > () ;} extern "C" void vtkPlanesIntersection_destructor (vtkNew < vtkPlanesIntersection > sself) {sself . Reset () ; return ;} extern "C" void * vtkPlanesIntersection_get_ptr (vtkNew < vtkPlanesIntersection > sself) {return sself . GetPointer () ;} +extern "C" void vtk_planes_intersection_set_region_vertices(vtkNew sself, double v, int nvertices) { sself->SetRegionVertices(v, nvertices); } +extern "C" int vtk_planes_intersection_get_number_of_region_vertices(vtkNew sself) { return sself->GetNumberOfRegionVertices(); } +extern "C" int vtk_planes_intersection_get_num_region_vertices(vtkNew sself) { return sself->GetNumRegionVertices(); } +extern "C" int vtk_planes_intersection_get_region_vertices(vtkNew sself, double v, int nvertices) { return sself->GetRegionVertices(v, nvertices); } extern "C" vtkNew < vtkPointData > vtkPointData_new () {return vtkNew < vtkPointData > () ;} extern "C" void vtkPointData_destructor (vtkNew < vtkPointData > sself) {sself . Reset () ; return ;} extern "C" void * vtkPointData_get_ptr (vtkNew < vtkPointData > sself) {return sself . GetPointer () ;} +extern "C" void vtk_point_data_null_point(vtkNew sself, long long ptId) { sself->NullPoint(ptId); } extern "C" vtkNew < vtkPointLocator > vtkPointLocator_new () {return vtkNew < vtkPointLocator > () ;} extern "C" void vtkPointLocator_destructor (vtkNew < vtkPointLocator > sself) {sself . Reset () ; return ;} extern "C" void * vtkPointLocator_get_ptr (vtkNew < vtkPointLocator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_point_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } +extern "C" void vtk_point_locator_set_divisions(vtkNew sself, const int _arg) { sself->SetDivisions(_arg); } +extern "C" int* vtk_point_locator_get_divisions(vtkNew sself) { return sself->GetDivisions(); } +extern "C" void vtk_point_locator_get_divisions(vtkNew sself, int data) { sself->GetDivisions(data); } +extern "C" void vtk_point_locator_set_number_of_points_per_bucket(vtkNew sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_min_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_max_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } +extern "C" int vtk_point_locator_get_number_of_points_per_bucket(vtkNew sself) { return sself->GetNumberOfPointsPerBucket(); } +extern "C" long long vtk_point_locator_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } +extern "C" long long vtk_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } +extern "C" long long vtk_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, inputDataLength, dist2); } +extern "C" void vtk_point_locator_insert_point(vtkNew sself, long long ptId, const double x) { sself->InsertPoint(ptId, x); } +extern "C" long long vtk_point_locator_insert_next_point(vtkNew sself, const double x) { return sself->InsertNextPoint(x); } +extern "C" long long vtk_point_locator_is_inserted_point(vtkNew sself, double x, double y, double z) { return sself->IsInsertedPoint(x, y, z); } +extern "C" long long vtk_point_locator_is_inserted_point(vtkNew sself, const double x) { return sself->IsInsertedPoint(x); } +extern "C" int vtk_point_locator_insert_unique_point(vtkNew sself, const double x, long long ptId) { return sself->InsertUniquePoint(x, ptId); } +extern "C" long long vtk_point_locator_find_closest_inserted_point(vtkNew sself, const double x) { return sself->FindClosestInsertedPoint(x); } +extern "C" void vtk_point_locator_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_point_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_point_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } extern "C" vtkNew < vtkPointSet > vtkPointSet_new () {return vtkNew < vtkPointSet > () ;} extern "C" void vtkPointSet_destructor (vtkNew < vtkPointSet > sself) {sself . Reset () ; return ;} extern "C" void * vtkPointSet_get_ptr (vtkNew < vtkPointSet > sself) {return sself . GetPointer () ;} +extern "C" void vtk_point_set_set_editable(vtkNew sself, bool _arg) { sself->SetEditable(_arg); } +extern "C" bool vtk_point_set_get_editable(vtkNew sself) { return sself->GetEditable(); } +extern "C" void vtk_point_set_editable_on(vtkNew sself) { sself->EditableOn(); } +extern "C" void vtk_point_set_editable_off(vtkNew sself) { sself->EditableOff(); } +extern "C" void vtk_point_set_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" long long vtk_point_set_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_point_set_get_point(vtkNew sself, long long ptId, double x) { sself->GetPoint(ptId, x); } +extern "C" long long vtk_point_set_find_point(vtkNew sself, double x) { return sself->FindPoint(x); } +extern "C" long long vtk_point_set_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } +extern "C" int vtk_point_set_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } +extern "C" int vtk_point_set_get_cell_type(vtkNew sself, long long p0) { return sself->GetCellType(p0); } +extern "C" double* vtk_point_set_get_point(vtkNew sself, long long ptId) { return sself->GetPoint(ptId); } +extern "C" void vtk_point_set_build_point_locator(vtkNew sself) { sself->BuildPointLocator(); } +extern "C" void vtk_point_set_build_locator(vtkNew sself) { sself->BuildLocator(); } +extern "C" void vtk_point_set_build_cell_locator(vtkNew sself) { sself->BuildCellLocator(); } +extern "C" unsigned long vtk_point_set_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_point_set_compute_bounds(vtkNew sself) { sself->ComputeBounds(); } +extern "C" void vtk_point_set_squeeze(vtkNew sself) { sself->Squeeze(); } extern "C" vtkNew < vtkPointSetCellIterator > vtkPointSetCellIterator_new () {return vtkNew < vtkPointSetCellIterator > () ;} extern "C" void vtkPointSetCellIterator_destructor (vtkNew < vtkPointSetCellIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkPointSetCellIterator_get_ptr (vtkNew < vtkPointSetCellIterator > sself) {return sself . GetPointer () ;} +extern "C" bool vtk_point_set_cell_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_point_set_cell_iterator_get_cell_id(vtkNew sself) { return sself->GetCellId(); } extern "C" vtkNew < vtkPointsProjectedHull > vtkPointsProjectedHull_new () {return vtkNew < vtkPointsProjectedHull > () ;} extern "C" void vtkPointsProjectedHull_destructor (vtkNew < vtkPointsProjectedHull > sself) {sself . Reset () ; return ;} extern "C" void * vtkPointsProjectedHull_get_ptr (vtkNew < vtkPointsProjectedHull > sself) {return sself . GetPointer () ;} +extern "C" int vtk_points_projected_hull_rectangle_intersection_x(vtkNew sself, float ymin, float ymax, float zmin, float zmax) { return sself->RectangleIntersectionX(ymin, ymax, zmin, zmax); } +extern "C" int vtk_points_projected_hull_rectangle_intersection_x(vtkNew sself, double ymin, double ymax, double zmin, double zmax) { return sself->RectangleIntersectionX(ymin, ymax, zmin, zmax); } +extern "C" int vtk_points_projected_hull_rectangle_intersection_y(vtkNew sself, float zmin, float zmax, float xmin, float xmax) { return sself->RectangleIntersectionY(zmin, zmax, xmin, xmax); } +extern "C" int vtk_points_projected_hull_rectangle_intersection_y(vtkNew sself, double zmin, double zmax, double xmin, double xmax) { return sself->RectangleIntersectionY(zmin, zmax, xmin, xmax); } +extern "C" int vtk_points_projected_hull_rectangle_intersection_z(vtkNew sself, float xmin, float xmax, float ymin, float ymax) { return sself->RectangleIntersectionZ(xmin, xmax, ymin, ymax); } +extern "C" int vtk_points_projected_hull_rectangle_intersection_z(vtkNew sself, double xmin, double xmax, double ymin, double ymax) { return sself->RectangleIntersectionZ(xmin, xmax, ymin, ymax); } +extern "C" int vtk_points_projected_hull_get_ccw_hull_x(vtkNew sself, float pts, int len) { return sself->GetCCWHullX(pts, len); } +extern "C" int vtk_points_projected_hull_get_ccw_hull_x(vtkNew sself, double pts, int len) { return sself->GetCCWHullX(pts, len); } +extern "C" int vtk_points_projected_hull_get_ccw_hull_y(vtkNew sself, float pts, int len) { return sself->GetCCWHullY(pts, len); } +extern "C" int vtk_points_projected_hull_get_ccw_hull_y(vtkNew sself, double pts, int len) { return sself->GetCCWHullY(pts, len); } +extern "C" int vtk_points_projected_hull_get_ccw_hull_z(vtkNew sself, float pts, int len) { return sself->GetCCWHullZ(pts, len); } +extern "C" int vtk_points_projected_hull_get_ccw_hull_z(vtkNew sself, double pts, int len) { return sself->GetCCWHullZ(pts, len); } +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_x(vtkNew sself) { return sself->GetSizeCCWHullX(); } +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_y(vtkNew sself) { return sself->GetSizeCCWHullY(); } +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_z(vtkNew sself) { return sself->GetSizeCCWHullZ(); } +extern "C" void vtk_points_projected_hull_update(vtkNew sself) { sself->Update(); } extern "C" vtkNew < vtkPolyData > vtkPolyData_new () {return vtkNew < vtkPolyData > () ;} extern "C" void vtkPolyData_destructor (vtkNew < vtkPolyData > sself) {sself . Reset () ; return ;} extern "C" void * vtkPolyData_get_ptr (vtkNew < vtkPolyData > sself) {return sself . GetPointer () ;} +extern "C" int vtk_poly_data_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_poly_data_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } +extern "C" int vtk_poly_data_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_poly_data_compute_cells_bounds(vtkNew sself) { sself->ComputeCellsBounds(); } +extern "C" void vtk_poly_data_get_cells_bounds(vtkNew sself, double bounds) { sself->GetCellsBounds(bounds); } +extern "C" void vtk_poly_data_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" int vtk_poly_data_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } +extern "C" long long vtk_poly_data_get_cell_id_relative_to_cell_array(vtkNew sself, long long cellId) { return sself->GetCellIdRelativeToCellArray(cellId); } +extern "C" long long vtk_poly_data_get_number_of_verts(vtkNew sself) { return sself->GetNumberOfVerts(); } +extern "C" long long vtk_poly_data_get_number_of_lines(vtkNew sself) { return sself->GetNumberOfLines(); } +extern "C" long long vtk_poly_data_get_number_of_polys(vtkNew sself) { return sself->GetNumberOfPolys(); } +extern "C" long long vtk_poly_data_get_number_of_strips(vtkNew sself) { return sself->GetNumberOfStrips(); } +extern "C" bool vtk_poly_data_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } +extern "C" bool vtk_poly_data_allocate_estimate(vtkNew sself, long long numVerts, long long maxVertSize, long long numLines, long long maxLineSize, long long numPolys, long long maxPolySize, long long numStrips, long long maxStripSize) { return sself->AllocateEstimate(numVerts, maxVertSize, numLines, maxLineSize, numPolys, maxPolySize, numStrips, maxStripSize); } +extern "C" bool vtk_poly_data_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } +extern "C" bool vtk_poly_data_allocate_exact(vtkNew sself, long long numVerts, long long vertConnSize, long long numLines, long long lineConnSize, long long numPolys, long long polyConnSize, long long numStrips, long long stripConnSize) { return sself->AllocateExact(numVerts, vertConnSize, numLines, lineConnSize, numPolys, polyConnSize, numStrips, stripConnSize); } +extern "C" void vtk_poly_data_allocate(vtkNew sself, long long numCells, int extSize) { sself->Allocate(numCells, extSize); } +extern "C" long long vtk_poly_data_insert_next_cell(vtkNew sself, int type, int npts, const long long pts) { return sself->InsertNextCell(type, npts, pts); } +extern "C" void vtk_poly_data_reset(vtkNew sself) { sself->Reset(); } +extern "C" void vtk_poly_data_build_cells(vtkNew sself) { sself->BuildCells(); } +extern "C" bool vtk_poly_data_need_to_build_cells(vtkNew sself) { return sself->NeedToBuildCells(); } +extern "C" void vtk_poly_data_build_links(vtkNew sself, int initialSize) { sself->BuildLinks(initialSize); } +extern "C" void vtk_poly_data_delete_cells(vtkNew sself) { sself->DeleteCells(); } +extern "C" void vtk_poly_data_delete_links(vtkNew sself) { sself->DeleteLinks(); } +extern "C" void vtk_poly_data_get_point_cells(vtkNew sself, long long ptId, long long ncells, long long cells) { sself->GetPointCells(ptId, ncells, cells); } +extern "C" void vtk_poly_data_get_point_cells(vtkNew sself, long long ptId, unsigned short ncells, long long cells) { sself->GetPointCells(ptId, ncells, cells); } +extern "C" unsigned char vtk_poly_data_get_cell_points(vtkNew sself, long long cellId, long long npts, const long long pts) { return sself->GetCellPoints(cellId, npts, pts); } +extern "C" int vtk_poly_data_is_triangle(vtkNew sself, int v1, int v2, int v3) { return sself->IsTriangle(v1, v2, v3); } +extern "C" int vtk_poly_data_is_edge(vtkNew sself, long long p1, long long p2) { return sself->IsEdge(p1, p2); } +extern "C" int vtk_poly_data_is_point_used_by_cell(vtkNew sself, long long ptId, long long cellId) { return sself->IsPointUsedByCell(ptId, cellId); } +extern "C" void vtk_poly_data_replace_cell(vtkNew sself, long long cellId, int npts, const long long pts) { sself->ReplaceCell(cellId, npts, pts); } +extern "C" void vtk_poly_data_replace_cell_point(vtkNew sself, long long cellId, long long oldPtId, long long newPtId) { sself->ReplaceCellPoint(cellId, oldPtId, newPtId); } +extern "C" void vtk_poly_data_reverse_cell(vtkNew sself, long long cellId) { sself->ReverseCell(cellId); } +extern "C" void vtk_poly_data_delete_point(vtkNew sself, long long ptId) { sself->DeletePoint(ptId); } +extern "C" void vtk_poly_data_delete_cell(vtkNew sself, long long cellId) { sself->DeleteCell(cellId); } +extern "C" void vtk_poly_data_remove_deleted_cells(vtkNew sself) { sself->RemoveDeletedCells(); } +extern "C" long long vtk_poly_data_insert_next_linked_point(vtkNew sself, int numLinks) { return sself->InsertNextLinkedPoint(numLinks); } +extern "C" long long vtk_poly_data_insert_next_linked_point(vtkNew sself, double x, int numLinks) { return sself->InsertNextLinkedPoint(x, numLinks); } +extern "C" long long vtk_poly_data_insert_next_linked_cell(vtkNew sself, int type, int npts, const long long pts) { return sself->InsertNextLinkedCell(type, npts, pts); } +extern "C" void vtk_poly_data_replace_linked_cell(vtkNew sself, long long cellId, int npts, const long long pts) { sself->ReplaceLinkedCell(cellId, npts, pts); } +extern "C" void vtk_poly_data_remove_cell_reference(vtkNew sself, long long cellId) { sself->RemoveCellReference(cellId); } +extern "C" void vtk_poly_data_add_cell_reference(vtkNew sself, long long cellId) { sself->AddCellReference(cellId); } +extern "C" void vtk_poly_data_remove_reference_to_cell(vtkNew sself, long long ptId, long long cellId) { sself->RemoveReferenceToCell(ptId, cellId); } +extern "C" void vtk_poly_data_add_reference_to_cell(vtkNew sself, long long ptId, long long cellId) { sself->AddReferenceToCell(ptId, cellId); } +extern "C" void vtk_poly_data_resize_cell_list(vtkNew sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } +extern "C" void vtk_poly_data_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_poly_data_get_piece(vtkNew sself) { return sself->GetPiece(); } +extern "C" int vtk_poly_data_get_number_of_pieces(vtkNew sself) { return sself->GetNumberOfPieces(); } +extern "C" int vtk_poly_data_get_ghost_level(vtkNew sself) { return sself->GetGhostLevel(); } +extern "C" void vtk_poly_data_remove_ghost_cells(vtkNew sself) { sself->RemoveGhostCells(); } +extern "C" int vtk_poly_data_get_scalar_field_critical_index(vtkNew sself, long long pointId, int fieldId) { return sself->GetScalarFieldCriticalIndex(pointId, fieldId); } +extern "C" int vtk_poly_data_get_scalar_field_critical_index(vtkNew sself, long long pointId, const char fieldName) { return sself->GetScalarFieldCriticalIndex(pointId, fieldName); } +extern "C" unsigned long vtk_poly_data_get_mesh_m_time(vtkNew sself) { return sself->GetMeshMTime(); } +extern "C" unsigned long vtk_poly_data_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" unsigned char vtk_poly_data_get_cell(vtkNew sself, long long cellId, const long long pts) { return sself->GetCell(cellId, pts); } extern "C" vtkNew < vtkPolyDataCollection > vtkPolyDataCollection_new () {return vtkNew < vtkPolyDataCollection > () ;} extern "C" void vtkPolyDataCollection_destructor (vtkNew < vtkPolyDataCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkPolyDataCollection_get_ptr (vtkNew < vtkPolyDataCollection > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkPolyLine > vtkPolyLine_new () {return vtkNew < vtkPolyLine > () ;} extern "C" void vtkPolyLine_destructor (vtkNew < vtkPolyLine > sself) {sself . Reset () ; return ;} extern "C" void * vtkPolyLine_get_ptr (vtkNew < vtkPolyLine > sself) {return sself . GetPointer () ;} +extern "C" int vtk_poly_line_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_poly_line_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_poly_line_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_poly_line_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_poly_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_poly_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_poly_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_poly_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_poly_line_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } extern "C" vtkNew < vtkPolyPlane > vtkPolyPlane_new () {return vtkNew < vtkPolyPlane > () ;} extern "C" void vtkPolyPlane_destructor (vtkNew < vtkPolyPlane > sself) {sself . Reset () ; return ;} extern "C" void * vtkPolyPlane_get_ptr (vtkNew < vtkPolyPlane > sself) {return sself . GetPointer () ;} +extern "C" double vtk_poly_plane_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_poly_plane_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } +extern "C" unsigned long vtk_poly_plane_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkPolyVertex > vtkPolyVertex_new () {return vtkNew < vtkPolyVertex > () ;} extern "C" void vtkPolyVertex_destructor (vtkNew < vtkPolyVertex > sself) {sself . Reset () ; return ;} extern "C" void * vtkPolyVertex_get_ptr (vtkNew < vtkPolyVertex > sself) {return sself . GetPointer () ;} +extern "C" int vtk_poly_vertex_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_poly_vertex_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_poly_vertex_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_poly_vertex_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_poly_vertex_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_poly_vertex_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_poly_vertex_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_poly_vertex_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_poly_vertex_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } extern "C" vtkNew < vtkPolygon > vtkPolygon_new () {return vtkNew < vtkPolygon > () ;} extern "C" void vtkPolygon_destructor (vtkNew < vtkPolygon > sself) {sself . Reset () ; return ;} extern "C" void * vtkPolygon_get_ptr (vtkNew < vtkPolygon > sself) {return sself . GetPointer () ;} +extern "C" int vtk_polygon_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_polygon_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_polygon_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_polygon_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_polygon_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_polygon_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_polygon_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_polygon_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" double vtk_polygon_compute_area(vtkNew sself) { return sself->ComputeArea(); } +extern "C" void vtk_polygon_interpolate_functions(vtkNew sself, const double x, double sf) { sself->InterpolateFunctions(x, sf); } +extern "C" void vtk_polygon_compute_normal(vtkNew sself, int numPts, double pts, double n) { sself->ComputeNormal(numPts, pts, n); } +extern "C" bool vtk_polygon_is_convex(vtkNew sself) { return sself->IsConvex(); } +extern "C" int vtk_polygon_parameterize_polygon(vtkNew sself, double p0, double p10, double l10, double p20, double l20, double n) { return sself->ParameterizePolygon(p0, p10, l10, p20, l20, n); } +extern "C" int vtk_polygon_point_in_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double n) { return sself->PointInPolygon(x, numPts, pts, bounds, n); } +extern "C" double vtk_polygon_distance_to_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double closest) { return sself->DistanceToPolygon(x, numPts, pts, bounds, closest); } +extern "C" int vtk_polygon_intersect_polygon_with_polygon(vtkNew sself, int npts, double pts, double bounds, int npts2, double pts2, double bounds2, double tol, double x) { return sself->IntersectPolygonWithPolygon(npts, pts, bounds, npts2, pts2, bounds2, tol, x); } +extern "C" bool vtk_polygon_get_use_mvc_interpolation(vtkNew sself) { return sself->GetUseMVCInterpolation(); } +extern "C" void vtk_polygon_set_use_mvc_interpolation(vtkNew sself, bool _arg) { sself->SetUseMVCInterpolation(_arg); } +extern "C" void vtk_polygon_set_tolerance(vtkNew sself, double _arg) { sself->SetTolerance(_arg); } +extern "C" double vtk_polygon_get_tolerance_min_value(vtkNew sself) { return sself->GetToleranceMinValue(); } +extern "C" double vtk_polygon_get_tolerance_max_value(vtkNew sself) { return sself->GetToleranceMaxValue(); } +extern "C" double vtk_polygon_get_tolerance(vtkNew sself) { return sself->GetTolerance(); } +extern "C" int vtk_polygon_ear_cut_triangulation(vtkNew sself, int measure) { return sself->EarCutTriangulation(measure); } +extern "C" int vtk_polygon_unbiased_ear_cut_triangulation(vtkNew sself, int seed, int measure) { return sself->UnbiasedEarCutTriangulation(seed, measure); } extern "C" vtkNew < vtkPolyhedron > vtkPolyhedron_new () {return vtkNew < vtkPolyhedron > () ;} extern "C" void vtkPolyhedron_destructor (vtkNew < vtkPolyhedron > sself) {sself . Reset () ; return ;} extern "C" void * vtkPolyhedron_get_ptr (vtkNew < vtkPolyhedron > sself) {return sself . GetPointer () ;} +extern "C" void vtk_polyhedron_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" void vtk_polyhedron_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" long long vtk_polyhedron_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_polyhedron_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_polyhedron_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } +extern "C" long long vtk_polyhedron_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } +extern "C" long long vtk_polyhedron_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } +extern "C" long long vtk_polyhedron_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } +extern "C" long long vtk_polyhedron_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } +extern "C" bool vtk_polyhedron_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } +extern "C" double* vtk_polyhedron_get_parametric_coords(vtkNew sself) { return sself->GetParametricCoords(); } +extern "C" int vtk_polyhedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_polyhedron_requires_initialization(vtkNew sself) { return sself->RequiresInitialization(); } +extern "C" int vtk_polyhedron_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_polyhedron_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_polyhedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_polyhedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_polyhedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_polyhedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_polyhedron_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" int vtk_polyhedron_is_primary_cell(vtkNew sself) { return sself->IsPrimaryCell(); } +extern "C" void vtk_polyhedron_interpolate_functions(vtkNew sself, const double x, double sf) { sself->InterpolateFunctions(x, sf); } +extern "C" void vtk_polyhedron_interpolate_derivs(vtkNew sself, const double x, double derivs) { sself->InterpolateDerivs(x, derivs); } +extern "C" int vtk_polyhedron_requires_explicit_face_representation(vtkNew sself) { return sself->RequiresExplicitFaceRepresentation(); } +extern "C" int vtk_polyhedron_is_inside(vtkNew sself, const double x, double tolerance) { return sself->IsInside(x, tolerance); } +extern "C" bool vtk_polyhedron_is_convex(vtkNew sself) { return sself->IsConvex(); } extern "C" vtkNew < vtkPyramid > vtkPyramid_new () {return vtkNew < vtkPyramid > () ;} extern "C" void vtkPyramid_destructor (vtkNew < vtkPyramid > sself) {sself . Reset () ; return ;} extern "C" void * vtkPyramid_get_ptr (vtkNew < vtkPyramid > sself) {return sself . GetPointer () ;} +extern "C" void vtk_pyramid_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" void vtk_pyramid_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" long long vtk_pyramid_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_pyramid_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_pyramid_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } +extern "C" long long vtk_pyramid_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } +extern "C" long long vtk_pyramid_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } +extern "C" long long vtk_pyramid_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } +extern "C" long long vtk_pyramid_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } +extern "C" bool vtk_pyramid_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } +extern "C" int vtk_pyramid_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_pyramid_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_pyramid_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int* vtk_pyramid_get_triangle_cases(vtkNew sself, int caseId) { return sself->GetTriangleCases(caseId); } +extern "C" int vtk_pyramid_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" int vtk_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { return sself->JacobianInverse(pcoords, inverse, derivs); } +extern "C" const long long* vtk_pyramid_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_pyramid_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" const long long* vtk_pyramid_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } +extern "C" const long long* vtk_pyramid_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } +extern "C" const long long* vtk_pyramid_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } +extern "C" const long long* vtk_pyramid_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } +extern "C" const long long* vtk_pyramid_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } extern "C" vtkNew < vtkQuad > vtkQuad_new () {return vtkNew < vtkQuad > () ;} extern "C" void vtkQuad_destructor (vtkNew < vtkQuad > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuad_get_ptr (vtkNew < vtkQuad > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quad_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quad_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quad_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quad_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_quad_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_quad_interpolation_functions(vtkNew sself, const double pcoords, double sf) { sself->InterpolationFunctions(pcoords, sf); } +extern "C" void vtk_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_quad_interpolate_functions(vtkNew sself, const double pcoords, double sf) { sself->InterpolateFunctions(pcoords, sf); } +extern "C" void vtk_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_quad_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } extern "C" vtkNew < vtkQuadraticEdge > vtkQuadraticEdge_new () {return vtkNew < vtkQuadraticEdge > () ;} extern "C" void vtkQuadraticEdge_destructor (vtkNew < vtkQuadraticEdge > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadraticEdge_get_ptr (vtkNew < vtkQuadraticEdge > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quadratic_edge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_edge_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_edge_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_edge_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quadratic_edge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quadratic_edge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_quadratic_edge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_quadratic_edge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_quadratic_edge_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_quadratic_edge_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_edge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_quadratic_edge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_edge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } extern "C" vtkNew < vtkQuadraticHexahedron > vtkQuadraticHexahedron_new () {return vtkNew < vtkQuadraticHexahedron > () ;} extern "C" void vtkQuadraticHexahedron_destructor (vtkNew < vtkQuadraticHexahedron > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadraticHexahedron_get_ptr (vtkNew < vtkQuadraticHexahedron > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quadratic_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_hexahedron_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_hexahedron_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_hexahedron_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" void vtk_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkQuadraticLinearQuad > vtkQuadraticLinearQuad_new () {return vtkNew < vtkQuadraticLinearQuad > () ;} extern "C" void vtkQuadraticLinearQuad_destructor (vtkNew < vtkQuadraticLinearQuad > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadraticLinearQuad_get_ptr (vtkNew < vtkQuadraticLinearQuad > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quadratic_linear_quad_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_linear_quad_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_linear_quad_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_linear_quad_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quadratic_linear_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quadratic_linear_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_quadratic_linear_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_quadratic_linear_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_quadratic_linear_quad_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_quadratic_linear_quad_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_linear_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_quadratic_linear_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_linear_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" int* vtk_quadratic_linear_quad_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } extern "C" vtkNew < vtkQuadraticLinearWedge > vtkQuadraticLinearWedge_new () {return vtkNew < vtkQuadraticLinearWedge > () ;} extern "C" void vtkQuadraticLinearWedge_destructor (vtkNew < vtkQuadraticLinearWedge > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadraticLinearWedge_get_ptr (vtkNew < vtkQuadraticLinearWedge > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quadratic_linear_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_linear_wedge_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_linear_wedge_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_linear_wedge_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quadratic_linear_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quadratic_linear_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_quadratic_linear_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_quadratic_linear_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_quadratic_linear_wedge_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_quadratic_linear_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_linear_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_quadratic_linear_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_linear_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_quadratic_linear_wedge_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_quadratic_linear_wedge_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" void vtk_quadratic_linear_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkQuadraticPolygon > vtkQuadraticPolygon_new () {return vtkNew < vtkQuadraticPolygon > () ;} extern "C" void vtkQuadraticPolygon_destructor (vtkNew < vtkQuadraticPolygon > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadraticPolygon_get_ptr (vtkNew < vtkQuadraticPolygon > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quadratic_polygon_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_polygon_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_polygon_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_polygon_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quadratic_polygon_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quadratic_polygon_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_quadratic_polygon_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_quadratic_polygon_interpolate_functions(vtkNew sself, const double x, double weights) { sself->InterpolateFunctions(x, weights); } +extern "C" int vtk_quadratic_polygon_parameterize_polygon(vtkNew sself, double p0, double p10, double l10, double p20, double l20, double n) { return sself->ParameterizePolygon(p0, p10, l10, p20, l20, n); } +extern "C" int vtk_quadratic_polygon_point_in_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double n) { return sself->PointInPolygon(x, numPts, pts, bounds, n); } +extern "C" double vtk_quadratic_polygon_distance_to_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double closest) { return sself->DistanceToPolygon(x, numPts, pts, bounds, closest); } +extern "C" int vtk_quadratic_polygon_intersect_polygon_with_polygon(vtkNew sself, int npts, double pts, double bounds, int npts2, double pts2, double bounds2, double tol, double x) { return sself->IntersectPolygonWithPolygon(npts, pts, bounds, npts2, pts2, bounds2, tol, x); } +extern "C" void vtk_quadratic_polygon_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" bool vtk_quadratic_polygon_get_use_mvc_interpolation(vtkNew sself) { return sself->GetUseMVCInterpolation(); } +extern "C" void vtk_quadratic_polygon_set_use_mvc_interpolation(vtkNew sself, bool _arg) { sself->SetUseMVCInterpolation(_arg); } extern "C" vtkNew < vtkQuadraticPyramid > vtkQuadraticPyramid_new () {return vtkNew < vtkQuadraticPyramid > () ;} extern "C" void vtkQuadraticPyramid_destructor (vtkNew < vtkQuadraticPyramid > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadraticPyramid_get_ptr (vtkNew < vtkQuadraticPyramid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quadratic_pyramid_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_pyramid_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_pyramid_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_pyramid_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quadratic_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quadratic_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_quadratic_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_quadratic_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_quadratic_pyramid_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_quadratic_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_quadratic_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_quadratic_pyramid_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_quadratic_pyramid_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" void vtk_quadratic_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkQuadraticQuad > vtkQuadraticQuad_new () {return vtkNew < vtkQuadraticQuad > () ;} extern "C" void vtkQuadraticQuad_destructor (vtkNew < vtkQuadraticQuad > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadraticQuad_get_ptr (vtkNew < vtkQuadraticQuad > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quadratic_quad_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_quad_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_quad_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_quad_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quadratic_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quadratic_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_quadratic_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_quadratic_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_quadratic_quad_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_quadratic_quad_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_quadratic_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } extern "C" vtkNew < vtkQuadraticTetra > vtkQuadraticTetra_new () {return vtkNew < vtkQuadraticTetra > () ;} extern "C" void vtkQuadraticTetra_destructor (vtkNew < vtkQuadraticTetra > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadraticTetra_get_ptr (vtkNew < vtkQuadraticTetra > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quadratic_tetra_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_tetra_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_tetra_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_tetra_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quadratic_tetra_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quadratic_tetra_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_quadratic_tetra_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_quadratic_tetra_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_quadratic_tetra_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" double vtk_quadratic_tetra_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } +extern "C" void vtk_quadratic_tetra_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_tetra_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_quadratic_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_tetra_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_quadratic_tetra_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_quadratic_tetra_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" void vtk_quadratic_tetra_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkQuadraticTriangle > vtkQuadraticTriangle_new () {return vtkNew < vtkQuadraticTriangle > () ;} extern "C" void vtkQuadraticTriangle_destructor (vtkNew < vtkQuadraticTriangle > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadraticTriangle_get_ptr (vtkNew < vtkQuadraticTriangle > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quadratic_triangle_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_triangle_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_triangle_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_triangle_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quadratic_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quadratic_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_quadratic_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_quadratic_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_quadratic_triangle_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" double vtk_quadratic_triangle_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } +extern "C" void vtk_quadratic_triangle_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_quadratic_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } extern "C" vtkNew < vtkQuadraticWedge > vtkQuadraticWedge_new () {return vtkNew < vtkQuadraticWedge > () ;} extern "C" void vtkQuadraticWedge_destructor (vtkNew < vtkQuadraticWedge > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadraticWedge_get_ptr (vtkNew < vtkQuadraticWedge > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quadratic_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_wedge_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_wedge_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_wedge_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_quadratic_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_quadratic_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_quadratic_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_quadratic_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_quadratic_wedge_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_quadratic_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_quadratic_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_quadratic_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_quadratic_wedge_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_quadratic_wedge_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" void vtk_quadratic_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkQuadratureSchemeDefinition > vtkQuadratureSchemeDefinition_new () {return vtkNew < vtkQuadratureSchemeDefinition > () ;} extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkNew < vtkQuadratureSchemeDefinition > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadratureSchemeDefinition_get_ptr (vtkNew < vtkQuadratureSchemeDefinition > sself) {return sself . GetPointer () ;} +extern "C" void vtk_quadrature_scheme_definition_clear(vtkNew sself) { sself->Clear(); } +extern "C" void vtk_quadrature_scheme_definition_initialize(vtkNew sself, int cellType, int numberOfNodes, int numberOfQuadraturePoints, double shapeFunctionWeights) { sself->Initialize(cellType, numberOfNodes, numberOfQuadraturePoints, shapeFunctionWeights); } +extern "C" void vtk_quadrature_scheme_definition_initialize(vtkNew sself, int cellType, int numberOfNodes, int numberOfQuadraturePoints, double shapeFunctionWeights, double quadratureWeights) { sself->Initialize(cellType, numberOfNodes, numberOfQuadraturePoints, shapeFunctionWeights, quadratureWeights); } +extern "C" int vtk_quadrature_scheme_definition_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_quadrature_scheme_definition_get_quadrature_key(vtkNew sself) { return sself->GetQuadratureKey(); } +extern "C" int vtk_quadrature_scheme_definition_get_number_of_nodes(vtkNew sself) { return sself->GetNumberOfNodes(); } +extern "C" int vtk_quadrature_scheme_definition_get_number_of_quadrature_points(vtkNew sself) { return sself->GetNumberOfQuadraturePoints(); } +extern "C" const double* vtk_quadrature_scheme_definition_get_shape_function_weights(vtkNew sself) { return sself->GetShapeFunctionWeights(); } +extern "C" const double* vtk_quadrature_scheme_definition_get_shape_function_weights(vtkNew sself, int quadraturePointId) { return sself->GetShapeFunctionWeights(quadraturePointId); } +extern "C" const double* vtk_quadrature_scheme_definition_get_quadrature_weights(vtkNew sself) { return sself->GetQuadratureWeights(); } extern "C" vtkNew < vtkQuadric > vtkQuadric_new () {return vtkNew < vtkQuadric > () ;} extern "C" void vtkQuadric_destructor (vtkNew < vtkQuadric > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuadric_get_ptr (vtkNew < vtkQuadric > sself) {return sself . GetPointer () ;} +extern "C" double vtk_quadric_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_quadric_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } +extern "C" void vtk_quadric_set_coefficients(vtkNew sself, double a) { sself->SetCoefficients(a); } +extern "C" void vtk_quadric_set_coefficients(vtkNew sself, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9) { sself->SetCoefficients(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } +extern "C" double* vtk_quadric_get_coefficients(vtkNew sself) { return sself->GetCoefficients(); } +extern "C" void vtk_quadric_get_coefficients(vtkNew sself, double data) { sself->GetCoefficients(data); } extern "C" vtkNew < vtkRectilinearGrid > vtkRectilinearGrid_new () {return vtkNew < vtkRectilinearGrid > () ;} extern "C" void vtkRectilinearGrid_destructor (vtkNew < vtkRectilinearGrid > sself) {sself . Reset () ; return ;} extern "C" void * vtkRectilinearGrid_get_ptr (vtkNew < vtkRectilinearGrid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_rectilinear_grid_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_rectilinear_grid_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" long long vtk_rectilinear_grid_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } +extern "C" long long vtk_rectilinear_grid_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" double* vtk_rectilinear_grid_get_point(vtkNew sself, long long ptId) { return sself->GetPoint(ptId); } +extern "C" long long vtk_rectilinear_grid_find_point(vtkNew sself, double x) { return sself->FindPoint(x); } +extern "C" int vtk_rectilinear_grid_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" int vtk_rectilinear_grid_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } +extern "C" unsigned char vtk_rectilinear_grid_is_point_visible(vtkNew sself, long long ptId) { return sself->IsPointVisible(ptId); } +extern "C" unsigned char vtk_rectilinear_grid_is_cell_visible(vtkNew sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" bool vtk_rectilinear_grid_has_any_blank_points(vtkNew sself) { return sself->HasAnyBlankPoints(); } +extern "C" bool vtk_rectilinear_grid_has_any_blank_cells(vtkNew sself) { return sself->HasAnyBlankCells(); } +extern "C" void vtk_rectilinear_grid_get_cell_dims(vtkNew sself, int cellDims) { sself->GetCellDims(cellDims); } +extern "C" void vtk_rectilinear_grid_set_dimensions(vtkNew sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" void vtk_rectilinear_grid_set_dimensions(vtkNew sself, const int dim) { sself->SetDimensions(dim); } +extern "C" int* vtk_rectilinear_grid_get_dimensions(vtkNew sself) { return sself->GetDimensions(); } +extern "C" void vtk_rectilinear_grid_get_dimensions(vtkNew sself, int data) { sself->GetDimensions(data); } +extern "C" int vtk_rectilinear_grid_get_data_dimension(vtkNew sself) { return sself->GetDataDimension(); } +extern "C" int vtk_rectilinear_grid_compute_structured_coordinates(vtkNew sself, double x, int ijk, double pcoords) { return sself->ComputeStructuredCoordinates(x, ijk, pcoords); } +extern "C" long long vtk_rectilinear_grid_compute_point_id(vtkNew sself, int ijk) { return sself->ComputePointId(ijk); } +extern "C" long long vtk_rectilinear_grid_compute_cell_id(vtkNew sself, int ijk) { return sself->ComputeCellId(ijk); } +extern "C" void vtk_rectilinear_grid_get_point(vtkNew sself, const int i, const int j, const int k, double p) { sself->GetPoint(i, j, k, p); } +extern "C" void vtk_rectilinear_grid_set_extent(vtkNew sself, int extent) { sself->SetExtent(extent); } +extern "C" void vtk_rectilinear_grid_set_extent(vtkNew sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax) { sself->SetExtent(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" int* vtk_rectilinear_grid_get_extent(vtkNew sself) { return sself->GetExtent(); } +extern "C" void vtk_rectilinear_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_rectilinear_grid_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } +extern "C" int vtk_rectilinear_grid_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } +extern "C" void vtk_rectilinear_grid_crop(vtkNew sself, const int updateExtent) { sself->Crop(updateExtent); } +extern "C" int vtk_rectilinear_grid_get_scalar_type(vtkNew sself) { return sself->GetScalarType(); } +extern "C" const char* vtk_rectilinear_grid_get_scalar_type_as_string(vtkNew sself) { return sself->GetScalarTypeAsString(); } +extern "C" int vtk_rectilinear_grid_get_number_of_scalar_components(vtkNew sself) { return sself->GetNumberOfScalarComponents(); } extern "C" vtkNew < vtkReebGraph > vtkReebGraph_new () {return vtkNew < vtkReebGraph > () ;} extern "C" void vtkReebGraph_destructor (vtkNew < vtkReebGraph > sself) {sself . Reset () ; return ;} extern "C" void * vtkReebGraph_get_ptr (vtkNew < vtkReebGraph > sself) {return sself . GetPointer () ;} +extern "C" int vtk_reeb_graph_stream_triangle(vtkNew sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2) { return sself->StreamTriangle(vertex0Id, scalar0, vertex1Id, scalar1, vertex2Id, scalar2); } +extern "C" int vtk_reeb_graph_stream_tetrahedron(vtkNew sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2, long long vertex3Id, double scalar3) { return sself->StreamTetrahedron(vertex0Id, scalar0, vertex1Id, scalar1, vertex2Id, scalar2, vertex3Id, scalar3); } +extern "C" void vtk_reeb_graph_close_stream(vtkNew sself) { sself->CloseStream(); } extern "C" vtkNew < vtkReebGraphSimplificationMetric > vtkReebGraphSimplificationMetric_new () {return vtkNew < vtkReebGraphSimplificationMetric > () ;} extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkNew < vtkReebGraphSimplificationMetric > sself) {sself . Reset () ; return ;} extern "C" void * vtkReebGraphSimplificationMetric_get_ptr (vtkNew < vtkReebGraphSimplificationMetric > sself) {return sself . GetPointer () ;} +extern "C" void vtk_reeb_graph_simplification_metric_set_lower_bound(vtkNew sself, double _arg) { sself->SetLowerBound(_arg); } +extern "C" double vtk_reeb_graph_simplification_metric_get_lower_bound(vtkNew sself) { return sself->GetLowerBound(); } +extern "C" void vtk_reeb_graph_simplification_metric_set_upper_bound(vtkNew sself, double _arg) { sself->SetUpperBound(_arg); } +extern "C" double vtk_reeb_graph_simplification_metric_get_upper_bound(vtkNew sself) { return sself->GetUpperBound(); } extern "C" vtkNew < vtkSelection > vtkSelection_new () {return vtkNew < vtkSelection > () ;} extern "C" void vtkSelection_destructor (vtkNew < vtkSelection > sself) {sself . Reset () ; return ;} extern "C" void * vtkSelection_get_ptr (vtkNew < vtkSelection > sself) {return sself . GetPointer () ;} +extern "C" int vtk_selection_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" unsigned int vtk_selection_get_number_of_nodes(vtkNew sself) { return sself->GetNumberOfNodes(); } +extern "C" const char* vtk_selection_get_node_name_at_index(vtkNew sself, unsigned int idx) { return sself->GetNodeNameAtIndex(idx); } +extern "C" void vtk_selection_remove_node(vtkNew sself, unsigned int idx) { sself->RemoveNode(idx); } +extern "C" void vtk_selection_remove_node(vtkNew sself, const char* name) { sself->RemoveNode(name); } +extern "C" void vtk_selection_remove_all_nodes(vtkNew sself) { sself->RemoveAllNodes(); } +extern "C" void vtk_selection_set_expression(vtkNew sself, const char* _arg) { sself->SetExpression(_arg); } +extern "C" const char* vtk_selection_get_expression(vtkNew sself) { return sself->GetExpression(); } +extern "C" unsigned long vtk_selection_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_selection_dump(vtkNew sself) { sself->Dump(); } extern "C" vtkNew < vtkSelectionNode > vtkSelectionNode_new () {return vtkNew < vtkSelectionNode > () ;} extern "C" void vtkSelectionNode_destructor (vtkNew < vtkSelectionNode > sself) {sself . Reset () ; return ;} extern "C" void * vtkSelectionNode_get_ptr (vtkNew < vtkSelectionNode > sself) {return sself . GetPointer () ;} +extern "C" void vtk_selection_node_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" unsigned long vtk_selection_node_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_selection_node_set_content_type(vtkNew sself, int type) { sself->SetContentType(type); } +extern "C" int vtk_selection_node_get_content_type(vtkNew sself) { return sself->GetContentType(); } +extern "C" const char* vtk_selection_node_get_content_type_as_string(vtkNew sself, int type) { return sself->GetContentTypeAsString(type); } +extern "C" void vtk_selection_node_set_field_type(vtkNew sself, int type) { sself->SetFieldType(type); } +extern "C" int vtk_selection_node_get_field_type(vtkNew sself) { return sself->GetFieldType(); } +extern "C" const char* vtk_selection_node_get_field_type_as_string(vtkNew sself, int type) { return sself->GetFieldTypeAsString(type); } +extern "C" int vtk_selection_node_get_field_type_from_string(vtkNew sself, const char type) { return sself->GetFieldTypeFromString(type); } +extern "C" int vtk_selection_node_convert_selection_field_to_attribute_type(vtkNew sself, int val) { return sself->ConvertSelectionFieldToAttributeType(val); } +extern "C" int vtk_selection_node_convert_attribute_type_to_selection_field(vtkNew sself, int val) { return sself->ConvertAttributeTypeToSelectionField(val); } +extern "C" void vtk_selection_node_set_query_string(vtkNew sself, const char _arg) { sself->SetQueryString(_arg); } +extern "C" char* vtk_selection_node_get_query_string(vtkNew sself) { return sself->GetQueryString(); } extern "C" vtkNew < vtkSimpleCellTessellator > vtkSimpleCellTessellator_new () {return vtkNew < vtkSimpleCellTessellator > () ;} extern "C" void vtkSimpleCellTessellator_destructor (vtkNew < vtkSimpleCellTessellator > sself) {sself . Reset () ; return ;} extern "C" void * vtkSimpleCellTessellator_get_ptr (vtkNew < vtkSimpleCellTessellator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_simple_cell_tessellator_reset(vtkNew sself) { sself->Reset(); } +extern "C" int vtk_simple_cell_tessellator_get_fixed_subdivisions(vtkNew sself) { return sself->GetFixedSubdivisions(); } +extern "C" int vtk_simple_cell_tessellator_get_max_subdivision_level(vtkNew sself) { return sself->GetMaxSubdivisionLevel(); } +extern "C" int vtk_simple_cell_tessellator_get_max_adaptive_subdivisions(vtkNew sself) { return sself->GetMaxAdaptiveSubdivisions(); } +extern "C" void vtk_simple_cell_tessellator_set_fixed_subdivisions(vtkNew sself, int level) { sself->SetFixedSubdivisions(level); } +extern "C" void vtk_simple_cell_tessellator_set_max_subdivision_level(vtkNew sself, int level) { sself->SetMaxSubdivisionLevel(level); } +extern "C" void vtk_simple_cell_tessellator_set_subdivision_levels(vtkNew sself, int fixed, int maxLevel) { sself->SetSubdivisionLevels(fixed, maxLevel); } extern "C" vtkNew < vtkSmoothErrorMetric > vtkSmoothErrorMetric_new () {return vtkNew < vtkSmoothErrorMetric > () ;} extern "C" void vtkSmoothErrorMetric_destructor (vtkNew < vtkSmoothErrorMetric > sself) {sself . Reset () ; return ;} extern "C" void * vtkSmoothErrorMetric_get_ptr (vtkNew < vtkSmoothErrorMetric > sself) {return sself . GetPointer () ;} +extern "C" double vtk_smooth_error_metric_get_angle_tolerance(vtkNew sself) { return sself->GetAngleTolerance(); } +extern "C" void vtk_smooth_error_metric_set_angle_tolerance(vtkNew sself, double value) { sself->SetAngleTolerance(value); } +extern "C" int vtk_smooth_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->RequiresEdgeSubdivision(leftPoint, midPoint, rightPoint, alpha); } +extern "C" double vtk_smooth_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->GetError(leftPoint, midPoint, rightPoint, alpha); } extern "C" vtkNew < vtkSortFieldData > vtkSortFieldData_new () {return vtkNew < vtkSortFieldData > () ;} extern "C" void vtkSortFieldData_destructor (vtkNew < vtkSortFieldData > sself) {sself . Reset () ; return ;} extern "C" void * vtkSortFieldData_get_ptr (vtkNew < vtkSortFieldData > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkSphere > vtkSphere_new () {return vtkNew < vtkSphere > () ;} extern "C" void vtkSphere_destructor (vtkNew < vtkSphere > sself) {sself . Reset () ; return ;} extern "C" void * vtkSphere_get_ptr (vtkNew < vtkSphere > sself) {return sself . GetPointer () ;} +extern "C" double vtk_sphere_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_sphere_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } +extern "C" void vtk_sphere_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_sphere_get_radius(vtkNew sself) { return sself->GetRadius(); } +extern "C" void vtk_sphere_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_sphere_set_center(vtkNew sself, const double _arg) { sself->SetCenter(_arg); } +extern "C" double* vtk_sphere_get_center(vtkNew sself) { return sself->GetCenter(); } +extern "C" void vtk_sphere_get_center(vtkNew sself, double data) { sself->GetCenter(data); } +extern "C" double vtk_sphere_evaluate(vtkNew sself, double center, double R, double x) { return sself->Evaluate(center, R, x); } +extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, float pts, long long numPts, float sphere, long long hints) { sself->ComputeBoundingSphere(pts, numPts, sphere, hints); } +extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, double pts, long long numPts, double sphere, long long hints) { sself->ComputeBoundingSphere(pts, numPts, sphere, hints); } +extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, float spheres, long long numSpheres, float sphere, long long hints) { sself->ComputeBoundingSphere(spheres, numSpheres, sphere, hints); } +extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, double spheres, long long numSpheres, double sphere, long long hints) { sself->ComputeBoundingSphere(spheres, numSpheres, sphere, hints); } extern "C" vtkNew < vtkSpheres > vtkSpheres_new () {return vtkNew < vtkSpheres > () ;} extern "C" void vtkSpheres_destructor (vtkNew < vtkSpheres > sself) {sself . Reset () ; return ;} extern "C" void * vtkSpheres_get_ptr (vtkNew < vtkSpheres > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSphericalPointIterator > vtkSphericalPointIterator_new () {return vtkNew < vtkSphericalPointIterator > () ;} -extern "C" void vtkSphericalPointIterator_destructor (vtkNew < vtkSphericalPointIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSphericalPointIterator_get_ptr (vtkNew < vtkSphericalPointIterator > sself) {return sself . GetPointer () ;} +extern "C" double vtk_spheres_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_spheres_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } +extern "C" int vtk_spheres_get_number_of_spheres(vtkNew sself) { return sself->GetNumberOfSpheres(); } extern "C" vtkNew < vtkStaticCellLinks > vtkStaticCellLinks_new () {return vtkNew < vtkStaticCellLinks > () ;} extern "C" void vtkStaticCellLinks_destructor (vtkNew < vtkStaticCellLinks > sself) {sself . Reset () ; return ;} extern "C" void * vtkStaticCellLinks_get_ptr (vtkNew < vtkStaticCellLinks > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_static_cell_links_get_number_of_cells(vtkNew sself, long long ptId) { return sself->GetNumberOfCells(ptId); } +extern "C" long long vtk_static_cell_links_get_ncells(vtkNew sself, long long ptId) { return sself->GetNcells(ptId); } +extern "C" long long* vtk_static_cell_links_get_cells(vtkNew sself, long long ptId) { return sself->GetCells(ptId); } +extern "C" void vtk_static_cell_links_select_cells(vtkNew sself, long long minMaxDegree, unsigned char cellSelection) { sself->SelectCells(minMaxDegree, cellSelection); } +extern "C" void vtk_static_cell_links_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_static_cell_links_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" void vtk_static_cell_links_reset(vtkNew sself) { sself->Reset(); } +extern "C" unsigned long vtk_static_cell_links_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } extern "C" vtkNew < vtkStaticCellLocator > vtkStaticCellLocator_new () {return vtkNew < vtkStaticCellLocator > () ;} extern "C" void vtkStaticCellLocator_destructor (vtkNew < vtkStaticCellLocator > sself) {sself . Reset () ; return ;} extern "C" void * vtkStaticCellLocator_get_ptr (vtkNew < vtkStaticCellLocator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_static_cell_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } +extern "C" void vtk_static_cell_locator_set_divisions(vtkNew sself, const int _arg) { sself->SetDivisions(_arg); } +extern "C" int* vtk_static_cell_locator_get_divisions(vtkNew sself) { return sself->GetDivisions(); } +extern "C" void vtk_static_cell_locator_get_divisions(vtkNew sself, int data) { sself->GetDivisions(data); } +extern "C" long long vtk_static_cell_locator_find_cell(vtkNew sself, double x) { return sself->FindCell(x); } +extern "C" int vtk_static_cell_locator_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_static_cell_locator_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId, long long cellId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId, cellId); } +extern "C" void vtk_static_cell_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_static_cell_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } +extern "C" void vtk_static_cell_locator_set_max_number_of_buckets(vtkNew sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_min_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMinValue(); } +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_max_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets(vtkNew sself) { return sself->GetMaxNumberOfBuckets(); } +extern "C" bool vtk_static_cell_locator_get_large_ids(vtkNew sself) { return sself->GetLargeIds(); } +extern "C" void vtk_static_cell_locator_set_use_diagonal_length_tolerance(vtkNew sself, bool _arg) { sself->SetUseDiagonalLengthTolerance(_arg); } +extern "C" bool vtk_static_cell_locator_get_use_diagonal_length_tolerance(vtkNew sself) { return sself->GetUseDiagonalLengthTolerance(); } +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_on(vtkNew sself) { sself->UseDiagonalLengthToleranceOn(); } +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_off(vtkNew sself) { sself->UseDiagonalLengthToleranceOff(); } extern "C" vtkNew < vtkStaticPointLocator > vtkStaticPointLocator_new () {return vtkNew < vtkStaticPointLocator > () ;} extern "C" void vtkStaticPointLocator_destructor (vtkNew < vtkStaticPointLocator > sself) {sself . Reset () ; return ;} extern "C" void * vtkStaticPointLocator_get_ptr (vtkNew < vtkStaticPointLocator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_static_point_locator_set_number_of_points_per_bucket(vtkNew sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_min_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_max_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket(vtkNew sself) { return sself->GetNumberOfPointsPerBucket(); } +extern "C" void vtk_static_point_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } +extern "C" void vtk_static_point_locator_set_divisions(vtkNew sself, const int _arg) { sself->SetDivisions(_arg); } +extern "C" int* vtk_static_point_locator_get_divisions(vtkNew sself) { return sself->GetDivisions(); } +extern "C" void vtk_static_point_locator_get_divisions(vtkNew sself, int data) { sself->GetDivisions(data); } +extern "C" long long vtk_static_point_locator_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } +extern "C" long long vtk_static_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } +extern "C" long long vtk_static_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, inputDataLength, dist2); } +extern "C" int vtk_static_point_locator_intersect_with_line(vtkNew sself, double a0, double a1, double tol, double t, double lineX, double ptX, long long ptId) { return sself->IntersectWithLine(a0, a1, tol, t, lineX, ptX, ptId); } +extern "C" void vtk_static_point_locator_merge_points(vtkNew sself, double tol, long long mergeMap) { sself->MergePoints(tol, mergeMap); } +extern "C" void vtk_static_point_locator_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_static_point_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_static_point_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } +extern "C" void vtk_static_point_locator_build_locator(vtkNew sself, const double inBounds) { sself->BuildLocator(inBounds); } +extern "C" long long vtk_static_point_locator_get_number_of_points_in_bucket(vtkNew sself, long long bNum) { return sself->GetNumberOfPointsInBucket(bNum); } +extern "C" void vtk_static_point_locator_set_max_number_of_buckets(vtkNew sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_min_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMinValue(); } +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_max_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets(vtkNew sself) { return sself->GetMaxNumberOfBuckets(); } +extern "C" bool vtk_static_point_locator_get_large_ids(vtkNew sself) { return sself->GetLargeIds(); } +extern "C" double* vtk_static_point_locator_get_spacing(vtkNew sself) { return sself->GetSpacing(); } +extern "C" void vtk_static_point_locator_get_spacing(vtkNew sself, double spacing) { sself->GetSpacing(spacing); } extern "C" vtkNew < vtkStaticPointLocator2D > vtkStaticPointLocator2D_new () {return vtkNew < vtkStaticPointLocator2D > () ;} extern "C" void vtkStaticPointLocator2D_destructor (vtkNew < vtkStaticPointLocator2D > sself) {sself . Reset () ; return ;} extern "C" void * vtkStaticPointLocator2D_get_ptr (vtkNew < vtkStaticPointLocator2D > sself) {return sself . GetPointer () ;} +extern "C" void vtk_static_point_locator_2_d_set_number_of_points_per_bucket(vtkNew sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket(vtkNew sself) { return sself->GetNumberOfPointsPerBucket(); } +extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkNew sself, int _arg1, int _arg2) { sself->SetDivisions(_arg1, _arg2); } +extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkNew sself, const int _arg) { sself->SetDivisions(_arg); } +extern "C" int* vtk_static_point_locator_2_d_get_divisions(vtkNew sself) { return sself->GetDivisions(); } +extern "C" void vtk_static_point_locator_2_d_get_divisions(vtkNew sself, int data) { sself->GetDivisions(data); } +extern "C" long long vtk_static_point_locator_2_d_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } +extern "C" long long vtk_static_point_locator_2_d_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } +extern "C" long long vtk_static_point_locator_2_d_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, inputDataLength, dist2); } +extern "C" int vtk_static_point_locator_2_d_intersect_with_line(vtkNew sself, double a0, double a1, double tol, double t, double lineX, double ptX, long long ptId) { return sself->IntersectWithLine(a0, a1, tol, t, lineX, ptX, ptId); } +extern "C" void vtk_static_point_locator_2_d_merge_points(vtkNew sself, double tol, long long mergeMap) { sself->MergePoints(tol, mergeMap); } +extern "C" void vtk_static_point_locator_2_d_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_static_point_locator_2_d_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_static_point_locator_2_d_build_locator(vtkNew sself) { sself->BuildLocator(); } +extern "C" long long vtk_static_point_locator_2_d_get_number_of_points_in_bucket(vtkNew sself, long long bNum) { return sself->GetNumberOfPointsInBucket(bNum); } +extern "C" void vtk_static_point_locator_2_d_set_max_number_of_buckets(vtkNew sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMinValue(); } +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets(vtkNew sself) { return sself->GetMaxNumberOfBuckets(); } +extern "C" bool vtk_static_point_locator_2_d_get_large_ids(vtkNew sself) { return sself->GetLargeIds(); } +extern "C" void vtk_static_point_locator_2_d_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" double* vtk_static_point_locator_2_d_get_spacing(vtkNew sself) { return sself->GetSpacing(); } +extern "C" void vtk_static_point_locator_2_d_get_spacing(vtkNew sself, double spacing) { sself->GetSpacing(spacing); } +extern "C" void vtk_static_point_locator_2_d_get_bucket_indices(vtkNew sself, const double x, int ij) { sself->GetBucketIndices(x, ij); } +extern "C" long long vtk_static_point_locator_2_d_get_bucket_index(vtkNew sself, const double x) { return sself->GetBucketIndex(x); } extern "C" vtkNew < vtkStructuredExtent > vtkStructuredExtent_new () {return vtkNew < vtkStructuredExtent > () ;} extern "C" void vtkStructuredExtent_destructor (vtkNew < vtkStructuredExtent > sself) {sself . Reset () ; return ;} extern "C" void * vtkStructuredExtent_get_ptr (vtkNew < vtkStructuredExtent > sself) {return sself . GetPointer () ;} +extern "C" void vtk_structured_extent_clamp(vtkNew sself, int ext, const int wholeExt) { sself->Clamp(ext, wholeExt); } +extern "C" bool vtk_structured_extent_strictly_smaller(vtkNew sself, const int ext, const int wholeExt) { return sself->StrictlySmaller(ext, wholeExt); } +extern "C" bool vtk_structured_extent_smaller(vtkNew sself, const int ext, const int wholeExt) { return sself->Smaller(ext, wholeExt); } +extern "C" void vtk_structured_extent_grow(vtkNew sself, int ext, int count) { sself->Grow(ext, count); } +extern "C" void vtk_structured_extent_grow(vtkNew sself, int ext, int count, int wholeExt) { sself->Grow(ext, count, wholeExt); } +extern "C" void vtk_structured_extent_transform(vtkNew sself, int ext, int wholeExt) { sself->Transform(ext, wholeExt); } +extern "C" void vtk_structured_extent_get_dimensions(vtkNew sself, const int ext, int dims) { sself->GetDimensions(ext, dims); } extern "C" vtkNew < vtkStructuredGrid > vtkStructuredGrid_new () {return vtkNew < vtkStructuredGrid > () ;} extern "C" void vtkStructuredGrid_destructor (vtkNew < vtkStructuredGrid > sself) {sself . Reset () ; return ;} extern "C" void * vtkStructuredGrid_get_ptr (vtkNew < vtkStructuredGrid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_structured_grid_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_structured_grid_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_structured_grid_get_point(vtkNew sself, long long ptId, double p) { sself->GetPoint(ptId, p); } +extern "C" int vtk_structured_grid_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_structured_grid_set_dimensions(vtkNew sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" void vtk_structured_grid_set_dimensions(vtkNew sself, const int dim) { sself->SetDimensions(dim); } +extern "C" int* vtk_structured_grid_get_dimensions(vtkNew sself) { return sself->GetDimensions(); } +extern "C" void vtk_structured_grid_get_dimensions(vtkNew sself, int dim) { sself->GetDimensions(dim); } +extern "C" int vtk_structured_grid_get_data_dimension(vtkNew sself) { return sself->GetDataDimension(); } +extern "C" void vtk_structured_grid_set_extent(vtkNew sself, int extent) { sself->SetExtent(extent); } +extern "C" void vtk_structured_grid_set_extent(vtkNew sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax) { sself->SetExtent(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" int* vtk_structured_grid_get_extent(vtkNew sself) { return sself->GetExtent(); } +extern "C" void vtk_structured_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_structured_grid_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } +extern "C" int vtk_structured_grid_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } +extern "C" void vtk_structured_grid_blank_point(vtkNew sself, long long ptId) { sself->BlankPoint(ptId); } +extern "C" void vtk_structured_grid_un_blank_point(vtkNew sself, long long ptId) { sself->UnBlankPoint(ptId); } +extern "C" void vtk_structured_grid_blank_cell(vtkNew sself, long long ptId) { sself->BlankCell(ptId); } +extern "C" void vtk_structured_grid_un_blank_cell(vtkNew sself, long long ptId) { sself->UnBlankCell(ptId); } +extern "C" unsigned char vtk_structured_grid_is_point_visible(vtkNew sself, long long ptId) { return sself->IsPointVisible(ptId); } +extern "C" unsigned char vtk_structured_grid_is_cell_visible(vtkNew sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" bool vtk_structured_grid_has_any_blank_points(vtkNew sself) { return sself->HasAnyBlankPoints(); } +extern "C" bool vtk_structured_grid_has_any_blank_cells(vtkNew sself) { return sself->HasAnyBlankCells(); } +extern "C" void vtk_structured_grid_get_cell_dims(vtkNew sself, int cellDims) { sself->GetCellDims(cellDims); } +extern "C" void vtk_structured_grid_crop(vtkNew sself, const int updateExtent) { sself->Crop(updateExtent); } +extern "C" void vtk_structured_grid_get_point(vtkNew sself, int i, int j, int k, double p, bool adjustForExtent) { sself->GetPoint(i, j, k, p, adjustForExtent); } extern "C" vtkNew < vtkStructuredPoints > vtkStructuredPoints_new () {return vtkNew < vtkStructuredPoints > () ;} extern "C" void vtkStructuredPoints_destructor (vtkNew < vtkStructuredPoints > sself) {sself . Reset () ; return ;} extern "C" void * vtkStructuredPoints_get_ptr (vtkNew < vtkStructuredPoints > sself) {return sself . GetPointer () ;} +extern "C" int vtk_structured_points_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } extern "C" vtkNew < vtkStructuredPointsCollection > vtkStructuredPointsCollection_new () {return vtkNew < vtkStructuredPointsCollection > () ;} extern "C" void vtkStructuredPointsCollection_destructor (vtkNew < vtkStructuredPointsCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkStructuredPointsCollection_get_ptr (vtkNew < vtkStructuredPointsCollection > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkSuperquadric > vtkSuperquadric_new () {return vtkNew < vtkSuperquadric > () ;} extern "C" void vtkSuperquadric_destructor (vtkNew < vtkSuperquadric > sself) {sself . Reset () ; return ;} extern "C" void * vtkSuperquadric_get_ptr (vtkNew < vtkSuperquadric > sself) {return sself . GetPointer () ;} +extern "C" double vtk_superquadric_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } +extern "C" void vtk_superquadric_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } +extern "C" void vtk_superquadric_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_superquadric_set_center(vtkNew sself, const double _arg) { sself->SetCenter(_arg); } +extern "C" double* vtk_superquadric_get_center(vtkNew sself) { return sself->GetCenter(); } +extern "C" void vtk_superquadric_get_center(vtkNew sself, double data) { sself->GetCenter(data); } +extern "C" void vtk_superquadric_set_scale(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetScale(_arg1, _arg2, _arg3); } +extern "C" void vtk_superquadric_set_scale(vtkNew sself, const double _arg) { sself->SetScale(_arg); } +extern "C" double* vtk_superquadric_get_scale(vtkNew sself) { return sself->GetScale(); } +extern "C" void vtk_superquadric_get_scale(vtkNew sself, double data) { sself->GetScale(data); } +extern "C" double vtk_superquadric_get_thickness(vtkNew sself) { return sself->GetThickness(); } +extern "C" void vtk_superquadric_set_thickness(vtkNew sself, double _arg) { sself->SetThickness(_arg); } +extern "C" double vtk_superquadric_get_thickness_min_value(vtkNew sself) { return sself->GetThicknessMinValue(); } +extern "C" double vtk_superquadric_get_thickness_max_value(vtkNew sself) { return sself->GetThicknessMaxValue(); } +extern "C" double vtk_superquadric_get_phi_roundness(vtkNew sself) { return sself->GetPhiRoundness(); } +extern "C" void vtk_superquadric_set_phi_roundness(vtkNew sself, double e) { sself->SetPhiRoundness(e); } +extern "C" double vtk_superquadric_get_theta_roundness(vtkNew sself) { return sself->GetThetaRoundness(); } +extern "C" void vtk_superquadric_set_theta_roundness(vtkNew sself, double e) { sself->SetThetaRoundness(e); } +extern "C" void vtk_superquadric_set_size(vtkNew sself, double _arg) { sself->SetSize(_arg); } +extern "C" double vtk_superquadric_get_size(vtkNew sself) { return sself->GetSize(); } +extern "C" void vtk_superquadric_toroidal_on(vtkNew sself) { sself->ToroidalOn(); } +extern "C" void vtk_superquadric_toroidal_off(vtkNew sself) { sself->ToroidalOff(); } +extern "C" int vtk_superquadric_get_toroidal(vtkNew sself) { return sself->GetToroidal(); } +extern "C" void vtk_superquadric_set_toroidal(vtkNew sself, int _arg) { sself->SetToroidal(_arg); } extern "C" vtkNew < vtkTable > vtkTable_new () {return vtkNew < vtkTable > () ;} extern "C" void vtkTable_destructor (vtkNew < vtkTable > sself) {sself . Reset () ; return ;} extern "C" void * vtkTable_get_ptr (vtkNew < vtkTable > sself) {return sself . GetPointer () ;} +extern "C" void vtk_table_dump(vtkNew sself, unsigned int colWidth, int rowLimit) { sself->Dump(colWidth, rowLimit); } +extern "C" int vtk_table_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_table_get_number_of_rows(vtkNew sself) { return sself->GetNumberOfRows(); } +extern "C" void vtk_table_set_number_of_rows(vtkNew sself, const long long p0) { sself->SetNumberOfRows(p0); } +extern "C" long long vtk_table_insert_next_blank_row(vtkNew sself, double default_num_val) { return sself->InsertNextBlankRow(default_num_val); } +extern "C" void vtk_table_remove_row(vtkNew sself, long long row) { sself->RemoveRow(row); } +extern "C" long long vtk_table_get_number_of_columns(vtkNew sself) { return sself->GetNumberOfColumns(); } +extern "C" const char* vtk_table_get_column_name(vtkNew sself, long long col) { return sself->GetColumnName(col); } +extern "C" void vtk_table_remove_column_by_name(vtkNew sself, const char name) { sself->RemoveColumnByName(name); } +extern "C" void vtk_table_remove_column(vtkNew sself, long long col) { sself->RemoveColumn(col); } +extern "C" void vtk_table_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" long long vtk_table_get_number_of_elements(vtkNew sself, int type) { return sself->GetNumberOfElements(type); } extern "C" vtkNew < vtkTetra > vtkTetra_new () {return vtkNew < vtkTetra > () ;} extern "C" void vtkTetra_destructor (vtkNew < vtkTetra > sself) {sself . Reset () ; return ;} extern "C" void * vtkTetra_get_ptr (vtkNew < vtkTetra > sself) {return sself . GetPointer () ;} +extern "C" void vtk_tetra_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" void vtk_tetra_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" long long vtk_tetra_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_tetra_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_tetra_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } +extern "C" long long vtk_tetra_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } +extern "C" long long vtk_tetra_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } +extern "C" long long vtk_tetra_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } +extern "C" long long vtk_tetra_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } +extern "C" bool vtk_tetra_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } +extern "C" int vtk_tetra_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_tetra_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_tetra_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_tetra_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_tetra_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_tetra_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_tetra_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int* vtk_tetra_get_triangle_cases(vtkNew sself, int caseId) { return sself->GetTriangleCases(caseId); } +extern "C" int vtk_tetra_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" double vtk_tetra_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } +extern "C" void vtk_tetra_tetra_center(vtkNew sself, double p1, double p2, double p3, double p4, double center) { sself->TetraCenter(p1, p2, p3, p4, center); } +extern "C" double vtk_tetra_circumsphere(vtkNew sself, double x1, double x2, double x3, double x4, double center) { return sself->Circumsphere(x1, x2, x3, x4, center); } +extern "C" double vtk_tetra_insphere(vtkNew sself, double p1, double p2, double p3, double p4, double center) { return sself->Insphere(p1, p2, p3, p4, center); } +extern "C" int vtk_tetra_barycentric_coords(vtkNew sself, double x, double x1, double x2, double x3, double x4, double bcoords) { return sself->BarycentricCoords(x, x1, x2, x3, x4, bcoords); } +extern "C" double vtk_tetra_compute_volume(vtkNew sself, double p1, double p2, double p3, double p4) { return sself->ComputeVolume(p1, p2, p3, p4); } +extern "C" int vtk_tetra_jacobian_inverse(vtkNew sself, double inverse, double derivs) { return sself->JacobianInverse(inverse, derivs); } +extern "C" void vtk_tetra_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_tetra_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_tetra_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_tetra_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_tetra_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" const long long* vtk_tetra_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } +extern "C" const long long* vtk_tetra_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } +extern "C" const long long* vtk_tetra_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } +extern "C" const long long* vtk_tetra_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } +extern "C" const long long* vtk_tetra_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } extern "C" vtkNew < vtkTree > vtkTree_new () {return vtkNew < vtkTree > () ;} extern "C" void vtkTree_destructor (vtkNew < vtkTree > sself) {sself . Reset () ; return ;} extern "C" void * vtkTree_get_ptr (vtkNew < vtkTree > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_tree_get_root(vtkNew sself) { return sself->GetRoot(); } +extern "C" long long vtk_tree_get_number_of_children(vtkNew sself, long long v) { return sself->GetNumberOfChildren(v); } +extern "C" long long vtk_tree_get_child(vtkNew sself, long long v, long long i) { return sself->GetChild(v, i); } +extern "C" long long vtk_tree_get_parent(vtkNew sself, long long v) { return sself->GetParent(v); } +extern "C" long long vtk_tree_get_level(vtkNew sself, long long v) { return sself->GetLevel(v); } +extern "C" bool vtk_tree_is_leaf(vtkNew sself, long long vertex) { return sself->IsLeaf(vertex); } extern "C" vtkNew < vtkTreeBFSIterator > vtkTreeBFSIterator_new () {return vtkNew < vtkTreeBFSIterator > () ;} extern "C" void vtkTreeBFSIterator_destructor (vtkNew < vtkTreeBFSIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkTreeBFSIterator_get_ptr (vtkNew < vtkTreeBFSIterator > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkTreeDFSIterator > vtkTreeDFSIterator_new () {return vtkNew < vtkTreeDFSIterator > () ;} extern "C" void vtkTreeDFSIterator_destructor (vtkNew < vtkTreeDFSIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkTreeDFSIterator_get_ptr (vtkNew < vtkTreeDFSIterator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_tree_dfs_iterator_set_mode(vtkNew sself, int mode) { sself->SetMode(mode); } +extern "C" int vtk_tree_dfs_iterator_get_mode(vtkNew sself) { return sself->GetMode(); } extern "C" vtkNew < vtkTriQuadraticHexahedron > vtkTriQuadraticHexahedron_new () {return vtkNew < vtkTriQuadraticHexahedron > () ;} extern "C" void vtkTriQuadraticHexahedron_destructor (vtkNew < vtkTriQuadraticHexahedron > sself) {sself . Reset () ; return ;} extern "C" void * vtkTriQuadraticHexahedron_get_ptr (vtkNew < vtkTriQuadraticHexahedron > sself) {return sself . GetPointer () ;} +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_tri_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_tri_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_tri_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_tri_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_tri_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_tri_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_tri_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_tri_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_tri_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_tri_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" void vtk_tri_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } extern "C" vtkNew < vtkTriQuadraticPyramid > vtkTriQuadraticPyramid_new () {return vtkNew < vtkTriQuadraticPyramid > () ;} extern "C" void vtkTriQuadraticPyramid_destructor (vtkNew < vtkTriQuadraticPyramid > sself) {sself . Reset () ; return ;} extern "C" void * vtkTriQuadraticPyramid_get_ptr (vtkNew < vtkTriQuadraticPyramid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_tri_quadratic_pyramid_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_tri_quadratic_pyramid_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_tri_quadratic_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_tri_quadratic_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_tri_quadratic_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_tri_quadratic_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_tri_quadratic_pyramid_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" double vtk_tri_quadratic_pyramid_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } +extern "C" void vtk_tri_quadratic_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_tri_quadratic_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_tri_quadratic_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_tri_quadratic_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" void vtk_tri_quadratic_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } +extern "C" const long long* vtk_tri_quadratic_pyramid_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_tri_quadratic_pyramid_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } extern "C" vtkNew < vtkTriangle > vtkTriangle_new () {return vtkNew < vtkTriangle > () ;} extern "C" void vtkTriangle_destructor (vtkNew < vtkTriangle > sself) {sself . Reset () ; return ;} extern "C" void * vtkTriangle_get_ptr (vtkNew < vtkTriangle > sself) {return sself . GetPointer () ;} +extern "C" int vtk_triangle_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_triangle_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_triangle_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_triangle_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" void vtk_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" double vtk_triangle_compute_area(vtkNew sself) { return sself->ComputeArea(); } +extern "C" void vtk_triangle_interpolation_functions(vtkNew sself, const double pcoords, double sf) { sself->InterpolationFunctions(pcoords, sf); } +extern "C" void vtk_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_triangle_interpolate_functions(vtkNew sself, const double pcoords, double sf) { sself->InterpolateFunctions(pcoords, sf); } +extern "C" void vtk_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" const long long* vtk_triangle_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" int vtk_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" int vtk_triangle_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" double vtk_triangle_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } +extern "C" void vtk_triangle_triangle_center(vtkNew sself, const double p1, const double p2, const double p3, double center) { sself->TriangleCenter(p1, p2, p3, center); } +extern "C" double vtk_triangle_triangle_area(vtkNew sself, const double p1, const double p2, const double p3) { return sself->TriangleArea(p1, p2, p3); } +extern "C" double vtk_triangle_circumcircle(vtkNew sself, const double p1, const double p2, const double p3, double center) { return sself->Circumcircle(p1, p2, p3, center); } +extern "C" int vtk_triangle_barycentric_coords(vtkNew sself, const double x, const double x1, const double x2, const double x3, double bcoords) { return sself->BarycentricCoords(x, x1, x2, x3, bcoords); } +extern "C" int vtk_triangle_project_to_2_d(vtkNew sself, const double x1, const double x2, const double x3, double v1, double v2, double v3) { return sself->ProjectTo2D(x1, x2, x3, v1, v2, v3); } +extern "C" void vtk_triangle_compute_normal(vtkNew sself, const double v1, const double v2, const double v3, double n) { sself->ComputeNormal(v1, v2, v3, n); } +extern "C" void vtk_triangle_compute_normal_direction(vtkNew sself, const double v1, const double v2, const double v3, double n) { sself->ComputeNormalDirection(v1, v2, v3, n); } +extern "C" int vtk_triangle_triangles_intersect(vtkNew sself, const double p1, const double q1, const double r1, const double p2, const double q2, const double r2) { return sself->TrianglesIntersect(p1, q1, r1, p2, q2, r2); } +extern "C" int vtk_triangle_point_in_triangle(vtkNew sself, const double x, const double x1, const double x2, const double x3, const double tol2) { return sself->PointInTriangle(x, x1, x2, x3, tol2); } +extern "C" void vtk_triangle_compute_quadric(vtkNew sself, const double x1, const double x2, const double x3, double quadric) { sself->ComputeQuadric(x1, x2, x3, quadric); } extern "C" vtkNew < vtkTriangleStrip > vtkTriangleStrip_new () {return vtkNew < vtkTriangleStrip > () ;} extern "C" void vtkTriangleStrip_destructor (vtkNew < vtkTriangleStrip > sself) {sself . Reset () ; return ;} extern "C" void * vtkTriangleStrip_get_ptr (vtkNew < vtkTriangleStrip > sself) {return sself . GetPointer () ;} +extern "C" int vtk_triangle_strip_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_triangle_strip_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_triangle_strip_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_triangle_strip_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_triangle_strip_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_triangle_strip_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_triangle_strip_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_triangle_strip_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_triangle_strip_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } extern "C" vtkNew < vtkUndirectedGraph > vtkUndirectedGraph_new () {return vtkNew < vtkUndirectedGraph > () ;} extern "C" void vtkUndirectedGraph_destructor (vtkNew < vtkUndirectedGraph > sself) {sself . Reset () ; return ;} extern "C" void * vtkUndirectedGraph_get_ptr (vtkNew < vtkUndirectedGraph > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_undirected_graph_get_in_degree(vtkNew sself, long long v) { return sself->GetInDegree(v); } extern "C" vtkNew < vtkUniformGrid > vtkUniformGrid_new () {return vtkNew < vtkUniformGrid > () ;} extern "C" void vtkUniformGrid_destructor (vtkNew < vtkUniformGrid > sself) {sself . Reset () ; return ;} extern "C" void * vtkUniformGrid_get_ptr (vtkNew < vtkUniformGrid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_uniform_grid_get_grid_description(vtkNew sself) { return sself->GetGridDescription(); } +extern "C" void vtk_uniform_grid_blank_point(vtkNew sself, long long ptId) { sself->BlankPoint(ptId); } +extern "C" void vtk_uniform_grid_un_blank_point(vtkNew sself, long long ptId) { sself->UnBlankPoint(ptId); } +extern "C" void vtk_uniform_grid_blank_point(vtkNew sself, const int i, const int j, const int k) { sself->BlankPoint(i, j, k); } +extern "C" void vtk_uniform_grid_un_blank_point(vtkNew sself, const int i, const int j, const int k) { sself->UnBlankPoint(i, j, k); } +extern "C" void vtk_uniform_grid_blank_cell(vtkNew sself, long long ptId) { sself->BlankCell(ptId); } +extern "C" void vtk_uniform_grid_un_blank_cell(vtkNew sself, long long ptId) { sself->UnBlankCell(ptId); } +extern "C" void vtk_uniform_grid_blank_cell(vtkNew sself, const int i, const int j, const int k) { sself->BlankCell(i, j, k); } +extern "C" void vtk_uniform_grid_un_blank_cell(vtkNew sself, const int i, const int j, const int k) { sself->UnBlankCell(i, j, k); } +extern "C" unsigned char vtk_uniform_grid_is_point_visible(vtkNew sself, long long pointId) { return sself->IsPointVisible(pointId); } +extern "C" unsigned char vtk_uniform_grid_is_cell_visible(vtkNew sself, long long cellId) { return sself->IsCellVisible(cellId); } extern "C" vtkNew < vtkUniformGridAMR > vtkUniformGridAMR_new () {return vtkNew < vtkUniformGridAMR > () ;} extern "C" void vtkUniformGridAMR_destructor (vtkNew < vtkUniformGridAMR > sself) {sself . Reset () ; return ;} extern "C" void * vtkUniformGridAMR_get_ptr (vtkNew < vtkUniformGridAMR > sself) {return sself . GetPointer () ;} +extern "C" int vtk_uniform_grid_amr_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_uniform_grid_amr_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_uniform_grid_amr_initialize(vtkNew sself, int numLevels, const int blocksPerLevel) { sself->Initialize(numLevels, blocksPerLevel); } +extern "C" void vtk_uniform_grid_amr_set_grid_description(vtkNew sself, int gridDescription) { sself->SetGridDescription(gridDescription); } +extern "C" int vtk_uniform_grid_amr_get_grid_description(vtkNew sself) { return sself->GetGridDescription(); } +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_levels(vtkNew sself) { return sself->GetNumberOfLevels(); } +extern "C" unsigned int vtk_uniform_grid_amr_get_total_number_of_blocks(vtkNew sself) { return sself->GetTotalNumberOfBlocks(); } +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_data_sets(vtkNew sself, const unsigned int level) { return sself->GetNumberOfDataSets(level); } +extern "C" void vtk_uniform_grid_amr_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } +extern "C" const double* vtk_uniform_grid_amr_get_bounds(vtkNew sself) { return sself->GetBounds(); } +extern "C" void vtk_uniform_grid_amr_get_min(vtkNew sself, double min) { sself->GetMin(min); } +extern "C" void vtk_uniform_grid_amr_get_max(vtkNew sself, double max) { sself->GetMax(max); } +extern "C" int vtk_uniform_grid_amr_get_composite_index(vtkNew sself, const unsigned int level, const unsigned int index) { return sself->GetCompositeIndex(level, index); } +extern "C" void vtk_uniform_grid_amr_get_level_and_index(vtkNew sself, const unsigned int compositeIdx, unsigned int level, unsigned int idx) { sself->GetLevelAndIndex(compositeIdx, level, idx); } extern "C" vtkNew < vtkUniformGridAMRDataIterator > vtkUniformGridAMRDataIterator_new () {return vtkNew < vtkUniformGridAMRDataIterator > () ;} extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkNew < vtkUniformGridAMRDataIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkUniformGridAMRDataIterator_get_ptr (vtkNew < vtkUniformGridAMRDataIterator > sself) {return sself . GetPointer () ;} +extern "C" int vtk_uniform_grid_amr_data_iterator_has_current_meta_data(vtkNew sself) { return sself->HasCurrentMetaData(); } +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_flat_index(vtkNew sself) { return sself->GetCurrentFlatIndex(); } +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_level(vtkNew sself) { return sself->GetCurrentLevel(); } +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_index(vtkNew sself) { return sself->GetCurrentIndex(); } +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_first_item(vtkNew sself) { sself->GoToFirstItem(); } +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_next_item(vtkNew sself) { sself->GoToNextItem(); } +extern "C" int vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } extern "C" vtkNew < vtkUniformHyperTreeGrid > vtkUniformHyperTreeGrid_new () {return vtkNew < vtkUniformHyperTreeGrid > () ;} extern "C" void vtkUniformHyperTreeGrid_destructor (vtkNew < vtkUniformHyperTreeGrid > sself) {sself . Reset () ; return ;} extern "C" void * vtkUniformHyperTreeGrid_get_ptr (vtkNew < vtkUniformHyperTreeGrid > sself) {return sself . GetPointer () ;} +extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkNew sself, const double _arg) { sself->SetOrigin(_arg); } +extern "C" double* vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself) { return sself->GetOrigin(); } +extern "C" void vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself, double _arg) { sself->GetOrigin(_arg); } +extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0, double p1, double p2) { sself->SetGridScale(p0, p1, p2); } +extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0) { sself->SetGridScale(p0); } +extern "C" double* vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself) { return sself->GetGridScale(); } +extern "C" void vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetGridScale(_arg1, _arg2, _arg3); } +extern "C" void vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself, double _arg) { sself->GetGridScale(_arg); } +extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0) { sself->SetGridScale(p0); } +extern "C" void vtk_uniform_hyper_tree_grid_get_level_zero_origin_from_index(vtkNew sself, long long p0, double p1) { sself->GetLevelZeroOriginFromIndex(p0, p1); } +extern "C" unsigned long vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(vtkNew sself) { return sself->GetActualMemorySizeBytes(); } extern "C" vtkNew < vtkUnstructuredGrid > vtkUnstructuredGrid_new () {return vtkNew < vtkUnstructuredGrid > () ;} extern "C" void vtkUnstructuredGrid_destructor (vtkNew < vtkUnstructuredGrid > sself) {sself . Reset () ; return ;} extern "C" void * vtkUnstructuredGrid_get_ptr (vtkNew < vtkUnstructuredGrid > sself) {return sself . GetPointer () ;} +extern "C" int vtk_unstructured_grid_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } +extern "C" bool vtk_unstructured_grid_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } +extern "C" bool vtk_unstructured_grid_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } +extern "C" void vtk_unstructured_grid_allocate(vtkNew sself, long long numCells, int extSize) { sself->Allocate(numCells, extSize); } +extern "C" void vtk_unstructured_grid_reset(vtkNew sself) { sself->Reset(); } +extern "C" int vtk_unstructured_grid_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_unstructured_grid_get_cell_points(vtkNew sself, long long cellId, long long npts, const long long pts) { sself->GetCellPoints(cellId, npts, pts); } +extern "C" void vtk_unstructured_grid_get_point_cells(vtkNew sself, long long ptId, long long ncells, long long cells) { sself->GetPointCells(ptId, ncells, cells); } +extern "C" void vtk_unstructured_grid_get_point_cells(vtkNew sself, long long ptId, unsigned short ncells, long long cells) { sself->GetPointCells(ptId, ncells, cells); } +extern "C" void vtk_unstructured_grid_squeeze(vtkNew sself) { sself->Squeeze(); } +extern "C" void vtk_unstructured_grid_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" int vtk_unstructured_grid_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } +extern "C" void vtk_unstructured_grid_build_links(vtkNew sself) { sself->BuildLinks(); } +extern "C" void vtk_unstructured_grid_get_face_stream(vtkNew sself, long long cellId, long long nfaces, const long long ptIds) { sself->GetFaceStream(cellId, nfaces, ptIds); } +extern "C" bool vtk_unstructured_grid_is_cell_boundary(vtkNew sself, long long cellId, long long npts, const long long ptIds) { return sself->IsCellBoundary(cellId, npts, ptIds); } +extern "C" long long vtk_unstructured_grid_insert_next_linked_cell(vtkNew sself, int type, int npts, const long long pts) { return sself->InsertNextLinkedCell(type, npts, pts); } +extern "C" void vtk_unstructured_grid_remove_reference_to_cell(vtkNew sself, long long ptId, long long cellId) { sself->RemoveReferenceToCell(ptId, cellId); } +extern "C" void vtk_unstructured_grid_add_reference_to_cell(vtkNew sself, long long ptId, long long cellId) { sself->AddReferenceToCell(ptId, cellId); } +extern "C" void vtk_unstructured_grid_resize_cell_list(vtkNew sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } +extern "C" int vtk_unstructured_grid_get_piece(vtkNew sself) { return sself->GetPiece(); } +extern "C" int vtk_unstructured_grid_get_number_of_pieces(vtkNew sself) { return sself->GetNumberOfPieces(); } +extern "C" int vtk_unstructured_grid_get_ghost_level(vtkNew sself) { return sself->GetGhostLevel(); } +extern "C" int vtk_unstructured_grid_is_homogeneous(vtkNew sself) { return sself->IsHomogeneous(); } +extern "C" void vtk_unstructured_grid_remove_ghost_cells(vtkNew sself) { sself->RemoveGhostCells(); } +extern "C" long long* vtk_unstructured_grid_get_faces(vtkNew sself, long long cellId) { return sself->GetFaces(cellId); } +extern "C" int vtk_unstructured_grid_initialize_faces_representation(vtkNew sself, long long numPrevCells) { return sself->InitializeFacesRepresentation(numPrevCells); } +extern "C" unsigned long vtk_unstructured_grid_get_mesh_m_time(vtkNew sself) { return sself->GetMeshMTime(); } +extern "C" void vtk_unstructured_grid_convert_face_stream_point_ids(vtkNew sself, long long nfaces, long long faceStream, long long idMap) { sself->ConvertFaceStreamPointIds(nfaces, faceStream, idMap); } extern "C" vtkNew < vtkUnstructuredGridCellIterator > vtkUnstructuredGridCellIterator_new () {return vtkNew < vtkUnstructuredGridCellIterator > () ;} extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkNew < vtkUnstructuredGridCellIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkUnstructuredGridCellIterator_get_ptr (vtkNew < vtkUnstructuredGridCellIterator > sself) {return sself . GetPointer () ;} +extern "C" bool vtk_unstructured_grid_cell_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_unstructured_grid_cell_iterator_get_cell_id(vtkNew sself) { return sself->GetCellId(); } +extern "C" void vtk_unstructured_grid_cell_iterator_go_to_cell(vtkNew sself, long long cellId) { sself->GoToCell(cellId); } extern "C" vtkNew < vtkVertex > vtkVertex_new () {return vtkNew < vtkVertex > () ;} extern "C" void vtkVertex_destructor (vtkNew < vtkVertex > sself) {sself . Reset () ; return ;} extern "C" void * vtkVertex_get_ptr (vtkNew < vtkVertex > sself) {return sself . GetPointer () ;} +extern "C" int vtk_vertex_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_vertex_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } +extern "C" int vtk_vertex_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_vertex_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_vertex_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_vertex_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_vertex_inflate(vtkNew sself, double p0) { return sself->Inflate(p0); } +extern "C" int vtk_vertex_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" int vtk_vertex_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_vertex_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" void vtk_vertex_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_vertex_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_vertex_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_vertex_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } extern "C" vtkNew < vtkVertexListIterator > vtkVertexListIterator_new () {return vtkNew < vtkVertexListIterator > () ;} extern "C" void vtkVertexListIterator_destructor (vtkNew < vtkVertexListIterator > sself) {sself . Reset () ; return ;} extern "C" void * vtkVertexListIterator_get_ptr (vtkNew < vtkVertexListIterator > sself) {return sself . GetPointer () ;} +extern "C" long long vtk_vertex_list_iterator_next(vtkNew sself) { return sself->Next(); } +extern "C" bool vtk_vertex_list_iterator_has_next(vtkNew sself) { return sself->HasNext(); } extern "C" vtkNew < vtkVoxel > vtkVoxel_new () {return vtkNew < vtkVoxel > () ;} extern "C" void vtkVoxel_destructor (vtkNew < vtkVoxel > sself) {sself . Reset () ; return ;} extern "C" void * vtkVoxel_get_ptr (vtkNew < vtkVoxel > sself) {return sself . GetPointer () ;} +extern "C" void vtk_voxel_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" void vtk_voxel_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" long long vtk_voxel_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_voxel_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_voxel_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } +extern "C" long long vtk_voxel_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faces) { return sself->GetFaceToAdjacentFaces(faceId, faces); } +extern "C" long long vtk_voxel_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edges) { return sself->GetPointToIncidentEdges(pointId, edges); } +extern "C" long long vtk_voxel_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faces) { return sself->GetPointToIncidentFaces(pointId, faces); } +extern "C" long long vtk_voxel_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } +extern "C" bool vtk_voxel_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } +extern "C" double vtk_voxel_compute_bounding_sphere(vtkNew sself, double center) { return sself->ComputeBoundingSphere(center); } +extern "C" int vtk_voxel_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_voxel_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_voxel_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_voxel_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_voxel_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_voxel_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_voxel_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int vtk_voxel_inflate(vtkNew sself, double dist) { return sself->Inflate(dist); } +extern "C" void vtk_voxel_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_voxel_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_voxel_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" void vtk_voxel_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" int* vtk_voxel_get_triangle_cases(vtkNew sself, int caseId) { return sself->GetTriangleCases(caseId); } +extern "C" const long long* vtk_voxel_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_voxel_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" const long long* vtk_voxel_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } +extern "C" const long long* vtk_voxel_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } +extern "C" const long long* vtk_voxel_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } +extern "C" const long long* vtk_voxel_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } +extern "C" const long long* vtk_voxel_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } extern "C" vtkNew < vtkWedge > vtkWedge_new () {return vtkNew < vtkWedge > () ;} extern "C" void vtkWedge_destructor (vtkNew < vtkWedge > sself) {sself . Reset () ; return ;} extern "C" void * vtkWedge_get_ptr (vtkNew < vtkWedge > sself) {return sself . GetPointer () ;} +extern "C" void vtk_wedge_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" void vtk_wedge_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } +extern "C" long long vtk_wedge_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_wedge_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } +extern "C" void vtk_wedge_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } +extern "C" long long vtk_wedge_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } +extern "C" long long vtk_wedge_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } +extern "C" long long vtk_wedge_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } +extern "C" long long vtk_wedge_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } +extern "C" bool vtk_wedge_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } +extern "C" int vtk_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } +extern "C" int vtk_wedge_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_wedge_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } +extern "C" void vtk_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } +extern "C" int vtk_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } +extern "C" void vtk_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } +extern "C" int* vtk_wedge_get_triangle_cases(vtkNew sself, int caseId) { return sself->GetTriangleCases(caseId); } +extern "C" int vtk_wedge_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } +extern "C" void vtk_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } +extern "C" void vtk_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } +extern "C" void vtk_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } +extern "C" void vtk_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } +extern "C" int vtk_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { return sself->JacobianInverse(pcoords, inverse, derivs); } +extern "C" const long long* vtk_wedge_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } +extern "C" const long long* vtk_wedge_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } +extern "C" const long long* vtk_wedge_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } +extern "C" const long long* vtk_wedge_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } +extern "C" const long long* vtk_wedge_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } +extern "C" const long long* vtk_wedge_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } +extern "C" const long long* vtk_wedge_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } extern "C" vtkNew < vtkXMLDataElement > vtkXMLDataElement_new () {return vtkNew < vtkXMLDataElement > () ;} extern "C" void vtkXMLDataElement_destructor (vtkNew < vtkXMLDataElement > sself) {sself . Reset () ; return ;} extern "C" void * vtkXMLDataElement_get_ptr (vtkNew < vtkXMLDataElement > sself) {return sself . GetPointer () ;} +extern "C" char* vtk_xml_data_element_get_name(vtkNew sself) { return sself->GetName(); } +extern "C" void vtk_xml_data_element_set_name(vtkNew sself, const char _arg) { sself->SetName(_arg); } +extern "C" char* vtk_xml_data_element_get_id(vtkNew sself) { return sself->GetId(); } +extern "C" void vtk_xml_data_element_set_id(vtkNew sself, const char _arg) { sself->SetId(_arg); } +extern "C" const char* vtk_xml_data_element_get_attribute(vtkNew sself, const char name) { return sself->GetAttribute(name); } +extern "C" void vtk_xml_data_element_set_attribute(vtkNew sself, const char name, const char value) { sself->SetAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_character_data(vtkNew sself, const char data, int length) { sself->SetCharacterData(data, length); } +extern "C" void vtk_xml_data_element_add_character_data(vtkNew sself, const char c, size_t length) { sself->AddCharacterData(c, length); } +extern "C" char* vtk_xml_data_element_get_character_data(vtkNew sself) { return sself->GetCharacterData(); } +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, int value) { return sself->GetScalarAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, float value) { return sself->GetScalarAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, double value) { return sself->GetScalarAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, long value) { return sself->GetScalarAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, unsigned long value) { return sself->GetScalarAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_int_attribute(vtkNew sself, const char name, int value) { sself->SetIntAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_float_attribute(vtkNew sself, const char name, float value) { sself->SetFloatAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_double_attribute(vtkNew sself, const char name, double value) { sself->SetDoubleAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_unsigned_long_attribute(vtkNew sself, const char name, unsigned long value) { sself->SetUnsignedLongAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, int value) { return sself->GetVectorAttribute(name, length, value); } +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, float value) { return sself->GetVectorAttribute(name, length, value); } +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, double value) { return sself->GetVectorAttribute(name, length, value); } +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, long value) { return sself->GetVectorAttribute(name, length, value); } +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, unsigned long value) { return sself->GetVectorAttribute(name, length, value); } +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const int value) { sself->SetVectorAttribute(name, length, value); } +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const float value) { sself->SetVectorAttribute(name, length, value); } +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const double value) { sself->SetVectorAttribute(name, length, value); } +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const unsigned long value) { sself->SetVectorAttribute(name, length, value); } +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, long long value) { return sself->GetScalarAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, long long value) { return sself->GetVectorAttribute(name, length, value); } +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const long long value) { sself->SetVectorAttribute(name, length, value); } +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, unsigned long long value) { return sself->GetScalarAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, unsigned long long value) { return sself->GetVectorAttribute(name, length, value); } +extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const unsigned long long value) { sself->SetVectorAttribute(name, length, value); } +extern "C" int vtk_xml_data_element_get_word_type_attribute(vtkNew sself, const char name, int value) { return sself->GetWordTypeAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_number_of_attributes(vtkNew sself) { return sself->GetNumberOfAttributes(); } +extern "C" const char* vtk_xml_data_element_get_attribute_name(vtkNew sself, int idx) { return sself->GetAttributeName(idx); } +extern "C" const char* vtk_xml_data_element_get_attribute_value(vtkNew sself, int idx) { return sself->GetAttributeValue(idx); } +extern "C" void vtk_xml_data_element_remove_attribute(vtkNew sself, const char name) { sself->RemoveAttribute(name); } +extern "C" void vtk_xml_data_element_remove_all_attributes(vtkNew sself) { sself->RemoveAllAttributes(); } +extern "C" int vtk_xml_data_element_get_number_of_nested_elements(vtkNew sself) { return sself->GetNumberOfNestedElements(); } +extern "C" void vtk_xml_data_element_remove_all_nested_elements(vtkNew sself) { sself->RemoveAllNestedElements(); } +extern "C" long long vtk_xml_data_element_get_xml_byte_index(vtkNew sself) { return sself->GetXMLByteIndex(); } +extern "C" void vtk_xml_data_element_set_xml_byte_index(vtkNew sself, long long _arg) { sself->SetXMLByteIndex(_arg); } +extern "C" void vtk_xml_data_element_set_attribute_encoding(vtkNew sself, int _arg) { sself->SetAttributeEncoding(_arg); } +extern "C" int vtk_xml_data_element_get_attribute_encoding_min_value(vtkNew sself) { return sself->GetAttributeEncodingMinValue(); } +extern "C" int vtk_xml_data_element_get_attribute_encoding_max_value(vtkNew sself) { return sself->GetAttributeEncodingMaxValue(); } +extern "C" int vtk_xml_data_element_get_attribute_encoding(vtkNew sself) { return sself->GetAttributeEncoding(); } +extern "C" void vtk_xml_data_element_print_xml(vtkNew sself, const char fname) { sself->PrintXML(fname); } +extern "C" int vtk_xml_data_element_get_character_data_width(vtkNew sself) { return sself->GetCharacterDataWidth(); } +extern "C" void vtk_xml_data_element_set_character_data_width(vtkNew sself, int _arg) { sself->SetCharacterDataWidth(_arg); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp index ebd83c3..51babc2 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp @@ -80,9 +80,61 @@ extern "C" vtkNew < vtkAlgorithm > vtkAlgorithm_new () {return vtkNew < vtkAlgorithm > () ;} extern "C" void vtkAlgorithm_destructor (vtkNew < vtkAlgorithm > sself) {sself . Reset () ; return ;} extern "C" void * vtkAlgorithm_get_ptr (vtkNew < vtkAlgorithm > sself) {return sself . GetPointer () ;} +extern "C" int vtk_algorithm_has_executive(vtkNew sself) { return sself->HasExecutive(); } +extern "C" int vtk_algorithm_get_number_of_input_ports(vtkNew sself) { return sself->GetNumberOfInputPorts(); } +extern "C" int vtk_algorithm_get_number_of_output_ports(vtkNew sself) { return sself->GetNumberOfOutputPorts(); } +extern "C" void vtk_algorithm_set_abort_execute(vtkNew sself, int _arg) { sself->SetAbortExecute(_arg); } +extern "C" int vtk_algorithm_get_abort_execute(vtkNew sself) { return sself->GetAbortExecute(); } +extern "C" void vtk_algorithm_abort_execute_on(vtkNew sself) { sself->AbortExecuteOn(); } +extern "C" void vtk_algorithm_abort_execute_off(vtkNew sself) { sself->AbortExecuteOff(); } +extern "C" double vtk_algorithm_get_progress(vtkNew sself) { return sself->GetProgress(); } +extern "C" void vtk_algorithm_set_progress(vtkNew sself, double p0) { sself->SetProgress(p0); } +extern "C" void vtk_algorithm_update_progress(vtkNew sself, double amount) { sself->UpdateProgress(amount); } +extern "C" void vtk_algorithm_set_progress_shift_scale(vtkNew sself, double shift, double scale) { sself->SetProgressShiftScale(shift, scale); } +extern "C" double vtk_algorithm_get_progress_shift(vtkNew sself) { return sself->GetProgressShift(); } +extern "C" double vtk_algorithm_get_progress_scale(vtkNew sself) { return sself->GetProgressScale(); } +extern "C" void vtk_algorithm_set_progress_text(vtkNew sself, const char ptext) { sself->SetProgressText(ptext); } +extern "C" char* vtk_algorithm_get_progress_text(vtkNew sself) { return sself->GetProgressText(); } +extern "C" unsigned long vtk_algorithm_get_error_code(vtkNew sself) { return sself->GetErrorCode(); } +extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, int fieldAssociation, const char name) { sself->SetInputArrayToProcess(idx, port, connection, fieldAssociation, name); } +extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, int fieldAssociation, int fieldAttributeType) { sself->SetInputArrayToProcess(idx, port, connection, fieldAssociation, fieldAttributeType); } +extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, const char fieldAssociation, const char attributeTypeorName) { sself->SetInputArrayToProcess(idx, port, connection, fieldAssociation, attributeTypeorName); } +extern "C" void vtk_algorithm_remove_all_inputs(vtkNew sself) { sself->RemoveAllInputs(); } +extern "C" void vtk_algorithm_remove_input_connection(vtkNew sself, int port, int idx) { sself->RemoveInputConnection(port, idx); } +extern "C" void vtk_algorithm_remove_all_input_connections(vtkNew sself, int port) { sself->RemoveAllInputConnections(port); } +extern "C" int vtk_algorithm_get_number_of_input_connections(vtkNew sself, int port) { return sself->GetNumberOfInputConnections(port); } +extern "C" int vtk_algorithm_get_total_number_of_input_connections(vtkNew sself) { return sself->GetTotalNumberOfInputConnections(); } +extern "C" void vtk_algorithm_update(vtkNew sself, int port) { sself->Update(port); } +extern "C" void vtk_algorithm_update(vtkNew sself) { sself->Update(); } +extern "C" int vtk_algorithm_update_piece(vtkNew sself, int piece, int numPieces, int ghostLevels, const int extents) { return sself->UpdatePiece(piece, numPieces, ghostLevels, extents); } +extern "C" int vtk_algorithm_update_extent(vtkNew sself, const int extents) { return sself->UpdateExtent(extents); } +extern "C" int vtk_algorithm_update_time_step(vtkNew sself, double time, int piece, int numPieces, int ghostLevels, const int extents) { return sself->UpdateTimeStep(time, piece, numPieces, ghostLevels, extents); } +extern "C" void vtk_algorithm_update_information(vtkNew sself) { sself->UpdateInformation(); } +extern "C" void vtk_algorithm_update_data_object(vtkNew sself) { sself->UpdateDataObject(); } +extern "C" void vtk_algorithm_propagate_update_extent(vtkNew sself) { sself->PropagateUpdateExtent(); } +extern "C" void vtk_algorithm_update_whole_extent(vtkNew sself) { sself->UpdateWholeExtent(); } +extern "C" void vtk_algorithm_convert_total_input_to_port_connection(vtkNew sself, int ind, int port, int conn) { sself->ConvertTotalInputToPortConnection(ind, port, conn); } +extern "C" void vtk_algorithm_set_release_data_flag(vtkNew sself, int p0) { sself->SetReleaseDataFlag(p0); } +extern "C" int vtk_algorithm_get_release_data_flag(vtkNew sself) { return sself->GetReleaseDataFlag(); } +extern "C" void vtk_algorithm_release_data_flag_on(vtkNew sself) { sself->ReleaseDataFlagOn(); } +extern "C" void vtk_algorithm_release_data_flag_off(vtkNew sself) { sself->ReleaseDataFlagOff(); } +extern "C" int* vtk_algorithm_get_update_extent(vtkNew sself) { return sself->GetUpdateExtent(); } +extern "C" int* vtk_algorithm_get_update_extent(vtkNew sself, int port) { return sself->GetUpdateExtent(port); } +extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1) { sself->GetUpdateExtent(x0, x1, y0, y1, z0, z1); } +extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int port, int x0, int x1, int y0, int y1, int z0, int z1) { sself->GetUpdateExtent(port, x0, x1, y0, y1, z0, z1); } +extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int extent) { sself->GetUpdateExtent(extent); } +extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int port, int extent) { sself->GetUpdateExtent(port, extent); } +extern "C" int vtk_algorithm_get_update_piece(vtkNew sself) { return sself->GetUpdatePiece(); } +extern "C" int vtk_algorithm_get_update_piece(vtkNew sself, int port) { return sself->GetUpdatePiece(port); } +extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkNew sself) { return sself->GetUpdateNumberOfPieces(); } +extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkNew sself, int port) { return sself->GetUpdateNumberOfPieces(port); } +extern "C" int vtk_algorithm_get_update_ghost_level(vtkNew sself) { return sself->GetUpdateGhostLevel(); } +extern "C" int vtk_algorithm_get_update_ghost_level(vtkNew sself, int port) { return sself->GetUpdateGhostLevel(port); } extern "C" vtkNew < vtkAlgorithmOutput > vtkAlgorithmOutput_new () {return vtkNew < vtkAlgorithmOutput > () ;} extern "C" void vtkAlgorithmOutput_destructor (vtkNew < vtkAlgorithmOutput > sself) {sself . Reset () ; return ;} extern "C" void * vtkAlgorithmOutput_get_ptr (vtkNew < vtkAlgorithmOutput > sself) {return sself . GetPointer () ;} +extern "C" void vtk_algorithm_output_set_index(vtkNew sself, int index) { sself->SetIndex(index); } +extern "C" int vtk_algorithm_output_get_index(vtkNew sself) { return sself->GetIndex(); } extern "C" vtkNew < vtkAnnotationLayersAlgorithm > vtkAnnotationLayersAlgorithm_new () {return vtkNew < vtkAnnotationLayersAlgorithm > () ;} extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkNew < vtkAnnotationLayersAlgorithm > sself) {sself . Reset () ; return ;} extern "C" void * vtkAnnotationLayersAlgorithm_get_ptr (vtkNew < vtkAnnotationLayersAlgorithm > sself) {return sself . GetPointer () ;} @@ -92,6 +144,8 @@ extern "C" void * vtkArrayDataAlgorithm_get_ptr (vtkNew < vtkArrayDataAlgorithm extern "C" vtkNew < vtkCachedStreamingDemandDrivenPipeline > vtkCachedStreamingDemandDrivenPipeline_new () {return vtkNew < vtkCachedStreamingDemandDrivenPipeline > () ;} extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) {sself . Reset () ; return ;} extern "C" void * vtkCachedStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) {return sself . GetPointer () ;} +extern "C" void vtk_cached_streaming_demand_driven_pipeline_set_cache_size(vtkNew sself, int size) { sself->SetCacheSize(size); } +extern "C" int vtk_cached_streaming_demand_driven_pipeline_get_cache_size(vtkNew sself) { return sself->GetCacheSize(); } extern "C" vtkNew < vtkCastToConcrete > vtkCastToConcrete_new () {return vtkNew < vtkCastToConcrete > () ;} extern "C" void vtkCastToConcrete_destructor (vtkNew < vtkCastToConcrete > sself) {sself . Reset () ; return ;} extern "C" void * vtkCastToConcrete_get_ptr (vtkNew < vtkCastToConcrete > sself) {return sself . GetPointer () ;} @@ -110,24 +164,86 @@ extern "C" void * vtkDataSetAlgorithm_get_ptr (vtkNew < vtkDataSetAlgorithm > ss extern "C" vtkNew < vtkDemandDrivenPipeline > vtkDemandDrivenPipeline_new () {return vtkNew < vtkDemandDrivenPipeline > () ;} extern "C" void vtkDemandDrivenPipeline_destructor (vtkNew < vtkDemandDrivenPipeline > sself) {sself . Reset () ; return ;} extern "C" void * vtkDemandDrivenPipeline_get_ptr (vtkNew < vtkDemandDrivenPipeline > sself) {return sself . GetPointer () ;} +extern "C" unsigned long vtk_demand_driven_pipeline_get_pipeline_m_time(vtkNew sself) { return sself->GetPipelineMTime(); } +extern "C" int vtk_demand_driven_pipeline_set_release_data_flag(vtkNew sself, int port, int n) { return sself->SetReleaseDataFlag(port, n); } +extern "C" int vtk_demand_driven_pipeline_get_release_data_flag(vtkNew sself, int port) { return sself->GetReleaseDataFlag(port); } +extern "C" int vtk_demand_driven_pipeline_update_pipeline_m_time(vtkNew sself) { return sself->UpdatePipelineMTime(); } +extern "C" int vtk_demand_driven_pipeline_update_data_object(vtkNew sself) { return sself->UpdateDataObject(); } +extern "C" int vtk_demand_driven_pipeline_update_data(vtkNew sself, int outputPort) { return sself->UpdateData(outputPort); } extern "C" vtkNew < vtkDirectedGraphAlgorithm > vtkDirectedGraphAlgorithm_new () {return vtkNew < vtkDirectedGraphAlgorithm > () ;} extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkNew < vtkDirectedGraphAlgorithm > sself) {sself . Reset () ; return ;} extern "C" void * vtkDirectedGraphAlgorithm_get_ptr (vtkNew < vtkDirectedGraphAlgorithm > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkEnsembleSource > vtkEnsembleSource_new () {return vtkNew < vtkEnsembleSource > () ;} extern "C" void vtkEnsembleSource_destructor (vtkNew < vtkEnsembleSource > sself) {sself . Reset () ; return ;} extern "C" void * vtkEnsembleSource_get_ptr (vtkNew < vtkEnsembleSource > sself) {return sself . GetPointer () ;} +extern "C" void vtk_ensemble_source_remove_all_members(vtkNew sself) { sself->RemoveAllMembers(); } +extern "C" unsigned int vtk_ensemble_source_get_number_of_members(vtkNew sself) { return sself->GetNumberOfMembers(); } +extern "C" void vtk_ensemble_source_set_current_member(vtkNew sself, unsigned int _arg) { sself->SetCurrentMember(_arg); } +extern "C" unsigned int vtk_ensemble_source_get_current_member(vtkNew sself) { return sself->GetCurrentMember(); } extern "C" vtkNew < vtkExplicitStructuredGridAlgorithm > vtkExplicitStructuredGridAlgorithm_new () {return vtkNew < vtkExplicitStructuredGridAlgorithm > () ;} extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) {sself . Reset () ; return ;} extern "C" void * vtkExplicitStructuredGridAlgorithm_get_ptr (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkExtentRCBPartitioner > vtkExtentRCBPartitioner_new () {return vtkNew < vtkExtentRCBPartitioner > () ;} extern "C" void vtkExtentRCBPartitioner_destructor (vtkNew < vtkExtentRCBPartitioner > sself) {sself . Reset () ; return ;} extern "C" void * vtkExtentRCBPartitioner_get_ptr (vtkNew < vtkExtentRCBPartitioner > sself) {return sself . GetPointer () ;} +extern "C" void vtk_extent_rcb_partitioner_set_number_of_partitions(vtkNew sself, const int N) { sself->SetNumberOfPartitions(N); } +extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkNew sself, int imin, int imax, int jmin, int jmax, int kmin, int kmax) { sself->SetGlobalExtent(imin, imax, jmin, jmax, kmin, kmax); } +extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkNew sself, int ext) { sself->SetGlobalExtent(ext); } +extern "C" void vtk_extent_rcb_partitioner_set_duplicate_nodes(vtkNew sself, int _arg) { sself->SetDuplicateNodes(_arg); } +extern "C" int vtk_extent_rcb_partitioner_get_duplicate_nodes(vtkNew sself) { return sself->GetDuplicateNodes(); } +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_on(vtkNew sself) { sself->DuplicateNodesOn(); } +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_off(vtkNew sself) { sself->DuplicateNodesOff(); } +extern "C" void vtk_extent_rcb_partitioner_set_number_of_ghost_layers(vtkNew sself, int _arg) { sself->SetNumberOfGhostLayers(_arg); } +extern "C" int vtk_extent_rcb_partitioner_get_number_of_ghost_layers(vtkNew sself) { return sself->GetNumberOfGhostLayers(); } +extern "C" int vtk_extent_rcb_partitioner_get_num_extents(vtkNew sself) { return sself->GetNumExtents(); } +extern "C" void vtk_extent_rcb_partitioner_partition(vtkNew sself) { sself->Partition(); } +extern "C" void vtk_extent_rcb_partitioner_get_partition_extent(vtkNew sself, const int idx, int ext) { sself->GetPartitionExtent(idx, ext); } extern "C" vtkNew < vtkExtentSplitter > vtkExtentSplitter_new () {return vtkNew < vtkExtentSplitter > () ;} extern "C" void vtkExtentSplitter_destructor (vtkNew < vtkExtentSplitter > sself) {sself . Reset () ; return ;} extern "C" void * vtkExtentSplitter_get_ptr (vtkNew < vtkExtentSplitter > sself) {return sself . GetPointer () ;} +extern "C" void vtk_extent_splitter_add_extent_source(vtkNew sself, int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1) { sself->AddExtentSource(id, priority, x0, x1, y0, y1, z0, z1); } +extern "C" void vtk_extent_splitter_add_extent_source(vtkNew sself, int id, int priority, int extent) { sself->AddExtentSource(id, priority, extent); } +extern "C" void vtk_extent_splitter_remove_extent_source(vtkNew sself, int id) { sself->RemoveExtentSource(id); } +extern "C" void vtk_extent_splitter_remove_all_extent_sources(vtkNew sself) { sself->RemoveAllExtentSources(); } +extern "C" void vtk_extent_splitter_add_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1) { sself->AddExtent(x0, x1, y0, y1, z0, z1); } +extern "C" void vtk_extent_splitter_add_extent(vtkNew sself, int extent) { sself->AddExtent(extent); } +extern "C" int vtk_extent_splitter_compute_sub_extents(vtkNew sself) { return sself->ComputeSubExtents(); } +extern "C" int vtk_extent_splitter_get_number_of_sub_extents(vtkNew sself) { return sself->GetNumberOfSubExtents(); } +extern "C" int* vtk_extent_splitter_get_sub_extent(vtkNew sself, int index) { return sself->GetSubExtent(index); } +extern "C" void vtk_extent_splitter_get_sub_extent(vtkNew sself, int index, int extent) { sself->GetSubExtent(index, extent); } +extern "C" int vtk_extent_splitter_get_sub_extent_source(vtkNew sself, int index) { return sself->GetSubExtentSource(index); } +extern "C" int vtk_extent_splitter_get_point_mode(vtkNew sself) { return sself->GetPointMode(); } +extern "C" void vtk_extent_splitter_set_point_mode(vtkNew sself, int _arg) { sself->SetPointMode(_arg); } +extern "C" void vtk_extent_splitter_point_mode_on(vtkNew sself) { sself->PointModeOn(); } +extern "C" void vtk_extent_splitter_point_mode_off(vtkNew sself) { sself->PointModeOff(); } extern "C" vtkNew < vtkExtentTranslator > vtkExtentTranslator_new () {return vtkNew < vtkExtentTranslator > () ;} extern "C" void vtkExtentTranslator_destructor (vtkNew < vtkExtentTranslator > sself) {sself . Reset () ; return ;} extern "C" void * vtkExtentTranslator_get_ptr (vtkNew < vtkExtentTranslator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_extent_translator_set_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_extent_translator_set_whole_extent(vtkNew sself, const int _arg) { sself->SetWholeExtent(_arg); } +extern "C" int* vtk_extent_translator_get_whole_extent(vtkNew sself) { return sself->GetWholeExtent(); } +extern "C" void vtk_extent_translator_get_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_extent_translator_get_whole_extent(vtkNew sself, int _arg) { sself->GetWholeExtent(_arg); } +extern "C" void vtk_extent_translator_set_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_extent_translator_set_extent(vtkNew sself, const int _arg) { sself->SetExtent(_arg); } +extern "C" int* vtk_extent_translator_get_extent(vtkNew sself) { return sself->GetExtent(); } +extern "C" void vtk_extent_translator_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_extent_translator_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } +extern "C" void vtk_extent_translator_set_piece(vtkNew sself, int _arg) { sself->SetPiece(_arg); } +extern "C" int vtk_extent_translator_get_piece(vtkNew sself) { return sself->GetPiece(); } +extern "C" void vtk_extent_translator_set_number_of_pieces(vtkNew sself, int _arg) { sself->SetNumberOfPieces(_arg); } +extern "C" int vtk_extent_translator_get_number_of_pieces(vtkNew sself) { return sself->GetNumberOfPieces(); } +extern "C" void vtk_extent_translator_set_ghost_level(vtkNew sself, int _arg) { sself->SetGhostLevel(_arg); } +extern "C" int vtk_extent_translator_get_ghost_level(vtkNew sself) { return sself->GetGhostLevel(); } +extern "C" int vtk_extent_translator_piece_to_extent(vtkNew sself) { return sself->PieceToExtent(); } +extern "C" int vtk_extent_translator_piece_to_extent_by_points(vtkNew sself) { return sself->PieceToExtentByPoints(); } +extern "C" int vtk_extent_translator_piece_to_extent_thread_safe(vtkNew sself, int piece, int numPieces, int ghostLevel, int wholeExtent, int resultExtent, int splitMode, int byPoints) { return sself->PieceToExtentThreadSafe(piece, numPieces, ghostLevel, wholeExtent, resultExtent, splitMode, byPoints); } +extern "C" void vtk_extent_translator_set_split_mode_to_block(vtkNew sself) { sself->SetSplitModeToBlock(); } +extern "C" void vtk_extent_translator_set_split_mode_to_x_slab(vtkNew sself) { sself->SetSplitModeToXSlab(); } +extern "C" void vtk_extent_translator_set_split_mode_to_y_slab(vtkNew sself) { sself->SetSplitModeToYSlab(); } +extern "C" void vtk_extent_translator_set_split_mode_to_z_slab(vtkNew sself) { sself->SetSplitModeToZSlab(); } +extern "C" int vtk_extent_translator_get_split_mode(vtkNew sself) { return sself->GetSplitMode(); } +extern "C" void vtk_extent_translator_set_split_path(vtkNew sself, int len, int splitpath) { sself->SetSplitPath(len, splitpath); } extern "C" vtkNew < vtkGraphAlgorithm > vtkGraphAlgorithm_new () {return vtkNew < vtkGraphAlgorithm > () ;} extern "C" void vtkGraphAlgorithm_destructor (vtkNew < vtkGraphAlgorithm > sself) {sself . Reset () ; return ;} extern "C" void * vtkGraphAlgorithm_get_ptr (vtkNew < vtkGraphAlgorithm > sself) {return sself . GetPointer () ;} @@ -164,6 +280,14 @@ extern "C" void * vtkPiecewiseFunctionAlgorithm_get_ptr (vtkNew < vtkPiecewiseFu extern "C" vtkNew < vtkPiecewiseFunctionShiftScale > vtkPiecewiseFunctionShiftScale_new () {return vtkNew < vtkPiecewiseFunctionShiftScale > () ;} extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkNew < vtkPiecewiseFunctionShiftScale > sself) {sself . Reset () ; return ;} extern "C" void * vtkPiecewiseFunctionShiftScale_get_ptr (vtkNew < vtkPiecewiseFunctionShiftScale > sself) {return sself . GetPointer () ;} +extern "C" void vtk_piecewise_function_shift_scale_set_position_shift(vtkNew sself, double _arg) { sself->SetPositionShift(_arg); } +extern "C" void vtk_piecewise_function_shift_scale_set_position_scale(vtkNew sself, double _arg) { sself->SetPositionScale(_arg); } +extern "C" void vtk_piecewise_function_shift_scale_set_value_shift(vtkNew sself, double _arg) { sself->SetValueShift(_arg); } +extern "C" void vtk_piecewise_function_shift_scale_set_value_scale(vtkNew sself, double _arg) { sself->SetValueScale(_arg); } +extern "C" double vtk_piecewise_function_shift_scale_get_position_shift(vtkNew sself) { return sself->GetPositionShift(); } +extern "C" double vtk_piecewise_function_shift_scale_get_position_scale(vtkNew sself) { return sself->GetPositionScale(); } +extern "C" double vtk_piecewise_function_shift_scale_get_value_shift(vtkNew sself) { return sself->GetValueShift(); } +extern "C" double vtk_piecewise_function_shift_scale_get_value_scale(vtkNew sself) { return sself->GetValueScale(); } extern "C" vtkNew < vtkPointSetAlgorithm > vtkPointSetAlgorithm_new () {return vtkNew < vtkPointSetAlgorithm > () ;} extern "C" void vtkPointSetAlgorithm_destructor (vtkNew < vtkPointSetAlgorithm > sself) {sself . Reset () ; return ;} extern "C" void * vtkPointSetAlgorithm_get_ptr (vtkNew < vtkPointSetAlgorithm > sself) {return sself . GetPointer () ;} @@ -173,6 +297,8 @@ extern "C" void * vtkPolyDataAlgorithm_get_ptr (vtkNew < vtkPolyDataAlgorithm > extern "C" vtkNew < vtkProgressObserver > vtkProgressObserver_new () {return vtkNew < vtkProgressObserver > () ;} extern "C" void vtkProgressObserver_destructor (vtkNew < vtkProgressObserver > sself) {sself . Reset () ; return ;} extern "C" void * vtkProgressObserver_get_ptr (vtkNew < vtkProgressObserver > sself) {return sself . GetPointer () ;} +extern "C" void vtk_progress_observer_update_progress(vtkNew sself, double amount) { sself->UpdateProgress(amount); } +extern "C" double vtk_progress_observer_get_progress(vtkNew sself) { return sself->GetProgress(); } extern "C" vtkNew < vtkReaderExecutive > vtkReaderExecutive_new () {return vtkNew < vtkReaderExecutive > () ;} extern "C" void vtkReaderExecutive_destructor (vtkNew < vtkReaderExecutive > sself) {sself . Reset () ; return ;} extern "C" void * vtkReaderExecutive_get_ptr (vtkNew < vtkReaderExecutive > sself) {return sself . GetPointer () ;} @@ -182,21 +308,91 @@ extern "C" void * vtkRectilinearGridAlgorithm_get_ptr (vtkNew < vtkRectilinearGr extern "C" vtkNew < vtkSMPProgressObserver > vtkSMPProgressObserver_new () {return vtkNew < vtkSMPProgressObserver > () ;} extern "C" void vtkSMPProgressObserver_destructor (vtkNew < vtkSMPProgressObserver > sself) {sself . Reset () ; return ;} extern "C" void * vtkSMPProgressObserver_get_ptr (vtkNew < vtkSMPProgressObserver > sself) {return sself . GetPointer () ;} +extern "C" void vtk_smp_progress_observer_update_progress(vtkNew sself, double progress) { sself->UpdateProgress(progress); } extern "C" vtkNew < vtkSelectionAlgorithm > vtkSelectionAlgorithm_new () {return vtkNew < vtkSelectionAlgorithm > () ;} extern "C" void vtkSelectionAlgorithm_destructor (vtkNew < vtkSelectionAlgorithm > sself) {sself . Reset () ; return ;} extern "C" void * vtkSelectionAlgorithm_get_ptr (vtkNew < vtkSelectionAlgorithm > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkSimpleScalarTree > vtkSimpleScalarTree_new () {return vtkNew < vtkSimpleScalarTree > () ;} extern "C" void vtkSimpleScalarTree_destructor (vtkNew < vtkSimpleScalarTree > sself) {sself . Reset () ; return ;} extern "C" void * vtkSimpleScalarTree_get_ptr (vtkNew < vtkSimpleScalarTree > sself) {return sself . GetPointer () ;} +extern "C" void vtk_simple_scalar_tree_set_branching_factor(vtkNew sself, int _arg) { sself->SetBranchingFactor(_arg); } +extern "C" int vtk_simple_scalar_tree_get_branching_factor_min_value(vtkNew sself) { return sself->GetBranchingFactorMinValue(); } +extern "C" int vtk_simple_scalar_tree_get_branching_factor_max_value(vtkNew sself) { return sself->GetBranchingFactorMaxValue(); } +extern "C" int vtk_simple_scalar_tree_get_branching_factor(vtkNew sself) { return sself->GetBranchingFactor(); } +extern "C" int vtk_simple_scalar_tree_get_level(vtkNew sself) { return sself->GetLevel(); } +extern "C" void vtk_simple_scalar_tree_set_max_level(vtkNew sself, int _arg) { sself->SetMaxLevel(_arg); } +extern "C" int vtk_simple_scalar_tree_get_max_level_min_value(vtkNew sself) { return sself->GetMaxLevelMinValue(); } +extern "C" int vtk_simple_scalar_tree_get_max_level_max_value(vtkNew sself) { return sself->GetMaxLevelMaxValue(); } +extern "C" int vtk_simple_scalar_tree_get_max_level(vtkNew sself) { return sself->GetMaxLevel(); } +extern "C" void vtk_simple_scalar_tree_build_tree(vtkNew sself) { sself->BuildTree(); } +extern "C" void vtk_simple_scalar_tree_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_simple_scalar_tree_init_traversal(vtkNew sself, double scalarValue) { sself->InitTraversal(scalarValue); } +extern "C" long long vtk_simple_scalar_tree_get_number_of_cell_batches(vtkNew sself, double scalarValue) { return sself->GetNumberOfCellBatches(scalarValue); } +extern "C" const long long* vtk_simple_scalar_tree_get_cell_batch(vtkNew sself, long long batchNum, long long numCells) { return sself->GetCellBatch(batchNum, numCells); } extern "C" vtkNew < vtkSpanSpace > vtkSpanSpace_new () {return vtkNew < vtkSpanSpace > () ;} extern "C" void vtkSpanSpace_destructor (vtkNew < vtkSpanSpace > sself) {sself . Reset () ; return ;} extern "C" void * vtkSpanSpace_get_ptr (vtkNew < vtkSpanSpace > sself) {return sself . GetPointer () ;} +extern "C" void vtk_span_space_set_scalar_range(vtkNew sself, double _arg1, double _arg2) { sself->SetScalarRange(_arg1, _arg2); } +extern "C" void vtk_span_space_set_scalar_range(vtkNew sself, const double _arg) { sself->SetScalarRange(_arg); } +extern "C" double* vtk_span_space_get_scalar_range(vtkNew sself) { return sself->GetScalarRange(); } +extern "C" void vtk_span_space_get_scalar_range(vtkNew sself, double data) { sself->GetScalarRange(data); } +extern "C" void vtk_span_space_set_compute_scalar_range(vtkNew sself, int _arg) { sself->SetComputeScalarRange(_arg); } +extern "C" int vtk_span_space_get_compute_scalar_range(vtkNew sself) { return sself->GetComputeScalarRange(); } +extern "C" void vtk_span_space_compute_scalar_range_on(vtkNew sself) { sself->ComputeScalarRangeOn(); } +extern "C" void vtk_span_space_compute_scalar_range_off(vtkNew sself) { sself->ComputeScalarRangeOff(); } +extern "C" void vtk_span_space_set_resolution(vtkNew sself, long long _arg) { sself->SetResolution(_arg); } +extern "C" long long vtk_span_space_get_resolution_min_value(vtkNew sself) { return sself->GetResolutionMinValue(); } +extern "C" long long vtk_span_space_get_resolution_max_value(vtkNew sself) { return sself->GetResolutionMaxValue(); } +extern "C" long long vtk_span_space_get_resolution(vtkNew sself) { return sself->GetResolution(); } +extern "C" void vtk_span_space_set_compute_resolution(vtkNew sself, int _arg) { sself->SetComputeResolution(_arg); } +extern "C" int vtk_span_space_get_compute_resolution(vtkNew sself) { return sself->GetComputeResolution(); } +extern "C" void vtk_span_space_compute_resolution_on(vtkNew sself) { sself->ComputeResolutionOn(); } +extern "C" void vtk_span_space_compute_resolution_off(vtkNew sself) { sself->ComputeResolutionOff(); } +extern "C" void vtk_span_space_set_number_of_cells_per_bucket(vtkNew sself, int _arg) { sself->SetNumberOfCellsPerBucket(_arg); } +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_min_value(vtkNew sself) { return sself->GetNumberOfCellsPerBucketMinValue(); } +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_max_value(vtkNew sself) { return sself->GetNumberOfCellsPerBucketMaxValue(); } +extern "C" int vtk_span_space_get_number_of_cells_per_bucket(vtkNew sself) { return sself->GetNumberOfCellsPerBucket(); } +extern "C" void vtk_span_space_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_span_space_build_tree(vtkNew sself) { sself->BuildTree(); } +extern "C" void vtk_span_space_init_traversal(vtkNew sself, double scalarValue) { sself->InitTraversal(scalarValue); } +extern "C" long long vtk_span_space_get_number_of_cell_batches(vtkNew sself, double scalarValue) { return sself->GetNumberOfCellBatches(scalarValue); } +extern "C" const long long* vtk_span_space_get_cell_batch(vtkNew sself, long long batchNum, long long numCells) { return sself->GetCellBatch(batchNum, numCells); } +extern "C" void vtk_span_space_set_batch_size(vtkNew sself, long long _arg) { sself->SetBatchSize(_arg); } +extern "C" long long vtk_span_space_get_batch_size_min_value(vtkNew sself) { return sself->GetBatchSizeMinValue(); } +extern "C" long long vtk_span_space_get_batch_size_max_value(vtkNew sself) { return sself->GetBatchSizeMaxValue(); } +extern "C" long long vtk_span_space_get_batch_size(vtkNew sself) { return sself->GetBatchSize(); } extern "C" vtkNew < vtkSphereTree > vtkSphereTree_new () {return vtkNew < vtkSphereTree > () ;} extern "C" void vtkSphereTree_destructor (vtkNew < vtkSphereTree > sself) {sself . Reset () ; return ;} extern "C" void * vtkSphereTree_get_ptr (vtkNew < vtkSphereTree > sself) {return sself . GetPointer () ;} +extern "C" void vtk_sphere_tree_build(vtkNew sself) { sself->Build(); } +extern "C" void vtk_sphere_tree_set_build_hierarchy(vtkNew sself, bool _arg) { sself->SetBuildHierarchy(_arg); } +extern "C" bool vtk_sphere_tree_get_build_hierarchy(vtkNew sself) { return sself->GetBuildHierarchy(); } +extern "C" void vtk_sphere_tree_build_hierarchy_on(vtkNew sself) { sself->BuildHierarchyOn(); } +extern "C" void vtk_sphere_tree_build_hierarchy_off(vtkNew sself) { sself->BuildHierarchyOff(); } +extern "C" const unsigned char* vtk_sphere_tree_select_point(vtkNew sself, double point, long long numSelected) { return sself->SelectPoint(point, numSelected); } +extern "C" const unsigned char* vtk_sphere_tree_select_line(vtkNew sself, double origin, double ray, long long numSelected) { return sself->SelectLine(origin, ray, numSelected); } +extern "C" const unsigned char* vtk_sphere_tree_select_plane(vtkNew sself, double origin, double normal, long long numSelected) { return sself->SelectPlane(origin, normal, numSelected); } +extern "C" void vtk_sphere_tree_set_resolution(vtkNew sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_sphere_tree_get_resolution_min_value(vtkNew sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_sphere_tree_get_resolution_max_value(vtkNew sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_sphere_tree_get_resolution(vtkNew sself) { return sself->GetResolution(); } +extern "C" void vtk_sphere_tree_set_max_level(vtkNew sself, int _arg) { sself->SetMaxLevel(_arg); } +extern "C" int vtk_sphere_tree_get_max_level_min_value(vtkNew sself) { return sself->GetMaxLevelMinValue(); } +extern "C" int vtk_sphere_tree_get_max_level_max_value(vtkNew sself) { return sself->GetMaxLevelMaxValue(); } +extern "C" int vtk_sphere_tree_get_max_level(vtkNew sself) { return sself->GetMaxLevel(); } +extern "C" int vtk_sphere_tree_get_number_of_levels(vtkNew sself) { return sself->GetNumberOfLevels(); } +extern "C" const double* vtk_sphere_tree_get_cell_spheres(vtkNew sself) { return sself->GetCellSpheres(); } +extern "C" const double* vtk_sphere_tree_get_tree_spheres(vtkNew sself, int level, long long numSpheres) { return sself->GetTreeSpheres(level, numSpheres); } extern "C" vtkNew < vtkStreamingDemandDrivenPipeline > vtkStreamingDemandDrivenPipeline_new () {return vtkNew < vtkStreamingDemandDrivenPipeline > () ;} extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkNew < vtkStreamingDemandDrivenPipeline > sself) {sself . Reset () ; return ;} extern "C" void * vtkStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkStreamingDemandDrivenPipeline > sself) {return sself . GetPointer () ;} +extern "C" int vtk_streaming_demand_driven_pipeline_update(vtkNew sself) { return sself->Update(); } +extern "C" int vtk_streaming_demand_driven_pipeline_update_whole_extent(vtkNew sself) { return sself->UpdateWholeExtent(); } +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_update_extent(vtkNew sself, int outputPort) { return sself->PropagateUpdateExtent(outputPort); } +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_time(vtkNew sself, int outputPort) { return sself->PropagateTime(outputPort); } +extern "C" int vtk_streaming_demand_driven_pipeline_update_time_dependent_information(vtkNew sself, int outputPort) { return sself->UpdateTimeDependentInformation(outputPort); } +extern "C" int vtk_streaming_demand_driven_pipeline_set_request_exact_extent(vtkNew sself, int port, int flag) { return sself->SetRequestExactExtent(port, flag); } +extern "C" int vtk_streaming_demand_driven_pipeline_get_request_exact_extent(vtkNew sself, int port) { return sself->GetRequestExactExtent(port); } extern "C" vtkNew < vtkStructuredGridAlgorithm > vtkStructuredGridAlgorithm_new () {return vtkNew < vtkStructuredGridAlgorithm > () ;} extern "C" void vtkStructuredGridAlgorithm_destructor (vtkNew < vtkStructuredGridAlgorithm > sself) {sself . Reset () ; return ;} extern "C" void * vtkStructuredGridAlgorithm_get_ptr (vtkNew < vtkStructuredGridAlgorithm > sself) {return sself . GetPointer () ;} @@ -215,6 +411,12 @@ extern "C" void * vtkTrivialConsumer_get_ptr (vtkNew < vtkTrivialConsumer > ssel extern "C" vtkNew < vtkTrivialProducer > vtkTrivialProducer_new () {return vtkNew < vtkTrivialProducer > () ;} extern "C" void vtkTrivialProducer_destructor (vtkNew < vtkTrivialProducer > sself) {sself . Reset () ; return ;} extern "C" void * vtkTrivialProducer_get_ptr (vtkNew < vtkTrivialProducer > sself) {return sself . GetPointer () ;} +extern "C" unsigned long vtk_trivial_producer_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_trivial_producer_set_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_trivial_producer_set_whole_extent(vtkNew sself, const int _arg) { sself->SetWholeExtent(_arg); } +extern "C" int* vtk_trivial_producer_get_whole_extent(vtkNew sself) { return sself->GetWholeExtent(); } +extern "C" void vtk_trivial_producer_get_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_trivial_producer_get_whole_extent(vtkNew sself, int _arg) { sself->GetWholeExtent(_arg); } extern "C" vtkNew < vtkUndirectedGraphAlgorithm > vtkUndirectedGraphAlgorithm_new () {return vtkNew < vtkUndirectedGraphAlgorithm > () ;} extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkNew < vtkUndirectedGraphAlgorithm > sself) {sself . Reset () ; return ;} extern "C" void * vtkUndirectedGraphAlgorithm_get_ptr (vtkNew < vtkUndirectedGraphAlgorithm > sself) {return sself . GetPointer () ;} @@ -224,6 +426,14 @@ extern "C" void * vtkUniformGridAMRAlgorithm_get_ptr (vtkNew < vtkUniformGridAMR extern "C" vtkNew < vtkUniformGridPartitioner > vtkUniformGridPartitioner_new () {return vtkNew < vtkUniformGridPartitioner > () ;} extern "C" void vtkUniformGridPartitioner_destructor (vtkNew < vtkUniformGridPartitioner > sself) {sself . Reset () ; return ;} extern "C" void * vtkUniformGridPartitioner_get_ptr (vtkNew < vtkUniformGridPartitioner > sself) {return sself . GetPointer () ;} +extern "C" int vtk_uniform_grid_partitioner_get_number_of_partitions(vtkNew sself) { return sself->GetNumberOfPartitions(); } +extern "C" void vtk_uniform_grid_partitioner_set_number_of_partitions(vtkNew sself, int _arg) { sself->SetNumberOfPartitions(_arg); } +extern "C" int vtk_uniform_grid_partitioner_get_number_of_ghost_layers(vtkNew sself) { return sself->GetNumberOfGhostLayers(); } +extern "C" void vtk_uniform_grid_partitioner_set_number_of_ghost_layers(vtkNew sself, int _arg) { sself->SetNumberOfGhostLayers(_arg); } +extern "C" int vtk_uniform_grid_partitioner_get_duplicate_nodes(vtkNew sself) { return sself->GetDuplicateNodes(); } +extern "C" void vtk_uniform_grid_partitioner_set_duplicate_nodes(vtkNew sself, int _arg) { sself->SetDuplicateNodes(_arg); } +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_on(vtkNew sself) { sself->DuplicateNodesOn(); } +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_off(vtkNew sself) { sself->DuplicateNodesOff(); } extern "C" vtkNew < vtkUnstructuredGridAlgorithm > vtkUnstructuredGridAlgorithm_new () {return vtkNew < vtkUnstructuredGridAlgorithm > () ;} extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkNew < vtkUnstructuredGridAlgorithm > sself) {sself . Reset () ; return ;} extern "C" void * vtkUnstructuredGridAlgorithm_get_ptr (vtkNew < vtkUnstructuredGridAlgorithm > sself) {return sself . GetPointer () ;} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp index 1d8e7f9..13f614a 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp @@ -26,27 +26,154 @@ extern "C" vtkNew < vtkAmoebaMinimizer > vtkAmoebaMinimizer_new () {return vtkNew < vtkAmoebaMinimizer > () ;} extern "C" void vtkAmoebaMinimizer_destructor (vtkNew < vtkAmoebaMinimizer > sself) {sself . Reset () ; return ;} extern "C" void * vtkAmoebaMinimizer_get_ptr (vtkNew < vtkAmoebaMinimizer > sself) {return sself . GetPointer () ;} +extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkNew sself, const char name, double value) { sself->SetParameterValue(name, value); } +extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkNew sself, int i, double value) { sself->SetParameterValue(i, value); } +extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkNew sself, const char name, double scale) { sself->SetParameterScale(name, scale); } +extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkNew sself, const char name) { return sself->GetParameterScale(name); } +extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkNew sself, int i, double scale) { sself->SetParameterScale(i, scale); } +extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkNew sself, int i) { return sself->GetParameterScale(i); } +extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkNew sself, const char name) { return sself->GetParameterValue(name); } +extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkNew sself, int i) { return sself->GetParameterValue(i); } +extern "C" const char* vtk_amoeba_minimizer_get_parameter_name(vtkNew sself, int i) { return sself->GetParameterName(i); } +extern "C" int vtk_amoeba_minimizer_get_number_of_parameters(vtkNew sself) { return sself->GetNumberOfParameters(); } +extern "C" void vtk_amoeba_minimizer_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_amoeba_minimizer_minimize(vtkNew sself) { sself->Minimize(); } +extern "C" int vtk_amoeba_minimizer_iterate(vtkNew sself) { return sself->Iterate(); } +extern "C" void vtk_amoeba_minimizer_set_function_value(vtkNew sself, double _arg) { sself->SetFunctionValue(_arg); } +extern "C" double vtk_amoeba_minimizer_get_function_value(vtkNew sself) { return sself->GetFunctionValue(); } +extern "C" void vtk_amoeba_minimizer_set_contraction_ratio(vtkNew sself, double _arg) { sself->SetContractionRatio(_arg); } +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_min_value(vtkNew sself) { return sself->GetContractionRatioMinValue(); } +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_max_value(vtkNew sself) { return sself->GetContractionRatioMaxValue(); } +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio(vtkNew sself) { return sself->GetContractionRatio(); } +extern "C" void vtk_amoeba_minimizer_set_expansion_ratio(vtkNew sself, double _arg) { sself->SetExpansionRatio(_arg); } +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_min_value(vtkNew sself) { return sself->GetExpansionRatioMinValue(); } +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_max_value(vtkNew sself) { return sself->GetExpansionRatioMaxValue(); } +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio(vtkNew sself) { return sself->GetExpansionRatio(); } +extern "C" void vtk_amoeba_minimizer_set_tolerance(vtkNew sself, double _arg) { sself->SetTolerance(_arg); } +extern "C" double vtk_amoeba_minimizer_get_tolerance(vtkNew sself) { return sself->GetTolerance(); } +extern "C" void vtk_amoeba_minimizer_set_parameter_tolerance(vtkNew sself, double _arg) { sself->SetParameterTolerance(_arg); } +extern "C" double vtk_amoeba_minimizer_get_parameter_tolerance(vtkNew sself) { return sself->GetParameterTolerance(); } +extern "C" void vtk_amoeba_minimizer_set_max_iterations(vtkNew sself, int _arg) { sself->SetMaxIterations(_arg); } +extern "C" int vtk_amoeba_minimizer_get_max_iterations(vtkNew sself) { return sself->GetMaxIterations(); } +extern "C" int vtk_amoeba_minimizer_get_iterations(vtkNew sself) { return sself->GetIterations(); } +extern "C" int vtk_amoeba_minimizer_get_function_evaluations(vtkNew sself) { return sself->GetFunctionEvaluations(); } +extern "C" void vtk_amoeba_minimizer_evaluate_function(vtkNew sself) { sself->EvaluateFunction(); } extern "C" vtkNew < vtkFFT > vtkFFT_new () {return vtkNew < vtkFFT > () ;} extern "C" void vtkFFT_destructor (vtkNew < vtkFFT > sself) {sself . Reset () ; return ;} extern "C" void * vtkFFT_get_ptr (vtkNew < vtkFFT > sself) {return sself . GetPointer () ;} +extern "C" double vtk_fft_hanning_generator(vtkNew sself, const size_t x, const size_t size) { return sself->HanningGenerator(x, size); } +extern "C" double vtk_fft_bartlett_generator(vtkNew sself, const size_t x, const size_t size) { return sself->BartlettGenerator(x, size); } +extern "C" double vtk_fft_sine_generator(vtkNew sself, const size_t x, const size_t size) { return sself->SineGenerator(x, size); } +extern "C" double vtk_fft_blackman_generator(vtkNew sself, const size_t x, const size_t size) { return sself->BlackmanGenerator(x, size); } +extern "C" double vtk_fft_rectangular_generator(vtkNew sself, const size_t x, const size_t size) { return sself->RectangularGenerator(x, size); } extern "C" vtkNew < vtkMatrix3x3 > vtkMatrix3x3_new () {return vtkNew < vtkMatrix3x3 > () ;} extern "C" void vtkMatrix3x3_destructor (vtkNew < vtkMatrix3x3 > sself) {sself . Reset () ; return ;} extern "C" void * vtkMatrix3x3_get_ptr (vtkNew < vtkMatrix3x3 > sself) {return sself . GetPointer () ;} +extern "C" void vtk_matrix_3_x_3_deep_copy(vtkNew sself, double elements, const double newElements) { sself->DeepCopy(elements, newElements); } +extern "C" void vtk_matrix_3_x_3_deep_copy(vtkNew sself, const double elements) { sself->DeepCopy(elements); } +extern "C" void vtk_matrix_3_x_3_zero(vtkNew sself) { sself->Zero(); } +extern "C" void vtk_matrix_3_x_3_zero(vtkNew sself, double elements) { sself->Zero(elements); } +extern "C" void vtk_matrix_3_x_3_identity(vtkNew sself) { sself->Identity(); } +extern "C" void vtk_matrix_3_x_3_identity(vtkNew sself, double elements) { sself->Identity(elements); } +extern "C" void vtk_matrix_3_x_3_invert(vtkNew sself) { sself->Invert(); } +extern "C" void vtk_matrix_3_x_3_invert(vtkNew sself, const double inElements, double outElements) { sself->Invert(inElements, outElements); } +extern "C" void vtk_matrix_3_x_3_transpose(vtkNew sself) { sself->Transpose(); } +extern "C" void vtk_matrix_3_x_3_transpose(vtkNew sself, const double inElements, double outElements) { sself->Transpose(inElements, outElements); } +extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const float in, float out) { sself->MultiplyPoint(in, out); } +extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double in, double out) { sself->MultiplyPoint(in, out); } +extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double elements, const float in, float out) { sself->MultiplyPoint(elements, in, out); } +extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double elements, const double in, double out) { sself->MultiplyPoint(elements, in, out); } +extern "C" void vtk_matrix_3_x_3_multiply_3_x_3(vtkNew sself, const double a, const double b, double c) { sself->Multiply3x3(a, b, c); } +extern "C" void vtk_matrix_3_x_3_adjoint(vtkNew sself, const double inElements, double outElements) { sself->Adjoint(inElements, outElements); } +extern "C" double vtk_matrix_3_x_3_determinant(vtkNew sself) { return sself->Determinant(); } +extern "C" double vtk_matrix_3_x_3_determinant(vtkNew sself, const double elements) { return sself->Determinant(elements); } +extern "C" void vtk_matrix_3_x_3_set_element(vtkNew sself, int i, int j, double value) { sself->SetElement(i, j, value); } +extern "C" double vtk_matrix_3_x_3_get_element(vtkNew sself, int i, int j) { return sself->GetElement(i, j); } +extern "C" bool vtk_matrix_3_x_3_is_identity(vtkNew sself) { return sself->IsIdentity(); } +extern "C" double* vtk_matrix_3_x_3_get_data(vtkNew sself) { return sself->GetData(); } +extern "C" const double* vtk_matrix_3_x_3_get_data(vtkNew sself) { return sself->GetData(); } extern "C" vtkNew < vtkMatrix4x4 > vtkMatrix4x4_new () {return vtkNew < vtkMatrix4x4 > () ;} extern "C" void vtkMatrix4x4_destructor (vtkNew < vtkMatrix4x4 > sself) {sself . Reset () ; return ;} extern "C" void * vtkMatrix4x4_get_ptr (vtkNew < vtkMatrix4x4 > sself) {return sself . GetPointer () ;} +extern "C" void vtk_matrix_4_x_4_deep_copy(vtkNew sself, double destination, const double source) { sself->DeepCopy(destination, source); } +extern "C" void vtk_matrix_4_x_4_deep_copy(vtkNew sself, const double elements) { sself->DeepCopy(elements); } +extern "C" void vtk_matrix_4_x_4_zero(vtkNew sself) { sself->Zero(); } +extern "C" void vtk_matrix_4_x_4_zero(vtkNew sself, double elements) { sself->Zero(elements); } +extern "C" void vtk_matrix_4_x_4_identity(vtkNew sself) { sself->Identity(); } +extern "C" void vtk_matrix_4_x_4_identity(vtkNew sself, double elements) { sself->Identity(elements); } +extern "C" bool vtk_matrix_4_x_4_is_identity(vtkNew sself) { return sself->IsIdentity(); } +extern "C" void vtk_matrix_4_x_4_invert(vtkNew sself) { sself->Invert(); } +extern "C" void vtk_matrix_4_x_4_invert(vtkNew sself, const double inElements, double outElements) { sself->Invert(inElements, outElements); } +extern "C" void vtk_matrix_4_x_4_transpose(vtkNew sself) { sself->Transpose(); } +extern "C" void vtk_matrix_4_x_4_transpose(vtkNew sself, const double inElements, double outElements) { sself->Transpose(inElements, outElements); } +extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const float in, float out) { sself->MultiplyPoint(in, out); } +extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double in, double out) { sself->MultiplyPoint(in, out); } +extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double elements, const float in, float out) { sself->MultiplyPoint(elements, in, out); } +extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double elements, const double in, double out) { sself->MultiplyPoint(elements, in, out); } +extern "C" float* vtk_matrix_4_x_4_multiply_point(vtkNew sself, const float in) { return sself->MultiplyPoint(in); } +extern "C" double* vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double in) { return sself->MultiplyPoint(in); } +extern "C" float* vtk_matrix_4_x_4_multiply_float_point(vtkNew sself, const float in) { return sself->MultiplyFloatPoint(in); } +extern "C" double* vtk_matrix_4_x_4_multiply_double_point(vtkNew sself, const double in) { return sself->MultiplyDoublePoint(in); } +extern "C" void vtk_matrix_4_x_4_multiply_4_x_4(vtkNew sself, const double a, const double b, double c) { sself->Multiply4x4(a, b, c); } +extern "C" void vtk_matrix_4_x_4_multiply_4_x_4(vtkNew sself, const double a, const double b, float c) { sself->Multiply4x4(a, b, c); } +extern "C" void vtk_matrix_4_x_4_multiply_and_transpose_4_x_4(vtkNew sself, const double a, const double b, float c) { sself->MultiplyAndTranspose4x4(a, b, c); } +extern "C" void vtk_matrix_4_x_4_adjoint(vtkNew sself, const double inElements, double outElements) { sself->Adjoint(inElements, outElements); } +extern "C" double vtk_matrix_4_x_4_determinant(vtkNew sself) { return sself->Determinant(); } +extern "C" double vtk_matrix_4_x_4_determinant(vtkNew sself, const double elements) { return sself->Determinant(elements); } +extern "C" void vtk_matrix_4_x_4_set_element(vtkNew sself, int i, int j, double value) { sself->SetElement(i, j, value); } +extern "C" double vtk_matrix_4_x_4_get_element(vtkNew sself, int i, int j) { return sself->GetElement(i, j); } +extern "C" double* vtk_matrix_4_x_4_get_data(vtkNew sself) { return sself->GetData(); } +extern "C" const double* vtk_matrix_4_x_4_get_data(vtkNew sself) { return sself->GetData(); } extern "C" vtkNew < vtkPolynomialSolversUnivariate > vtkPolynomialSolversUnivariate_new () {return vtkNew < vtkPolynomialSolversUnivariate > () ;} extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkNew < vtkPolynomialSolversUnivariate > sself) {sself . Reset () ; return ;} extern "C" void * vtkPolynomialSolversUnivariate_get_ptr (vtkNew < vtkPolynomialSolversUnivariate > sself) {return sself . GetPointer () ;} +extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol) { return sself->HabichtBisectionSolve(P, d, a, upperBnds, tol); } +extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType) { return sself->HabichtBisectionSolve(P, d, a, upperBnds, tol, intervalType); } +extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType, bool divideGCD) { return sself->HabichtBisectionSolve(P, d, a, upperBnds, tol, intervalType, divideGCD); } +extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol) { return sself->SturmBisectionSolve(P, d, a, upperBnds, tol); } +extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType) { return sself->SturmBisectionSolve(P, d, a, upperBnds, tol, intervalType); } +extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType, bool divideGCD) { return sself->SturmBisectionSolve(P, d, a, upperBnds, tol, intervalType, divideGCD); } +extern "C" int vtk_polynomial_solvers_univariate_filter_roots(vtkNew sself, double P, int d, double upperBnds, int rootcount, double diameter) { return sself->FilterRoots(P, d, upperBnds, rootcount, diameter); } +extern "C" int vtk_polynomial_solvers_univariate_lin_bairstow_solve(vtkNew sself, double c, int d, double r, double tolerance) { return sself->LinBairstowSolve(c, d, r, tolerance); } +extern "C" int vtk_polynomial_solvers_univariate_ferrari_solve(vtkNew sself, double c, double r, int m, double tol) { return sself->FerrariSolve(c, r, m, tol); } +extern "C" int vtk_polynomial_solvers_univariate_tartaglia_cardan_solve(vtkNew sself, double c, double r, int m, double tol) { return sself->TartagliaCardanSolve(c, r, m, tol); } +extern "C" double* vtk_polynomial_solvers_univariate_solve_cubic(vtkNew sself, double c0, double c1, double c2, double c3) { return sself->SolveCubic(c0, c1, c2, c3); } +extern "C" double* vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c0, double c1, double c2) { return sself->SolveQuadratic(c0, c1, c2); } +extern "C" double* vtk_polynomial_solvers_univariate_solve_linear(vtkNew sself, double c0, double c1) { return sself->SolveLinear(c0, c1); } +extern "C" int vtk_polynomial_solvers_univariate_solve_cubic(vtkNew sself, double c0, double c1, double c2, double c3, double r1, double r2, double r3, int num_roots) { return sself->SolveCubic(c0, c1, c2, c3, r1, r2, r3, num_roots); } +extern "C" int vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c0, double c1, double c2, double r1, double r2, int num_roots) { return sself->SolveQuadratic(c0, c1, c2, r1, r2, num_roots); } +extern "C" int vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c, double r, int m) { return sself->SolveQuadratic(c, r, m); } +extern "C" int vtk_polynomial_solvers_univariate_solve_linear(vtkNew sself, double c0, double c1, double r1, int num_roots) { return sself->SolveLinear(c0, c1, r1, num_roots); } +extern "C" void vtk_polynomial_solvers_univariate_set_division_tolerance(vtkNew sself, double tol) { sself->SetDivisionTolerance(tol); } +extern "C" double vtk_polynomial_solvers_univariate_get_division_tolerance(vtkNew sself) { return sself->GetDivisionTolerance(); } extern "C" vtkNew < vtkQuaternionInterpolator > vtkQuaternionInterpolator_new () {return vtkNew < vtkQuaternionInterpolator > () ;} extern "C" void vtkQuaternionInterpolator_destructor (vtkNew < vtkQuaternionInterpolator > sself) {sself . Reset () ; return ;} extern "C" void * vtkQuaternionInterpolator_get_ptr (vtkNew < vtkQuaternionInterpolator > sself) {return sself . GetPointer () ;} +extern "C" int vtk_quaternion_interpolator_get_number_of_quaternions(vtkNew sself) { return sself->GetNumberOfQuaternions(); } +extern "C" double vtk_quaternion_interpolator_get_minimum_t(vtkNew sself) { return sself->GetMinimumT(); } +extern "C" double vtk_quaternion_interpolator_get_maximum_t(vtkNew sself) { return sself->GetMaximumT(); } +extern "C" void vtk_quaternion_interpolator_initialize(vtkNew sself) { sself->Initialize(); } +extern "C" void vtk_quaternion_interpolator_add_quaternion(vtkNew sself, double t, double q) { sself->AddQuaternion(t, q); } +extern "C" void vtk_quaternion_interpolator_remove_quaternion(vtkNew sself, double t) { sself->RemoveQuaternion(t); } +extern "C" void vtk_quaternion_interpolator_interpolate_quaternion(vtkNew sself, double t, double q) { sself->InterpolateQuaternion(t, q); } +extern "C" int vtk_quaternion_interpolator_get_search_method(vtkNew sself) { return sself->GetSearchMethod(); } +extern "C" void vtk_quaternion_interpolator_set_search_method(vtkNew sself, int type) { sself->SetSearchMethod(type); } +extern "C" void vtk_quaternion_interpolator_set_interpolation_type(vtkNew sself, int _arg) { sself->SetInterpolationType(_arg); } +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_min_value(vtkNew sself) { return sself->GetInterpolationTypeMinValue(); } +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_max_value(vtkNew sself) { return sself->GetInterpolationTypeMaxValue(); } +extern "C" int vtk_quaternion_interpolator_get_interpolation_type(vtkNew sself) { return sself->GetInterpolationType(); } +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_linear(vtkNew sself) { sself->SetInterpolationTypeToLinear(); } +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_spline(vtkNew sself) { sself->SetInterpolationTypeToSpline(); } extern "C" vtkNew < vtkRungeKutta2 > vtkRungeKutta2_new () {return vtkNew < vtkRungeKutta2 > () ;} extern "C" void vtkRungeKutta2_destructor (vtkNew < vtkRungeKutta2 > sself) {sself . Reset () ; return ;} extern "C" void * vtkRungeKutta2_get_ptr (vtkNew < vtkRungeKutta2 > sself) {return sself . GetPointer () ;} +extern "C" int vtk_runge_kutta_2_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData) { return sself->ComputeNextStep(xprev, xnext, t, delT, maxError, error, userData); } extern "C" vtkNew < vtkRungeKutta4 > vtkRungeKutta4_new () {return vtkNew < vtkRungeKutta4 > () ;} extern "C" void vtkRungeKutta4_destructor (vtkNew < vtkRungeKutta4 > sself) {sself . Reset () ; return ;} extern "C" void * vtkRungeKutta4_get_ptr (vtkNew < vtkRungeKutta4 > sself) {return sself . GetPointer () ;} +extern "C" int vtk_runge_kutta_4_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData) { return sself->ComputeNextStep(xprev, xnext, t, delT, maxError, error, userData); } extern "C" vtkNew < vtkRungeKutta45 > vtkRungeKutta45_new () {return vtkNew < vtkRungeKutta45 > () ;} extern "C" void vtkRungeKutta45_destructor (vtkNew < vtkRungeKutta45 > sself) {sself . Reset () ; return ;} extern "C" void * vtkRungeKutta45_get_ptr (vtkNew < vtkRungeKutta45 > sself) {return sself . GetPointer () ;} +extern "C" int vtk_runge_kutta_45_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData) { return sself->ComputeNextStep(xprev, xnext, t, delT, maxError, error, userData); } +extern "C" int vtk_runge_kutta_45_compute_next_step(vtkNew sself, double xprev, double dxprev, double xnext, double t, double delT, double delTActual, double minStep, double maxStep, double maxError, double estErr, void userData) { return sself->ComputeNextStep(xprev, dxprev, xnext, t, delT, delTActual, minStep, maxStep, maxError, estErr, userData); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp index 09815bd..eb16364 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp @@ -18,15 +18,131 @@ extern "C" vtkNew < vtkContourValues > vtkContourValues_new () {return vtkNew < vtkContourValues > () ;} extern "C" void vtkContourValues_destructor (vtkNew < vtkContourValues > sself) {sself . Reset () ; return ;} extern "C" void * vtkContourValues_get_ptr (vtkNew < vtkContourValues > sself) {return sself . GetPointer () ;} +extern "C" void vtk_contour_values_set_value(vtkNew sself, int i, double value) { sself->SetValue(i, value); } +extern "C" double vtk_contour_values_get_value(vtkNew sself, int i) { return sself->GetValue(i); } +extern "C" double* vtk_contour_values_get_values(vtkNew sself) { return sself->GetValues(); } +extern "C" void vtk_contour_values_get_values(vtkNew sself, double contourValues) { sself->GetValues(contourValues); } +extern "C" void vtk_contour_values_set_number_of_contours(vtkNew sself, const int number) { sself->SetNumberOfContours(number); } +extern "C" int vtk_contour_values_get_number_of_contours(vtkNew sself) { return sself->GetNumberOfContours(); } +extern "C" void vtk_contour_values_generate_values(vtkNew sself, int numContours, double range) { sself->GenerateValues(numContours, range); } +extern "C" void vtk_contour_values_generate_values(vtkNew sself, int numContours, double rangeStart, double rangeEnd) { sself->GenerateValues(numContours, rangeStart, rangeEnd); } extern "C" vtkNew < vtkExprTkFunctionParser > vtkExprTkFunctionParser_new () {return vtkNew < vtkExprTkFunctionParser > () ;} extern "C" void vtkExprTkFunctionParser_destructor (vtkNew < vtkExprTkFunctionParser > sself) {sself . Reset () ; return ;} extern "C" void * vtkExprTkFunctionParser_get_ptr (vtkNew < vtkExprTkFunctionParser > sself) {return sself . GetPointer () ;} +extern "C" unsigned long vtk_expr_tk_function_parser_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_expr_tk_function_parser_set_function(vtkNew sself, const char function) { sself->SetFunction(function); } +extern "C" const char* vtk_expr_tk_function_parser_get_function(vtkNew sself) { return sself->GetFunction(); } +extern "C" int vtk_expr_tk_function_parser_is_scalar_result(vtkNew sself) { return sself->IsScalarResult(); } +extern "C" int vtk_expr_tk_function_parser_is_vector_result(vtkNew sself) { return sself->IsVectorResult(); } +extern "C" double vtk_expr_tk_function_parser_get_scalar_result(vtkNew sself) { return sself->GetScalarResult(); } +extern "C" double* vtk_expr_tk_function_parser_get_vector_result(vtkNew sself) { return sself->GetVectorResult(); } +extern "C" void vtk_expr_tk_function_parser_get_vector_result(vtkNew sself, double result) { sself->GetVectorResult(result); } +extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkNew sself, const char* variableName, double value) { sself->SetScalarVariableValue(variableName, value); } +extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkNew sself, int i, double value) { sself->SetScalarVariableValue(i, value); } +extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkNew sself, const char* variableName) { return sself->GetScalarVariableValue(variableName); } +extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkNew sself, int i) { return sself->GetScalarVariableValue(i); } +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(variableName, xValue, yValue, zValue); } +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double values) { sself->SetVectorVariableValue(variableName, values); } +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, int i, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(i, xValue, yValue, zValue); } +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, int i, double values) { sself->SetVectorVariableValue(i, values); } +extern "C" double* vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName) { return sself->GetVectorVariableValue(variableName); } +extern "C" void vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName, double value) { sself->GetVectorVariableValue(variableName, value); } +extern "C" double* vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, int i) { return sself->GetVectorVariableValue(i); } +extern "C" void vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, int i, double value) { sself->GetVectorVariableValue(i, value); } +extern "C" int vtk_expr_tk_function_parser_get_number_of_scalar_variables(vtkNew sself) { return sself->GetNumberOfScalarVariables(); } +extern "C" int vtk_expr_tk_function_parser_get_scalar_variable_index(vtkNew sself, const char* name) { return sself->GetScalarVariableIndex(name); } +extern "C" int vtk_expr_tk_function_parser_get_number_of_vector_variables(vtkNew sself) { return sself->GetNumberOfVectorVariables(); } +extern "C" int vtk_expr_tk_function_parser_get_vector_variable_index(vtkNew sself, const char* name) { return sself->GetVectorVariableIndex(name); } +extern "C" const char* vtk_expr_tk_function_parser_get_scalar_variable_name(vtkNew sself, int i) { return sself->GetScalarVariableName(i); } +extern "C" const char* vtk_expr_tk_function_parser_get_vector_variable_name(vtkNew sself, int i) { return sself->GetVectorVariableName(i); } +extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkNew sself, int i) { return sself->GetScalarVariableNeeded(i); } +extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkNew sself, const char* variableName) { return sself->GetScalarVariableNeeded(variableName); } +extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkNew sself, int i) { return sself->GetVectorVariableNeeded(i); } +extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkNew sself, const char* variableName) { return sself->GetVectorVariableNeeded(variableName); } +extern "C" void vtk_expr_tk_function_parser_remove_all_variables(vtkNew sself) { sself->RemoveAllVariables(); } +extern "C" void vtk_expr_tk_function_parser_remove_scalar_variables(vtkNew sself) { sself->RemoveScalarVariables(); } +extern "C" void vtk_expr_tk_function_parser_remove_vector_variables(vtkNew sself) { sself->RemoveVectorVariables(); } +extern "C" void vtk_expr_tk_function_parser_set_replace_invalid_values(vtkNew sself, int _arg) { sself->SetReplaceInvalidValues(_arg); } +extern "C" int vtk_expr_tk_function_parser_get_replace_invalid_values(vtkNew sself) { return sself->GetReplaceInvalidValues(); } +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_on(vtkNew sself) { sself->ReplaceInvalidValuesOn(); } +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_off(vtkNew sself) { sself->ReplaceInvalidValuesOff(); } +extern "C" void vtk_expr_tk_function_parser_set_replacement_value(vtkNew sself, double _arg) { sself->SetReplacementValue(_arg); } +extern "C" double vtk_expr_tk_function_parser_get_replacement_value(vtkNew sself) { return sself->GetReplacementValue(); } +extern "C" void vtk_expr_tk_function_parser_invalidate_function(vtkNew sself) { sself->InvalidateFunction(); } +extern "C" const char* vtk_expr_tk_function_parser_sanitize_name(vtkNew sself, const char name) { return sself->SanitizeName(name); } extern "C" vtkNew < vtkFunctionParser > vtkFunctionParser_new () {return vtkNew < vtkFunctionParser > () ;} extern "C" void vtkFunctionParser_destructor (vtkNew < vtkFunctionParser > sself) {sself . Reset () ; return ;} extern "C" void * vtkFunctionParser_get_ptr (vtkNew < vtkFunctionParser > sself) {return sself . GetPointer () ;} +extern "C" unsigned long vtk_function_parser_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_function_parser_set_function(vtkNew sself, const char function) { sself->SetFunction(function); } +extern "C" char* vtk_function_parser_get_function(vtkNew sself) { return sself->GetFunction(); } +extern "C" int vtk_function_parser_is_scalar_result(vtkNew sself) { return sself->IsScalarResult(); } +extern "C" int vtk_function_parser_is_vector_result(vtkNew sself) { return sself->IsVectorResult(); } +extern "C" double vtk_function_parser_get_scalar_result(vtkNew sself) { return sself->GetScalarResult(); } +extern "C" double* vtk_function_parser_get_vector_result(vtkNew sself) { return sself->GetVectorResult(); } +extern "C" void vtk_function_parser_get_vector_result(vtkNew sself, double result) { sself->GetVectorResult(result); } +extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, const char variableName, double value) { sself->SetScalarVariableValue(variableName, value); } +extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, const char* variableName, double value) { sself->SetScalarVariableValue(variableName, value); } +extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, int i, double value) { sself->SetScalarVariableValue(i, value); } +extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, const char variableName) { return sself->GetScalarVariableValue(variableName); } +extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, const char* variableName) { return sself->GetScalarVariableValue(variableName); } +extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, int i) { return sself->GetScalarVariableValue(i); } +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char variableName, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(variableName, xValue, yValue, zValue); } +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(variableName, xValue, yValue, zValue); } +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char variableName, const double values) { sself->SetVectorVariableValue(variableName, values); } +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, const double values) { sself->SetVectorVariableValue(variableName, values); } +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, int i, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(i, xValue, yValue, zValue); } +extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, int i, const double values) { sself->SetVectorVariableValue(i, values); } +extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, const char variableName) { return sself->GetVectorVariableValue(variableName); } +extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName) { return sself->GetVectorVariableValue(variableName); } +extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, const char variableName, double value) { sself->GetVectorVariableValue(variableName, value); } +extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName, double value) { sself->GetVectorVariableValue(variableName, value); } +extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, int i) { return sself->GetVectorVariableValue(i); } +extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, int i, double value) { sself->GetVectorVariableValue(i, value); } +extern "C" int vtk_function_parser_get_number_of_scalar_variables(vtkNew sself) { return sself->GetNumberOfScalarVariables(); } +extern "C" int vtk_function_parser_get_scalar_variable_index(vtkNew sself, const char name) { return sself->GetScalarVariableIndex(name); } +extern "C" int vtk_function_parser_get_scalar_variable_index(vtkNew sself, const char* name) { return sself->GetScalarVariableIndex(name); } +extern "C" int vtk_function_parser_get_number_of_vector_variables(vtkNew sself) { return sself->GetNumberOfVectorVariables(); } +extern "C" int vtk_function_parser_get_vector_variable_index(vtkNew sself, const char name) { return sself->GetVectorVariableIndex(name); } +extern "C" int vtk_function_parser_get_vector_variable_index(vtkNew sself, const char* name) { return sself->GetVectorVariableIndex(name); } +extern "C" const char* vtk_function_parser_get_scalar_variable_name(vtkNew sself, int i) { return sself->GetScalarVariableName(i); } +extern "C" const char* vtk_function_parser_get_vector_variable_name(vtkNew sself, int i) { return sself->GetVectorVariableName(i); } +extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, int i) { return sself->GetScalarVariableNeeded(i); } +extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, const char variableName) { return sself->GetScalarVariableNeeded(variableName); } +extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, const char* variableName) { return sself->GetScalarVariableNeeded(variableName); } +extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, int i) { return sself->GetVectorVariableNeeded(i); } +extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, const char variableName) { return sself->GetVectorVariableNeeded(variableName); } +extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, const char* variableName) { return sself->GetVectorVariableNeeded(variableName); } +extern "C" void vtk_function_parser_remove_all_variables(vtkNew sself) { sself->RemoveAllVariables(); } +extern "C" void vtk_function_parser_remove_scalar_variables(vtkNew sself) { sself->RemoveScalarVariables(); } +extern "C" void vtk_function_parser_remove_vector_variables(vtkNew sself) { sself->RemoveVectorVariables(); } +extern "C" void vtk_function_parser_set_replace_invalid_values(vtkNew sself, int _arg) { sself->SetReplaceInvalidValues(_arg); } +extern "C" int vtk_function_parser_get_replace_invalid_values(vtkNew sself) { return sself->GetReplaceInvalidValues(); } +extern "C" void vtk_function_parser_replace_invalid_values_on(vtkNew sself) { sself->ReplaceInvalidValuesOn(); } +extern "C" void vtk_function_parser_replace_invalid_values_off(vtkNew sself) { sself->ReplaceInvalidValuesOff(); } +extern "C" void vtk_function_parser_set_replacement_value(vtkNew sself, double _arg) { sself->SetReplacementValue(_arg); } +extern "C" double vtk_function_parser_get_replacement_value(vtkNew sself) { return sself->GetReplacementValue(); } +extern "C" void vtk_function_parser_check_expression(vtkNew sself, int pos, char error) { sself->CheckExpression(pos, error); } +extern "C" void vtk_function_parser_invalidate_function(vtkNew sself) { sself->InvalidateFunction(); } extern "C" vtkNew < vtkHeap > vtkHeap_new () {return vtkNew < vtkHeap > () ;} extern "C" void vtkHeap_destructor (vtkNew < vtkHeap > sself) {sself . Reset () ; return ;} extern "C" void * vtkHeap_get_ptr (vtkNew < vtkHeap > sself) {return sself . GetPointer () ;} +extern "C" void* vtk_heap_allocate_memory(vtkNew sself, size_t n) { return sself->AllocateMemory(n); } +extern "C" void vtk_heap_set_block_size(vtkNew sself, size_t p0) { sself->SetBlockSize(p0); } +extern "C" size_t vtk_heap_get_block_size(vtkNew sself) { return sself->GetBlockSize(); } +extern "C" int vtk_heap_get_number_of_blocks(vtkNew sself) { return sself->GetNumberOfBlocks(); } +extern "C" int vtk_heap_get_number_of_allocations(vtkNew sself) { return sself->GetNumberOfAllocations(); } +extern "C" void vtk_heap_reset(vtkNew sself) { sself->Reset(); } +extern "C" char* vtk_heap_string_dup(vtkNew sself, const char str) { return sself->StringDup(str); } extern "C" vtkNew < vtkResourceFileLocator > vtkResourceFileLocator_new () {return vtkNew < vtkResourceFileLocator > () ;} extern "C" void vtkResourceFileLocator_destructor (vtkNew < vtkResourceFileLocator > sself) {sself . Reset () ; return ;} extern "C" void * vtkResourceFileLocator_get_ptr (vtkNew < vtkResourceFileLocator > sself) {return sself . GetPointer () ;} +extern "C" void vtk_resource_file_locator_set_print_debug_information(vtkNew sself, bool p0) { sself->SetPrintDebugInformation(p0); } +extern "C" bool vtk_resource_file_locator_get_print_debug_information(vtkNew sself) { return sself->GetPrintDebugInformation(); } +extern "C" void vtk_resource_file_locator_print_debug_information_on(vtkNew sself) { sself->PrintDebugInformationOn(); } +extern "C" void vtk_resource_file_locator_print_debug_information_off(vtkNew sself) { sself->PrintDebugInformationOff(); } +extern "C" void vtk_resource_file_locator_set_log_verbosity(vtkNew sself, int _arg) { sself->SetLogVerbosity(_arg); } +extern "C" int vtk_resource_file_locator_get_log_verbosity(vtkNew sself) { return sself->GetLogVerbosity(); } +extern "C" const char* vtk_resource_file_locator_locate(vtkNew sself, const char* anchor, const char* landmark, const char* defaultDir) { return sself->Locate(anchor, landmark, defaultDir); } +extern "C" const char* vtk_resource_file_locator_get_library_path_for_symbol_unix(vtkNew sself, const char symbolname) { return sself->GetLibraryPathForSymbolUnix(symbolname); } +extern "C" const char* vtk_resource_file_locator_get_library_path_for_symbol_win_32(vtkNew sself, const void fptr) { return sself->GetLibraryPathForSymbolWin32(fptr); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp index ad66e6f..dcd8b09 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp @@ -21,21 +21,73 @@ extern "C" vtkNew < vtkClientSocket > vtkClientSocket_new () {return vtkNew < vtkClientSocket > () ;} extern "C" void vtkClientSocket_destructor (vtkNew < vtkClientSocket > sself) {sself . Reset () ; return ;} extern "C" void * vtkClientSocket_get_ptr (vtkNew < vtkClientSocket > sself) {return sself . GetPointer () ;} +extern "C" int vtk_client_socket_connect_to_server(vtkNew sself, const char hostname, int port) { return sself->ConnectToServer(hostname, port); } +extern "C" bool vtk_client_socket_get_connecting_side(vtkNew sself) { return sself->GetConnectingSide(); } extern "C" vtkNew < vtkDirectory > vtkDirectory_new () {return vtkNew < vtkDirectory > () ;} extern "C" void vtkDirectory_destructor (vtkNew < vtkDirectory > sself) {sself . Reset () ; return ;} extern "C" void * vtkDirectory_get_ptr (vtkNew < vtkDirectory > sself) {return sself . GetPointer () ;} +extern "C" int vtk_directory_open(vtkNew sself, const char dir) { return sself->Open(dir); } +extern "C" long long vtk_directory_get_number_of_files(vtkNew sself) { return sself->GetNumberOfFiles(); } +extern "C" const char* vtk_directory_get_file(vtkNew sself, long long index) { return sself->GetFile(index); } +extern "C" int vtk_directory_file_is_directory(vtkNew sself, const char name) { return sself->FileIsDirectory(name); } +extern "C" const char* vtk_directory_get_current_working_directory(vtkNew sself, char buf, unsigned int len) { return sself->GetCurrentWorkingDirectory(buf, len); } +extern "C" int vtk_directory_make_directory(vtkNew sself, const char dir) { return sself->MakeDirectory(dir); } +extern "C" int vtk_directory_delete_directory(vtkNew sself, const char dir) { return sself->DeleteDirectory(dir); } +extern "C" int vtk_directory_rename(vtkNew sself, const char oldname, const char newname) { return sself->Rename(oldname, newname); } extern "C" vtkNew < vtkExecutableRunner > vtkExecutableRunner_new () {return vtkNew < vtkExecutableRunner > () ;} extern "C" void vtkExecutableRunner_destructor (vtkNew < vtkExecutableRunner > sself) {sself . Reset () ; return ;} extern "C" void * vtkExecutableRunner_get_ptr (vtkNew < vtkExecutableRunner > sself) {return sself . GetPointer () ;} +extern "C" void vtk_executable_runner_execute(vtkNew sself) { sself->Execute(); } +extern "C" void vtk_executable_runner_set_timeout(vtkNew sself, double _arg) { sself->SetTimeout(_arg); } +extern "C" double vtk_executable_runner_get_timeout(vtkNew sself) { return sself->GetTimeout(); } +extern "C" void vtk_executable_runner_set_right_trim_result(vtkNew sself, bool _arg) { sself->SetRightTrimResult(_arg); } +extern "C" bool vtk_executable_runner_get_right_trim_result(vtkNew sself) { return sself->GetRightTrimResult(); } +extern "C" void vtk_executable_runner_right_trim_result_on(vtkNew sself) { sself->RightTrimResultOn(); } +extern "C" void vtk_executable_runner_right_trim_result_off(vtkNew sself) { sself->RightTrimResultOff(); } +extern "C" const char* vtk_executable_runner_get_command(vtkNew sself) { return sself->GetCommand(); } +extern "C" void vtk_executable_runner_set_command(vtkNew sself, const char arg) { sself->SetCommand(arg); } +extern "C" const char* vtk_executable_runner_get_std_out(vtkNew sself) { return sself->GetStdOut(); } +extern "C" const char* vtk_executable_runner_get_std_err(vtkNew sself) { return sself->GetStdErr(); } +extern "C" int vtk_executable_runner_get_return_value(vtkNew sself) { return sself->GetReturnValue(); } extern "C" vtkNew < vtkServerSocket > vtkServerSocket_new () {return vtkNew < vtkServerSocket > () ;} extern "C" void vtkServerSocket_destructor (vtkNew < vtkServerSocket > sself) {sself . Reset () ; return ;} extern "C" void * vtkServerSocket_get_ptr (vtkNew < vtkServerSocket > sself) {return sself . GetPointer () ;} +extern "C" int vtk_server_socket_create_server(vtkNew sself, int port) { return sself->CreateServer(port); } +extern "C" int vtk_server_socket_get_server_port(vtkNew sself) { return sself->GetServerPort(); } extern "C" vtkNew < vtkSocketCollection > vtkSocketCollection_new () {return vtkNew < vtkSocketCollection > () ;} extern "C" void vtkSocketCollection_destructor (vtkNew < vtkSocketCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkSocketCollection_get_ptr (vtkNew < vtkSocketCollection > sself) {return sself . GetPointer () ;} +extern "C" int vtk_socket_collection_select_sockets(vtkNew sself, unsigned long msec) { return sself->SelectSockets(msec); } extern "C" vtkNew < vtkThreadMessager > vtkThreadMessager_new () {return vtkNew < vtkThreadMessager > () ;} extern "C" void vtkThreadMessager_destructor (vtkNew < vtkThreadMessager > sself) {sself . Reset () ; return ;} extern "C" void * vtkThreadMessager_get_ptr (vtkNew < vtkThreadMessager > sself) {return sself . GetPointer () ;} +extern "C" void vtk_thread_messager_wait_for_message(vtkNew sself) { sself->WaitForMessage(); } +extern "C" void vtk_thread_messager_send_wake_message(vtkNew sself) { sself->SendWakeMessage(); } +extern "C" void vtk_thread_messager_enable_wait_for_receiver(vtkNew sself) { sself->EnableWaitForReceiver(); } +extern "C" void vtk_thread_messager_disable_wait_for_receiver(vtkNew sself) { sself->DisableWaitForReceiver(); } +extern "C" void vtk_thread_messager_wait_for_receiver(vtkNew sself) { sself->WaitForReceiver(); } extern "C" vtkNew < vtkTimerLog > vtkTimerLog_new () {return vtkNew < vtkTimerLog > () ;} extern "C" void vtkTimerLog_destructor (vtkNew < vtkTimerLog > sself) {sself . Reset () ; return ;} extern "C" void * vtkTimerLog_get_ptr (vtkNew < vtkTimerLog > sself) {return sself . GetPointer () ;} +extern "C" void vtk_timer_log_set_logging(vtkNew sself, int v) { sself->SetLogging(v); } +extern "C" int vtk_timer_log_get_logging(vtkNew sself) { return sself->GetLogging(); } +extern "C" void vtk_timer_log_logging_on(vtkNew sself) { sself->LoggingOn(); } +extern "C" void vtk_timer_log_logging_off(vtkNew sself) { sself->LoggingOff(); } +extern "C" void vtk_timer_log_set_max_entries(vtkNew sself, int a) { sself->SetMaxEntries(a); } +extern "C" int vtk_timer_log_get_max_entries(vtkNew sself) { return sself->GetMaxEntries(); } +extern "C" void vtk_timer_log_dump_log(vtkNew sself, const char filename) { sself->DumpLog(filename); } +extern "C" void vtk_timer_log_mark_start_event(vtkNew sself, const char EventString) { sself->MarkStartEvent(EventString); } +extern "C" void vtk_timer_log_mark_end_event(vtkNew sself, const char EventString) { sself->MarkEndEvent(EventString); } +extern "C" void vtk_timer_log_insert_timed_event(vtkNew sself, const char EventString, double time, int cpuTicks) { sself->InsertTimedEvent(EventString, time, cpuTicks); } +extern "C" int vtk_timer_log_get_number_of_events(vtkNew sself) { return sself->GetNumberOfEvents(); } +extern "C" int vtk_timer_log_get_event_indent(vtkNew sself, int i) { return sself->GetEventIndent(i); } +extern "C" double vtk_timer_log_get_event_wall_time(vtkNew sself, int i) { return sself->GetEventWallTime(i); } +extern "C" const char* vtk_timer_log_get_event_string(vtkNew sself, int i) { return sself->GetEventString(i); } +extern "C" void vtk_timer_log_mark_event(vtkNew sself, const char EventString) { sself->MarkEvent(EventString); } +extern "C" void vtk_timer_log_reset_log(vtkNew sself) { sself->ResetLog(); } +extern "C" void vtk_timer_log_cleanup_log(vtkNew sself) { sself->CleanupLog(); } +extern "C" double vtk_timer_log_get_universal_time(vtkNew sself) { return sself->GetUniversalTime(); } +extern "C" double vtk_timer_log_get_cpu_time(vtkNew sself) { return sself->GetCPUTime(); } +extern "C" void vtk_timer_log_start_timer(vtkNew sself) { sself->StartTimer(); } +extern "C" void vtk_timer_log_stop_timer(vtkNew sself) { sself->StopTimer(); } +extern "C" double vtk_timer_log_get_elapsed_time(vtkNew sself) { return sself->GetElapsedTime(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp index 8fc78c2..dbc01da 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp @@ -33,33 +33,174 @@ extern "C" void * vtkCylindricalTransform_get_ptr (vtkNew < vtkCylindricalTransf extern "C" vtkNew < vtkGeneralTransform > vtkGeneralTransform_new () {return vtkNew < vtkGeneralTransform > () ;} extern "C" void vtkGeneralTransform_destructor (vtkNew < vtkGeneralTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkGeneralTransform_get_ptr (vtkNew < vtkGeneralTransform > sself) {return sself . GetPointer () ;} +extern "C" void vtk_general_transform_identity(vtkNew sself) { sself->Identity(); } +extern "C" void vtk_general_transform_inverse(vtkNew sself) { sself->Inverse(); } +extern "C" void vtk_general_transform_translate(vtkNew sself, double x, double y, double z) { sself->Translate(x, y, z); } +extern "C" void vtk_general_transform_translate(vtkNew sself, const double x) { sself->Translate(x); } +extern "C" void vtk_general_transform_translate(vtkNew sself, const float x) { sself->Translate(x); } +extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } +extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, const double axis) { sself->RotateWXYZ(angle, axis); } +extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, const float axis) { sself->RotateWXYZ(angle, axis); } +extern "C" void vtk_general_transform_rotate_x(vtkNew sself, double angle) { sself->RotateX(angle); } +extern "C" void vtk_general_transform_rotate_y(vtkNew sself, double angle) { sself->RotateY(angle); } +extern "C" void vtk_general_transform_rotate_z(vtkNew sself, double angle) { sself->RotateZ(angle); } +extern "C" void vtk_general_transform_scale(vtkNew sself, double x, double y, double z) { sself->Scale(x, y, z); } +extern "C" void vtk_general_transform_scale(vtkNew sself, const double s) { sself->Scale(s); } +extern "C" void vtk_general_transform_scale(vtkNew sself, const float s) { sself->Scale(s); } +extern "C" void vtk_general_transform_concatenate(vtkNew sself, const double elements) { sself->Concatenate(elements); } +extern "C" void vtk_general_transform_pre_multiply(vtkNew sself) { sself->PreMultiply(); } +extern "C" void vtk_general_transform_post_multiply(vtkNew sself) { sself->PostMultiply(); } +extern "C" int vtk_general_transform_get_number_of_concatenated_transforms(vtkNew sself) { return sself->GetNumberOfConcatenatedTransforms(); } +extern "C" int vtk_general_transform_get_inverse_flag(vtkNew sself) { return sself->GetInverseFlag(); } +extern "C" void vtk_general_transform_push(vtkNew sself) { sself->Push(); } +extern "C" void vtk_general_transform_pop(vtkNew sself) { sself->Pop(); } +extern "C" void vtk_general_transform_internal_transform_point(vtkNew sself, const float in, float out) { sself->InternalTransformPoint(in, out); } +extern "C" void vtk_general_transform_internal_transform_point(vtkNew sself, const double in, double out) { sself->InternalTransformPoint(in, out); } +extern "C" void vtk_general_transform_internal_transform_derivative(vtkNew sself, const float in, float out, float derivative) { sself->InternalTransformDerivative(in, out, derivative); } +extern "C" void vtk_general_transform_internal_transform_derivative(vtkNew sself, const double in, double out, double derivative) { sself->InternalTransformDerivative(in, out, derivative); } +extern "C" unsigned long vtk_general_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkIdentityTransform > vtkIdentityTransform_new () {return vtkNew < vtkIdentityTransform > () ;} extern "C" void vtkIdentityTransform_destructor (vtkNew < vtkIdentityTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkIdentityTransform_get_ptr (vtkNew < vtkIdentityTransform > sself) {return sself . GetPointer () ;} +extern "C" void vtk_identity_transform_inverse(vtkNew sself) { sself->Inverse(); } extern "C" vtkNew < vtkLandmarkTransform > vtkLandmarkTransform_new () {return vtkNew < vtkLandmarkTransform > () ;} extern "C" void vtkLandmarkTransform_destructor (vtkNew < vtkLandmarkTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkLandmarkTransform_get_ptr (vtkNew < vtkLandmarkTransform > sself) {return sself . GetPointer () ;} +extern "C" void vtk_landmark_transform_set_mode(vtkNew sself, int _arg) { sself->SetMode(_arg); } +extern "C" void vtk_landmark_transform_set_mode_to_rigid_body(vtkNew sself) { sself->SetModeToRigidBody(); } +extern "C" void vtk_landmark_transform_set_mode_to_similarity(vtkNew sself) { sself->SetModeToSimilarity(); } +extern "C" void vtk_landmark_transform_set_mode_to_affine(vtkNew sself) { sself->SetModeToAffine(); } +extern "C" int vtk_landmark_transform_get_mode(vtkNew sself) { return sself->GetMode(); } +extern "C" const char* vtk_landmark_transform_get_mode_as_string(vtkNew sself) { return sself->GetModeAsString(); } +extern "C" void vtk_landmark_transform_inverse(vtkNew sself) { sself->Inverse(); } +extern "C" unsigned long vtk_landmark_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkMatrixToHomogeneousTransform > vtkMatrixToHomogeneousTransform_new () {return vtkNew < vtkMatrixToHomogeneousTransform > () ;} extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkNew < vtkMatrixToHomogeneousTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkMatrixToHomogeneousTransform_get_ptr (vtkNew < vtkMatrixToHomogeneousTransform > sself) {return sself . GetPointer () ;} +extern "C" void vtk_matrix_to_homogeneous_transform_inverse(vtkNew sself) { sself->Inverse(); } +extern "C" unsigned long vtk_matrix_to_homogeneous_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkMatrixToLinearTransform > vtkMatrixToLinearTransform_new () {return vtkNew < vtkMatrixToLinearTransform > () ;} extern "C" void vtkMatrixToLinearTransform_destructor (vtkNew < vtkMatrixToLinearTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkMatrixToLinearTransform_get_ptr (vtkNew < vtkMatrixToLinearTransform > sself) {return sself . GetPointer () ;} +extern "C" void vtk_matrix_to_linear_transform_inverse(vtkNew sself) { sself->Inverse(); } +extern "C" unsigned long vtk_matrix_to_linear_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkPerspectiveTransform > vtkPerspectiveTransform_new () {return vtkNew < vtkPerspectiveTransform > () ;} extern "C" void vtkPerspectiveTransform_destructor (vtkNew < vtkPerspectiveTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkPerspectiveTransform_get_ptr (vtkNew < vtkPerspectiveTransform > sself) {return sself . GetPointer () ;} +extern "C" void vtk_perspective_transform_identity(vtkNew sself) { sself->Identity(); } +extern "C" void vtk_perspective_transform_inverse(vtkNew sself) { sself->Inverse(); } +extern "C" void vtk_perspective_transform_adjust_viewport(vtkNew sself, double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax) { sself->AdjustViewport(oldXMin, oldXMax, oldYMin, oldYMax, newXMin, newXMax, newYMin, newYMax); } +extern "C" void vtk_perspective_transform_adjust_z_buffer(vtkNew sself, double oldNearZ, double oldFarZ, double newNearZ, double newFarZ) { sself->AdjustZBuffer(oldNearZ, oldFarZ, newNearZ, newFarZ); } +extern "C" void vtk_perspective_transform_ortho(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar) { sself->Ortho(xmin, xmax, ymin, ymax, znear, zfar); } +extern "C" void vtk_perspective_transform_frustum(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar) { sself->Frustum(xmin, xmax, ymin, ymax, znear, zfar); } +extern "C" void vtk_perspective_transform_perspective(vtkNew sself, double angle, double aspect, double znear, double zfar) { sself->Perspective(angle, aspect, znear, zfar); } +extern "C" void vtk_perspective_transform_shear(vtkNew sself, double dxdz, double dydz, double zplane) { sself->Shear(dxdz, dydz, zplane); } +extern "C" void vtk_perspective_transform_stereo(vtkNew sself, double angle, double focaldistance) { sself->Stereo(angle, focaldistance); } +extern "C" void vtk_perspective_transform_setup_camera(vtkNew sself, const double position, const double focalpoint, const double viewup) { sself->SetupCamera(position, focalpoint, viewup); } +extern "C" void vtk_perspective_transform_setup_camera(vtkNew sself, double p0, double p1, double p2, double fp0, double fp1, double fp2, double vup0, double vup1, double vup2) { sself->SetupCamera(p0, p1, p2, fp0, fp1, fp2, vup0, vup1, vup2); } +extern "C" void vtk_perspective_transform_translate(vtkNew sself, double x, double y, double z) { sself->Translate(x, y, z); } +extern "C" void vtk_perspective_transform_translate(vtkNew sself, const double x) { sself->Translate(x); } +extern "C" void vtk_perspective_transform_translate(vtkNew sself, const float x) { sself->Translate(x); } +extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } +extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, const double axis) { sself->RotateWXYZ(angle, axis); } +extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, const float axis) { sself->RotateWXYZ(angle, axis); } +extern "C" void vtk_perspective_transform_rotate_x(vtkNew sself, double angle) { sself->RotateX(angle); } +extern "C" void vtk_perspective_transform_rotate_y(vtkNew sself, double angle) { sself->RotateY(angle); } +extern "C" void vtk_perspective_transform_rotate_z(vtkNew sself, double angle) { sself->RotateZ(angle); } +extern "C" void vtk_perspective_transform_scale(vtkNew sself, double x, double y, double z) { sself->Scale(x, y, z); } +extern "C" void vtk_perspective_transform_scale(vtkNew sself, const double s) { sself->Scale(s); } +extern "C" void vtk_perspective_transform_scale(vtkNew sself, const float s) { sself->Scale(s); } +extern "C" void vtk_perspective_transform_set_matrix(vtkNew sself, const double elements) { sself->SetMatrix(elements); } +extern "C" void vtk_perspective_transform_concatenate(vtkNew sself, const double elements) { sself->Concatenate(elements); } +extern "C" void vtk_perspective_transform_pre_multiply(vtkNew sself) { sself->PreMultiply(); } +extern "C" void vtk_perspective_transform_post_multiply(vtkNew sself) { sself->PostMultiply(); } +extern "C" int vtk_perspective_transform_get_number_of_concatenated_transforms(vtkNew sself) { return sself->GetNumberOfConcatenatedTransforms(); } +extern "C" int vtk_perspective_transform_get_inverse_flag(vtkNew sself) { return sself->GetInverseFlag(); } +extern "C" void vtk_perspective_transform_push(vtkNew sself) { sself->Push(); } +extern "C" void vtk_perspective_transform_pop(vtkNew sself) { sself->Pop(); } +extern "C" unsigned long vtk_perspective_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } extern "C" vtkNew < vtkSphericalTransform > vtkSphericalTransform_new () {return vtkNew < vtkSphericalTransform > () ;} extern "C" void vtkSphericalTransform_destructor (vtkNew < vtkSphericalTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkSphericalTransform_get_ptr (vtkNew < vtkSphericalTransform > sself) {return sself . GetPointer () ;} extern "C" vtkNew < vtkThinPlateSplineTransform > vtkThinPlateSplineTransform_new () {return vtkNew < vtkThinPlateSplineTransform > () ;} extern "C" void vtkThinPlateSplineTransform_destructor (vtkNew < vtkThinPlateSplineTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkThinPlateSplineTransform_get_ptr (vtkNew < vtkThinPlateSplineTransform > sself) {return sself . GetPointer () ;} +extern "C" double vtk_thin_plate_spline_transform_get_sigma(vtkNew sself) { return sself->GetSigma(); } +extern "C" void vtk_thin_plate_spline_transform_set_sigma(vtkNew sself, double _arg) { sself->SetSigma(_arg); } +extern "C" void vtk_thin_plate_spline_transform_set_basis(vtkNew sself, int basis) { sself->SetBasis(basis); } +extern "C" int vtk_thin_plate_spline_transform_get_basis(vtkNew sself) { return sself->GetBasis(); } +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r(vtkNew sself) { sself->SetBasisToR(); } +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(vtkNew sself) { sself->SetBasisToR2LogR(); } +extern "C" const char* vtk_thin_plate_spline_transform_get_basis_as_string(vtkNew sself) { return sself->GetBasisAsString(); } +extern "C" unsigned long vtk_thin_plate_spline_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" bool vtk_thin_plate_spline_transform_get_regularize_bulk_transform(vtkNew sself) { return sself->GetRegularizeBulkTransform(); } +extern "C" void vtk_thin_plate_spline_transform_set_regularize_bulk_transform(vtkNew sself, bool _arg) { sself->SetRegularizeBulkTransform(_arg); } +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_on(vtkNew sself) { sself->RegularizeBulkTransformOn(); } +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_off(vtkNew sself) { sself->RegularizeBulkTransformOff(); } extern "C" vtkNew < vtkTransform > vtkTransform_new () {return vtkNew < vtkTransform > () ;} extern "C" void vtkTransform_destructor (vtkNew < vtkTransform > sself) {sself . Reset () ; return ;} extern "C" void * vtkTransform_get_ptr (vtkNew < vtkTransform > sself) {return sself . GetPointer () ;} +extern "C" void vtk_transform_identity(vtkNew sself) { sself->Identity(); } +extern "C" void vtk_transform_inverse(vtkNew sself) { sself->Inverse(); } +extern "C" void vtk_transform_translate(vtkNew sself, double x, double y, double z) { sself->Translate(x, y, z); } +extern "C" void vtk_transform_translate(vtkNew sself, const double x) { sself->Translate(x); } +extern "C" void vtk_transform_translate(vtkNew sself, const float x) { sself->Translate(x); } +extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } +extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, const double axis) { sself->RotateWXYZ(angle, axis); } +extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, const float axis) { sself->RotateWXYZ(angle, axis); } +extern "C" void vtk_transform_rotate_x(vtkNew sself, double angle) { sself->RotateX(angle); } +extern "C" void vtk_transform_rotate_y(vtkNew sself, double angle) { sself->RotateY(angle); } +extern "C" void vtk_transform_rotate_z(vtkNew sself, double angle) { sself->RotateZ(angle); } +extern "C" void vtk_transform_scale(vtkNew sself, double x, double y, double z) { sself->Scale(x, y, z); } +extern "C" void vtk_transform_scale(vtkNew sself, const double s) { sself->Scale(s); } +extern "C" void vtk_transform_scale(vtkNew sself, const float s) { sself->Scale(s); } +extern "C" void vtk_transform_set_matrix(vtkNew sself, const double elements) { sself->SetMatrix(elements); } +extern "C" void vtk_transform_concatenate(vtkNew sself, const double elements) { sself->Concatenate(elements); } +extern "C" void vtk_transform_pre_multiply(vtkNew sself) { sself->PreMultiply(); } +extern "C" void vtk_transform_post_multiply(vtkNew sself) { sself->PostMultiply(); } +extern "C" int vtk_transform_get_number_of_concatenated_transforms(vtkNew sself) { return sself->GetNumberOfConcatenatedTransforms(); } +extern "C" void vtk_transform_get_orientation(vtkNew sself, double orient) { sself->GetOrientation(orient); } +extern "C" void vtk_transform_get_orientation(vtkNew sself, float orient) { sself->GetOrientation(orient); } +extern "C" double* vtk_transform_get_orientation(vtkNew sself) { return sself->GetOrientation(); } +extern "C" void vtk_transform_get_orientation_wxyz(vtkNew sself, double wxyz) { sself->GetOrientationWXYZ(wxyz); } +extern "C" void vtk_transform_get_orientation_wxyz(vtkNew sself, float wxyz) { sself->GetOrientationWXYZ(wxyz); } +extern "C" double* vtk_transform_get_orientation_wxyz(vtkNew sself) { return sself->GetOrientationWXYZ(); } +extern "C" void vtk_transform_get_position(vtkNew sself, double pos) { sself->GetPosition(pos); } +extern "C" void vtk_transform_get_position(vtkNew sself, float pos) { sself->GetPosition(pos); } +extern "C" double* vtk_transform_get_position(vtkNew sself) { return sself->GetPosition(); } +extern "C" void vtk_transform_get_scale(vtkNew sself, double scale) { sself->GetScale(scale); } +extern "C" void vtk_transform_get_scale(vtkNew sself, float scale) { sself->GetScale(scale); } +extern "C" double* vtk_transform_get_scale(vtkNew sself) { return sself->GetScale(); } +extern "C" int vtk_transform_get_inverse_flag(vtkNew sself) { return sself->GetInverseFlag(); } +extern "C" void vtk_transform_push(vtkNew sself) { sself->Push(); } +extern "C" void vtk_transform_pop(vtkNew sself) { sself->Pop(); } +extern "C" unsigned long vtk_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_transform_multiply_point(vtkNew sself, const float in, float out) { sself->MultiplyPoint(in, out); } +extern "C" void vtk_transform_multiply_point(vtkNew sself, const double in, double out) { sself->MultiplyPoint(in, out); } extern "C" vtkNew < vtkTransform2D > vtkTransform2D_new () {return vtkNew < vtkTransform2D > () ;} extern "C" void vtkTransform2D_destructor (vtkNew < vtkTransform2D > sself) {sself . Reset () ; return ;} extern "C" void * vtkTransform2D_get_ptr (vtkNew < vtkTransform2D > sself) {return sself . GetPointer () ;} +extern "C" void vtk_transform_2_d_identity(vtkNew sself) { sself->Identity(); } +extern "C" void vtk_transform_2_d_inverse(vtkNew sself) { sself->Inverse(); } +extern "C" void vtk_transform_2_d_translate(vtkNew sself, double x, double y) { sself->Translate(x, y); } +extern "C" void vtk_transform_2_d_translate(vtkNew sself, const double x) { sself->Translate(x); } +extern "C" void vtk_transform_2_d_translate(vtkNew sself, const float x) { sself->Translate(x); } +extern "C" void vtk_transform_2_d_rotate(vtkNew sself, double angle) { sself->Rotate(angle); } +extern "C" void vtk_transform_2_d_scale(vtkNew sself, double x, double y) { sself->Scale(x, y); } +extern "C" void vtk_transform_2_d_scale(vtkNew sself, const double s) { sself->Scale(s); } +extern "C" void vtk_transform_2_d_scale(vtkNew sself, const float s) { sself->Scale(s); } +extern "C" void vtk_transform_2_d_set_matrix(vtkNew sself, const double elements) { sself->SetMatrix(elements); } +extern "C" void vtk_transform_2_d_get_position(vtkNew sself, double pos) { sself->GetPosition(pos); } +extern "C" void vtk_transform_2_d_get_position(vtkNew sself, float pos) { sself->GetPosition(pos); } +extern "C" void vtk_transform_2_d_get_scale(vtkNew sself, double scale) { sself->GetScale(scale); } +extern "C" void vtk_transform_2_d_get_scale(vtkNew sself, float pos) { sself->GetScale(pos); } +extern "C" unsigned long vtk_transform_2_d_get_m_time(vtkNew sself) { return sself->GetMTime(); } +extern "C" void vtk_transform_2_d_transform_points(vtkNew sself, const float inPts, float outPts, int n) { sself->TransformPoints(inPts, outPts, n); } +extern "C" void vtk_transform_2_d_transform_points(vtkNew sself, const double inPts, double outPts, int n) { sself->TransformPoints(inPts, outPts, n); } +extern "C" void vtk_transform_2_d_inverse_transform_points(vtkNew sself, const float inPts, float outPts, int n) { sself->InverseTransformPoints(inPts, outPts, n); } +extern "C" void vtk_transform_2_d_inverse_transform_points(vtkNew sself, const double inPts, double outPts, int n) { sself->InverseTransformPoints(inPts, outPts, n); } +extern "C" void vtk_transform_2_d_multiply_point(vtkNew sself, const float in, float out) { sself->MultiplyPoint(in, out); } +extern "C" void vtk_transform_2_d_multiply_point(vtkNew sself, const double in, double out) { sself->MultiplyPoint(in, out); } extern "C" vtkNew < vtkTransformCollection > vtkTransformCollection_new () {return vtkNew < vtkTransformCollection > () ;} extern "C" void vtkTransformCollection_destructor (vtkNew < vtkTransformCollection > sself) {sself . Reset () ; return ;} extern "C" void * vtkTransformCollection_get_ptr (vtkNew < vtkTransformCollection > sself) {return sself . GetPointer () ;} diff --git a/vtk-rs-9.1/src/lib.rs b/vtk-rs-9.1/src/lib.rs index f5d6964..93331ba 100644 --- a/vtk-rs-9.1/src/lib.rs +++ b/vtk-rs-9.1/src/lib.rs @@ -1,6 +1,5 @@ #![allow(non_camel_case_types)] #![allow(non_snake_case)] -pub mod vtkCommonArchive; pub mod vtkCommonColor; pub mod vtkCommonComputationalGeometry; pub mod vtkCommonCore; @@ -8,6 +7,5 @@ pub mod vtkCommonDataModel; pub mod vtkCommonExecutionModel; pub mod vtkCommonMath; pub mod vtkCommonMisc; -pub mod vtkCommonPython; pub mod vtkCommonSystem; pub mod vtkCommonTransforms; diff --git a/vtk-rs-9.1/src/vtkCommonColor.rs b/vtk-rs-9.1/src/vtkCommonColor.rs index 4a38677..10f51f5 100644 --- a/vtk-rs-9.1/src/vtkCommonColor.rs +++ b/vtk-rs-9.1/src/vtkCommonColor.rs @@ -1,3 +1,707 @@ +pub trait VtkColorSeries { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_color_scheme(&mut self, scheme: core::ffi::c_int) -> (); + fn set_color_scheme_by_name(&mut self, schemeName: vtkStdString) -> core::ffi::c_int; + fn get_number_of_color_schemes(&mut self) -> core::ffi::c_int; + fn get_color_scheme_name(&mut self) -> *mut core::ffi::c_void; + fn set_color_scheme_name(&mut self, name: vtkStdString) -> (); + fn get_color_scheme(&mut self) -> core::ffi::c_int; + fn get_number_of_colors(&mut self) -> core::ffi::c_int; + fn set_number_of_colors(&mut self, numColors: core::ffi::c_int) -> (); + fn get_color(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_color_repeating(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_color(&mut self, index: core::ffi::c_int, color: vtkColor3ub) -> (); + fn add_color(&mut self, color: vtkColor3ub) -> (); + fn insert_color(&mut self, index: core::ffi::c_int, color: vtkColor3ub) -> (); + fn remove_color(&mut self, index: core::ffi::c_int) -> (); + fn clear_colors(&mut self) -> (); + fn deep_copy(&mut self, chartColors: *mut core::ffi::c_void) -> (); + fn build_lookup_table( + &mut self, + lkup: *mut core::ffi::c_void, + lutIndexing: core::ffi::c_int, + ) -> (); + fn create_lookup_table( + &mut self, + lutIndexing: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkNamedColors { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_colors(&mut self) -> core::ffi::c_int; + fn reset_colors(&mut self) -> (); + fn color_exists(&mut self, name: vtkStdString) -> bool; + fn get_color_4_ub(&mut self, name: vtkStdString) -> *mut core::ffi::c_void; + fn get_color( + &mut self, + name: vtkStdString, + r: core::ffi::c_uchar, + g: core::ffi::c_uchar, + b: core::ffi::c_uchar, + a: core::ffi::c_uchar, + ) -> (); + fn get_color(&mut self, name: vtkStdString, rgba: core::ffi::c_uchar) -> (); + fn get_color(&mut self, name: vtkStdString, rgba: *mut core::ffi::c_void) -> (); + fn get_color_4_d(&mut self, name: vtkStdString) -> *mut core::ffi::c_void; + fn get_color( + &mut self, + name: vtkStdString, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ) -> (); + fn get_color(&mut self, name: vtkStdString, rgba: core::ffi::c_double) -> (); + fn get_color(&mut self, name: vtkStdString, rgba: *mut core::ffi::c_void) -> (); + fn get_color_3_ub(&mut self, name: vtkStdString) -> *mut core::ffi::c_void; + fn get_color_3_d(&mut self, name: vtkStdString) -> *mut core::ffi::c_void; + fn get_color( + &mut self, + name: vtkStdString, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + ) -> (); + fn get_color_rgb(&mut self, name: vtkStdString, rgb: core::ffi::c_double) -> (); + fn get_color(&mut self, name: vtkStdString, rgb: *mut core::ffi::c_void) -> (); + fn get_color(&mut self, name: vtkStdString, rgb: *mut core::ffi::c_void) -> (); + fn set_color( + &mut self, + name: vtkStdString, + r: core::ffi::c_uchar, + g: core::ffi::c_uchar, + b: core::ffi::c_uchar, + a: core::ffi::c_uchar, + ) -> (); + fn set_color( + &mut self, + name: vtkStdString, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ) -> (); + fn set_color(&mut self, name: vtkStdString, rgba: core::ffi::c_uchar) -> (); + fn set_color(&mut self, name: vtkStdString, rgba: vtkColor4ub) -> (); + fn set_color(&mut self, name: vtkStdString, rgb: vtkColor3ub) -> (); + fn set_color(&mut self, name: vtkStdString, rgba: core::ffi::c_double) -> (); + fn set_color(&mut self, name: vtkStdString, rgba: vtkColor4d) -> (); + fn set_color(&mut self, name: vtkStdString, rgb: vtkColor3d) -> (); + fn remove_color(&mut self, name: vtkStdString) -> (); + fn get_color_names(&mut self) -> *mut core::ffi::c_void; + fn get_color_names(&mut self, colorNames: *mut core::ffi::c_void) -> (); + fn get_synonyms(&mut self) -> *mut core::ffi::c_void; + fn html_color_to_rgba( + &mut self, + colorString: vtkStdString, + ) -> *mut core::ffi::c_void; + fn html_color_to_rgb(&mut self, colorString: vtkStdString) -> *mut core::ffi::c_void; + fn rgb_to_html_color(&mut self, rgb: vtkColor3ub) -> *mut core::ffi::c_void; + fn rgba_to_html_color(&mut self, rgba: vtkColor4ub) -> *mut core::ffi::c_void; + fn set_color(&mut self, name: vtkStdString, htmlString: vtkStdString) -> (); +} +impl VtkColorSeries for vtkColorSeries { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_new(self.0) } + } + fn set_color_scheme(&mut self, scheme: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_color_series_set_color_scheme( + sself: *mut core::ffi::c_void, + scheme: core::ffi::c_int, + ); + } + unsafe { vtk_color_series_set_color_scheme(self.0, scheme) } + } + fn set_color_scheme_by_name( + &mut self, + schemeName: vtkStdString, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_color_series_set_color_scheme_by_name( + sself: *mut core::ffi::c_void, + schemeName: vtkStdString, + ) -> core::ffi::c_int; + } + unsafe { vtk_color_series_set_color_scheme_by_name(self.0, schemeName) } + } + fn get_number_of_color_schemes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_color_series_get_number_of_color_schemes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_color_series_get_number_of_color_schemes(self.0) } + } + fn get_color_scheme_name(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_get_color_scheme_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_get_color_scheme_name(self.0) } + } + fn set_color_scheme_name(&mut self, name: vtkStdString) -> () { + unsafe extern "C" { + fn vtk_color_series_set_color_scheme_name( + sself: *mut core::ffi::c_void, + name: vtkStdString, + ); + } + unsafe { vtk_color_series_set_color_scheme_name(self.0, name) } + } + fn get_color_scheme(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_color_series_get_color_scheme( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_color_series_get_color_scheme(self.0) } + } + fn get_number_of_colors(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_color_series_get_number_of_colors( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_color_series_get_number_of_colors(self.0) } + } + fn set_number_of_colors(&mut self, numColors: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_color_series_set_number_of_colors( + sself: *mut core::ffi::c_void, + numColors: core::ffi::c_int, + ); + } + unsafe { vtk_color_series_set_number_of_colors(self.0, numColors) } + } + fn get_color(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_get_color( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_get_color(self.0, index) } + } + fn get_color_repeating( + &mut self, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_get_color_repeating( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_get_color_repeating(self.0, index) } + } + fn set_color(&mut self, index: core::ffi::c_int, color: vtkColor3ub) -> () { + unsafe extern "C" { + fn vtk_color_series_set_color( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + color: vtkColor3ub, + ); + } + unsafe { vtk_color_series_set_color(self.0, index, color) } + } + fn add_color(&mut self, color: vtkColor3ub) -> () { + unsafe extern "C" { + fn vtk_color_series_add_color( + sself: *mut core::ffi::c_void, + color: vtkColor3ub, + ); + } + unsafe { vtk_color_series_add_color(self.0, color) } + } + fn insert_color(&mut self, index: core::ffi::c_int, color: vtkColor3ub) -> () { + unsafe extern "C" { + fn vtk_color_series_insert_color( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + color: vtkColor3ub, + ); + } + unsafe { vtk_color_series_insert_color(self.0, index, color) } + } + fn remove_color(&mut self, index: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_color_series_remove_color( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ); + } + unsafe { vtk_color_series_remove_color(self.0, index) } + } + fn clear_colors(&mut self) -> () { + unsafe extern "C" { + fn vtk_color_series_clear_colors(sself: *mut core::ffi::c_void); + } + unsafe { vtk_color_series_clear_colors(self.0) } + } + fn deep_copy(&mut self, chartColors: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_color_series_deep_copy( + sself: *mut core::ffi::c_void, + chartColors: *mut core::ffi::c_void, + ); + } + unsafe { vtk_color_series_deep_copy(self.0, chartColors) } + } + fn build_lookup_table( + &mut self, + lkup: *mut core::ffi::c_void, + lutIndexing: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_color_series_build_lookup_table( + sself: *mut core::ffi::c_void, + lkup: *mut core::ffi::c_void, + lutIndexing: core::ffi::c_int, + ); + } + unsafe { vtk_color_series_build_lookup_table(self.0, lkup, lutIndexing) } + } + fn create_lookup_table( + &mut self, + lutIndexing: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_create_lookup_table( + sself: *mut core::ffi::c_void, + lutIndexing: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_create_lookup_table(self.0, lutIndexing) } + } +} +impl VtkNamedColors for vtkNamedColors { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_new(self.0) } + } + fn get_number_of_colors(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_named_colors_get_number_of_colors( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_named_colors_get_number_of_colors(self.0) } + } + fn reset_colors(&mut self) -> () { + unsafe extern "C" { + fn vtk_named_colors_reset_colors(sself: *mut core::ffi::c_void); + } + unsafe { vtk_named_colors_reset_colors(self.0) } + } + fn color_exists(&mut self, name: vtkStdString) -> bool { + unsafe extern "C" { + fn vtk_named_colors_color_exists( + sself: *mut core::ffi::c_void, + name: vtkStdString, + ) -> bool; + } + unsafe { vtk_named_colors_color_exists(self.0, name) } + } + fn get_color_4_ub(&mut self, name: vtkStdString) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_get_color_4_ub( + sself: *mut core::ffi::c_void, + name: vtkStdString, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_get_color_4_ub(self.0, name) } + } + fn get_color( + &mut self, + name: vtkStdString, + r: core::ffi::c_uchar, + g: core::ffi::c_uchar, + b: core::ffi::c_uchar, + a: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + r: core::ffi::c_uchar, + g: core::ffi::c_uchar, + b: core::ffi::c_uchar, + a: core::ffi::c_uchar, + ); + } + unsafe { vtk_named_colors_get_color(self.0, name, r, g, b, a) } + } + fn get_color(&mut self, name: vtkStdString, rgba: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgba: core::ffi::c_uchar, + ); + } + unsafe { vtk_named_colors_get_color(self.0, name, rgba) } + } + fn get_color(&mut self, name: vtkStdString, rgba: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgba: *mut core::ffi::c_void, + ); + } + unsafe { vtk_named_colors_get_color(self.0, name, rgba) } + } + fn get_color_4_d(&mut self, name: vtkStdString) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_get_color_4_d( + sself: *mut core::ffi::c_void, + name: vtkStdString, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_get_color_4_d(self.0, name) } + } + fn get_color( + &mut self, + name: vtkStdString, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ); + } + unsafe { vtk_named_colors_get_color(self.0, name, r, g, b, a) } + } + fn get_color(&mut self, name: vtkStdString, rgba: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgba: core::ffi::c_double, + ); + } + unsafe { vtk_named_colors_get_color(self.0, name, rgba) } + } + fn get_color(&mut self, name: vtkStdString, rgba: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgba: *mut core::ffi::c_void, + ); + } + unsafe { vtk_named_colors_get_color(self.0, name, rgba) } + } + fn get_color_3_ub(&mut self, name: vtkStdString) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_get_color_3_ub( + sself: *mut core::ffi::c_void, + name: vtkStdString, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_get_color_3_ub(self.0, name) } + } + fn get_color_3_d(&mut self, name: vtkStdString) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_get_color_3_d( + sself: *mut core::ffi::c_void, + name: vtkStdString, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_get_color_3_d(self.0, name) } + } + fn get_color( + &mut self, + name: vtkStdString, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + ); + } + unsafe { vtk_named_colors_get_color(self.0, name, r, g, b) } + } + fn get_color_rgb(&mut self, name: vtkStdString, rgb: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color_rgb( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgb: core::ffi::c_double, + ); + } + unsafe { vtk_named_colors_get_color_rgb(self.0, name, rgb) } + } + fn get_color(&mut self, name: vtkStdString, rgb: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgb: *mut core::ffi::c_void, + ); + } + unsafe { vtk_named_colors_get_color(self.0, name, rgb) } + } + fn get_color(&mut self, name: vtkStdString, rgb: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgb: *mut core::ffi::c_void, + ); + } + unsafe { vtk_named_colors_get_color(self.0, name, rgb) } + } + fn set_color( + &mut self, + name: vtkStdString, + r: core::ffi::c_uchar, + g: core::ffi::c_uchar, + b: core::ffi::c_uchar, + a: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_named_colors_set_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + r: core::ffi::c_uchar, + g: core::ffi::c_uchar, + b: core::ffi::c_uchar, + a: core::ffi::c_uchar, + ); + } + unsafe { vtk_named_colors_set_color(self.0, name, r, g, b, a) } + } + fn set_color( + &mut self, + name: vtkStdString, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_named_colors_set_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ); + } + unsafe { vtk_named_colors_set_color(self.0, name, r, g, b, a) } + } + fn set_color(&mut self, name: vtkStdString, rgba: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_named_colors_set_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgba: core::ffi::c_uchar, + ); + } + unsafe { vtk_named_colors_set_color(self.0, name, rgba) } + } + fn set_color(&mut self, name: vtkStdString, rgba: vtkColor4ub) -> () { + unsafe extern "C" { + fn vtk_named_colors_set_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgba: vtkColor4ub, + ); + } + unsafe { vtk_named_colors_set_color(self.0, name, rgba) } + } + fn set_color(&mut self, name: vtkStdString, rgb: vtkColor3ub) -> () { + unsafe extern "C" { + fn vtk_named_colors_set_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgb: vtkColor3ub, + ); + } + unsafe { vtk_named_colors_set_color(self.0, name, rgb) } + } + fn set_color(&mut self, name: vtkStdString, rgba: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_named_colors_set_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgba: core::ffi::c_double, + ); + } + unsafe { vtk_named_colors_set_color(self.0, name, rgba) } + } + fn set_color(&mut self, name: vtkStdString, rgba: vtkColor4d) -> () { + unsafe extern "C" { + fn vtk_named_colors_set_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgba: vtkColor4d, + ); + } + unsafe { vtk_named_colors_set_color(self.0, name, rgba) } + } + fn set_color(&mut self, name: vtkStdString, rgb: vtkColor3d) -> () { + unsafe extern "C" { + fn vtk_named_colors_set_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + rgb: vtkColor3d, + ); + } + unsafe { vtk_named_colors_set_color(self.0, name, rgb) } + } + fn remove_color(&mut self, name: vtkStdString) -> () { + unsafe extern "C" { + fn vtk_named_colors_remove_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + ); + } + unsafe { vtk_named_colors_remove_color(self.0, name) } + } + fn get_color_names(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_get_color_names( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_get_color_names(self.0) } + } + fn get_color_names(&mut self, colorNames: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_named_colors_get_color_names( + sself: *mut core::ffi::c_void, + colorNames: *mut core::ffi::c_void, + ); + } + unsafe { vtk_named_colors_get_color_names(self.0, colorNames) } + } + fn get_synonyms(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_get_synonyms( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_get_synonyms(self.0) } + } + fn html_color_to_rgba( + &mut self, + colorString: vtkStdString, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_html_color_to_rgba( + sself: *mut core::ffi::c_void, + colorString: vtkStdString, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_html_color_to_rgba(self.0, colorString) } + } + fn html_color_to_rgb( + &mut self, + colorString: vtkStdString, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_html_color_to_rgb( + sself: *mut core::ffi::c_void, + colorString: vtkStdString, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_html_color_to_rgb(self.0, colorString) } + } + fn rgb_to_html_color(&mut self, rgb: vtkColor3ub) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_rgb_to_html_color( + sself: *mut core::ffi::c_void, + rgb: vtkColor3ub, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_rgb_to_html_color(self.0, rgb) } + } + fn rgba_to_html_color(&mut self, rgba: vtkColor4ub) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_rgba_to_html_color( + sself: *mut core::ffi::c_void, + rgba: vtkColor4ub, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_rgba_to_html_color(self.0, rgba) } + } + fn set_color(&mut self, name: vtkStdString, htmlString: vtkStdString) -> () { + unsafe extern "C" { + fn vtk_named_colors_set_color( + sself: *mut core::ffi::c_void, + name: vtkStdString, + htmlString: vtkStdString, + ); + } + unsafe { vtk_named_colors_set_color(self.0, name, htmlString) } + } +} /// stores a list of colors. /// /// diff --git a/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs b/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs index dd6b563..37dac7c 100644 --- a/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs +++ b/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs @@ -1,3 +1,3254 @@ +pub trait VtkBilinearQuadIntersection { + fn get_p_00_data(&mut self) -> *mut core::ffi::c_double; + fn get_p_01_data(&mut self) -> *mut core::ffi::c_double; + fn get_p_10_data(&mut self) -> *mut core::ffi::c_double; + fn get_p_11_data(&mut self) -> *mut core::ffi::c_double; + fn compute_cartesian_coordinates( + &mut self, + u: core::ffi::c_double, + v: core::ffi::c_double, + ) -> *mut core::ffi::c_void; + fn ray_intersection( + &mut self, + r: vtkVector3d, + q: vtkVector3d, + uv: *mut core::ffi::c_void, + ) -> bool; +} +pub trait VtkCardinalSpline { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn compute(&mut self) -> (); + fn evaluate(&mut self, t: core::ffi::c_double) -> core::ffi::c_double; + fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> (); +} +pub trait VtkKochanekSpline { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn compute(&mut self) -> (); + fn evaluate(&mut self, t: core::ffi::c_double) -> core::ffi::c_double; + fn set_default_bias(&mut self, _arg: core::ffi::c_double) -> (); + fn get_default_bias(&mut self) -> core::ffi::c_double; + fn set_default_tension(&mut self, _arg: core::ffi::c_double) -> (); + fn get_default_tension(&mut self) -> core::ffi::c_double; + fn set_default_continuity(&mut self, _arg: core::ffi::c_double) -> (); + fn get_default_continuity(&mut self) -> core::ffi::c_double; + fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> (); +} +pub trait VtkParametricBohemianDome: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_a(&mut self) -> core::ffi::c_double; + fn set_a(&mut self, _arg: core::ffi::c_double) -> (); + fn get_b(&mut self) -> core::ffi::c_double; + fn set_b(&mut self, _arg: core::ffi::c_double) -> (); + fn get_c(&mut self) -> core::ffi::c_double; + fn set_c(&mut self, _arg: core::ffi::c_double) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricBour: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricBoy: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_z_scale(&mut self, _arg: core::ffi::c_double) -> (); + fn get_z_scale(&mut self) -> core::ffi::c_double; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricCatalanMinimal: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricConicSpiral: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_a(&mut self, _arg: core::ffi::c_double) -> (); + fn get_a(&mut self) -> core::ffi::c_double; + fn set_b(&mut self, _arg: core::ffi::c_double) -> (); + fn get_b(&mut self) -> core::ffi::c_double; + fn set_c(&mut self, _arg: core::ffi::c_double) -> (); + fn get_c(&mut self) -> core::ffi::c_double; + fn set_n(&mut self, _arg: core::ffi::c_double) -> (); + fn get_n(&mut self) -> core::ffi::c_double; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricCrossCap: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricDini: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_a(&mut self, _arg: core::ffi::c_double) -> (); + fn get_a(&mut self) -> core::ffi::c_double; + fn set_b(&mut self, _arg: core::ffi::c_double) -> (); + fn get_b(&mut self) -> core::ffi::c_double; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricEllipsoid: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_x_radius(&mut self) -> core::ffi::c_double; + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_y_radius(&mut self) -> core::ffi::c_double; + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_z_radius(&mut self) -> core::ffi::c_double; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricEnneper: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricFigure8Klein: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + fn set_minimum_u(&mut self, _arg: core::ffi::c_double) -> (); + fn get_minimum_u(&mut self) -> core::ffi::c_double; + fn set_maximum_u(&mut self, _arg: core::ffi::c_double) -> (); + fn get_maximum_u(&mut self) -> core::ffi::c_double; + fn set_minimum_v(&mut self, _arg: core::ffi::c_double) -> (); + fn get_minimum_v(&mut self) -> core::ffi::c_double; + fn set_maximum_v(&mut self, _arg: core::ffi::c_double) -> (); + fn get_maximum_v(&mut self) -> core::ffi::c_double; + fn set_minimum_w(&mut self, _arg: core::ffi::c_double) -> (); + fn get_minimum_w(&mut self) -> core::ffi::c_double; + fn set_maximum_w(&mut self, _arg: core::ffi::c_double) -> (); + fn get_maximum_w(&mut self) -> core::ffi::c_double; + fn set_join_u(&mut self, _arg: core::ffi::c_int) -> (); + fn get_join_u_min_value(&mut self) -> core::ffi::c_int; + fn get_join_u_max_value(&mut self) -> core::ffi::c_int; + fn get_join_u(&mut self) -> core::ffi::c_int; + fn join_u_on(&mut self) -> (); + fn join_u_off(&mut self) -> (); + fn set_join_v(&mut self, _arg: core::ffi::c_int) -> (); + fn get_join_v_min_value(&mut self) -> core::ffi::c_int; + fn get_join_v_max_value(&mut self) -> core::ffi::c_int; + fn get_join_v(&mut self) -> core::ffi::c_int; + fn join_v_on(&mut self) -> (); + fn join_v_off(&mut self) -> (); + fn set_join_w(&mut self, _arg: core::ffi::c_int) -> (); + fn get_join_w_min_value(&mut self) -> core::ffi::c_int; + fn get_join_w_max_value(&mut self) -> core::ffi::c_int; + fn get_join_w(&mut self) -> core::ffi::c_int; + fn join_w_on(&mut self) -> (); + fn join_w_off(&mut self) -> (); + fn set_twist_u(&mut self, _arg: core::ffi::c_int) -> (); + fn get_twist_u_min_value(&mut self) -> core::ffi::c_int; + fn get_twist_u_max_value(&mut self) -> core::ffi::c_int; + fn get_twist_u(&mut self) -> core::ffi::c_int; + fn twist_u_on(&mut self) -> (); + fn twist_u_off(&mut self) -> (); + fn set_twist_v(&mut self, _arg: core::ffi::c_int) -> (); + fn get_twist_v_min_value(&mut self) -> core::ffi::c_int; + fn get_twist_v_max_value(&mut self) -> core::ffi::c_int; + fn get_twist_v(&mut self) -> core::ffi::c_int; + fn twist_v_on(&mut self) -> (); + fn twist_v_off(&mut self) -> (); + fn set_twist_w(&mut self, _arg: core::ffi::c_int) -> (); + fn get_twist_w_min_value(&mut self) -> core::ffi::c_int; + fn get_twist_w_max_value(&mut self) -> core::ffi::c_int; + fn get_twist_w(&mut self) -> core::ffi::c_int; + fn twist_w_on(&mut self) -> (); + fn twist_w_off(&mut self) -> (); + fn set_clockwise_ordering(&mut self, _arg: core::ffi::c_int) -> (); + fn get_clockwise_ordering_min_value(&mut self) -> core::ffi::c_int; + fn get_clockwise_ordering_max_value(&mut self) -> core::ffi::c_int; + fn get_clockwise_ordering(&mut self) -> core::ffi::c_int; + fn clockwise_ordering_on(&mut self) -> (); + fn clockwise_ordering_off(&mut self) -> (); + fn set_derivatives_available(&mut self, _arg: core::ffi::c_int) -> (); + fn get_derivatives_available_min_value(&mut self) -> core::ffi::c_int; + fn get_derivatives_available_max_value(&mut self) -> core::ffi::c_int; + fn get_derivatives_available(&mut self) -> core::ffi::c_int; + fn derivatives_available_on(&mut self) -> (); + fn derivatives_available_off(&mut self) -> (); +} +pub trait VtkParametricHenneberg: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricKlein: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricKuen: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_delta_v_0(&mut self, _arg: core::ffi::c_double) -> (); + fn get_delta_v_0(&mut self) -> core::ffi::c_double; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricMobius: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricPluckerConoid: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_n(&mut self) -> core::ffi::c_int; + fn set_n(&mut self, _arg: core::ffi::c_int) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricPseudosphere: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricRandomHills: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_hills(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_hills(&mut self) -> core::ffi::c_int; + fn set_hill_x_variance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_hill_x_variance(&mut self) -> core::ffi::c_double; + fn set_hill_y_variance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_hill_y_variance(&mut self) -> core::ffi::c_double; + fn set_hill_amplitude(&mut self, _arg: core::ffi::c_double) -> (); + fn get_hill_amplitude(&mut self) -> core::ffi::c_double; + fn set_random_seed(&mut self, _arg: core::ffi::c_int) -> (); + fn get_random_seed(&mut self) -> core::ffi::c_int; + fn set_allow_random_generation(&mut self, _arg: core::ffi::c_int) -> (); + fn get_allow_random_generation_min_value(&mut self) -> core::ffi::c_int; + fn get_allow_random_generation_max_value(&mut self) -> core::ffi::c_int; + fn get_allow_random_generation(&mut self) -> core::ffi::c_int; + fn allow_random_generation_on(&mut self) -> (); + fn allow_random_generation_off(&mut self) -> (); + fn set_x_variance_scale_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_x_variance_scale_factor(&mut self) -> core::ffi::c_double; + fn set_y_variance_scale_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_y_variance_scale_factor(&mut self) -> core::ffi::c_double; + fn set_amplitude_scale_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_amplitude_scale_factor(&mut self) -> core::ffi::c_double; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricRoman: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricSpline: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + u: core::ffi::c_double, + Pt: core::ffi::c_double, + Du: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + u: core::ffi::c_double, + Pt: core::ffi::c_double, + Du: core::ffi::c_double, + ) -> core::ffi::c_double; + fn set_x_spline(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_y_spline(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_z_spline(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_x_spline(&mut self) -> *mut core::ffi::c_void; + fn get_y_spline(&mut self) -> *mut core::ffi::c_void; + fn get_z_spline(&mut self) -> *mut core::ffi::c_void; + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points(&mut self, numPts: core::ffi::c_uchar) -> (); + fn set_point( + &mut self, + index: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_closed(&mut self, _arg: core::ffi::c_int) -> (); + fn get_closed(&mut self) -> core::ffi::c_int; + fn closed_on(&mut self) -> (); + fn closed_off(&mut self) -> (); + fn set_parameterize_by_length(&mut self, _arg: core::ffi::c_int) -> (); + fn get_parameterize_by_length(&mut self) -> core::ffi::c_int; + fn parameterize_by_length_on(&mut self) -> (); + fn parameterize_by_length_off(&mut self) -> (); + fn set_left_constraint(&mut self, _arg: core::ffi::c_int) -> (); + fn get_left_constraint_min_value(&mut self) -> core::ffi::c_int; + fn get_left_constraint_max_value(&mut self) -> core::ffi::c_int; + fn get_left_constraint(&mut self) -> core::ffi::c_int; + fn set_right_constraint(&mut self, _arg: core::ffi::c_int) -> (); + fn get_right_constraint_min_value(&mut self) -> core::ffi::c_int; + fn get_right_constraint_max_value(&mut self) -> core::ffi::c_int; + fn get_right_constraint(&mut self) -> core::ffi::c_int; + fn set_left_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_left_value(&mut self) -> core::ffi::c_double; + fn set_right_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_right_value(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricSuperEllipsoid: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_x_radius(&mut self) -> core::ffi::c_double; + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_y_radius(&mut self) -> core::ffi::c_double; + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_z_radius(&mut self) -> core::ffi::c_double; + fn set_n_1(&mut self, _arg: core::ffi::c_double) -> (); + fn get_n_1(&mut self) -> core::ffi::c_double; + fn set_n_2(&mut self, _arg: core::ffi::c_double) -> (); + fn get_n_2(&mut self) -> core::ffi::c_double; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricSuperToroid: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_ring_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_ring_radius(&mut self) -> core::ffi::c_double; + fn set_cross_section_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_cross_section_radius(&mut self) -> core::ffi::c_double; + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_x_radius(&mut self) -> core::ffi::c_double; + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_y_radius(&mut self) -> core::ffi::c_double; + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_z_radius(&mut self) -> core::ffi::c_double; + fn set_n_1(&mut self, _arg: core::ffi::c_double) -> (); + fn get_n_1(&mut self) -> core::ffi::c_double; + fn set_n_2(&mut self, _arg: core::ffi::c_double) -> (); + fn get_n_2(&mut self) -> core::ffi::c_double; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkParametricTorus: VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_ring_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_ring_radius(&mut self) -> core::ffi::c_double; + fn set_cross_section_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_cross_section_radius(&mut self) -> core::ffi::c_double; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> (); + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; +} +impl VtkCardinalSpline for vtkCardinalSpline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cardinal_spline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cardinal_spline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cardinal_spline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cardinal_spline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cardinal_spline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cardinal_spline_new_instance(self.0) } + } + fn compute(&mut self) -> () { + unsafe extern "C" { + fn vtk_cardinal_spline_compute(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cardinal_spline_compute(self.0) } + } + fn evaluate(&mut self, t: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cardinal_spline_evaluate( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_cardinal_spline_evaluate(self.0, t) } + } + fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cardinal_spline_deep_copy( + sself: *mut core::ffi::c_void, + s: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cardinal_spline_deep_copy(self.0, s) } + } +} +impl VtkKochanekSpline for vtkKochanekSpline { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kochanek_spline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kochanek_spline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kochanek_spline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kochanek_spline_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kochanek_spline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kochanek_spline_new(self.0) } + } + fn compute(&mut self) -> () { + unsafe extern "C" { + fn vtk_kochanek_spline_compute(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kochanek_spline_compute(self.0) } + } + fn evaluate(&mut self, t: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kochanek_spline_evaluate( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_kochanek_spline_evaluate(self.0, t) } + } + fn set_default_bias(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kochanek_spline_set_default_bias( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_kochanek_spline_set_default_bias(self.0, _arg) } + } + fn get_default_bias(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kochanek_spline_get_default_bias( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_kochanek_spline_get_default_bias(self.0) } + } + fn set_default_tension(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kochanek_spline_set_default_tension( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_kochanek_spline_set_default_tension(self.0, _arg) } + } + fn get_default_tension(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kochanek_spline_get_default_tension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_kochanek_spline_get_default_tension(self.0) } + } + fn set_default_continuity(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kochanek_spline_set_default_continuity( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_kochanek_spline_set_default_continuity(self.0, _arg) } + } + fn get_default_continuity(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kochanek_spline_get_default_continuity( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_kochanek_spline_get_default_continuity(self.0) } + } + fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kochanek_spline_deep_copy( + sself: *mut core::ffi::c_void, + s: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kochanek_spline_deep_copy(self.0, s) } + } +} +impl VtkParametricBohemianDome for vtkParametricBohemianDome { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bohemian_dome_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bohemian_dome_new_instance(self.0) } + } + fn get_a(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_get_a( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_bohemian_dome_get_a(self.0) } + } + fn set_a(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_set_a( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_bohemian_dome_set_a(self.0, _arg) } + } + fn get_b(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_get_b( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_bohemian_dome_get_b(self.0) } + } + fn set_b(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_set_b( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_bohemian_dome_set_b(self.0, _arg) } + } + fn get_c(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_get_c( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_bohemian_dome_get_c(self.0) } + } + fn set_c(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_set_c( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_bohemian_dome_set_c(self.0, _arg) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bohemian_dome_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_bohemian_dome_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_bohemian_dome_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_bohemian_dome_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricBour for vtkParametricBour { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bour_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bour_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bour_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bour_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bour_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bour_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_bour_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_bour_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_bour_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_bour_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_bour_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_bour_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricBoy for vtkParametricBoy { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_boy_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_boy_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_boy_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_boy_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_boy_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_boy_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_boy_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_boy_get_dimension(self.0) } + } + fn set_z_scale(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_boy_set_z_scale( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_boy_set_z_scale(self.0, _arg) } + } + fn get_z_scale(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_boy_get_z_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_boy_get_z_scale(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_boy_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_boy_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_boy_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_boy_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricCatalanMinimal for vtkParametricCatalanMinimal { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_catalan_minimal_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_catalan_minimal_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_catalan_minimal_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_catalan_minimal_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_catalan_minimal_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_catalan_minimal_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_catalan_minimal_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_catalan_minimal_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_catalan_minimal_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_catalan_minimal_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_catalan_minimal_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_catalan_minimal_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricConicSpiral for vtkParametricConicSpiral { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_conic_spiral_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_conic_spiral_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_conic_spiral_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_conic_spiral_get_dimension(self.0) } + } + fn set_a(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_set_a( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_conic_spiral_set_a(self.0, _arg) } + } + fn get_a(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_get_a( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_conic_spiral_get_a(self.0) } + } + fn set_b(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_set_b( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_conic_spiral_set_b(self.0, _arg) } + } + fn get_b(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_get_b( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_conic_spiral_get_b(self.0) } + } + fn set_c(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_set_c( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_conic_spiral_set_c(self.0, _arg) } + } + fn get_c(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_get_c( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_conic_spiral_get_c(self.0) } + } + fn set_n(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_set_n( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_conic_spiral_set_n(self.0, _arg) } + } + fn get_n(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_get_n( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_conic_spiral_get_n(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_conic_spiral_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_conic_spiral_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricCrossCap for vtkParametricCrossCap { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_cross_cap_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_cross_cap_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_cross_cap_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_cross_cap_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_cross_cap_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_cross_cap_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_cross_cap_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_cross_cap_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_cross_cap_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_cross_cap_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_cross_cap_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_cross_cap_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricDini for vtkParametricDini { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_dini_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_dini_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_dini_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_dini_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_dini_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_dini_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_dini_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_dini_get_dimension(self.0) } + } + fn set_a(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_dini_set_a( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_dini_set_a(self.0, _arg) } + } + fn get_a(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_dini_get_a( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_dini_get_a(self.0) } + } + fn set_b(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_dini_set_b( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_dini_set_b(self.0, _arg) } + } + fn get_b(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_dini_get_b( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_dini_get_b(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_dini_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_dini_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_dini_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_dini_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricEllipsoid for vtkParametricEllipsoid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_ellipsoid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_ellipsoid_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_ellipsoid_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_ellipsoid_get_dimension(self.0) } + } + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_set_x_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_ellipsoid_set_x_radius(self.0, _arg) } + } + fn get_x_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_get_x_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_ellipsoid_get_x_radius(self.0) } + } + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_set_y_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_ellipsoid_set_y_radius(self.0, _arg) } + } + fn get_y_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_get_y_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_ellipsoid_get_y_radius(self.0) } + } + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_set_z_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_ellipsoid_set_z_radius(self.0, _arg) } + } + fn get_z_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_get_z_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_ellipsoid_get_z_radius(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_ellipsoid_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_ellipsoid_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricEnneper for vtkParametricEnneper { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_enneper_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_enneper_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_enneper_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_enneper_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_enneper_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_enneper_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_enneper_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_enneper_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_enneper_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_enneper_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_enneper_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_enneper_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricFigure8Klein for vtkParametricFigure8Klein { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_figure_8_klein_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_figure_8_klein_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_figure_8_klein_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_figure_8_klein_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_figure_8_klein_get_radius(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_figure_8_klein_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_figure_8_klein_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_figure_8_klein_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricHenneberg for vtkParametricHenneberg { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_henneberg_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_henneberg_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_henneberg_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_henneberg_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_henneberg_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_henneberg_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_henneberg_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_henneberg_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_henneberg_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_henneberg_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_henneberg_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_henneberg_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricKlein for vtkParametricKlein { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_klein_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_klein_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_klein_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_klein_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_klein_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_klein_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_klein_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_klein_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_klein_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_klein_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_klein_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_klein_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricKuen for vtkParametricKuen { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_kuen_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_kuen_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_kuen_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_kuen_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_kuen_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_kuen_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_kuen_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_kuen_get_dimension(self.0) } + } + fn set_delta_v_0(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_kuen_set_delta_v_0( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_kuen_set_delta_v_0(self.0, _arg) } + } + fn get_delta_v_0(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_kuen_get_delta_v_0( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_kuen_get_delta_v_0(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_kuen_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_kuen_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_kuen_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_kuen_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricMobius for vtkParametricMobius { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_mobius_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_mobius_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_mobius_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_mobius_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_mobius_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_mobius_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_mobius_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_mobius_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_mobius_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_mobius_get_radius(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_mobius_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_mobius_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_mobius_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_mobius_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_mobius_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_mobius_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricPluckerConoid for vtkParametricPluckerConoid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_plucker_conoid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_plucker_conoid_new_instance(self.0) } + } + fn get_n(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_get_n( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_plucker_conoid_get_n(self.0) } + } + fn set_n(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_set_n( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_plucker_conoid_set_n(self.0, _arg) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_plucker_conoid_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_plucker_conoid_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_plucker_conoid_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_plucker_conoid_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricPseudosphere for vtkParametricPseudosphere { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_pseudosphere_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_pseudosphere_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_pseudosphere_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_pseudosphere_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_pseudosphere_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_pseudosphere_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_pseudosphere_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_pseudosphere_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_pseudosphere_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_pseudosphere_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_pseudosphere_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_pseudosphere_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricRandomHills for vtkParametricRandomHills { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_random_hills_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_random_hills_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_random_hills_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_random_hills_new_instance(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_random_hills_get_dimension(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_random_hills_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_random_hills_new(self.0) } + } + fn set_number_of_hills(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_number_of_hills( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_random_hills_set_number_of_hills(self.0, _arg) } + } + fn get_number_of_hills(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_number_of_hills( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_random_hills_get_number_of_hills(self.0) } + } + fn set_hill_x_variance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_hill_x_variance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_hill_x_variance(self.0, _arg) } + } + fn get_hill_x_variance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_hill_x_variance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_hill_x_variance(self.0) } + } + fn set_hill_y_variance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_hill_y_variance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_hill_y_variance(self.0, _arg) } + } + fn get_hill_y_variance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_hill_y_variance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_hill_y_variance(self.0) } + } + fn set_hill_amplitude(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_hill_amplitude( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_hill_amplitude(self.0, _arg) } + } + fn get_hill_amplitude(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_hill_amplitude( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_hill_amplitude(self.0) } + } + fn set_random_seed(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_random_seed( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_random_hills_set_random_seed(self.0, _arg) } + } + fn get_random_seed(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_random_seed( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_random_hills_get_random_seed(self.0) } + } + fn set_allow_random_generation(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_allow_random_generation( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_random_hills_set_allow_random_generation(self.0, _arg) } + } + fn get_allow_random_generation_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_allow_random_generation_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_parametric_random_hills_get_allow_random_generation_min_value(self.0) + } + } + fn get_allow_random_generation_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_allow_random_generation_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_parametric_random_hills_get_allow_random_generation_max_value(self.0) + } + } + fn get_allow_random_generation(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_allow_random_generation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_random_hills_get_allow_random_generation(self.0) } + } + fn allow_random_generation_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_allow_random_generation_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_random_hills_allow_random_generation_on(self.0) } + } + fn allow_random_generation_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_allow_random_generation_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_random_hills_allow_random_generation_off(self.0) } + } + fn set_x_variance_scale_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_x_variance_scale_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_x_variance_scale_factor(self.0, _arg) } + } + fn get_x_variance_scale_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_x_variance_scale_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_x_variance_scale_factor(self.0) } + } + fn set_y_variance_scale_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_y_variance_scale_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_y_variance_scale_factor(self.0, _arg) } + } + fn get_y_variance_scale_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_y_variance_scale_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_y_variance_scale_factor(self.0) } + } + fn set_amplitude_scale_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_amplitude_scale_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_amplitude_scale_factor(self.0, _arg) } + } + fn get_amplitude_scale_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_amplitude_scale_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_amplitude_scale_factor(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricRoman for vtkParametricRoman { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_roman_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_roman_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_roman_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_roman_new_instance(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_roman_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_roman_get_dimension(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_roman_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_roman_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_roman_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_roman_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_roman_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_roman_get_radius(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_roman_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_roman_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_roman_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_roman_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricSpline for vtkParametricSpline { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_dimension(self.0) } + } + fn evaluate( + &mut self, + u: core::ffi::c_double, + Pt: core::ffi::c_double, + Du: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_evaluate( + sself: *mut core::ffi::c_void, + u: core::ffi::c_double, + Pt: core::ffi::c_double, + Du: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_spline_evaluate(self.0, u, Pt, Du) } + } + fn evaluate_scalar( + &mut self, + u: core::ffi::c_double, + Pt: core::ffi::c_double, + Du: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_spline_evaluate_scalar( + sself: *mut core::ffi::c_void, + u: core::ffi::c_double, + Pt: core::ffi::c_double, + Du: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_spline_evaluate_scalar(self.0, u, Pt, Du) } + } + fn set_x_spline(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_x_spline( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_set_x_spline(self.0, p0) } + } + fn set_y_spline(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_y_spline( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_set_y_spline(self.0, p0) } + } + fn set_z_spline(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_z_spline( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_set_z_spline(self.0, p0) } + } + fn get_x_spline(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_get_x_spline( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_get_x_spline(self.0) } + } + fn get_y_spline(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_get_y_spline( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_get_y_spline(self.0) } + } + fn get_z_spline(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_get_z_spline( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_get_z_spline(self.0) } + } + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_points( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_set_points(self.0, p0) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_get_points(self.0) } + } + fn set_number_of_points(&mut self, numPts: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_number_of_points( + sself: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ); + } + unsafe { vtk_parametric_spline_set_number_of_points(self.0, numPts) } + } + fn set_point( + &mut self, + index: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_point( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_spline_set_point(self.0, index, x, y, z) } + } + fn set_closed(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_closed( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_spline_set_closed(self.0, _arg) } + } + fn get_closed(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_closed( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_closed(self.0) } + } + fn closed_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_closed_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_parametric_spline_closed_on(self.0) } + } + fn closed_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_closed_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_parametric_spline_closed_off(self.0) } + } + fn set_parameterize_by_length(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_parameterize_by_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_spline_set_parameterize_by_length(self.0, _arg) } + } + fn get_parameterize_by_length(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_parameterize_by_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_parameterize_by_length(self.0) } + } + fn parameterize_by_length_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_parameterize_by_length_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_parameterize_by_length_on(self.0) } + } + fn parameterize_by_length_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_parameterize_by_length_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_parameterize_by_length_off(self.0) } + } + fn set_left_constraint(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_left_constraint( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_spline_set_left_constraint(self.0, _arg) } + } + fn get_left_constraint_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_left_constraint_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_left_constraint_min_value(self.0) } + } + fn get_left_constraint_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_left_constraint_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_left_constraint_max_value(self.0) } + } + fn get_left_constraint(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_left_constraint( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_left_constraint(self.0) } + } + fn set_right_constraint(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_right_constraint( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_spline_set_right_constraint(self.0, _arg) } + } + fn get_right_constraint_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_right_constraint_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_right_constraint_min_value(self.0) } + } + fn get_right_constraint_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_right_constraint_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_right_constraint_max_value(self.0) } + } + fn get_right_constraint(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_right_constraint( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_right_constraint(self.0) } + } + fn set_left_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_left_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_spline_set_left_value(self.0, _arg) } + } + fn get_left_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_spline_get_left_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_spline_get_left_value(self.0) } + } + fn set_right_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_right_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_spline_set_right_value(self.0, _arg) } + } + fn get_right_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_spline_get_right_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_spline_get_right_value(self.0) } + } +} +impl VtkParametricSuperEllipsoid for vtkParametricSuperEllipsoid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_ellipsoid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_ellipsoid_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_ellipsoid_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_super_ellipsoid_get_dimension(self.0) } + } + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_set_x_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_set_x_radius(self.0, _arg) } + } + fn get_x_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_x_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_get_x_radius(self.0) } + } + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_set_y_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_set_y_radius(self.0, _arg) } + } + fn get_y_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_y_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_get_y_radius(self.0) } + } + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_set_z_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_set_z_radius(self.0, _arg) } + } + fn get_z_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_z_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_get_z_radius(self.0) } + } + fn set_n_1(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_set_n_1( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_set_n_1(self.0, _arg) } + } + fn get_n_1(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_n_1( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_get_n_1(self.0) } + } + fn set_n_2(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_set_n_2( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_set_n_2(self.0, _arg) } + } + fn get_n_2(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_n_2( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_get_n_2(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricSuperToroid for vtkParametricSuperToroid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_toroid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_toroid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_toroid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_toroid_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_toroid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_toroid_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_super_toroid_get_dimension(self.0) } + } + fn set_ring_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_ring_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_ring_radius(self.0, _arg) } + } + fn get_ring_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_ring_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_ring_radius(self.0) } + } + fn set_cross_section_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_cross_section_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_cross_section_radius(self.0, _arg) } + } + fn get_cross_section_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_cross_section_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_cross_section_radius(self.0) } + } + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_x_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_x_radius(self.0, _arg) } + } + fn get_x_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_x_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_x_radius(self.0) } + } + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_y_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_y_radius(self.0, _arg) } + } + fn get_y_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_y_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_y_radius(self.0) } + } + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_z_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_z_radius(self.0, _arg) } + } + fn get_z_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_z_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_z_radius(self.0) } + } + fn set_n_1(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_n_1( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_n_1(self.0, _arg) } + } + fn get_n_1(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_n_1( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_n_1(self.0) } + } + fn set_n_2(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_n_2( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_n_2(self.0, _arg) } + } + fn get_n_2(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_n_2( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_n_2(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} +impl VtkParametricTorus for vtkParametricTorus { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_torus_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_torus_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_torus_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_torus_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_torus_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_torus_new(self.0) } + } + fn set_ring_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_torus_set_ring_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_torus_set_ring_radius(self.0, _arg) } + } + fn get_ring_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_torus_get_ring_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_torus_get_ring_radius(self.0) } + } + fn set_cross_section_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_torus_set_cross_section_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_torus_set_cross_section_radius(self.0, _arg) } + } + fn get_cross_section_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_torus_get_cross_section_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_torus_get_cross_section_radius(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_torus_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_torus_get_dimension(self.0) } + } + fn evaluate( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_torus_evaluate( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_torus_evaluate(self.0, uvw, Pt, Duvw) } + } + fn evaluate_scalar( + &mut self, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_torus_evaluate_scalar( + sself: *mut core::ffi::c_void, + uvw: core::ffi::c_double, + Pt: core::ffi::c_double, + Duvw: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_torus_evaluate_scalar(self.0, uvw, Pt, Duvw) } + } +} /// computes an interpolating spline using a /// /// a Cardinal basis. diff --git a/vtk-rs-9.1/src/vtkCommonCore.rs b/vtk-rs-9.1/src/vtkCommonCore.rs index 3ba0b97..0b61290 100644 --- a/vtk-rs-9.1/src/vtkCommonCore.rs +++ b/vtk-rs-9.1/src/vtkCommonCore.rs @@ -1,3 +1,24377 @@ +pub trait VtkAOSDataArrayTemplate: VtkGenericDataArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_value(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_value( + &mut self, + valueIdx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn get_typed_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: *mut core::ffi::c_void, + ) -> (); + fn set_typed_tuple(&mut self, tupleIdx: core::ffi::c_uchar, tuple: ValueTypeT) -> (); + fn get_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + comp: core::ffi::c_int, + value: *mut core::ffi::c_void, + ) -> (); + fn write_pointer( + &mut self, + valueIdx: core::ffi::c_uchar, + numValues: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_pointer(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_array( + &mut self, + array: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_void_array( + &mut self, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn data_element_changed(&mut self, p0: core::ffi::c_uchar) -> (); + fn begin(&mut self) -> *mut core::ffi::c_void; + fn end(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkAbstractArray: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + numValues: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self, type_: core::ffi::c_int) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn set_number_of_components(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_components_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_components_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn set_component_name( + &mut self, + component: core::ffi::c_uchar, + name: core::ffi::c_char, + ) -> (); + fn get_component_name( + &mut self, + component: core::ffi::c_uchar, + ) -> *const core::ffi::c_char; + fn has_a_component_name(&mut self) -> bool; + fn copy_component_names(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, numTuples: core::ffi::c_uchar) -> (); + fn set_number_of_values(&mut self, numValues: core::ffi::c_uchar) -> bool; + fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar; + fn get_number_of_values(&mut self) -> core::ffi::c_uchar; + fn set_tuple( + &mut self, + dstTupleIdx: core::ffi::c_uchar, + srcTupleIdx: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + dstTupleIdx: core::ffi::c_uchar, + srcTupleIdx: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + srcTupleIdx: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn get_tuples( + &mut self, + tupleIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn get_tuples( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + output: *mut core::ffi::c_void, + ) -> (); + fn has_standard_memory_layout(&mut self) -> bool; + fn get_void_pointer(&mut self, valueIdx: core::ffi::c_uchar) -> *mut (); + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn interpolate_tuple( + &mut self, + dstTupleIdx: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_tuple( + &mut self, + dstTupleIdx: core::ffi::c_uchar, + srcTupleIdx1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + srcTupleIdx2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> (); + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; + fn reset(&mut self) -> (); + fn get_size(&mut self) -> core::ffi::c_uchar; + fn get_max_id(&mut self) -> core::ffi::c_uchar; + fn set_void_array( + &mut self, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_void_array( + &mut self, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn export_to_void_pointer(&mut self, out_ptr: ()) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn set_name(&mut self, _arg: core::ffi::c_char) -> (); + fn get_name(&mut self) -> *mut core::ffi::c_char; + fn get_data_type_as_string(&mut self) -> *const core::ffi::c_char; + fn create_array(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data_size(&mut self) -> core::ffi::c_uchar; + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + valueIds: *mut core::ffi::c_void, + ) -> (); + fn get_variant_value( + &mut self, + valueIdx: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn insert_variant_value( + &mut self, + valueIdx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn set_variant_value( + &mut self, + valueIdx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn data_changed(&mut self) -> (); + fn clear_lookup(&mut self) -> (); + fn get_prominent_component_values( + &mut self, + comp: core::ffi::c_int, + values: *mut core::ffi::c_void, + uncertainty: core::ffi::c_double, + minimumProminence: core::ffi::c_double, + ) -> (); + fn get_information(&mut self) -> *mut core::ffi::c_void; + fn has_information(&mut self) -> bool; + fn copy_information( + &mut self, + infoFrom: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> core::ffi::c_int; + fn gui_hide(&mut self) -> *mut core::ffi::c_void; + fn per_component(&mut self) -> *mut core::ffi::c_void; + fn per_finite_component(&mut self) -> *mut core::ffi::c_void; + fn modified(&mut self) -> (); + fn discrete_values(&mut self) -> *mut core::ffi::c_void; + fn discrete_value_sample_parameters(&mut self) -> *mut core::ffi::c_void; + fn get_max_discrete_values(&mut self) -> core::ffi::c_uint; + fn set_max_discrete_values(&mut self, _arg: core::ffi::c_uint) -> (); + fn get_array_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkAnimationCue: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_time_mode(&mut self, mode: core::ffi::c_int) -> (); + fn get_time_mode(&mut self) -> core::ffi::c_int; + fn set_time_mode_to_relative(&mut self) -> (); + fn set_time_mode_to_normalized(&mut self) -> (); + fn set_start_time(&mut self, _arg: core::ffi::c_double) -> (); + fn get_start_time(&mut self) -> core::ffi::c_double; + fn set_end_time(&mut self, _arg: core::ffi::c_double) -> (); + fn get_end_time(&mut self) -> core::ffi::c_double; + fn tick( + &mut self, + currenttime: core::ffi::c_double, + deltatime: core::ffi::c_double, + clocktime: core::ffi::c_double, + ) -> (); + fn initialize(&mut self) -> (); + fn finalize(&mut self) -> (); + fn get_animation_time(&mut self) -> core::ffi::c_double; + fn get_delta_time(&mut self) -> core::ffi::c_double; + fn get_clock_time(&mut self) -> core::ffi::c_double; +} +pub trait VtkArchiver: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_archive_name(&mut self) -> *mut core::ffi::c_char; + fn set_archive_name(&mut self, _arg: core::ffi::c_char) -> (); + fn open_archive(&mut self) -> (); + fn close_archive(&mut self) -> (); + fn insert_into_archive( + &mut self, + relativePath: &str, + data: core::ffi::c_char, + size: usize, + ) -> (); + fn contains(&mut self, relativePath: &str) -> bool; +} +pub trait VtkArray: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn create_array( + &mut self, + StorageType: core::ffi::c_int, + ValueType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn is_dense(&mut self) -> bool; + fn resize(&mut self, i: core::ffi::c_uchar) -> (); + fn resize(&mut self, i: core::ffi::c_uchar, j: core::ffi::c_uchar) -> (); + fn resize( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + k: core::ffi::c_uchar, + ) -> (); + fn resize(&mut self, i: vtkArrayRange) -> (); + fn resize(&mut self, i: vtkArrayRange, j: vtkArrayRange) -> (); + fn resize(&mut self, i: vtkArrayRange, j: vtkArrayRange, k: vtkArrayRange) -> (); + fn resize(&mut self, extents: vtkArrayExtents) -> (); + fn get_extent(&mut self, dimension: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_extents(&mut self) -> vtkArrayExtents; + fn get_dimensions(&mut self) -> core::ffi::c_uchar; + fn get_size(&mut self) -> core::ffi::c_ulonglong; + fn get_non_null_size(&mut self) -> core::ffi::c_ulonglong; + fn set_name(&mut self, name: vtkStdString) -> (); + fn get_name(&mut self) -> *mut core::ffi::c_void; + fn set_dimension_label(&mut self, i: core::ffi::c_uchar, label: vtkStdString) -> (); + fn get_dimension_label(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_coordinates_n( + &mut self, + n: core::ffi::c_ulonglong, + coordinates: *mut core::ffi::c_void, + ) -> (); + fn get_variant_value(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_variant_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_variant_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + k: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_variant_value( + &mut self, + coordinates: vtkArrayCoordinates, + ) -> *mut core::ffi::c_void; + fn get_variant_value_n( + &mut self, + n: core::ffi::c_ulonglong, + ) -> *mut core::ffi::c_void; + fn set_variant_value(&mut self, i: core::ffi::c_uchar, value: vtkVariant) -> (); + fn set_variant_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + value: vtkVariant, + ) -> (); + fn set_variant_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + k: core::ffi::c_uchar, + value: vtkVariant, + ) -> (); + fn set_variant_value( + &mut self, + coordinates: vtkArrayCoordinates, + value: vtkVariant, + ) -> (); + fn set_variant_value_n( + &mut self, + n: core::ffi::c_ulonglong, + value: vtkVariant, + ) -> (); + fn copy_value( + &mut self, + source: *mut core::ffi::c_void, + source_coordinates: vtkArrayCoordinates, + target_coordinates: vtkArrayCoordinates, + ) -> (); + fn copy_value( + &mut self, + source: *mut core::ffi::c_void, + source_index: core::ffi::c_ulonglong, + target_coordinates: vtkArrayCoordinates, + ) -> (); + fn copy_value( + &mut self, + source: *mut core::ffi::c_void, + source_coordinates: vtkArrayCoordinates, + target_index: core::ffi::c_ulonglong, + ) -> (); + fn deep_copy(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkArrayCoordinates { + fn get_dimensions(&mut self) -> core::ffi::c_uchar; + fn set_dimensions(&mut self, dimensions: core::ffi::c_uchar) -> (); + fn get_coordinate(&mut self, i: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn set_coordinate(&mut self, i: core::ffi::c_uchar, p1: core::ffi::c_uchar) -> (); +} +pub trait VtkArrayExtents { + fn uniform( + &mut self, + n: core::ffi::c_uchar, + m: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn append(&mut self, extent: vtkArrayRange) -> (); + fn get_dimensions(&mut self) -> core::ffi::c_uchar; + fn get_size(&mut self) -> core::ffi::c_ulonglong; + fn set_dimensions(&mut self, dimensions: core::ffi::c_uchar) -> (); + fn get_extent(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_extent(&mut self, i: core::ffi::c_uchar, p1: vtkArrayRange) -> (); + fn zero_based(&mut self) -> bool; + fn same_shape(&mut self, rhs: vtkArrayExtents) -> bool; + fn get_left_to_right_coordinates_n( + &mut self, + n: core::ffi::c_ulonglong, + coordinates: *mut core::ffi::c_void, + ) -> (); + fn get_right_to_left_coordinates_n( + &mut self, + n: core::ffi::c_ulonglong, + coordinates: *mut core::ffi::c_void, + ) -> (); + fn contains(&mut self, extents: vtkArrayExtents) -> bool; + fn contains(&mut self, coordinates: vtkArrayCoordinates) -> bool; +} +pub trait VtkArrayExtentsList { + fn get_count(&mut self) -> core::ffi::c_uchar; + fn set_count(&mut self, count: core::ffi::c_uchar) -> (); +} +pub trait VtkArrayIterator: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, array: *mut core::ffi::c_void) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkArrayIteratorTemplate: VtkArrayIterator + VtkObject + VtkObjectBase { + fn initialize(&mut self, array: *mut core::ffi::c_void) -> (); + fn get_array(&mut self) -> *mut core::ffi::c_void; + fn get_tuple(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_value(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_value(&mut self, id: core::ffi::c_uchar, value: *mut core::ffi::c_void) -> (); + fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar; + fn get_number_of_values(&mut self) -> core::ffi::c_uchar; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; +} +pub trait VtkArrayRange { + fn get_begin(&mut self) -> core::ffi::c_uchar; + fn get_end(&mut self) -> core::ffi::c_uchar; + fn get_size(&mut self) -> core::ffi::c_uchar; + fn contains(&mut self, range: vtkArrayRange) -> bool; + fn contains(&mut self, coordinate: core::ffi::c_uchar) -> bool; +} +pub trait VtkArraySort { + fn get_dimensions(&mut self) -> core::ffi::c_uchar; + fn set_dimensions(&mut self, dimensions: core::ffi::c_uchar) -> (); +} +pub trait VtkArrayWeights { + fn get_count(&mut self) -> core::ffi::c_uchar; + fn set_count(&mut self, count: core::ffi::c_uchar) -> (); +} +pub trait VtkBitArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn get_tuple(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> (); + fn set_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_float) -> (); + fn set_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> (); + fn insert_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_float) -> (); + fn insert_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> (); + fn insert_next_tuple(&mut self, tuple: core::ffi::c_float) -> core::ffi::c_uchar; + fn insert_next_tuple(&mut self, tuple: core::ffi::c_double) -> core::ffi::c_uchar; + fn remove_tuple(&mut self, id: core::ffi::c_uchar) -> (); + fn set_component( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_int, + c: core::ffi::c_double, + ) -> (); + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> (); + fn insert_value(&mut self, id: core::ffi::c_uchar, i: core::ffi::c_int) -> (); + fn set_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_next_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_uchar; + fn insert_component( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_int, + c: core::ffi::c_double, + ) -> (); + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + fn write_void_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut (); + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn set_void_array( + &mut self, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> (); + fn lookup_value(&mut self, value: core::ffi::c_int) -> core::ffi::c_uchar; + fn lookup_value( + &mut self, + value: core::ffi::c_int, + ids: *mut core::ffi::c_void, + ) -> (); + fn data_changed(&mut self) -> (); + fn clear_lookup(&mut self) -> (); +} +pub trait VtkBitArrayIterator: VtkArrayIterator + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, array: *mut core::ffi::c_void) -> (); + fn get_array(&mut self) -> *mut core::ffi::c_void; + fn get_tuple(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar; + fn get_number_of_values(&mut self) -> core::ffi::c_uchar; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> (); +} +pub trait VtkBoxMuellerRandomSequence: VtkGaussianRandomSequence + VtkRandomSequence + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn get_value(&mut self) -> core::ffi::c_double; + fn next(&mut self) -> (); + fn get_uniform_sequence(&mut self) -> *mut core::ffi::c_void; + fn set_uniform_sequence(&mut self, uniformSequence: *mut core::ffi::c_void) -> (); +} +pub trait VtkBreakPoint { + fn break_(&mut self) -> (); +} +pub trait VtkBuffer: VtkObject + VtkObjectBase { + fn get_buffer(&mut self) -> *mut core::ffi::c_void; + fn get_buffer(&mut self) -> *const ScalarTypeT; + fn set_buffer( + &mut self, + array: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + ) -> (); + fn set_malloc_function(&mut self, mallocFunction: *mut core::ffi::c_void) -> (); + fn set_realloc_function(&mut self, reallocFunction: *mut core::ffi::c_void) -> (); + fn set_free_function( + &mut self, + noFreeFunction: bool, + deleteFunction: *mut core::ffi::c_void, + ) -> (); + fn get_size(&mut self) -> core::ffi::c_uchar; + fn allocate(&mut self, size: core::ffi::c_uchar) -> bool; + fn reallocate(&mut self, newsize: core::ffi::c_uchar) -> bool; +} +pub trait VtkByteSwap: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn swap_le(&mut self, p: core::ffi::c_float) -> (); + fn swap_be(&mut self, p: core::ffi::c_float) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_float, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_float, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_double) -> (); + fn swap_be(&mut self, p: core::ffi::c_double) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_double, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_double, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_char) -> (); + fn swap_be(&mut self, p: core::ffi::c_char) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_char, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_char, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_short) -> (); + fn swap_be(&mut self, p: core::ffi::c_short) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_short, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_short, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_int) -> (); + fn swap_be(&mut self, p: core::ffi::c_int) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_int, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_int, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_long) -> (); + fn swap_be(&mut self, p: core::ffi::c_long) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_long, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_long, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_uchar) -> (); + fn swap_be(&mut self, p: core::ffi::c_uchar) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_uchar, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_uchar, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_char) -> (); + fn swap_be(&mut self, p: core::ffi::c_char) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_char, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_char, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_uchar) -> (); + fn swap_be(&mut self, p: core::ffi::c_uchar) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_uchar, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_uchar, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_ushort) -> (); + fn swap_be(&mut self, p: core::ffi::c_ushort) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_ushort, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_ushort, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_uint) -> (); + fn swap_be(&mut self, p: core::ffi::c_uint) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_uint, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_uint, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_ulong) -> (); + fn swap_be(&mut self, p: core::ffi::c_ulong) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_ulong, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_ulong, num: usize) -> (); + fn swap_le(&mut self, p: core::ffi::c_ulonglong) -> (); + fn swap_be(&mut self, p: core::ffi::c_ulonglong) -> (); + fn swap_le_range(&mut self, p: core::ffi::c_ulonglong, num: usize) -> (); + fn swap_be_range(&mut self, p: core::ffi::c_ulonglong, num: usize) -> (); + fn swap_2_le(&mut self, p: ()) -> (); + fn swap_4_le(&mut self, p: ()) -> (); + fn swap_8_le(&mut self, p: ()) -> (); + fn swap_2_le_range(&mut self, p: (), num: usize) -> (); + fn swap_4_le_range(&mut self, p: (), num: usize) -> (); + fn swap_8_le_range(&mut self, p: (), num: usize) -> (); + fn swap_2_be(&mut self, p: ()) -> (); + fn swap_4_be(&mut self, p: ()) -> (); + fn swap_8_be(&mut self, p: ()) -> (); + fn swap_2_be_range(&mut self, p: (), num: usize) -> (); + fn swap_4_be_range(&mut self, p: (), num: usize) -> (); + fn swap_8_be_range(&mut self, p: (), num: usize) -> (); + fn swap_void_range(&mut self, buffer: (), numWords: usize, wordSize: usize) -> (); +} +pub trait VtkCallbackCommand: VtkCommand + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn execute( + &mut self, + caller: *mut core::ffi::c_void, + eid: core::ffi::c_ulong, + callData: (), + ) -> (); + fn set_client_data(&mut self, cd: ()) -> (); + fn get_client_data(&mut self) -> *mut (); + fn set_callback(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_abort_flag_on_execute(&mut self, f: core::ffi::c_int) -> (); + fn get_abort_flag_on_execute(&mut self) -> core::ffi::c_int; + fn abort_flag_on_execute_on(&mut self) -> (); + fn abort_flag_on_execute_off(&mut self) -> (); +} +pub trait VtkCharArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_char) -> (); + fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_char) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_char; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_char) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_char; + fn get_value_range(&mut self) -> *mut core::ffi::c_char; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_char; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_char; + fn set_array( + &mut self, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_char; + fn get_data_type_value_max(&mut self) -> core::ffi::c_char; +} +pub trait VtkCollection: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn insert_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn remove_item(&mut self, i: core::ffi::c_int) -> (); + fn remove_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn remove_all_items(&mut self) -> (); + fn is_item_present(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_number_of_items(&mut self) -> core::ffi::c_int; + fn init_traversal(&mut self) -> (); + fn init_traversal(&mut self, cookie: ()) -> (); + fn get_next_item_as_object(&mut self) -> *mut core::ffi::c_void; + fn get_item_as_object(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_next_item_as_object(&mut self, cookie: ()) -> *mut core::ffi::c_void; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); +} +pub trait VtkCollectionIterator: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_collection(&mut self) -> *mut core::ffi::c_void; + fn init_traversal(&mut self) -> (); + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; + fn get_current_object(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCommand: VtkObjectBase { + fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; + fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn get_number_of_generations_from_base( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn un_register(&mut self) -> (); + fn un_register(&mut self, p0: *mut core::ffi::c_void) -> (); + fn execute( + &mut self, + caller: *mut core::ffi::c_void, + eventId: core::ffi::c_ulong, + callData: (), + ) -> (); + fn get_string_from_event_id( + &mut self, + event: core::ffi::c_ulong, + ) -> *const core::ffi::c_char; + fn get_event_id_from_string( + &mut self, + event: core::ffi::c_char, + ) -> core::ffi::c_ulong; + fn event_has_data(&mut self, event: core::ffi::c_ulong) -> bool; + fn set_abort_flag(&mut self, f: core::ffi::c_int) -> (); + fn get_abort_flag(&mut self) -> core::ffi::c_int; + fn abort_flag_on(&mut self) -> (); + fn abort_flag_off(&mut self) -> (); + fn set_passive_observer(&mut self, f: core::ffi::c_int) -> (); + fn get_passive_observer(&mut self) -> core::ffi::c_int; + fn passive_observer_on(&mut self) -> (); + fn passive_observer_off(&mut self) -> (); +} +pub trait VtkCommonInformationKeyManager { + fn register(&mut self, key: *mut core::ffi::c_void) -> (); +} +pub trait VtkConditionVariable: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn signal(&mut self) -> (); + fn broadcast(&mut self) -> (); + fn wait(&mut self, mutex: *mut core::ffi::c_void) -> core::ffi::c_int; +} +pub trait VtkCriticalSection: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn insert_tuple( + &mut self, + dstTupleIdx: core::ffi::c_uchar, + srcTupleIdx: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + srcTupleIdx: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn interpolate_tuple( + &mut self, + dstTupleIdx: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_tuple( + &mut self, + dstTupleIdx: core::ffi::c_uchar, + srcTupleIdx1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + srcTupleIdx2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> (); + fn get_tuple(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ) -> (); + fn get_tuple_1(&mut self, tupleIdx: core::ffi::c_uchar) -> core::ffi::c_double; + fn get_tuple_2(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_tuple_3(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_tuple_4(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_tuple_6(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_tuple_9(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn set_tuple( + &mut self, + dstTupleIdx: core::ffi::c_uchar, + srcTupleIdx: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn set_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ) -> (); + fn set_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ) -> (); + fn set_tuple_1( + &mut self, + tupleIdx: core::ffi::c_uchar, + value: core::ffi::c_double, + ) -> (); + fn set_tuple_2( + &mut self, + tupleIdx: core::ffi::c_uchar, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + ) -> (); + fn set_tuple_3( + &mut self, + tupleIdx: core::ffi::c_uchar, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + ) -> (); + fn set_tuple_4( + &mut self, + tupleIdx: core::ffi::c_uchar, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + ) -> (); + fn set_tuple_6( + &mut self, + tupleIdx: core::ffi::c_uchar, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + ) -> (); + fn set_tuple_9( + &mut self, + tupleIdx: core::ffi::c_uchar, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + val6: core::ffi::c_double, + val7: core::ffi::c_double, + val8: core::ffi::c_double, + ) -> (); + fn insert_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ) -> (); + fn insert_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ) -> (); + fn insert_tuple_1( + &mut self, + tupleIdx: core::ffi::c_uchar, + value: core::ffi::c_double, + ) -> (); + fn insert_tuple_2( + &mut self, + tupleIdx: core::ffi::c_uchar, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + ) -> (); + fn insert_tuple_3( + &mut self, + tupleIdx: core::ffi::c_uchar, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + ) -> (); + fn insert_tuple_4( + &mut self, + tupleIdx: core::ffi::c_uchar, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + ) -> (); + fn insert_tuple_6( + &mut self, + tupleIdx: core::ffi::c_uchar, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + ) -> (); + fn insert_tuple_9( + &mut self, + tupleIdx: core::ffi::c_uchar, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + val6: core::ffi::c_double, + val7: core::ffi::c_double, + val8: core::ffi::c_double, + ) -> (); + fn insert_next_tuple(&mut self, tuple: core::ffi::c_float) -> core::ffi::c_uchar; + fn insert_next_tuple(&mut self, tuple: core::ffi::c_double) -> core::ffi::c_uchar; + fn insert_next_tuple_1(&mut self, value: core::ffi::c_double) -> (); + fn insert_next_tuple_2( + &mut self, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + ) -> (); + fn insert_next_tuple_3( + &mut self, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + ) -> (); + fn insert_next_tuple_4( + &mut self, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + ) -> (); + fn insert_next_tuple_6( + &mut self, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + ) -> (); + fn insert_next_tuple_9( + &mut self, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + val6: core::ffi::c_double, + val7: core::ffi::c_double, + val8: core::ffi::c_double, + ) -> (); + fn remove_tuple(&mut self, tupleIdx: core::ffi::c_uchar) -> (); + fn remove_first_tuple(&mut self) -> (); + fn remove_last_tuple(&mut self) -> (); + fn get_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + compIdx: core::ffi::c_int, + ) -> core::ffi::c_double; + fn set_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + compIdx: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn insert_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + compIdx: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_data( + &mut self, + tupleMin: core::ffi::c_uchar, + tupleMax: core::ffi::c_uchar, + compMin: core::ffi::c_int, + compMax: core::ffi::c_int, + data: *mut core::ffi::c_void, + ) -> (); + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn fill_component( + &mut self, + compIdx: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn fill(&mut self, value: core::ffi::c_double) -> (); + fn copy_component( + &mut self, + dstComponent: core::ffi::c_int, + src: *mut core::ffi::c_void, + srcComponent: core::ffi::c_int, + ) -> (); + fn write_void_pointer( + &mut self, + valueIdx: core::ffi::c_uchar, + numValues: core::ffi::c_uchar, + ) -> *mut (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn create_default_lookup_table(&mut self) -> (); + fn set_lookup_table(&mut self, lut: *mut core::ffi::c_void) -> (); + fn get_lookup_table(&mut self) -> *mut core::ffi::c_void; + fn get_range(&mut self, range: core::ffi::c_double, comp: core::ffi::c_int) -> (); + fn get_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_double; + fn get_range(&mut self) -> *mut core::ffi::c_double; + fn get_range(&mut self, range: core::ffi::c_double) -> (); + fn get_finite_range( + &mut self, + range: core::ffi::c_double, + comp: core::ffi::c_int, + ) -> (); + fn get_finite_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_double; + fn get_finite_range(&mut self) -> *mut core::ffi::c_double; + fn get_finite_range(&mut self, range: core::ffi::c_double) -> (); + fn get_data_type_range(&mut self, range: core::ffi::c_double) -> (); + fn get_data_type_min(&mut self) -> core::ffi::c_double; + fn get_data_type_max(&mut self) -> core::ffi::c_double; + fn get_data_type_range( + &mut self, + type_: core::ffi::c_int, + range: core::ffi::c_double, + ) -> (); + fn get_data_type_min(&mut self, type_: core::ffi::c_int) -> core::ffi::c_double; + fn get_data_type_max(&mut self, type_: core::ffi::c_int) -> core::ffi::c_double; + fn get_max_norm(&mut self) -> core::ffi::c_double; + fn create_data_array( + &mut self, + dataType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn component_range(&mut self) -> *mut core::ffi::c_void; + fn l_2_norm_range(&mut self) -> *mut core::ffi::c_void; + fn l_2_norm_finite_range(&mut self) -> *mut core::ffi::c_void; + fn modified(&mut self) -> (); + fn units_label(&mut self) -> *mut core::ffi::c_void; + fn copy_information( + &mut self, + infoFrom: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_array_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkDataArrayCollection: VtkCollection + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_next_data_array(&mut self, cookie: ()) -> *mut core::ffi::c_void; + fn get_number_of_items(&mut self) -> core::ffi::c_int; +} +pub trait VtkDataArrayCollectionIterator: VtkCollectionIterator + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data_array(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkDataArraySelection: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn enable_array(&mut self, name: core::ffi::c_char) -> (); + fn disable_array(&mut self, name: core::ffi::c_char) -> (); + fn array_is_enabled(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn array_exists(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn enable_all_arrays(&mut self) -> (); + fn disable_all_arrays(&mut self) -> (); + fn get_number_of_arrays(&mut self) -> core::ffi::c_int; + fn get_number_of_arrays_enabled(&mut self) -> core::ffi::c_int; + fn get_array_name(&mut self, index: core::ffi::c_int) -> *const core::ffi::c_char; + fn get_array_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_enabled_array_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_array_setting(&mut self, index: core::ffi::c_int) -> core::ffi::c_int; + fn get_array_setting(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn set_array_setting( + &mut self, + name: core::ffi::c_char, + setting: core::ffi::c_int, + ) -> (); + fn remove_all_arrays(&mut self) -> (); + fn add_array(&mut self, name: core::ffi::c_char, state: bool) -> core::ffi::c_int; + fn remove_array_by_index(&mut self, index: core::ffi::c_int) -> (); + fn remove_array_by_name(&mut self, name: core::ffi::c_char) -> (); + fn set_arrays( + &mut self, + names: core::ffi::c_char, + numArrays: core::ffi::c_int, + ) -> (); + fn set_arrays_with_default( + &mut self, + names: core::ffi::c_char, + numArrays: core::ffi::c_int, + defaultStatus: core::ffi::c_int, + ) -> (); + fn copy_selections(&mut self, selections: *mut core::ffi::c_void) -> (); + fn union(&mut self, other: *mut core::ffi::c_void) -> (); + fn union(&mut self, other: *mut core::ffi::c_void, skipModified: bool) -> (); + fn set_unknown_array_setting(&mut self, _arg: core::ffi::c_int) -> (); + fn get_unknown_array_setting(&mut self) -> core::ffi::c_int; +} +pub trait VtkDebugLeaks: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn construct_class(&mut self, object: *mut core::ffi::c_void) -> (); + fn construct_class(&mut self, className: core::ffi::c_char) -> (); + fn destruct_class(&mut self, object: *mut core::ffi::c_void) -> (); + fn destruct_class(&mut self, className: core::ffi::c_char) -> (); + fn print_current_leaks(&mut self) -> core::ffi::c_int; + fn get_exit_error(&mut self) -> core::ffi::c_int; + fn set_exit_error(&mut self, p0: core::ffi::c_int) -> (); + fn set_debug_leaks_observer(&mut self, observer: *mut core::ffi::c_void) -> (); + fn get_debug_leaks_observer(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkDebugLeaksObserver { + fn constructing_object(&mut self, p0: *mut core::ffi::c_void) -> (); + fn destructing_object(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkDenseArray: VtkTypedArray + VtkArray + VtkObject + VtkObjectBase { + fn is_dense(&mut self) -> bool; + fn get_extents(&mut self) -> vtkArrayExtents; + fn get_non_null_size(&mut self) -> core::ffi::c_ulonglong; + fn get_coordinates_n( + &mut self, + n: core::ffi::c_ulonglong, + coordinates: *mut core::ffi::c_void, + ) -> (); + fn deep_copy(&mut self) -> *mut core::ffi::c_void; + fn get_value(&mut self, i: core::ffi::c_uchar) -> T; + fn get_value(&mut self, i: core::ffi::c_uchar, j: core::ffi::c_uchar) -> T; + fn get_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + k: core::ffi::c_uchar, + ) -> T; + fn get_value(&mut self, coordinates: vtkArrayCoordinates) -> T; + fn get_value_n(&mut self, n: core::ffi::c_ulonglong) -> T; + fn set_value(&mut self, i: core::ffi::c_uchar, value: T) -> (); + fn set_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + value: T, + ) -> (); + fn set_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + k: core::ffi::c_uchar, + value: T, + ) -> (); + fn set_value(&mut self, coordinates: vtkArrayCoordinates, value: T) -> (); + fn set_value_n(&mut self, n: core::ffi::c_ulonglong, value: T) -> (); + fn external_storage( + &mut self, + extents: vtkArrayExtents, + storage: *mut core::ffi::c_void, + ) -> (); + fn fill(&mut self, value: T) -> (); + fn get_storage(&mut self) -> *const T; + fn get_storage(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkDoubleArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ) -> (); + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_double) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_double) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_double) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_double; + fn get_value_range(&mut self) -> *mut core::ffi::c_double; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn set_array( + &mut self, + array: core::ffi::c_double, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_double, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_double; + fn get_data_type_value_max(&mut self) -> core::ffi::c_double; +} +pub trait VtkDynamicLoader: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn open_library(&mut self, p0: core::ffi::c_char) -> *mut core::ffi::c_void; + fn open_library( + &mut self, + p0: core::ffi::c_char, + p1: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn close_library(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_symbol_address( + &mut self, + p0: *mut core::ffi::c_void, + p1: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn lib_prefix(&mut self) -> *const core::ffi::c_char; + fn lib_extension(&mut self) -> *const core::ffi::c_char; + fn last_error(&mut self) -> *const core::ffi::c_char; +} +pub trait VtkEventData: VtkObjectBase { + fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; + fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn get_number_of_generations_from_base( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn get_type(&mut self) -> core::ffi::c_int; + fn set_type(&mut self, val: core::ffi::c_int) -> (); + fn get_as_event_data_for_device(&mut self) -> *mut core::ffi::c_void; + fn get_as_event_data_device_3_d(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkEventDataDevice3D: VtkEventDataForDevice + VtkEventData + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_world_position(&mut self, v: core::ffi::c_double) -> (); + fn get_world_position(&mut self) -> *const core::ffi::c_double; + fn set_world_position(&mut self, p: core::ffi::c_double) -> (); + fn get_world_direction(&mut self, v: core::ffi::c_double) -> (); + fn get_world_direction(&mut self) -> *const core::ffi::c_double; + fn set_world_direction(&mut self, p: core::ffi::c_double) -> (); + fn get_world_orientation(&mut self, v: core::ffi::c_double) -> (); + fn get_world_orientation(&mut self) -> *const core::ffi::c_double; + fn set_world_orientation(&mut self, p: core::ffi::c_double) -> (); + fn get_track_pad_position(&mut self, v: core::ffi::c_double) -> (); + fn get_track_pad_position(&mut self) -> *const core::ffi::c_double; + fn set_track_pad_position(&mut self, p: core::ffi::c_double) -> (); + fn set_track_pad_position( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> (); +} +pub trait VtkEventDataForDevice: VtkEventData + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_device(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_action(&mut self) -> *mut core::ffi::c_void; + fn set_device(&mut self, v: *mut core::ffi::c_void) -> (); + fn set_input(&mut self, v: *mut core::ffi::c_void) -> (); + fn set_action(&mut self, v: *mut core::ffi::c_void) -> (); + fn device_matches(&mut self, val: *mut core::ffi::c_void) -> bool; +} +pub trait VtkEventForwarderCommand: VtkCommand + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn execute( + &mut self, + caller: *mut core::ffi::c_void, + eid: core::ffi::c_ulong, + callData: (), + ) -> (); + fn set_target(&mut self, obj: *mut core::ffi::c_void) -> (); + fn get_target(&mut self) -> *mut (); +} +pub trait VtkFileOutputWindow: VtkOutputWindow + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn display_text(&mut self, p0: core::ffi::c_char) -> (); + fn set_file_name(&mut self, _arg: core::ffi::c_char) -> (); + fn get_file_name(&mut self) -> *mut core::ffi::c_char; + fn set_flush(&mut self, _arg: core::ffi::c_int) -> (); + fn get_flush(&mut self) -> core::ffi::c_int; + fn flush_on(&mut self) -> (); + fn flush_off(&mut self) -> (); + fn set_append(&mut self, _arg: core::ffi::c_int) -> (); + fn get_append(&mut self) -> core::ffi::c_int; + fn append_on(&mut self) -> (); + fn append_off(&mut self) -> (); +} +pub trait VtkFloatArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ) -> (); + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_float, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_float; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_float) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_float) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_float) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_float; + fn get_value_range(&mut self) -> *mut core::ffi::c_float; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_float; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_float; + fn set_array( + &mut self, + array: core::ffi::c_float, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_float, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_float; + fn get_data_type_value_max(&mut self) -> core::ffi::c_float; +} +pub trait VtkFloatingPointExceptions { + fn enable(&mut self) -> (); + fn disable(&mut self) -> (); +} +pub trait VtkGarbageCollector: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn collect(&mut self) -> (); + fn collect(&mut self, root: *mut core::ffi::c_void) -> (); + fn deferred_collection_push(&mut self) -> (); + fn deferred_collection_pop(&mut self) -> (); + fn set_global_debug_flag(&mut self, flag: bool) -> (); + fn get_global_debug_flag(&mut self) -> bool; +} +pub trait VtkGaussianRandomSequence: VtkRandomSequence + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_scaled_value( + &mut self, + mean: core::ffi::c_double, + standardDeviation: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_next_scaled_value( + &mut self, + mean: core::ffi::c_double, + standardDeviation: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkGenericDataArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn get_value(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_value( + &mut self, + valueIdx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn get_typed_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: *mut core::ffi::c_void, + ) -> (); + fn set_typed_tuple(&mut self, tupleIdx: core::ffi::c_uchar, tuple: ValueTypeT) -> (); + fn get_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + compIdx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + compIdx: core::ffi::c_int, + value: *mut core::ffi::c_void, + ) -> (); + fn get_void_pointer(&mut self, valueIdx: core::ffi::c_uchar) -> *mut (); + fn get_pointer(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_void_array( + &mut self, + p0: (), + p1: core::ffi::c_uchar, + p2: core::ffi::c_int, + ) -> (); + fn set_void_array( + &mut self, + p0: (), + p1: core::ffi::c_uchar, + p2: core::ffi::c_int, + p3: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn write_void_pointer( + &mut self, + valueIdx: core::ffi::c_uchar, + numValues: core::ffi::c_uchar, + ) -> *mut (); + fn write_pointer( + &mut self, + valueIdx: core::ffi::c_uchar, + numValues: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn remove_tuple(&mut self, tupleIdx: core::ffi::c_uchar) -> (); + fn insert_next_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn insert_value( + &mut self, + valueIdx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_typed_tuple(&mut self, tupleIdx: core::ffi::c_uchar, t: ValueTypeT) -> (); + fn insert_next_typed_tuple(&mut self, t: ValueTypeT) -> core::ffi::c_uchar; + fn insert_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + compIdx: core::ffi::c_int, + val: *mut core::ffi::c_void, + ) -> (); + fn get_value_range( + &mut self, + range: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> (); + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_value_range(&mut self) -> *mut core::ffi::c_void; + fn get_value_range(&mut self, range: *mut core::ffi::c_void) -> (); + fn get_finite_value_range( + &mut self, + range: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> (); + fn get_finite_value_range( + &mut self, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_finite_value_range(&mut self) -> *mut core::ffi::c_void; + fn get_finite_value_range(&mut self, range: *mut core::ffi::c_void) -> (); + fn capacity(&mut self) -> core::ffi::c_uchar; + fn fill_typed_component( + &mut self, + compIdx: core::ffi::c_int, + value: *mut core::ffi::c_void, + ) -> (); + fn fill_value(&mut self, value: *mut core::ffi::c_void) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn allocate( + &mut self, + size: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; + fn set_number_of_components(&mut self, num: core::ffi::c_int) -> (); + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); + fn initialize(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn insert_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + source: core::ffi::c_float, + ) -> (); + fn insert_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + source: core::ffi::c_double, + ) -> (); + fn insert_next_tuple(&mut self, tuple: core::ffi::c_float) -> core::ffi::c_uchar; + fn insert_next_tuple(&mut self, tuple: core::ffi::c_double) -> core::ffi::c_uchar; + fn get_tuple(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ) -> (); + fn set_variant_value( + &mut self, + valueIdx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_variant_value( + &mut self, + valueIdx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn lookup_typed_value( + &mut self, + value: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + valueIds: *mut core::ffi::c_void, + ) -> (); + fn lookup_typed_value( + &mut self, + value: *mut core::ffi::c_void, + valueIds: *mut core::ffi::c_void, + ) -> (); + fn clear_lookup(&mut self) -> (); + fn data_changed(&mut self) -> (); + fn new_iterator(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkGenericDataArrayLookupHelper { + fn set_array(&mut self, array: *mut core::ffi::c_void) -> (); + fn lookup_value(&mut self, elem: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn lookup_value( + &mut self, + elem: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> (); + fn clear_lookup(&mut self) -> (); +} +pub trait VtkIdList: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + strategy: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_number_of_ids(&mut self) -> core::ffi::c_uchar; + fn get_id(&mut self, i: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn find_id_location(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn set_number_of_ids(&mut self, number: core::ffi::c_uchar) -> (); + fn set_id(&mut self, i: core::ffi::c_uchar, vtkid: core::ffi::c_uchar) -> (); + fn insert_id(&mut self, i: core::ffi::c_uchar, vtkid: core::ffi::c_uchar) -> (); + fn insert_next_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn insert_unique_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn sort(&mut self) -> (); + fn fill(&mut self, value: core::ffi::c_uchar) -> (); + fn get_pointer(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn write_pointer( + &mut self, + i: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + fn set_array(&mut self, array: core::ffi::c_uchar, size: core::ffi::c_uchar) -> (); + fn reset(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn deep_copy(&mut self, ids: *mut core::ffi::c_void) -> (); + fn delete_id(&mut self, vtkid: core::ffi::c_uchar) -> (); + fn is_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> (); + fn resize(&mut self, sz: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> (); + fn begin(&mut self) -> *mut core::ffi::c_uchar; + fn end(&mut self) -> *mut core::ffi::c_uchar; + fn begin(&mut self) -> *const core::ffi::c_uchar; + fn end(&mut self) -> *const core::ffi::c_uchar; +} +pub trait VtkIdListCollection: VtkCollection + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_next_id_list(&mut self, cookie: ()) -> *mut core::ffi::c_void; + fn get_number_of_items(&mut self) -> core::ffi::c_int; +} +pub trait VtkIdTypeArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> (); + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar; + fn get_value_range(&mut self) -> *mut core::ffi::c_uchar; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar; + fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkIndent { + fn delete(&mut self) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_next_indent(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkInformation: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn modified(&mut self) -> (); + fn modified(&mut self, key: *mut core::ffi::c_void) -> (); + fn clear(&mut self) -> (); + fn get_number_of_keys(&mut self) -> core::ffi::c_int; + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> (); + fn append(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entries( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn set(&mut self, key: *mut core::ffi::c_void) -> (); + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_uchar) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_double; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set(&mut self, key: *mut core::ffi::c_void, value: vtkVariant) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> vtkVariant; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: core::ffi::c_int, + length: core::ffi::c_int, + ) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: core::ffi::c_int, + value2: core::ffi::c_int, + value3: core::ffi::c_int, + ) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: core::ffi::c_int, + value2: core::ffi::c_int, + value3: core::ffi::c_int, + value4: core::ffi::c_int, + value5: core::ffi::c_int, + value6: core::ffi::c_int, + ) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_int; + fn get( + &mut self, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_char) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: core::ffi::c_char, + idx: core::ffi::c_int, + ) -> (); + fn append(&mut self, key: *mut core::ffi::c_void, value: &str) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: &str, + idx: core::ffi::c_int, + ) -> (); + fn get( + &mut self, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: core::ffi::c_int, + length: core::ffi::c_int, + ) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_int; + fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_ulong) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_ulong; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: core::ffi::c_double, + length: core::ffi::c_int, + ) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: core::ffi::c_double, + value2: core::ffi::c_double, + value3: core::ffi::c_double, + ) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: core::ffi::c_double, + value2: core::ffi::c_double, + value3: core::ffi::c_double, + value4: core::ffi::c_double, + value5: core::ffi::c_double, + value6: core::ffi::c_double, + ) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_double; + fn get( + &mut self, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> core::ffi::c_double; + fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append(&mut self, key: *mut core::ffi::c_void, value: vtkVariant) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: vtkVariant, + length: core::ffi::c_int, + ) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: vtkVariant, + value2: vtkVariant, + value3: vtkVariant, + ) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: vtkVariant, + value2: vtkVariant, + value3: vtkVariant, + value4: vtkVariant, + value5: vtkVariant, + value6: vtkVariant, + ) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> *const vtkVariant; + fn get(&mut self, key: *mut core::ffi::c_void, idx: core::ffi::c_int) -> vtkVariant; + fn get(&mut self, key: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> (); + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + length: core::ffi::c_int, + ) -> (); + fn remove( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut &mut vtkInformationKey; + fn get( + &mut self, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get(&mut self, key: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> (); + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn set(&mut self, key: *mut core::ffi::c_void, p1: core::ffi::c_char) -> (); + fn set(&mut self, key: *mut core::ffi::c_void, p1: &str) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> *const core::ffi::c_char; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append( + &mut self, + key: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ) -> (); + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> (); + fn get( + &mut self, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn remove( + &mut self, + key: *mut core::ffi::c_void, + objectToRemove: *mut core::ffi::c_void, + ) -> (); + fn remove( + &mut self, + key: *mut core::ffi::c_void, + indexToRemove: core::ffi::c_int, + ) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn set_request(&mut self, request: *mut core::ffi::c_void) -> (); + fn get_request(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkInformationDataObjectKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationDoubleKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_double) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_double; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationDoubleVectorKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: core::ffi::c_double, + length: core::ffi::c_int, + ) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_double; + fn get( + &mut self, + info: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> core::ffi::c_double; + fn get(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIdTypeKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_uchar) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationInformationKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); + fn deep_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationInformationVectorKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); + fn deep_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIntegerKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_int) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIntegerPointerKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: core::ffi::c_int, + length: core::ffi::c_int, + ) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_int; + fn get(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIntegerVectorKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: core::ffi::c_int, + length: core::ffi::c_int, + ) -> (); + fn set(&mut self, info: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_int; + fn get( + &mut self, + info: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIterator: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_information(&mut self) -> *mut core::ffi::c_void; + fn set_information_weak(&mut self, p0: *mut core::ffi::c_void) -> (); + fn init_traversal(&mut self) -> (); + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; + fn get_current_key(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkInformationKey: VtkObjectBase { + fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; + fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn get_number_of_generations_from_base( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn register(&mut self, p0: *mut core::ffi::c_void) -> (); + fn un_register(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_name(&mut self) -> *const core::ffi::c_char; + fn get_location(&mut self) -> *const core::ffi::c_char; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); + fn deep_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); + fn has(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, info: *mut core::ffi::c_void) -> (); + fn report( + &mut self, + info: *mut core::ffi::c_void, + collector: *mut core::ffi::c_void, + ) -> (); + fn print(&mut self, info: *mut core::ffi::c_void) -> (); + fn need_to_execute( + &mut self, + pipelineInfo: *mut core::ffi::c_void, + dobjInfo: *mut core::ffi::c_void, + ) -> bool; + fn store_meta_data( + &mut self, + request: *mut core::ffi::c_void, + pipelineInfo: *mut core::ffi::c_void, + dobjInfo: *mut core::ffi::c_void, + ) -> (); + fn copy_default_information( + &mut self, + request: *mut core::ffi::c_void, + fromInfo: *mut core::ffi::c_void, + toInfo: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationKeyLookup: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn find(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; +} +pub trait VtkInformationKeyVectorKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn append( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + length: core::ffi::c_int, + ) -> (); + fn remove_item( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut &mut vtkInformationKey; + fn get( + &mut self, + info: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get(&mut self, info: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationObjectBaseKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + requiredClass: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationObjectBaseVectorKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + requiredClass: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn clear(&mut self, info: *mut core::ffi::c_void) -> (); + fn resize(&mut self, info: *mut core::ffi::c_void, size: core::ffi::c_int) -> (); + fn size(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> (); + fn remove( + &mut self, + info: *mut core::ffi::c_void, + val: *mut core::ffi::c_void, + ) -> (); + fn remove(&mut self, info: *mut core::ffi::c_void, idx: core::ffi::c_int) -> (); + fn set_range( + &mut self, + info: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + from: core::ffi::c_int, + to: core::ffi::c_int, + n: core::ffi::c_int, + ) -> (); + fn get_range( + &mut self, + info: *mut core::ffi::c_void, + dest: *mut core::ffi::c_void, + from: core::ffi::c_int, + to: core::ffi::c_int, + n: core::ffi::c_int, + ) -> (); + fn get( + &mut self, + info: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + source: *mut core::ffi::c_void, + dest: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationRequestKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void) -> (); + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationStringKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_char) -> (); + fn set(&mut self, info: *mut core::ffi::c_void, str: &str) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *const core::ffi::c_char; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationStringVectorKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_char) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: core::ffi::c_char, + index: core::ffi::c_int, + ) -> (); + fn append(&mut self, info: *mut core::ffi::c_void, value: &str) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: &str, + idx: core::ffi::c_int, + ) -> (); + fn get( + &mut self, + info: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationUnsignedLongKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_ulong) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_ulong; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationVariantKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: vtkVariant) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> vtkVariant; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationVariantVectorKey: VtkInformationKey + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void, value: vtkVariant) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: vtkVariant, + length: core::ffi::c_int, + ) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *const vtkVariant; + fn get(&mut self, info: *mut core::ffi::c_void, idx: core::ffi::c_int) -> vtkVariant; + fn get(&mut self, info: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationVector: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_information_objects(&mut self) -> core::ffi::c_int; + fn set_number_of_information_objects(&mut self, n: core::ffi::c_int) -> (); + fn set_information_object( + &mut self, + index: core::ffi::c_int, + info: *mut core::ffi::c_void, + ) -> (); + fn get_information_object( + &mut self, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void) -> (); + fn remove(&mut self, info: *mut core::ffi::c_void) -> (); + fn remove(&mut self, idx: core::ffi::c_int) -> (); + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> (); +} +pub trait VtkIntArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_int) -> (); + fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_int) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_int, + ) -> (); + fn insert_next_typed_tuple(&mut self, tuple: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_int) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_int; + fn get_value_range(&mut self) -> *mut core::ffi::c_int; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_int; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_int; + fn set_array( + &mut self, + array: core::ffi::c_int, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_int, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_int; + fn get_data_type_value_max(&mut self) -> core::ffi::c_int; +} +pub trait VtkLargeInteger { + fn cast_to_char(&mut self) -> core::ffi::c_char; + fn cast_to_short(&mut self) -> core::ffi::c_short; + fn cast_to_int(&mut self) -> core::ffi::c_int; + fn cast_to_long(&mut self) -> core::ffi::c_long; + fn cast_to_unsigned_long(&mut self) -> core::ffi::c_ulong; + fn is_even(&mut self) -> core::ffi::c_int; + fn is_odd(&mut self) -> core::ffi::c_int; + fn get_length(&mut self) -> core::ffi::c_int; + fn get_bit(&mut self, p: core::ffi::c_uint) -> core::ffi::c_int; + fn is_zero(&mut self) -> core::ffi::c_int; + fn get_sign(&mut self) -> core::ffi::c_int; + fn truncate(&mut self, n: core::ffi::c_uint) -> (); + fn complement(&mut self) -> (); +} +pub trait VtkLogger: VtkObjectBase { + fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; + fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn get_number_of_generations_from_base( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn init( + &mut self, + argc: core::ffi::c_int, + argv: core::ffi::c_char, + verbosity_flag: core::ffi::c_char, + ) -> (); + fn init(&mut self) -> (); + fn set_stderr_verbosity(&mut self, level: *mut core::ffi::c_void) -> (); + fn set_internal_verbosity_level(&mut self, level: *mut core::ffi::c_void) -> (); + fn end_log_to_file(&mut self, path: core::ffi::c_char) -> (); + fn set_thread_name(&mut self, name: &str) -> (); + fn get_thread_name(&mut self) -> &str; + fn get_identifier(&mut self, obj: *mut core::ffi::c_void) -> &str; + fn add_callback( + &mut self, + id: core::ffi::c_char, + callback: (), + user_data: (), + verbosity: *mut core::ffi::c_void, + on_close: (), + on_flush: (), + ) -> (); + fn remove_callback(&mut self, id: core::ffi::c_char) -> bool; + fn is_enabled(&mut self) -> bool; + fn get_current_verbosity_cutoff(&mut self) -> *mut core::ffi::c_void; + fn convert_to_verbosity( + &mut self, + value: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn convert_to_verbosity( + &mut self, + text: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn log( + &mut self, + verbosity: *mut core::ffi::c_void, + fname: core::ffi::c_char, + lineno: core::ffi::c_uint, + txt: core::ffi::c_char, + ) -> (); + fn start_scope( + &mut self, + verbosity: *mut core::ffi::c_void, + id: core::ffi::c_char, + fname: core::ffi::c_char, + lineno: core::ffi::c_uint, + ) -> (); + fn end_scope(&mut self, id: core::ffi::c_char) -> (); +} +pub trait VtkLongArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_long) -> (); + fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_long) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_long, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_long, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_long; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_long) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_long) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_long) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_long; + fn get_value_range(&mut self) -> *mut core::ffi::c_long; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_long; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_long; + fn set_array( + &mut self, + array: core::ffi::c_long, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_long, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_long; + fn get_data_type_value_max(&mut self) -> core::ffi::c_long; +} +pub trait VtkLongLongArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> (); + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar; + fn get_value_range(&mut self) -> *mut core::ffi::c_uchar; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar; + fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkLookupTable: VtkScalarsToColors + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_opaque(&mut self) -> core::ffi::c_int; + fn allocate( + &mut self, + sz: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> core::ffi::c_int; + fn build(&mut self) -> (); + fn force_build(&mut self) -> (); + fn build_special_colors(&mut self) -> (); + fn set_ramp(&mut self, _arg: core::ffi::c_int) -> (); + fn set_ramp_to_linear(&mut self) -> (); + fn set_ramp_to_s_curve(&mut self) -> (); + fn set_ramp_to_sqrt(&mut self) -> (); + fn get_ramp(&mut self) -> core::ffi::c_int; + fn set_scale(&mut self, scale: core::ffi::c_int) -> (); + fn set_scale_to_linear(&mut self) -> (); + fn set_scale_to_log_10(&mut self) -> (); + fn get_scale(&mut self) -> core::ffi::c_int; + fn set_table_range(&mut self, r: core::ffi::c_double) -> (); + fn set_table_range( + &mut self, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> (); + fn get_table_range(&mut self) -> *mut core::ffi::c_double; + fn get_table_range(&mut self, data: core::ffi::c_double) -> (); + fn set_hue_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_hue_range(&mut self, _arg: core::ffi::c_double) -> (); + fn get_hue_range(&mut self) -> *mut core::ffi::c_double; + fn get_hue_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn get_hue_range(&mut self, _arg: core::ffi::c_double) -> (); + fn set_saturation_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_saturation_range(&mut self, _arg: core::ffi::c_double) -> (); + fn get_saturation_range(&mut self) -> *mut core::ffi::c_double; + fn get_saturation_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn get_saturation_range(&mut self, _arg: core::ffi::c_double) -> (); + fn set_value_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_value_range(&mut self, _arg: core::ffi::c_double) -> (); + fn get_value_range(&mut self) -> *mut core::ffi::c_double; + fn get_value_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn get_value_range(&mut self, _arg: core::ffi::c_double) -> (); + fn set_alpha_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_alpha_range(&mut self, _arg: core::ffi::c_double) -> (); + fn get_alpha_range(&mut self) -> *mut core::ffi::c_double; + fn get_alpha_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn get_alpha_range(&mut self, _arg: core::ffi::c_double) -> (); + fn set_nan_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn set_nan_color(&mut self, _arg: core::ffi::c_double) -> (); + fn get_nan_color(&mut self) -> *mut core::ffi::c_double; + fn get_nan_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn get_nan_color(&mut self, _arg: core::ffi::c_double) -> (); + fn get_nan_color_as_unsigned_chars(&mut self) -> *mut core::ffi::c_uchar; + fn get_color_as_unsigned_chars( + &mut self, + colorIn: core::ffi::c_double, + colorOut: core::ffi::c_uchar, + ) -> (); + fn set_below_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn set_below_range_color(&mut self, _arg: core::ffi::c_double) -> (); + fn get_below_range_color(&mut self) -> *mut core::ffi::c_double; + fn get_below_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn get_below_range_color(&mut self, _arg: core::ffi::c_double) -> (); + fn set_use_below_range_color(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_below_range_color(&mut self) -> core::ffi::c_int; + fn use_below_range_color_on(&mut self) -> (); + fn use_below_range_color_off(&mut self) -> (); + fn set_above_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn set_above_range_color(&mut self, _arg: core::ffi::c_double) -> (); + fn get_above_range_color(&mut self) -> *mut core::ffi::c_double; + fn get_above_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn get_above_range_color(&mut self, _arg: core::ffi::c_double) -> (); + fn set_use_above_range_color(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_above_range_color(&mut self) -> core::ffi::c_int; + fn use_above_range_color_on(&mut self) -> (); + fn use_above_range_color_off(&mut self) -> (); + fn map_value(&mut self, v: core::ffi::c_double) -> *const core::ffi::c_uchar; + fn get_color(&mut self, v: core::ffi::c_double, rgb: core::ffi::c_double) -> (); + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; + fn get_index(&mut self, v: core::ffi::c_double) -> core::ffi::c_uchar; + fn set_number_of_table_values(&mut self, number: core::ffi::c_uchar) -> (); + fn get_number_of_table_values(&mut self) -> core::ffi::c_uchar; + fn set_table_value( + &mut self, + indx: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ) -> (); + fn set_table_value( + &mut self, + indx: core::ffi::c_uchar, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ) -> (); + fn get_table_value(&mut self, indx: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_table_value( + &mut self, + indx: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ) -> (); + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar; + fn get_range(&mut self) -> *mut core::ffi::c_double; + fn get_log_range( + &mut self, + range: core::ffi::c_double, + log_range: core::ffi::c_double, + ) -> (); + fn apply_log_scale( + &mut self, + v: core::ffi::c_double, + range: core::ffi::c_double, + log_range: core::ffi::c_double, + ) -> core::ffi::c_double; + fn set_number_of_colors(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_number_of_colors_min_value(&mut self) -> core::ffi::c_uchar; + fn get_number_of_colors_max_value(&mut self) -> core::ffi::c_uchar; + fn get_number_of_colors(&mut self) -> core::ffi::c_uchar; + fn set_table(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_table(&mut self) -> *mut core::ffi::c_void; + fn map_scalars_through_table_2( + &mut self, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> (); + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn using_log_scale(&mut self) -> core::ffi::c_int; + fn get_indexed_color( + &mut self, + idx: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ) -> (); +} +pub trait VtkMappedDataArray: VtkTypedDataArray + VtkGenericDataArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); + fn get_variant_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn get_tuples( + &mut self, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn get_tuples( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + output: *mut core::ffi::c_void, + ) -> (); + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> (); + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); + fn export_to_void_pointer(&mut self, ptr: ()) -> (); + fn data_changed(&mut self) -> (); + fn set_void_array( + &mut self, + p0: (), + p1: core::ffi::c_uchar, + p2: core::ffi::c_int, + ) -> (); + fn write_void_pointer( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_uchar, + ) -> *mut (); + fn modified(&mut self) -> (); +} +pub trait VtkMath: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn pi(&mut self) -> core::ffi::c_double; + fn radians_from_degrees( + &mut self, + degrees: core::ffi::c_float, + ) -> core::ffi::c_float; + fn radians_from_degrees( + &mut self, + degrees: core::ffi::c_double, + ) -> core::ffi::c_double; + fn degrees_from_radians( + &mut self, + radians: core::ffi::c_float, + ) -> core::ffi::c_float; + fn degrees_from_radians( + &mut self, + radians: core::ffi::c_double, + ) -> core::ffi::c_double; + fn round(&mut self, f: core::ffi::c_float) -> core::ffi::c_int; + fn round(&mut self, f: core::ffi::c_double) -> core::ffi::c_int; + fn floor(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn ceil(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn ceil_log_2(&mut self, x: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn is_power_of_two(&mut self, x: core::ffi::c_ulonglong) -> bool; + fn nearest_power_of_two(&mut self, x: core::ffi::c_int) -> core::ffi::c_int; + fn factorial(&mut self, N: core::ffi::c_int) -> core::ffi::c_uchar; + fn binomial( + &mut self, + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn begin_combination( + &mut self, + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_int; + fn next_combination( + &mut self, + m: core::ffi::c_int, + n: core::ffi::c_int, + combination: core::ffi::c_int, + ) -> core::ffi::c_int; + fn free_combination(&mut self, combination: core::ffi::c_int) -> (); + fn random_seed(&mut self, s: core::ffi::c_int) -> (); + fn get_seed(&mut self) -> core::ffi::c_int; + fn random(&mut self) -> core::ffi::c_double; + fn random( + &mut self, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> core::ffi::c_double; + fn gaussian(&mut self) -> core::ffi::c_double; + fn gaussian( + &mut self, + mean: core::ffi::c_double, + std: core::ffi::c_double, + ) -> core::ffi::c_double; + fn assign(&mut self, a: core::ffi::c_double, b: core::ffi::c_double) -> (); + fn add( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ) -> (); + fn add( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> (); + fn subtract( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ) -> (); + fn subtract( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> (); + fn multiply_scalar(&mut self, a: core::ffi::c_float, s: core::ffi::c_float) -> (); + fn multiply_scalar_2_d( + &mut self, + a: core::ffi::c_float, + s: core::ffi::c_float, + ) -> (); + fn multiply_scalar(&mut self, a: core::ffi::c_double, s: core::ffi::c_double) -> (); + fn multiply_scalar_2_d( + &mut self, + a: core::ffi::c_double, + s: core::ffi::c_double, + ) -> (); + fn dot( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + ) -> core::ffi::c_float; + fn dot( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + ) -> core::ffi::c_double; + fn outer( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ) -> (); + fn outer( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> (); + fn cross( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ) -> (); + fn cross( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> (); + fn norm(&mut self, x: core::ffi::c_float, n: core::ffi::c_int) -> core::ffi::c_float; + fn norm( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_int, + ) -> core::ffi::c_double; + fn norm(&mut self, v: core::ffi::c_float) -> core::ffi::c_float; + fn norm(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; + fn normalize(&mut self, v: core::ffi::c_float) -> core::ffi::c_float; + fn normalize(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; + fn perpendiculars( + &mut self, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + theta: core::ffi::c_double, + ) -> (); + fn perpendiculars( + &mut self, + v1: core::ffi::c_float, + v2: core::ffi::c_float, + v3: core::ffi::c_float, + theta: core::ffi::c_double, + ) -> (); + fn project_vector( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + projection: core::ffi::c_float, + ) -> bool; + fn project_vector( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + projection: core::ffi::c_double, + ) -> bool; + fn project_vector_2_d( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + projection: core::ffi::c_float, + ) -> bool; + fn project_vector_2_d( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + projection: core::ffi::c_double, + ) -> bool; + fn distance_2_between_points( + &mut self, + p1: core::ffi::c_float, + p2: core::ffi::c_float, + ) -> core::ffi::c_float; + fn distance_2_between_points( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_double; + fn angle_between_vectors( + &mut self, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + ) -> core::ffi::c_double; + fn signed_angle_between_vectors( + &mut self, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + vn: core::ffi::c_double, + ) -> core::ffi::c_double; + fn gaussian_amplitude( + &mut self, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; + fn gaussian_amplitude( + &mut self, + mean: core::ffi::c_double, + variance: core::ffi::c_double, + position: core::ffi::c_double, + ) -> core::ffi::c_double; + fn gaussian_weight( + &mut self, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; + fn gaussian_weight( + &mut self, + mean: core::ffi::c_double, + variance: core::ffi::c_double, + position: core::ffi::c_double, + ) -> core::ffi::c_double; + fn dot_2_d( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + ) -> core::ffi::c_float; + fn dot_2_d( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_double; + fn outer_2_d( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + A: core::ffi::c_float, + ) -> (); + fn outer_2_d( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + A: core::ffi::c_double, + ) -> (); + fn norm_2_d(&mut self, x: core::ffi::c_float) -> core::ffi::c_float; + fn norm_2_d(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn normalize_2_d(&mut self, v: core::ffi::c_float) -> core::ffi::c_float; + fn normalize_2_d(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; + fn determinant_2_x_2( + &mut self, + c1: core::ffi::c_float, + c2: core::ffi::c_float, + ) -> core::ffi::c_float; + fn determinant_2_x_2( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + d: core::ffi::c_double, + ) -> core::ffi::c_double; + fn determinant_2_x_2( + &mut self, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + ) -> core::ffi::c_double; + fn lu_factor_3_x_3(&mut self, A: core::ffi::c_float, index: core::ffi::c_int) -> (); + fn lu_factor_3_x_3(&mut self, A: core::ffi::c_double, index: core::ffi::c_int) -> (); + fn lu_solve_3_x_3( + &mut self, + A: core::ffi::c_float, + index: core::ffi::c_int, + x: core::ffi::c_float, + ) -> (); + fn lu_solve_3_x_3( + &mut self, + A: core::ffi::c_double, + index: core::ffi::c_int, + x: core::ffi::c_double, + ) -> (); + fn linear_solve_3_x_3( + &mut self, + A: core::ffi::c_float, + x: core::ffi::c_float, + y: core::ffi::c_float, + ) -> (); + fn linear_solve_3_x_3( + &mut self, + A: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> (); + fn multiply_3_x_3( + &mut self, + A: core::ffi::c_float, + v: core::ffi::c_float, + u: core::ffi::c_float, + ) -> (); + fn multiply_3_x_3( + &mut self, + A: core::ffi::c_double, + v: core::ffi::c_double, + u: core::ffi::c_double, + ) -> (); + fn multiply_3_x_3( + &mut self, + A: core::ffi::c_float, + B: core::ffi::c_float, + C: core::ffi::c_float, + ) -> (); + fn multiply_3_x_3( + &mut self, + A: core::ffi::c_double, + B: core::ffi::c_double, + C: core::ffi::c_double, + ) -> (); + fn multiply_matrix( + &mut self, + A: core::ffi::c_double, + B: core::ffi::c_double, + rowA: core::ffi::c_uint, + colA: core::ffi::c_uint, + rowB: core::ffi::c_uint, + colB: core::ffi::c_uint, + C: core::ffi::c_double, + ) -> (); + fn transpose_3_x_3(&mut self, A: core::ffi::c_float, AT: core::ffi::c_float) -> (); + fn transpose_3_x_3(&mut self, A: core::ffi::c_double, AT: core::ffi::c_double) -> (); + fn invert_3_x_3(&mut self, A: core::ffi::c_float, AI: core::ffi::c_float) -> (); + fn invert_3_x_3(&mut self, A: core::ffi::c_double, AI: core::ffi::c_double) -> (); + fn identity_3_x_3(&mut self, A: core::ffi::c_float) -> (); + fn identity_3_x_3(&mut self, A: core::ffi::c_double) -> (); + fn determinant_3_x_3(&mut self, A: core::ffi::c_float) -> core::ffi::c_double; + fn determinant_3_x_3(&mut self, A: core::ffi::c_double) -> core::ffi::c_double; + fn determinant_3_x_3( + &mut self, + c1: core::ffi::c_float, + c2: core::ffi::c_float, + c3: core::ffi::c_float, + ) -> core::ffi::c_float; + fn determinant_3_x_3( + &mut self, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double; + fn determinant_3_x_3( + &mut self, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + b1: core::ffi::c_double, + b2: core::ffi::c_double, + b3: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double; + fn quaternion_to_matrix_3_x_3( + &mut self, + quat: core::ffi::c_float, + A: core::ffi::c_float, + ) -> (); + fn quaternion_to_matrix_3_x_3( + &mut self, + quat: core::ffi::c_double, + A: core::ffi::c_double, + ) -> (); + fn matrix_3_x_3_to_quaternion( + &mut self, + A: core::ffi::c_float, + quat: core::ffi::c_float, + ) -> (); + fn matrix_3_x_3_to_quaternion( + &mut self, + A: core::ffi::c_double, + quat: core::ffi::c_double, + ) -> (); + fn multiply_quaternion( + &mut self, + q1: core::ffi::c_float, + q2: core::ffi::c_float, + q: core::ffi::c_float, + ) -> (); + fn multiply_quaternion( + &mut self, + q1: core::ffi::c_double, + q2: core::ffi::c_double, + q: core::ffi::c_double, + ) -> (); + fn rotate_vector_by_normalized_quaternion( + &mut self, + v: core::ffi::c_float, + q: core::ffi::c_float, + r: core::ffi::c_float, + ) -> (); + fn rotate_vector_by_normalized_quaternion( + &mut self, + v: core::ffi::c_double, + q: core::ffi::c_double, + r: core::ffi::c_double, + ) -> (); + fn rotate_vector_by_wxyz( + &mut self, + v: core::ffi::c_float, + q: core::ffi::c_float, + r: core::ffi::c_float, + ) -> (); + fn rotate_vector_by_wxyz( + &mut self, + v: core::ffi::c_double, + q: core::ffi::c_double, + r: core::ffi::c_double, + ) -> (); + fn orthogonalize_3_x_3( + &mut self, + A: core::ffi::c_float, + B: core::ffi::c_float, + ) -> (); + fn orthogonalize_3_x_3( + &mut self, + A: core::ffi::c_double, + B: core::ffi::c_double, + ) -> (); + fn diagonalize_3_x_3( + &mut self, + A: core::ffi::c_float, + w: core::ffi::c_float, + V: core::ffi::c_float, + ) -> (); + fn diagonalize_3_x_3( + &mut self, + A: core::ffi::c_double, + w: core::ffi::c_double, + V: core::ffi::c_double, + ) -> (); + fn singular_value_decomposition_3_x_3( + &mut self, + A: core::ffi::c_float, + U: core::ffi::c_float, + w: core::ffi::c_float, + VT: core::ffi::c_float, + ) -> (); + fn singular_value_decomposition_3_x_3( + &mut self, + A: core::ffi::c_double, + U: core::ffi::c_double, + w: core::ffi::c_double, + VT: core::ffi::c_double, + ) -> (); + fn solve_linear_system_gepp_2_x_2( + &mut self, + a00: core::ffi::c_double, + a01: core::ffi::c_double, + a10: core::ffi::c_double, + a11: core::ffi::c_double, + b0: core::ffi::c_double, + b1: core::ffi::c_double, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + ) -> core::ffi::c_int; + fn solve_linear_system( + &mut self, + A: core::ffi::c_double, + x: core::ffi::c_double, + size: core::ffi::c_int, + ) -> core::ffi::c_int; + fn invert_matrix( + &mut self, + A: core::ffi::c_double, + AI: core::ffi::c_double, + size: core::ffi::c_int, + ) -> core::ffi::c_int; + fn invert_matrix( + &mut self, + A: core::ffi::c_double, + AI: core::ffi::c_double, + size: core::ffi::c_int, + tmp1Size: core::ffi::c_int, + tmp2Size: core::ffi::c_double, + ) -> core::ffi::c_int; + fn lu_factor_linear_system( + &mut self, + A: core::ffi::c_double, + index: core::ffi::c_int, + size: core::ffi::c_int, + ) -> core::ffi::c_int; + fn lu_factor_linear_system( + &mut self, + A: core::ffi::c_double, + index: core::ffi::c_int, + size: core::ffi::c_int, + tmpSize: core::ffi::c_double, + ) -> core::ffi::c_int; + fn lu_solve_linear_system( + &mut self, + A: core::ffi::c_double, + index: core::ffi::c_int, + x: core::ffi::c_double, + size: core::ffi::c_int, + ) -> (); + fn estimate_matrix_condition( + &mut self, + A: core::ffi::c_double, + size: core::ffi::c_int, + ) -> core::ffi::c_double; + fn jacobi( + &mut self, + a: core::ffi::c_float, + w: core::ffi::c_float, + v: core::ffi::c_float, + ) -> core::ffi::c_int; + fn jacobi( + &mut self, + a: core::ffi::c_double, + w: core::ffi::c_double, + v: core::ffi::c_double, + ) -> core::ffi::c_int; + fn jacobi_n( + &mut self, + a: core::ffi::c_float, + n: core::ffi::c_int, + w: core::ffi::c_float, + v: core::ffi::c_float, + ) -> core::ffi::c_int; + fn jacobi_n( + &mut self, + a: core::ffi::c_double, + n: core::ffi::c_int, + w: core::ffi::c_double, + v: core::ffi::c_double, + ) -> core::ffi::c_int; + fn solve_homogeneous_least_squares( + &mut self, + numberOfSamples: core::ffi::c_int, + xt: core::ffi::c_double, + xOrder: core::ffi::c_int, + mt: core::ffi::c_double, + ) -> core::ffi::c_int; + fn solve_least_squares( + &mut self, + numberOfSamples: core::ffi::c_int, + xt: core::ffi::c_double, + xOrder: core::ffi::c_int, + yt: core::ffi::c_double, + yOrder: core::ffi::c_int, + mt: core::ffi::c_double, + checkHomogeneous: core::ffi::c_int, + ) -> core::ffi::c_int; + fn rgb_to_hsv(&mut self, rgb: core::ffi::c_float, hsv: core::ffi::c_float) -> (); + fn rgb_to_hsv( + &mut self, + r: core::ffi::c_float, + g: core::ffi::c_float, + b: core::ffi::c_float, + h: core::ffi::c_float, + s: core::ffi::c_float, + v: core::ffi::c_float, + ) -> (); + fn rgb_to_hsv(&mut self, rgb: core::ffi::c_double, hsv: core::ffi::c_double) -> (); + fn rgb_to_hsv( + &mut self, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + h: core::ffi::c_double, + s: core::ffi::c_double, + v: core::ffi::c_double, + ) -> (); + fn hsv_to_rgb(&mut self, hsv: core::ffi::c_float, rgb: core::ffi::c_float) -> (); + fn hsv_to_rgb( + &mut self, + h: core::ffi::c_float, + s: core::ffi::c_float, + v: core::ffi::c_float, + r: core::ffi::c_float, + g: core::ffi::c_float, + b: core::ffi::c_float, + ) -> (); + fn hsv_to_rgb(&mut self, hsv: core::ffi::c_double, rgb: core::ffi::c_double) -> (); + fn hsv_to_rgb( + &mut self, + h: core::ffi::c_double, + s: core::ffi::c_double, + v: core::ffi::c_double, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + ) -> (); + fn lab_to_xyz(&mut self, lab: core::ffi::c_double, xyz: core::ffi::c_double) -> (); + fn lab_to_xyz( + &mut self, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn xyz_to_lab(&mut self, xyz: core::ffi::c_double, lab: core::ffi::c_double) -> (); + fn xyz_to_lab( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + ) -> (); + fn xyz_to_rgb(&mut self, xyz: core::ffi::c_double, rgb: core::ffi::c_double) -> (); + fn xyz_to_rgb( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + ) -> (); + fn rgb_to_xyz(&mut self, rgb: core::ffi::c_double, xyz: core::ffi::c_double) -> (); + fn rgb_to_xyz( + &mut self, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rgb_to_lab(&mut self, rgb: core::ffi::c_double, lab: core::ffi::c_double) -> (); + fn rgb_to_lab( + &mut self, + red: core::ffi::c_double, + green: core::ffi::c_double, + blue: core::ffi::c_double, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + ) -> (); + fn lab_to_rgb(&mut self, lab: core::ffi::c_double, rgb: core::ffi::c_double) -> (); + fn lab_to_rgb( + &mut self, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + red: core::ffi::c_double, + green: core::ffi::c_double, + blue: core::ffi::c_double, + ) -> (); + fn uninitialize_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn are_bounds_initialized( + &mut self, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + fn clamp_value( + &mut self, + value: core::ffi::c_double, + range: core::ffi::c_double, + ) -> (); + fn clamp_value( + &mut self, + value: core::ffi::c_double, + range: core::ffi::c_double, + clamped_value: core::ffi::c_double, + ) -> (); + fn clamp_values( + &mut self, + values: core::ffi::c_double, + nb_values: core::ffi::c_int, + range: core::ffi::c_double, + ) -> (); + fn clamp_values( + &mut self, + values: core::ffi::c_double, + nb_values: core::ffi::c_int, + range: core::ffi::c_double, + clamped_values: core::ffi::c_double, + ) -> (); + fn clamp_and_normalize_value( + &mut self, + value: core::ffi::c_double, + range: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_scalar_type_fitting_range( + &mut self, + range_min: core::ffi::c_double, + range_max: core::ffi::c_double, + scale: core::ffi::c_double, + shift: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_adjusted_scalar_range( + &mut self, + array: *mut core::ffi::c_void, + comp: core::ffi::c_int, + range: core::ffi::c_double, + ) -> core::ffi::c_int; + fn extent_is_within_other_extent( + &mut self, + extent1: core::ffi::c_int, + extent2: core::ffi::c_int, + ) -> core::ffi::c_int; + fn bounds_is_within_other_bounds( + &mut self, + bounds1: core::ffi::c_double, + bounds2: core::ffi::c_double, + delta: core::ffi::c_double, + ) -> core::ffi::c_int; + fn point_is_within_bounds( + &mut self, + point: core::ffi::c_double, + bounds: core::ffi::c_double, + delta: core::ffi::c_double, + ) -> core::ffi::c_int; + fn plane_intersects_aabb( + &mut self, + bounds: core::ffi::c_double, + normal: core::ffi::c_double, + point: core::ffi::c_double, + ) -> core::ffi::c_int; + fn solve_3_point_circle( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + fn inf(&mut self) -> core::ffi::c_double; + fn neg_inf(&mut self) -> core::ffi::c_double; + fn nan(&mut self) -> core::ffi::c_double; + fn is_inf(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn is_nan(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn is_finite(&mut self, x: core::ffi::c_double) -> bool; + fn quadratic_root( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + min: core::ffi::c_double, + max: core::ffi::c_double, + u: core::ffi::c_double, + ) -> core::ffi::c_int; +} +pub trait VtkMersenneTwister: VtkRandomSequence + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn initialize_new_sequence( + &mut self, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> core::ffi::c_uint; + fn initialize_sequence( + &mut self, + id: core::ffi::c_uint, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> (); + fn get_value(&mut self, id: core::ffi::c_uint) -> core::ffi::c_double; + fn get_value(&mut self) -> core::ffi::c_double; + fn next(&mut self, id: core::ffi::c_uint) -> (); + fn next(&mut self) -> (); +} +pub trait VtkMinimalStandardRandomSequence: VtkRandomSequence + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn set_seed(&mut self, value: core::ffi::c_int) -> (); + fn set_seed_only(&mut self, value: core::ffi::c_int) -> (); + fn get_seed(&mut self) -> core::ffi::c_int; + fn get_value(&mut self) -> core::ffi::c_double; + fn next(&mut self) -> (); + fn get_range_value( + &mut self, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_next_range_value( + &mut self, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkMultiThreader: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_threads(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_threads_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_threads_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_threads(&mut self) -> core::ffi::c_int; + fn get_global_static_maximum_number_of_threads(&mut self) -> core::ffi::c_int; + fn set_global_maximum_number_of_threads(&mut self, val: core::ffi::c_int) -> (); + fn get_global_maximum_number_of_threads(&mut self) -> core::ffi::c_int; + fn set_global_default_number_of_threads(&mut self, val: core::ffi::c_int) -> (); + fn get_global_default_number_of_threads(&mut self) -> core::ffi::c_int; + fn single_method_execute(&mut self) -> (); + fn multiple_method_execute(&mut self) -> (); + fn set_single_method(&mut self, p0: *mut core::ffi::c_void, data: ()) -> (); + fn set_multiple_method( + &mut self, + index: core::ffi::c_int, + p1: *mut core::ffi::c_void, + data: (), + ) -> (); + fn spawn_thread(&mut self, p0: *mut core::ffi::c_void, data: ()) -> core::ffi::c_int; + fn terminate_thread(&mut self, threadId: core::ffi::c_int) -> (); + fn is_thread_active(&mut self, threadId: core::ffi::c_int) -> core::ffi::c_int; + fn get_current_thread_id(&mut self) -> *mut core::ffi::c_void; + fn threads_equal( + &mut self, + t1: *mut core::ffi::c_void, + t2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkMutexLock: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkNew { + fn reset(&mut self) -> (); + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn get(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkOStrStreamWrapper { + fn str(&mut self) -> *mut core::ffi::c_char; + fn rdbuf(&mut self) -> *mut core::ffi::c_void; + fn freeze(&mut self) -> (); + fn freeze(&mut self, p0: core::ffi::c_int) -> (); +} +pub trait VtkObject: VtkObjectBase { + fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; + fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn get_number_of_generations_from_base( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn new(&mut self) -> *mut core::ffi::c_void; + fn debug_on(&mut self) -> (); + fn debug_off(&mut self) -> (); + fn get_debug(&mut self) -> bool; + fn set_debug(&mut self, debugFlag: bool) -> (); + fn break_on_error(&mut self) -> (); + fn modified(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_global_warning_display(&mut self, val: core::ffi::c_int) -> (); + fn global_warning_display_on(&mut self) -> (); + fn global_warning_display_off(&mut self) -> (); + fn get_global_warning_display(&mut self) -> core::ffi::c_int; + fn add_observer( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + priority: core::ffi::c_float, + ) -> core::ffi::c_ulong; + fn add_observer( + &mut self, + event: core::ffi::c_char, + p1: *mut core::ffi::c_void, + priority: core::ffi::c_float, + ) -> core::ffi::c_ulong; + fn get_command(&mut self, tag: core::ffi::c_ulong) -> *mut core::ffi::c_void; + fn remove_observer(&mut self, p0: *mut core::ffi::c_void) -> (); + fn remove_observers( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> (); + fn remove_observers( + &mut self, + event: core::ffi::c_char, + p1: *mut core::ffi::c_void, + ) -> (); + fn has_observer( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn has_observer( + &mut self, + event: core::ffi::c_char, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn remove_observer(&mut self, tag: core::ffi::c_ulong) -> (); + fn remove_observers(&mut self, event: core::ffi::c_ulong) -> (); + fn remove_observers(&mut self, event: core::ffi::c_char) -> (); + fn remove_all_observers(&mut self) -> (); + fn has_observer(&mut self, event: core::ffi::c_ulong) -> core::ffi::c_int; + fn has_observer(&mut self, event: core::ffi::c_char) -> core::ffi::c_int; + fn invoke_event( + &mut self, + event: core::ffi::c_ulong, + callData: (), + ) -> core::ffi::c_int; + fn invoke_event( + &mut self, + event: core::ffi::c_char, + callData: (), + ) -> core::ffi::c_int; + fn invoke_event(&mut self, event: core::ffi::c_ulong) -> core::ffi::c_int; + fn invoke_event(&mut self, event: core::ffi::c_char) -> core::ffi::c_int; +} +pub trait VtkObjectBase { + fn get_class_name(&mut self) -> *const core::ffi::c_char; + fn is_type_of(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn is_a(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_number_of_generations_from_base_type( + &mut self, + name: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn get_number_of_generations_from_base( + &mut self, + name: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn delete(&mut self) -> (); + fn fast_delete(&mut self) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize_object_base(&mut self) -> (); + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn un_register(&mut self, o: *mut core::ffi::c_void) -> (); + fn get_reference_count(&mut self) -> core::ffi::c_int; + fn set_reference_count(&mut self, p0: core::ffi::c_int) -> (); + fn set_memkind_directory(&mut self, directoryname: core::ffi::c_char) -> (); + fn get_using_memkind(&mut self) -> bool; + fn get_is_in_memkind(&mut self) -> bool; +} +pub trait VtkObjectFactory: VtkObject + VtkObjectBase { + fn create_instance( + &mut self, + vtkclassname: core::ffi::c_char, + isAbstract: bool, + ) -> *mut core::ffi::c_void; + fn create_all_instance( + &mut self, + vtkclassname: core::ffi::c_char, + retList: *mut core::ffi::c_void, + ) -> (); + fn re_hash(&mut self) -> (); + fn register_factory(&mut self, p0: *mut core::ffi::c_void) -> (); + fn un_register_factory(&mut self, p0: *mut core::ffi::c_void) -> (); + fn un_register_all_factories(&mut self) -> (); + fn get_registered_factories(&mut self) -> *mut core::ffi::c_void; + fn has_override_any(&mut self, className: core::ffi::c_char) -> core::ffi::c_int; + fn get_override_information( + &mut self, + name: core::ffi::c_char, + p1: *mut core::ffi::c_void, + ) -> (); + fn set_all_enable_flags( + &mut self, + flag: core::ffi::c_int, + className: core::ffi::c_char, + ) -> (); + fn set_all_enable_flags( + &mut self, + flag: core::ffi::c_int, + className: core::ffi::c_char, + subclassName: core::ffi::c_char, + ) -> (); + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_vtk_source_version(&mut self) -> *const core::ffi::c_char; + fn get_description(&mut self) -> *const core::ffi::c_char; + fn get_number_of_overrides(&mut self) -> core::ffi::c_int; + fn get_class_override_name( + &mut self, + index: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn get_class_override_with_name( + &mut self, + index: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn get_enable_flag(&mut self, index: core::ffi::c_int) -> core::ffi::c_int; + fn get_override_description( + &mut self, + index: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn set_enable_flag( + &mut self, + flag: core::ffi::c_int, + className: core::ffi::c_char, + subclassName: core::ffi::c_char, + ) -> (); + fn get_enable_flag( + &mut self, + className: core::ffi::c_char, + subclassName: core::ffi::c_char, + ) -> core::ffi::c_int; + fn has_override(&mut self, className: core::ffi::c_char) -> core::ffi::c_int; + fn has_override( + &mut self, + className: core::ffi::c_char, + subclassName: core::ffi::c_char, + ) -> core::ffi::c_int; + fn disable(&mut self, className: core::ffi::c_char) -> (); + fn get_library_path(&mut self) -> *mut core::ffi::c_char; +} +pub trait VtkObjectFactoryCollection: VtkCollection + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, t: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_next_object_factory(&mut self, cookie: ()) -> *mut core::ffi::c_void; +} +pub trait VtkOldStyleCallbackCommand: VtkCommand + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn execute( + &mut self, + invoker: *mut core::ffi::c_void, + eid: core::ffi::c_ulong, + calldata: (), + ) -> (); + fn set_client_data(&mut self, cd: ()) -> (); + fn set_callback(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> (); +} +pub trait VtkOutputWindow: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_instance(&mut self) -> *mut core::ffi::c_void; + fn set_instance(&mut self, instance: *mut core::ffi::c_void) -> (); + fn display_text(&mut self, p0: core::ffi::c_char) -> (); + fn display_error_text(&mut self, p0: core::ffi::c_char) -> (); + fn display_warning_text(&mut self, p0: core::ffi::c_char) -> (); + fn display_generic_warning_text(&mut self, p0: core::ffi::c_char) -> (); + fn display_debug_text(&mut self, p0: core::ffi::c_char) -> (); + fn prompt_user_on(&mut self) -> (); + fn prompt_user_off(&mut self) -> (); + fn set_prompt_user(&mut self, _arg: bool) -> (); + fn set_use_std_error_for_all_messages(&mut self, p0: bool) -> (); + fn get_use_std_error_for_all_messages(&mut self) -> bool; + fn use_std_error_for_all_messages_on(&mut self) -> (); + fn use_std_error_for_all_messages_off(&mut self) -> (); + fn set_display_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_display_mode_min_value(&mut self) -> core::ffi::c_int; + fn get_display_mode_max_value(&mut self) -> core::ffi::c_int; + fn get_display_mode(&mut self) -> core::ffi::c_int; + fn set_display_mode_to_default(&mut self) -> (); + fn set_display_mode_to_never(&mut self) -> (); + fn set_display_mode_to_always(&mut self) -> (); + fn set_display_mode_to_always_std_err(&mut self) -> (); +} +pub trait VtkOverrideInformation: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_class_override_name(&mut self) -> *const core::ffi::c_char; + fn get_class_override_with_name(&mut self) -> *const core::ffi::c_char; + fn get_description(&mut self) -> *const core::ffi::c_char; + fn get_object_factory(&mut self) -> *mut core::ffi::c_void; + fn set_class_override_name(&mut self, _arg: core::ffi::c_char) -> (); + fn set_class_override_with_name(&mut self, _arg: core::ffi::c_char) -> (); + fn set_description(&mut self, _arg: core::ffi::c_char) -> (); +} +pub trait VtkOverrideInformationCollection: VtkCollection + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_next_override_information(&mut self, cookie: ()) -> *mut core::ffi::c_void; +} +pub trait VtkPoints: VtkObject + VtkObjectBase { + fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn set_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn set_data_type(&mut self, dataType: core::ffi::c_int) -> (); + fn set_data_type_to_bit(&mut self) -> (); + fn set_data_type_to_char(&mut self) -> (); + fn set_data_type_to_unsigned_char(&mut self) -> (); + fn set_data_type_to_short(&mut self) -> (); + fn set_data_type_to_unsigned_short(&mut self) -> (); + fn set_data_type_to_int(&mut self) -> (); + fn set_data_type_to_unsigned_int(&mut self) -> (); + fn set_data_type_to_long(&mut self) -> (); + fn set_data_type_to_unsigned_long(&mut self) -> (); + fn set_data_type_to_float(&mut self) -> (); + fn set_data_type_to_double(&mut self) -> (); + fn get_void_pointer(&mut self, id: core::ffi::c_int) -> *mut (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_point(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> (); + fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn set_point( + &mut self, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> (); + fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn insert_point( + &mut self, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn insert_points( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_points( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_point(&mut self, x: core::ffi::c_float) -> core::ffi::c_uchar; + fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn set_number_of_points(&mut self, numPoints: core::ffi::c_uchar) -> (); + fn resize(&mut self, numPoints: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_points( + &mut self, + ptId: *mut core::ffi::c_void, + outPoints: *mut core::ffi::c_void, + ) -> (); + fn compute_bounds(&mut self) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn modified(&mut self) -> (); +} +pub trait VtkPoints2D: VtkObject + VtkObjectBase { + fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn set_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn set_data_type(&mut self, dataType: core::ffi::c_int) -> (); + fn set_data_type_to_bit(&mut self) -> (); + fn set_data_type_to_char(&mut self) -> (); + fn set_data_type_to_unsigned_char(&mut self) -> (); + fn set_data_type_to_short(&mut self) -> (); + fn set_data_type_to_unsigned_short(&mut self) -> (); + fn set_data_type_to_int(&mut self) -> (); + fn set_data_type_to_unsigned_int(&mut self) -> (); + fn set_data_type_to_long(&mut self) -> (); + fn set_data_type_to_unsigned_long(&mut self) -> (); + fn set_data_type_to_float(&mut self) -> (); + fn set_data_type_to_double(&mut self) -> (); + fn get_void_pointer(&mut self, id: core::ffi::c_int) -> *mut (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_point(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> (); + fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn set_point( + &mut self, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> (); + fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> (); + fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn insert_point( + &mut self, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> (); + fn insert_next_point(&mut self, x: core::ffi::c_float) -> core::ffi::c_uchar; + fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn remove_point(&mut self, id: core::ffi::c_uchar) -> (); + fn set_number_of_points(&mut self, numPoints: core::ffi::c_uchar) -> (); + fn resize(&mut self, numPoints: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_points( + &mut self, + ptId: *mut core::ffi::c_void, + fp: *mut core::ffi::c_void, + ) -> (); + fn compute_bounds(&mut self) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); +} +pub trait VtkPriorityQueue: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate(&mut self, sz: core::ffi::c_uchar, ext: core::ffi::c_uchar) -> (); + fn insert(&mut self, priority: core::ffi::c_double, id: core::ffi::c_uchar) -> (); + fn pop( + &mut self, + location: core::ffi::c_uchar, + priority: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn pop(&mut self, location: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn peek( + &mut self, + location: core::ffi::c_uchar, + priority: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn peek(&mut self, location: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn delete_id(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double; + fn get_priority(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double; + fn get_number_of_items(&mut self) -> core::ffi::c_uchar; + fn reset(&mut self) -> (); +} +pub trait VtkRandomPool: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_sequence(&mut self, seq: *mut core::ffi::c_void) -> (); + fn get_sequence(&mut self) -> *mut core::ffi::c_void; + fn set_size(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_size_min_value(&mut self) -> core::ffi::c_uchar; + fn get_size_max_value(&mut self) -> core::ffi::c_uchar; + fn get_size(&mut self) -> core::ffi::c_uchar; + fn set_number_of_components(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_number_of_components_min_value(&mut self) -> core::ffi::c_uchar; + fn get_number_of_components_max_value(&mut self) -> core::ffi::c_uchar; + fn get_number_of_components(&mut self) -> core::ffi::c_uchar; + fn get_total_size(&mut self) -> core::ffi::c_uchar; + fn generate_pool(&mut self) -> *const core::ffi::c_double; + fn get_pool(&mut self) -> *const core::ffi::c_double; + fn get_value(&mut self, i: core::ffi::c_uchar) -> core::ffi::c_double; + fn get_value( + &mut self, + i: core::ffi::c_uchar, + compNum: core::ffi::c_int, + ) -> core::ffi::c_double; + fn populate_data_array( + &mut self, + da: *mut core::ffi::c_void, + minRange: core::ffi::c_double, + maxRange: core::ffi::c_double, + ) -> (); + fn populate_data_array( + &mut self, + da: *mut core::ffi::c_void, + compNumber: core::ffi::c_int, + minRange: core::ffi::c_double, + maxRange: core::ffi::c_double, + ) -> (); + fn set_chunk_size(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_chunk_size_min_value(&mut self) -> core::ffi::c_uchar; + fn get_chunk_size_max_value(&mut self) -> core::ffi::c_uchar; + fn get_chunk_size(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkRandomSequence: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn get_value(&mut self) -> core::ffi::c_double; + fn next(&mut self) -> (); + fn get_next_value(&mut self) -> core::ffi::c_double; +} +pub trait VtkReferenceCount: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkSMPThreadLocal { + fn local(&mut self) -> *mut core::ffi::c_void; + fn size(&mut self) -> usize; +} +pub trait VtkSMPThreadLocalObject { + fn local(&mut self) -> *mut core::ffi::c_void; + fn size(&mut self) -> usize; + fn begin(&mut self) -> *mut core::ffi::c_void; + fn end(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkSMPTools { + fn get_backend(&mut self) -> *const core::ffi::c_char; + fn set_backend(&mut self, backend: core::ffi::c_char) -> bool; + fn initialize(&mut self, numThreads: core::ffi::c_int) -> (); + fn get_estimated_number_of_threads(&mut self) -> core::ffi::c_int; + fn set_nested_parallelism(&mut self, isNested: bool) -> (); + fn get_nested_parallelism(&mut self) -> bool; + fn is_parallel_scope(&mut self) -> bool; +} +pub trait VtkSOADataArrayTemplate: VtkGenericDataArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_value(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_value( + &mut self, + valueIdx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn get_typed_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: *mut core::ffi::c_void, + ) -> (); + fn set_typed_tuple(&mut self, tupleIdx: core::ffi::c_uchar, tuple: ValueTypeT) -> (); + fn get_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + comp: core::ffi::c_int, + value: *mut core::ffi::c_void, + ) -> (); + fn set_array( + &mut self, + comp: core::ffi::c_int, + array: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + updateMaxId: bool, + save: bool, + deleteMethod: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn set_array_free_function( + &mut self, + comp: core::ffi::c_int, + callback: *mut core::ffi::c_void, + ) -> (); + fn get_component_array_pointer( + &mut self, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_void_pointer(&mut self, valueIdx: core::ffi::c_uchar) -> *mut (); + fn export_to_void_pointer(&mut self, ptr: ()) -> (); + fn set_number_of_components(&mut self, numComps: core::ffi::c_int) -> (); +} +pub trait VtkScalarsToColors: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn is_opaque(&mut self) -> core::ffi::c_int; + fn is_opaque( + &mut self, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_int; + fn build(&mut self) -> (); + fn get_range(&mut self) -> *mut core::ffi::c_double; + fn set_range(&mut self, min: core::ffi::c_double, max: core::ffi::c_double) -> (); + fn set_range(&mut self, rng: core::ffi::c_double) -> (); + fn map_value(&mut self, v: core::ffi::c_double) -> *const core::ffi::c_uchar; + fn get_color(&mut self, v: core::ffi::c_double, rgb: core::ffi::c_double) -> (); + fn get_color(&mut self, v: core::ffi::c_double) -> *mut core::ffi::c_double; + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; + fn get_luminance(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn set_alpha(&mut self, alpha: core::ffi::c_double) -> (); + fn get_alpha(&mut self) -> core::ffi::c_double; + fn map_scalars( + &mut self, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn map_scalars( + &mut self, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_vector_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_vector_mode(&mut self) -> core::ffi::c_int; + fn set_vector_mode_to_magnitude(&mut self) -> (); + fn set_vector_mode_to_component(&mut self) -> (); + fn set_vector_mode_to_rgb_colors(&mut self) -> (); + fn set_vector_component(&mut self, _arg: core::ffi::c_int) -> (); + fn get_vector_component(&mut self) -> core::ffi::c_int; + fn set_vector_size(&mut self, _arg: core::ffi::c_int) -> (); + fn get_vector_size(&mut self) -> core::ffi::c_int; + fn map_vectors_through_table( + &mut self, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + vectorComponent: core::ffi::c_int, + vectorSize: core::ffi::c_int, + ) -> (); + fn map_vectors_through_table( + &mut self, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> (); + fn map_scalars_through_table( + &mut self, + scalars: *mut core::ffi::c_void, + output: core::ffi::c_uchar, + outputFormat: core::ffi::c_int, + ) -> (); + fn map_scalars_through_table( + &mut self, + scalars: *mut core::ffi::c_void, + output: core::ffi::c_uchar, + ) -> (); + fn map_scalars_through_table( + &mut self, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> (); + fn map_scalars_through_table_2( + &mut self, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> (); + fn deep_copy(&mut self, o: *mut core::ffi::c_void) -> (); + fn using_log_scale(&mut self) -> core::ffi::c_int; + fn get_number_of_available_colors(&mut self) -> core::ffi::c_uchar; + fn set_annotations( + &mut self, + values: *mut core::ffi::c_void, + annotations: *mut core::ffi::c_void, + ) -> (); + fn get_annotated_values(&mut self) -> *mut core::ffi::c_void; + fn get_annotations(&mut self) -> *mut core::ffi::c_void; + fn set_annotation( + &mut self, + value: *mut core::ffi::c_void, + annotation: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn set_annotation( + &mut self, + value: *mut core::ffi::c_void, + annotation: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn get_number_of_annotated_values(&mut self) -> core::ffi::c_uchar; + fn get_annotated_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_annotation(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_annotation_color(&mut self, val: vtkVariant, rgba: core::ffi::c_double) -> (); + fn get_annotated_value_index( + &mut self, + val: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn get_annotated_value_index_internal( + &mut self, + val: vtkVariant, + ) -> core::ffi::c_uchar; + fn get_indexed_color( + &mut self, + i: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ) -> (); + fn remove_annotation(&mut self, value: *mut core::ffi::c_void) -> bool; + fn reset_annotations(&mut self) -> (); + fn set_indexed_lookup(&mut self, _arg: core::ffi::c_int) -> (); + fn get_indexed_lookup(&mut self) -> core::ffi::c_int; + fn indexed_lookup_on(&mut self) -> (); + fn indexed_lookup_off(&mut self) -> (); +} +pub trait VtkShortArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_short, + ) -> (); + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_short, + ) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_short, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_short, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_short; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_short) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_short) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_short) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_short; + fn get_value_range(&mut self) -> *mut core::ffi::c_short; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_short; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_short; + fn set_array( + &mut self, + array: core::ffi::c_short, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_short, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_short; + fn get_data_type_value_max(&mut self) -> core::ffi::c_short; +} +pub trait VtkSignedCharArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_char) -> (); + fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_char) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_char, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_char; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_char) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_char; + fn get_value_range(&mut self) -> *mut core::ffi::c_char; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_char; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_char; + fn set_array( + &mut self, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_char; + fn get_data_type_value_max(&mut self) -> core::ffi::c_char; +} +pub trait VtkSimpleConditionVariable { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn signal(&mut self) -> (); + fn broadcast(&mut self) -> (); + fn wait(&mut self, mutex: *mut core::ffi::c_void) -> core::ffi::c_int; +} +pub trait VtkSimpleCriticalSection { + fn init(&mut self) -> (); + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkSimpleMutexLock { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkSmartPointer: VtkSmartPointerBase { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn get(&mut self) -> *mut core::ffi::c_void; + fn take_reference(&mut self, t: *mut core::ffi::c_void) -> (); +} +pub trait VtkSmartPointerBase { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn report( + &mut self, + collector: *mut core::ffi::c_void, + desc: core::ffi::c_char, + ) -> (); +} +pub trait VtkSortDataArray: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn sort(&mut self, keys: *mut core::ffi::c_void) -> (); + fn sort(&mut self, keys: *mut core::ffi::c_void) -> (); + fn sort(&mut self, keys: *mut core::ffi::c_void, dir: core::ffi::c_int) -> (); + fn sort(&mut self, keys: *mut core::ffi::c_void, dir: core::ffi::c_int) -> (); + fn sort( + &mut self, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + ) -> (); + fn sort( + &mut self, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + ) -> (); + fn sort( + &mut self, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + dir: core::ffi::c_int, + ) -> (); + fn sort( + &mut self, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + dir: core::ffi::c_int, + ) -> (); + fn sort_array_by_component( + &mut self, + arr: *mut core::ffi::c_void, + k: core::ffi::c_int, + ) -> (); + fn sort_array_by_component( + &mut self, + arr: *mut core::ffi::c_void, + k: core::ffi::c_int, + dir: core::ffi::c_int, + ) -> (); + fn initialize_sort_indices( + &mut self, + numKeys: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + fn generate_sort_indices( + &mut self, + dataType: core::ffi::c_int, + dataIn: (), + numKeys: core::ffi::c_uchar, + numComp: core::ffi::c_int, + k: core::ffi::c_int, + idx: core::ffi::c_uchar, + ) -> (); + fn shuffle_array( + &mut self, + idx: core::ffi::c_uchar, + dataType: core::ffi::c_int, + numKeys: core::ffi::c_uchar, + numComp: core::ffi::c_int, + arr: *mut core::ffi::c_void, + dataIn: (), + dir: core::ffi::c_int, + ) -> (); + fn shuffle_id_list( + &mut self, + idx: core::ffi::c_uchar, + sze: core::ffi::c_uchar, + arrayIn: *mut core::ffi::c_void, + dataIn: core::ffi::c_uchar, + dir: core::ffi::c_int, + ) -> (); +} +pub trait VtkSparseArray: VtkTypedArray + VtkArray + VtkObject + VtkObjectBase { + fn is_dense(&mut self) -> bool; + fn get_extents(&mut self) -> vtkArrayExtents; + fn get_non_null_size(&mut self) -> core::ffi::c_ulonglong; + fn get_coordinates_n( + &mut self, + n: core::ffi::c_ulonglong, + coordinates: *mut core::ffi::c_void, + ) -> (); + fn deep_copy(&mut self) -> *mut core::ffi::c_void; + fn get_value(&mut self, i: core::ffi::c_uchar) -> T; + fn get_value(&mut self, i: core::ffi::c_uchar, j: core::ffi::c_uchar) -> T; + fn get_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + k: core::ffi::c_uchar, + ) -> T; + fn get_value(&mut self, coordinates: vtkArrayCoordinates) -> T; + fn get_value_n(&mut self, n: core::ffi::c_ulonglong) -> T; + fn set_value(&mut self, i: core::ffi::c_uchar, value: T) -> (); + fn set_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + value: T, + ) -> (); + fn set_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + k: core::ffi::c_uchar, + value: T, + ) -> (); + fn set_value(&mut self, coordinates: vtkArrayCoordinates, value: T) -> (); + fn set_value_n(&mut self, n: core::ffi::c_ulonglong, value: T) -> (); + fn set_null_value(&mut self, value: T) -> (); + fn get_null_value(&mut self) -> T; + fn clear(&mut self) -> (); + fn sort(&mut self, sort: vtkArraySort) -> (); + fn get_unique_coordinates( + &mut self, + dimension: core::ffi::c_uchar, + ) -> Vec; + fn get_coordinate_storage( + &mut self, + dimension: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_coordinate_storage( + &mut self, + dimension: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + fn get_value_storage(&mut self) -> *const T; + fn get_value_storage(&mut self) -> *mut core::ffi::c_void; + fn reserve_storage(&mut self, value_count: core::ffi::c_ulonglong) -> (); + fn set_extents_from_contents(&mut self) -> (); + fn set_extents(&mut self, extents: vtkArrayExtents) -> (); + fn add_value(&mut self, i: core::ffi::c_uchar, value: T) -> (); + fn add_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + value: T, + ) -> (); + fn add_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + k: core::ffi::c_uchar, + value: T, + ) -> (); + fn add_value(&mut self, coordinates: vtkArrayCoordinates, value: T) -> (); + fn validate(&mut self) -> bool; +} +pub trait VtkStringArray: VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> (); + fn get_tuples( + &mut self, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn get_tuples( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + output: *mut core::ffi::c_void, + ) -> (); + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_uchar) -> vtkStdString; + fn get_value(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_value(&mut self, id: core::ffi::c_uchar, value: *mut core::ffi::c_void) -> (); + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> (); + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); + fn get_number_of_values(&mut self) -> core::ffi::c_uchar; + fn get_number_of_element_components(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: *mut core::ffi::c_void) -> (); + fn insert_value(&mut self, id: core::ffi::c_uchar, val: core::ffi::c_char) -> (); + fn set_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_next_value(&mut self, f: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); + fn set_array( + &mut self, + array: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn set_void_array( + &mut self, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data_size(&mut self) -> core::ffi::c_uchar; + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> (); + fn lookup_value(&mut self, value: vtkStdString) -> core::ffi::c_uchar; + fn lookup_value(&mut self, value: vtkStdString, ids: *mut core::ffi::c_void) -> (); + fn lookup_value(&mut self, value: core::ffi::c_char) -> core::ffi::c_uchar; + fn lookup_value( + &mut self, + value: core::ffi::c_char, + ids: *mut core::ffi::c_void, + ) -> (); + fn data_changed(&mut self) -> (); + fn data_element_changed(&mut self, id: core::ffi::c_uchar) -> (); + fn clear_lookup(&mut self) -> (); +} +pub trait VtkStringOutputWindow: VtkOutputWindow + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn display_text(&mut self, p0: core::ffi::c_char) -> (); + fn get_output(&mut self) -> &str; +} +pub trait VtkTestDataArray: VtkGenericDataArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn get_value(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_value( + &mut self, + valueIdx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn get_typed_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: *mut core::ffi::c_void, + ) -> (); + fn set_typed_tuple( + &mut self, + tupleIdx: core::ffi::c_uchar, + tuple: ArrayT::ValueType, + ) -> (); + fn get_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + compIdx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + compIdx: core::ffi::c_int, + value: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkTimePointUtility: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn date_to_time_point( + &mut self, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + fn time_to_time_point( + &mut self, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + fn date_time_to_time_point( + &mut self, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + sec: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + fn get_date( + &mut self, + time: core::ffi::c_ulonglong, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + ) -> (); + fn get_time( + &mut self, + time: core::ffi::c_ulonglong, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> (); + fn get_date_time( + &mut self, + time: core::ffi::c_ulonglong, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> (); + fn get_year(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_month(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_day(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_hour(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_minute(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_second(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_millisecond(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn iso_8601_to_time_point( + &mut self, + str: core::ffi::c_char, + ok: bool, + ) -> core::ffi::c_ulonglong; + fn time_point_to_iso_8601( + &mut self, + p0: core::ffi::c_ulonglong, + format: core::ffi::c_int, + ) -> *const core::ffi::c_char; +} +pub trait VtkTimeStamp { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn modified(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkTypeFloat32Array: VtkFloatArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeFloat64Array: VtkDoubleArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt16Array: VtkShortArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt32Array: VtkIntArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt64Array: VtkLongLongArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt8Array: VtkSignedCharArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt16Array: VtkUnsignedShortArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt32Array: VtkUnsignedIntArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt64Array: VtkUnsignedLongLongArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt8Array: VtkUnsignedCharArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypedArray: VtkArray + VtkObject + VtkObjectBase { + fn get_variant_value( + &mut self, + coordinates: vtkArrayCoordinates, + ) -> *mut core::ffi::c_void; + fn get_variant_value_n( + &mut self, + n: core::ffi::c_ulonglong, + ) -> *mut core::ffi::c_void; + fn set_variant_value( + &mut self, + coordinates: vtkArrayCoordinates, + value: vtkVariant, + ) -> (); + fn set_variant_value_n( + &mut self, + n: core::ffi::c_ulonglong, + value: vtkVariant, + ) -> (); + fn copy_value( + &mut self, + source: *mut core::ffi::c_void, + source_coordinates: vtkArrayCoordinates, + target_coordinates: vtkArrayCoordinates, + ) -> (); + fn copy_value( + &mut self, + source: *mut core::ffi::c_void, + source_index: core::ffi::c_ulonglong, + target_coordinates: vtkArrayCoordinates, + ) -> (); + fn copy_value( + &mut self, + source: *mut core::ffi::c_void, + source_coordinates: vtkArrayCoordinates, + target_index: core::ffi::c_ulonglong, + ) -> (); + fn get_value(&mut self, i: core::ffi::c_uchar) -> T; + fn get_value(&mut self, i: core::ffi::c_uchar, j: core::ffi::c_uchar) -> T; + fn get_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + k: core::ffi::c_uchar, + ) -> T; + fn get_value(&mut self, coordinates: vtkArrayCoordinates) -> T; + fn get_value_n(&mut self, n: core::ffi::c_ulonglong) -> T; + fn set_value(&mut self, i: core::ffi::c_uchar, value: T) -> (); + fn set_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + value: T, + ) -> (); + fn set_value( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + k: core::ffi::c_uchar, + value: T, + ) -> (); + fn set_value(&mut self, coordinates: vtkArrayCoordinates, value: T) -> (); + fn set_value_n(&mut self, n: core::ffi::c_ulonglong, value: T) -> (); +} +pub trait VtkTypedDataArray: VtkGenericDataArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, t: ValueTypeT) -> (); + fn insert_typed_tuple(&mut self, i: core::ffi::c_uchar, t: ValueTypeT) -> (); + fn insert_next_typed_tuple(&mut self, t: ValueTypeT) -> core::ffi::c_uchar; + fn get_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_value_reference(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn get_typed_tuple( + &mut self, + idx: core::ffi::c_uchar, + t: *mut core::ffi::c_void, + ) -> (); + fn insert_next_value(&mut self, v: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn insert_value(&mut self, idx: core::ffi::c_uchar, v: *mut core::ffi::c_void) -> (); + fn get_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + comp: core::ffi::c_int, + v: *mut core::ffi::c_void, + ) -> (); + fn allocate( + &mut self, + size: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; +} +pub trait VtkUnicodeString { + fn is_utf_8(&mut self, p0: core::ffi::c_char) -> bool; + fn is_utf_8(&mut self, p0: &str) -> bool; + fn from_utf_8(&mut self, p0: core::ffi::c_char) -> *mut core::ffi::c_void; + fn from_utf_8( + &mut self, + begin: core::ffi::c_char, + end: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn from_utf_8(&mut self, p0: &str) -> *mut core::ffi::c_void; + fn from_utf_16(&mut self, p0: core::ffi::c_ushort) -> *mut core::ffi::c_void; + fn begin(&mut self) -> *mut core::ffi::c_void; + fn end(&mut self) -> *mut core::ffi::c_void; + fn at(&mut self, offset: *mut core::ffi::c_void) -> core::ffi::c_uint; + fn utf_8_str(&mut self) -> *const core::ffi::c_char; + fn utf_8_str(&mut self, result: &str) -> (); + fn utf_16_str(&mut self) -> Vec; + fn utf_16_str(&mut self, result: Vec) -> (); + fn byte_count(&mut self) -> *mut core::ffi::c_void; + fn character_count(&mut self) -> *mut core::ffi::c_void; + fn empty(&mut self) -> bool; + fn push_back(&mut self, p0: core::ffi::c_uint) -> (); + fn append(&mut self, value: vtkUnicodeString) -> (); + fn append( + &mut self, + count: *mut core::ffi::c_void, + character: core::ffi::c_uint, + ) -> (); + fn append( + &mut self, + begin: *mut core::ffi::c_void, + end: *mut core::ffi::c_void, + ) -> (); + fn assign(&mut self, value: vtkUnicodeString) -> (); + fn assign( + &mut self, + count: *mut core::ffi::c_void, + character: core::ffi::c_uint, + ) -> (); + fn assign( + &mut self, + begin: *mut core::ffi::c_void, + end: *mut core::ffi::c_void, + ) -> (); + fn clear(&mut self) -> (); + fn fold_case(&mut self) -> *mut core::ffi::c_void; + fn compare(&mut self, p0: vtkUnicodeString) -> core::ffi::c_int; + fn substr( + &mut self, + offset: *mut core::ffi::c_void, + count: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn swap(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkUnicodeStringArray: VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> (); + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; + fn set_void_array( + &mut self, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_variant_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> (); + fn set_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn data_changed(&mut self) -> (); + fn clear_lookup(&mut self) -> (); + fn insert_next_value(&mut self, p0: vtkUnicodeString) -> core::ffi::c_uchar; + fn insert_value(&mut self, idx: core::ffi::c_uchar, p1: vtkUnicodeString) -> (); + fn set_value(&mut self, i: core::ffi::c_uchar, p1: vtkUnicodeString) -> (); + fn get_value(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn insert_next_utf_8_value(&mut self, p0: core::ffi::c_char) -> (); + fn set_utf_8_value(&mut self, i: core::ffi::c_uchar, p1: core::ffi::c_char) -> (); + fn get_utf_8_value(&mut self, i: core::ffi::c_uchar) -> *const core::ffi::c_char; +} +pub trait VtkUnsignedCharArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> (); + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar; + fn get_value_range(&mut self) -> *mut core::ffi::c_uchar; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar; + fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkUnsignedIntArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_uint) -> (); + fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_uint) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uint, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_uint, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uint; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uint) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uint) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_uint) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uint; + fn get_value_range(&mut self) -> *mut core::ffi::c_uint; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uint; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uint; + fn set_array( + &mut self, + array: core::ffi::c_uint, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_uint, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_uint; + fn get_data_type_value_max(&mut self) -> core::ffi::c_uint; +} +pub trait VtkUnsignedLongArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulong, + ) -> (); + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulong, + ) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulong, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_ulong, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ulong; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_ulong) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ulong) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_ulong) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_ulong; + fn get_value_range(&mut self) -> *mut core::ffi::c_ulong; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ulong; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ulong; + fn set_array( + &mut self, + array: core::ffi::c_ulong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_ulong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_ulong; + fn get_data_type_value_max(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkUnsignedLongLongArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulonglong, + ) -> (); + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulonglong, + ) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulonglong, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_ulonglong, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ulonglong; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_ulonglong) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ulonglong) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_ulonglong) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_ulonglong; + fn get_value_range(&mut self) -> *mut core::ffi::c_ulonglong; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ulonglong; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ulonglong; + fn set_array( + &mut self, + array: core::ffi::c_ulonglong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_ulonglong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_ulonglong; + fn get_data_type_value_max(&mut self) -> core::ffi::c_ulonglong; +} +pub trait VtkUnsignedShortArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ushort, + ) -> (); + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ushort, + ) -> (); + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ushort, + ) -> (); + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_ushort, + ) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ushort; + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_ushort) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ushort) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_ushort) -> core::ffi::c_uchar; + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_ushort; + fn get_value_range(&mut self) -> *mut core::ffi::c_ushort; + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ushort; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ushort; + fn set_array( + &mut self, + array: core::ffi::c_ushort, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_array( + &mut self, + array: core::ffi::c_ushort, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_ushort; + fn get_data_type_value_max(&mut self) -> core::ffi::c_ushort; +} +pub trait VtkVariant { + fn is_valid(&mut self) -> bool; + fn is_string(&mut self) -> bool; + fn is_unicode_string(&mut self) -> bool; + fn is_numeric(&mut self) -> bool; + fn is_float(&mut self) -> bool; + fn is_double(&mut self) -> bool; + fn is_char(&mut self) -> bool; + fn is_unsigned_char(&mut self) -> bool; + fn is_signed_char(&mut self) -> bool; + fn is_short(&mut self) -> bool; + fn is_unsigned_short(&mut self) -> bool; + fn is_int(&mut self) -> bool; + fn is_unsigned_int(&mut self) -> bool; + fn is_long(&mut self) -> bool; + fn is_unsigned_long(&mut self) -> bool; + fn is__int_64(&mut self) -> bool; + fn is_unsigned__int_64(&mut self) -> bool; + fn is_long_long(&mut self) -> bool; + fn is_unsigned_long_long(&mut self) -> bool; + fn is_vtk_object(&mut self) -> bool; + fn is_array(&mut self) -> bool; + fn get_type(&mut self) -> core::ffi::c_uint; + fn get_type_as_string(&mut self) -> *const core::ffi::c_char; + fn to_string( + &mut self, + formatting: core::ffi::c_int, + precision: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn to_unicode_string( + &mut self, + formatting: core::ffi::c_int, + precision: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn to_float(&mut self, valid: bool) -> core::ffi::c_float; + fn to_float(&mut self) -> core::ffi::c_float; + fn to_double(&mut self, valid: bool) -> core::ffi::c_double; + fn to_double(&mut self) -> core::ffi::c_double; + fn to_char(&mut self, valid: bool) -> core::ffi::c_char; + fn to_char(&mut self) -> core::ffi::c_char; + fn to_unsigned_char(&mut self, valid: bool) -> core::ffi::c_uchar; + fn to_unsigned_char(&mut self) -> core::ffi::c_uchar; + fn to_signed_char(&mut self, valid: bool) -> core::ffi::c_char; + fn to_signed_char(&mut self) -> core::ffi::c_char; + fn to_short(&mut self, valid: bool) -> core::ffi::c_short; + fn to_short(&mut self) -> core::ffi::c_short; + fn to_unsigned_short(&mut self, valid: bool) -> core::ffi::c_ushort; + fn to_unsigned_short(&mut self) -> core::ffi::c_ushort; + fn to_int(&mut self, valid: bool) -> core::ffi::c_int; + fn to_int(&mut self) -> core::ffi::c_int; + fn to_unsigned_int(&mut self, valid: bool) -> core::ffi::c_uint; + fn to_unsigned_int(&mut self) -> core::ffi::c_uint; + fn to_long(&mut self, valid: bool) -> core::ffi::c_long; + fn to_long(&mut self) -> core::ffi::c_long; + fn to_unsigned_long(&mut self, valid: bool) -> core::ffi::c_ulong; + fn to_unsigned_long(&mut self) -> core::ffi::c_ulong; + fn to_long_long(&mut self, valid: bool) -> core::ffi::c_uchar; + fn to_long_long(&mut self) -> core::ffi::c_uchar; + fn to_unsigned_long_long(&mut self, valid: bool) -> core::ffi::c_ulonglong; + fn to_unsigned_long_long(&mut self) -> core::ffi::c_ulonglong; + fn to_type_int_64(&mut self, valid: bool) -> core::ffi::c_uchar; + fn to_type_int_64(&mut self) -> core::ffi::c_uchar; + fn to_type_u_int_64(&mut self, valid: bool) -> core::ffi::c_ulonglong; + fn to_type_u_int_64(&mut self) -> core::ffi::c_ulonglong; + fn to_vtk_object(&mut self) -> *mut core::ffi::c_void; + fn to_array(&mut self) -> *mut core::ffi::c_void; + fn is_equal(&mut self, other: vtkVariant) -> bool; +} +pub trait VtkVariantArray: VtkAbstractArray + VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> (); + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; + fn set_void_array( + &mut self, + arr: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> (); + fn set_void_array( + &mut self, + arr: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteM: core::ffi::c_int, + ) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_value(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_value(&mut self, id: core::ffi::c_uchar, value: *mut core::ffi::c_void) -> (); + fn insert_value( + &mut self, + id: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn set_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_next_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn set_array( + &mut self, + arr: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_number_of_values(&mut self) -> core::ffi::c_uchar; + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> (); + fn data_changed(&mut self) -> (); + fn data_element_changed(&mut self, id: core::ffi::c_uchar) -> (); + fn clear_lookup(&mut self) -> (); +} +pub trait VtkVersion: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_vtk_version(&mut self) -> *const core::ffi::c_char; + fn get_vtk_version_full(&mut self) -> *const core::ffi::c_char; + fn get_vtk_major_version(&mut self) -> core::ffi::c_int; + fn get_vtk_minor_version(&mut self) -> core::ffi::c_int; + fn get_vtk_build_version(&mut self) -> core::ffi::c_int; + fn get_vtk_source_version(&mut self) -> *const core::ffi::c_char; +} +pub trait VtkVoidArray: VtkObject + VtkObjectBase { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn set_number_of_pointers(&mut self, number: core::ffi::c_uchar) -> (); + fn get_number_of_pointers(&mut self) -> core::ffi::c_uchar; + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); + fn set_void_pointer(&mut self, id: core::ffi::c_uchar, ptr: ()) -> (); + fn insert_void_pointer(&mut self, i: core::ffi::c_uchar, ptr: ()) -> (); + fn insert_next_void_pointer(&mut self, tuple: ()) -> core::ffi::c_uchar; + fn reset(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut &mut (); + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut &mut (); + fn deep_copy(&mut self, va: *mut core::ffi::c_void) -> (); +} +pub trait VtkWeakPointer: VtkWeakPointerBase { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn get(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkWeakPointerBase { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkWeakReference: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set(&mut self, object: *mut core::ffi::c_void) -> (); + fn get(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkWindow: VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_display_id(&mut self, p0: ()) -> (); + fn set_window_id(&mut self, p0: ()) -> (); + fn set_parent_id(&mut self, p0: ()) -> (); + fn get_generic_display_id(&mut self) -> *mut (); + fn get_generic_window_id(&mut self) -> *mut (); + fn get_generic_parent_id(&mut self) -> *mut (); + fn get_generic_context(&mut self) -> *mut (); + fn get_generic_drawable(&mut self) -> *mut (); + fn set_window_info(&mut self, p0: core::ffi::c_char) -> (); + fn set_parent_info(&mut self, p0: core::ffi::c_char) -> (); + fn get_position(&mut self) -> *mut core::ffi::c_int; + fn set_position(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); + fn set_position(&mut self, a: core::ffi::c_int) -> (); + fn get_size(&mut self) -> *mut core::ffi::c_int; + fn set_size(&mut self, width: core::ffi::c_int, height: core::ffi::c_int) -> (); + fn set_size(&mut self, a: core::ffi::c_int) -> (); + fn get_actual_size(&mut self) -> *mut core::ffi::c_int; + fn get_screen_size(&mut self) -> *mut core::ffi::c_int; + fn get_mapped(&mut self) -> core::ffi::c_int; + fn get_show_window(&mut self) -> bool; + fn set_show_window(&mut self, _arg: bool) -> (); + fn show_window_on(&mut self) -> (); + fn show_window_off(&mut self) -> (); + fn set_use_off_screen_buffers(&mut self, _arg: bool) -> (); + fn get_use_off_screen_buffers(&mut self) -> bool; + fn use_off_screen_buffers_on(&mut self) -> (); + fn use_off_screen_buffers_off(&mut self) -> (); + fn set_erase(&mut self, _arg: core::ffi::c_int) -> (); + fn get_erase(&mut self) -> core::ffi::c_int; + fn erase_on(&mut self) -> (); + fn erase_off(&mut self) -> (); + fn set_double_buffer(&mut self, _arg: core::ffi::c_int) -> (); + fn get_double_buffer(&mut self) -> core::ffi::c_int; + fn double_buffer_on(&mut self) -> (); + fn double_buffer_off(&mut self) -> (); + fn get_window_name(&mut self) -> *mut core::ffi::c_char; + fn set_window_name(&mut self, _arg: core::ffi::c_char) -> (); + fn set_icon(&mut self, p0: *mut core::ffi::c_void) -> (); + fn render(&mut self) -> (); + fn release_graphics_resources(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_pixel_data( + &mut self, + p0: core::ffi::c_int, + p1: core::ffi::c_int, + p2: core::ffi::c_int, + p3: core::ffi::c_int, + p4: core::ffi::c_int, + p5: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar; + fn get_pixel_data( + &mut self, + p0: core::ffi::c_int, + p1: core::ffi::c_int, + p2: core::ffi::c_int, + p3: core::ffi::c_int, + p4: core::ffi::c_int, + p5: *mut core::ffi::c_void, + p6: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_dpi(&mut self) -> core::ffi::c_int; + fn set_dpi(&mut self, _arg: core::ffi::c_int) -> (); + fn get_dpi_min_value(&mut self) -> core::ffi::c_int; + fn get_dpi_max_value(&mut self) -> core::ffi::c_int; + fn detect_dpi(&mut self) -> bool; + fn set_off_screen_rendering(&mut self, val: core::ffi::c_int) -> (); + fn off_screen_rendering_on(&mut self) -> (); + fn off_screen_rendering_off(&mut self) -> (); + fn get_off_screen_rendering(&mut self) -> core::ffi::c_int; + fn make_current(&mut self) -> (); + fn release_current(&mut self) -> (); + fn set_tile_scale(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> (); + fn set_tile_scale(&mut self, _arg: core::ffi::c_int) -> (); + fn get_tile_scale(&mut self) -> *mut core::ffi::c_int; + fn get_tile_scale(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> (); + fn get_tile_scale(&mut self, _arg: core::ffi::c_int) -> (); + fn set_tile_scale(&mut self, s: core::ffi::c_int) -> (); + fn set_tile_viewport( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn set_tile_viewport(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tile_viewport(&mut self) -> *mut core::ffi::c_double; + fn get_tile_viewport( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn get_tile_viewport(&mut self, _arg: core::ffi::c_double) -> (); +} +pub trait VtkXMLFileOutputWindow: VtkFileOutputWindow + VtkOutputWindow + VtkObject + VtkObjectBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn display_text(&mut self, p0: core::ffi::c_char) -> (); + fn display_tag(&mut self, p0: core::ffi::c_char) -> (); +} +impl VtkAnimationCue for vtkAnimationCue { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_cue_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_cue_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_cue_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_cue_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_cue_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_cue_new(self.0) } + } + fn set_time_mode(&mut self, mode: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_animation_cue_set_time_mode( + sself: *mut core::ffi::c_void, + mode: core::ffi::c_int, + ); + } + unsafe { vtk_animation_cue_set_time_mode(self.0, mode) } + } + fn get_time_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_animation_cue_get_time_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_animation_cue_get_time_mode(self.0) } + } + fn set_time_mode_to_relative(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_cue_set_time_mode_to_relative( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_animation_cue_set_time_mode_to_relative(self.0) } + } + fn set_time_mode_to_normalized(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_cue_set_time_mode_to_normalized( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_animation_cue_set_time_mode_to_normalized(self.0) } + } + fn set_start_time(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_animation_cue_set_start_time( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_animation_cue_set_start_time(self.0, _arg) } + } + fn get_start_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_cue_get_start_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_cue_get_start_time(self.0) } + } + fn set_end_time(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_animation_cue_set_end_time( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_animation_cue_set_end_time(self.0, _arg) } + } + fn get_end_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_cue_get_end_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_cue_get_end_time(self.0) } + } + fn tick( + &mut self, + currenttime: core::ffi::c_double, + deltatime: core::ffi::c_double, + clocktime: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_animation_cue_tick( + sself: *mut core::ffi::c_void, + currenttime: core::ffi::c_double, + deltatime: core::ffi::c_double, + clocktime: core::ffi::c_double, + ); + } + unsafe { vtk_animation_cue_tick(self.0, currenttime, deltatime, clocktime) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_cue_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_cue_initialize(self.0) } + } + fn finalize(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_cue_finalize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_cue_finalize(self.0) } + } + fn get_animation_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_cue_get_animation_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_cue_get_animation_time(self.0) } + } + fn get_delta_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_cue_get_delta_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_cue_get_delta_time(self.0) } + } + fn get_clock_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_cue_get_clock_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_cue_get_clock_time(self.0) } + } +} +impl VtkArchiver for vtkArchiver { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_archiver_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_archiver_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_archiver_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_archiver_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_archiver_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_archiver_new_instance(self.0) } + } + fn get_archive_name(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_archiver_get_archive_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_archiver_get_archive_name(self.0) } + } + fn set_archive_name(&mut self, _arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_archiver_set_archive_name( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { vtk_archiver_set_archive_name(self.0, _arg) } + } + fn open_archive(&mut self) -> () { + unsafe extern "C" { + fn vtk_archiver_open_archive(sself: *mut core::ffi::c_void); + } + unsafe { vtk_archiver_open_archive(self.0) } + } + fn close_archive(&mut self) -> () { + unsafe extern "C" { + fn vtk_archiver_close_archive(sself: *mut core::ffi::c_void); + } + unsafe { vtk_archiver_close_archive(self.0) } + } + fn insert_into_archive( + &mut self, + relativePath: &str, + data: core::ffi::c_char, + size: usize, + ) -> () { + let c_relativePath = std::ffi::CString::new(relativePath) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_archiver_insert_into_archive( + sself: *mut core::ffi::c_void, + relativePath: *const core::ffi::c_char, + data: core::ffi::c_char, + size: usize, + ); + } + unsafe { + vtk_archiver_insert_into_archive(self.0, c_relativePath.as_ptr(), data, size) + } + } + fn contains(&mut self, relativePath: &str) -> bool { + let c_relativePath = std::ffi::CString::new(relativePath) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_archiver_contains( + sself: *mut core::ffi::c_void, + relativePath: *const core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_archiver_contains(self.0, c_relativePath.as_ptr()) } + } +} +impl VtkBitArray for vtkBitArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_bit_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bit_array_initialize(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_get_data_type(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_get_data_type_size(self.0) } + } + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_number_of_tuples( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ); + } + unsafe { vtk_bit_array_set_number_of_tuples(self.0, number) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_bit_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_bit_array_set_number_of_values(self.0, number) } + } + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_set_tuple(self.0, i, j, source) } + } + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_insert_tuple(self.0, i, j, source) } + } + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bit_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_bit_array_insert_next_tuple(self.0, j, source) } + } + fn get_tuple(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_bit_array_get_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_bit_array_get_tuple(self.0, i) } + } + fn get_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_bit_array_get_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ); + } + unsafe { vtk_bit_array_get_tuple(self.0, i, tuple) } + } + fn set_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ); + } + unsafe { vtk_bit_array_set_tuple(self.0, i, tuple) } + } + fn set_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ); + } + unsafe { vtk_bit_array_set_tuple(self.0, i, tuple) } + } + fn insert_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_bit_array_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ); + } + unsafe { vtk_bit_array_insert_tuple(self.0, i, tuple) } + } + fn insert_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_bit_array_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ); + } + unsafe { vtk_bit_array_insert_tuple(self.0, i, tuple) } + } + fn insert_next_tuple(&mut self, tuple: core::ffi::c_float) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bit_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_float, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_bit_array_insert_next_tuple(self.0, tuple) } + } + fn insert_next_tuple(&mut self, tuple: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bit_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_bit_array_insert_next_tuple(self.0, tuple) } + } + fn remove_tuple(&mut self, id: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_bit_array_remove_tuple( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ); + } + unsafe { vtk_bit_array_remove_tuple(self.0, id) } + } + fn set_component( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_int, + c: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_component( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_int, + c: core::ffi::c_double, + ); + } + unsafe { vtk_bit_array_set_component(self.0, i, j, c) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_bit_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bit_array_squeeze(self.0) } + } + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_resize( + sself: *mut core::ffi::c_void, + numTuples: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_resize(self.0, numTuples) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_int, + ); + } + unsafe { vtk_bit_array_set_value(self.0, id, value) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_bit_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + i: core::ffi::c_int, + ); + } + unsafe { vtk_bit_array_insert_value(self.0, id, i) } + } + fn set_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_variant_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_set_variant_value(self.0, idx, value) } + } + fn insert_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_insert_variant_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_insert_variant_value(self.0, idx, value) } + } + fn insert_next_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bit_array_insert_next_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_bit_array_insert_next_value(self.0, i) } + } + fn insert_component( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_int, + c: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_insert_component( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_int, + c: core::ffi::c_double, + ); + } + unsafe { vtk_bit_array_insert_component(self.0, i, j, c) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bit_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_bit_array_get_pointer(self.0, id) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bit_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_bit_array_write_pointer(self.0, id, number) } + } + fn write_void_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut () { + unsafe extern "C" { + fn vtk_bit_array_write_void_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut (); + } + unsafe { vtk_bit_array_write_void_pointer(self.0, id, number) } + } + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut () { + unsafe extern "C" { + fn vtk_bit_array_get_void_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut (); + } + unsafe { vtk_bit_array_get_void_pointer(self.0, id) } + } + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bit_array_deep_copy( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_deep_copy(self.0, da) } + } + fn set_void_array( + &mut self, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_void_array( + sself: *mut core::ffi::c_void, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_bit_array_set_void_array(self.0, array, size, save) } + } + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_array_free_function( + sself: *mut core::ffi::c_void, + callback: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_set_array_free_function(self.0, callback) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_new_iterator(self.0) } + } + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bit_array_lookup_value( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_bit_array_lookup_value(self.0, value) } + } + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_lookup_value( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_lookup_value(self.0, value, ids) } + } + fn lookup_value(&mut self, value: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bit_array_lookup_value( + sself: *mut core::ffi::c_void, + value: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_bit_array_lookup_value(self.0, value) } + } + fn lookup_value( + &mut self, + value: core::ffi::c_int, + ids: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_lookup_value( + sself: *mut core::ffi::c_void, + value: core::ffi::c_int, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_lookup_value(self.0, value, ids) } + } + fn data_changed(&mut self) -> () { + unsafe extern "C" { + fn vtk_bit_array_data_changed(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bit_array_data_changed(self.0) } + } + fn clear_lookup(&mut self) -> () { + unsafe extern "C" { + fn vtk_bit_array_clear_lookup(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bit_array_clear_lookup(self.0) } + } +} +impl VtkBitArrayIterator for vtkBitArrayIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_iterator_new_instance(self.0) } + } + fn initialize(&mut self, array: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bit_array_iterator_initialize( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_iterator_initialize(self.0, array) } + } + fn get_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_iterator_get_array(self.0) } + } + fn get_tuple(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_tuple( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_bit_array_iterator_get_tuple(self.0, id) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_iterator_get_value(self.0, id) } + } + fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_number_of_tuples( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_bit_array_iterator_get_number_of_tuples(self.0) } + } + fn get_number_of_values(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_number_of_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_bit_array_iterator_get_number_of_values(self.0) } + } + fn get_number_of_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_iterator_get_number_of_components(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_iterator_get_data_type(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_iterator_get_data_type_size(self.0) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_bit_array_iterator_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_int, + ); + } + unsafe { vtk_bit_array_iterator_set_value(self.0, id, value) } + } +} +impl VtkBoxMuellerRandomSequence for vtkBoxMuellerRandomSequence { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_mueller_random_sequence_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_mueller_random_sequence_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_mueller_random_sequence_new_instance(self.0) } + } + fn initialize(&mut self, seed: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_initialize( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_uint, + ); + } + unsafe { vtk_box_mueller_random_sequence_initialize(self.0, seed) } + } + fn get_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_get_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_box_mueller_random_sequence_get_value(self.0) } + } + fn next(&mut self) -> () { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_next(sself: *mut core::ffi::c_void); + } + unsafe { vtk_box_mueller_random_sequence_next(self.0) } + } + fn get_uniform_sequence(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_get_uniform_sequence( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_mueller_random_sequence_get_uniform_sequence(self.0) } + } + fn set_uniform_sequence(&mut self, uniformSequence: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_set_uniform_sequence( + sself: *mut core::ffi::c_void, + uniformSequence: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_box_mueller_random_sequence_set_uniform_sequence(self.0, uniformSequence) + } + } +} +impl VtkByteSwap for vtkByteSwap { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_byte_swap_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_byte_swap_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_byte_swap_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_byte_swap_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_byte_swap_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_byte_swap_new_instance(self.0) } + } + fn swap_le(&mut self, p: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_float, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_float, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_float, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_float, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_float, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_float, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_double, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_double, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_double, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_double, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_double, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_double, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_char, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_char, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_char, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_char, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_char, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_char, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_short) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_short, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_short) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_short, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_short, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_short, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_short, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_short, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le(sself: *mut core::ffi::c_void, p: core::ffi::c_int); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be(sself: *mut core::ffi::c_void, p: core::ffi::c_int); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_int, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_int, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_int, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_int, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_long) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_long, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_long) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_long, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_long, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_long, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_long, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_long, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uchar, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uchar, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_uchar, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uchar, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_uchar, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uchar, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_char, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_char, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_char, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_char, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_char, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_char, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uchar, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uchar, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_uchar, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uchar, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_uchar, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uchar, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_ushort) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ushort, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_ushort) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ushort, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_ushort, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ushort, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_ushort, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ushort, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uint, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uint, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_uint, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uint, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_uint, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_uint, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_ulong) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ulong, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_ulong) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ulong, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_ulong, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ulong, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_ulong, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ulong, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_le(&mut self, p: core::ffi::c_ulonglong) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ulonglong, + ); + } + unsafe { vtk_byte_swap_swap_le(self.0, p) } + } + fn swap_be(&mut self, p: core::ffi::c_ulonglong) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ulonglong, + ); + } + unsafe { vtk_byte_swap_swap_be(self.0, p) } + } + fn swap_le_range(&mut self, p: core::ffi::c_ulonglong, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_le_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ulonglong, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } + } + fn swap_be_range(&mut self, p: core::ffi::c_ulonglong, num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_be_range( + sself: *mut core::ffi::c_void, + p: core::ffi::c_ulonglong, + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } + } + fn swap_2_le(&mut self, p: ()) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_2_le(sself: *mut core::ffi::c_void, p: ()); + } + unsafe { vtk_byte_swap_swap_2_le(self.0, p) } + } + fn swap_4_le(&mut self, p: ()) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_4_le(sself: *mut core::ffi::c_void, p: ()); + } + unsafe { vtk_byte_swap_swap_4_le(self.0, p) } + } + fn swap_8_le(&mut self, p: ()) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_8_le(sself: *mut core::ffi::c_void, p: ()); + } + unsafe { vtk_byte_swap_swap_8_le(self.0, p) } + } + fn swap_2_le_range(&mut self, p: (), num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_2_le_range( + sself: *mut core::ffi::c_void, + p: (), + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_2_le_range(self.0, p, num) } + } + fn swap_4_le_range(&mut self, p: (), num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_4_le_range( + sself: *mut core::ffi::c_void, + p: (), + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_4_le_range(self.0, p, num) } + } + fn swap_8_le_range(&mut self, p: (), num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_8_le_range( + sself: *mut core::ffi::c_void, + p: (), + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_8_le_range(self.0, p, num) } + } + fn swap_2_be(&mut self, p: ()) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_2_be(sself: *mut core::ffi::c_void, p: ()); + } + unsafe { vtk_byte_swap_swap_2_be(self.0, p) } + } + fn swap_4_be(&mut self, p: ()) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_4_be(sself: *mut core::ffi::c_void, p: ()); + } + unsafe { vtk_byte_swap_swap_4_be(self.0, p) } + } + fn swap_8_be(&mut self, p: ()) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_8_be(sself: *mut core::ffi::c_void, p: ()); + } + unsafe { vtk_byte_swap_swap_8_be(self.0, p) } + } + fn swap_2_be_range(&mut self, p: (), num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_2_be_range( + sself: *mut core::ffi::c_void, + p: (), + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_2_be_range(self.0, p, num) } + } + fn swap_4_be_range(&mut self, p: (), num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_4_be_range( + sself: *mut core::ffi::c_void, + p: (), + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_4_be_range(self.0, p, num) } + } + fn swap_8_be_range(&mut self, p: (), num: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_8_be_range( + sself: *mut core::ffi::c_void, + p: (), + num: usize, + ); + } + unsafe { vtk_byte_swap_swap_8_be_range(self.0, p, num) } + } + fn swap_void_range(&mut self, buffer: (), numWords: usize, wordSize: usize) -> () { + unsafe extern "C" { + fn vtk_byte_swap_swap_void_range( + sself: *mut core::ffi::c_void, + buffer: (), + numWords: usize, + wordSize: usize, + ); + } + unsafe { vtk_byte_swap_swap_void_range(self.0, buffer, numWords, wordSize) } + } +} +impl VtkCallbackCommand for vtkCallbackCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_callback_command_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_callback_command_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_callback_command_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_callback_command_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_callback_command_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_callback_command_new(self.0) } + } + fn execute( + &mut self, + caller: *mut core::ffi::c_void, + eid: core::ffi::c_ulong, + callData: (), + ) -> () { + unsafe extern "C" { + fn vtk_callback_command_execute( + sself: *mut core::ffi::c_void, + caller: *mut core::ffi::c_void, + eid: core::ffi::c_ulong, + callData: (), + ); + } + unsafe { vtk_callback_command_execute(self.0, caller, eid, callData) } + } + fn set_client_data(&mut self, cd: ()) -> () { + unsafe extern "C" { + fn vtk_callback_command_set_client_data( + sself: *mut core::ffi::c_void, + cd: (), + ); + } + unsafe { vtk_callback_command_set_client_data(self.0, cd) } + } + fn get_client_data(&mut self) -> *mut () { + unsafe extern "C" { + fn vtk_callback_command_get_client_data( + sself: *mut core::ffi::c_void, + ) -> *mut (); + } + unsafe { vtk_callback_command_get_client_data(self.0) } + } + fn set_callback(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_callback_command_set_callback( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_callback_command_set_callback(self.0, f) } + } + fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_callback_command_set_client_data_delete_callback( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_callback_command_set_client_data_delete_callback(self.0, f) } + } + fn set_abort_flag_on_execute(&mut self, f: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_callback_command_set_abort_flag_on_execute( + sself: *mut core::ffi::c_void, + f: core::ffi::c_int, + ); + } + unsafe { vtk_callback_command_set_abort_flag_on_execute(self.0, f) } + } + fn get_abort_flag_on_execute(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_callback_command_get_abort_flag_on_execute( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_callback_command_get_abort_flag_on_execute(self.0) } + } + fn abort_flag_on_execute_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_callback_command_abort_flag_on_execute_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_callback_command_abort_flag_on_execute_on(self.0) } + } + fn abort_flag_on_execute_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_callback_command_abort_flag_on_execute_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_callback_command_abort_flag_on_execute_off(self.0) } + } +} +impl VtkCharArray for vtkCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_char_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_char_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_char_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_char_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_char_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_char_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_char_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_char_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_char_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_char_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_char_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ); + } + unsafe { vtk_char_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_char_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ); + } + unsafe { vtk_char_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_char_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ); + } + unsafe { vtk_char_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_char, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_char_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_char, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_char_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_char { + unsafe extern "C" { + fn vtk_char_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_char; + } + unsafe { vtk_char_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_char_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_char, + ); + } + unsafe { vtk_char_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_char_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_char_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_char_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_char, + ); + } + unsafe { vtk_char_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_char_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_char, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_char_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_char_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_char_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_char_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_char_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_char_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_char_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_char_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_char_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_char_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_char_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_char_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_char_array_set_array(self.0, array, size, save, deleteMethod) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_char_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_char_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_char { + unsafe extern "C" { + fn vtk_char_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_char; + } + unsafe { vtk_char_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_char { + unsafe extern "C" { + fn vtk_char_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_char; + } + unsafe { vtk_char_array_get_data_type_value_max(self.0) } + } +} +impl VtkCollection for vtkCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_new(self.0) } + } + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_add_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_add_item(self.0, p0) } + } + fn insert_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_insert_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_insert_item(self.0, i, p1) } + } + fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_replace_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_replace_item(self.0, i, p1) } + } + fn remove_item(&mut self, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_collection_remove_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ); + } + unsafe { vtk_collection_remove_item(self.0, i) } + } + fn remove_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_remove_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_remove_item(self.0, p0) } + } + fn remove_all_items(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_remove_all_items(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_remove_all_items(self.0) } + } + fn is_item_present(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_collection_is_item_present( + sself: *mut core::ffi::c_void, + a: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_collection_is_item_present(self.0, a) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_collection_get_number_of_items(self.0) } + } + fn init_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_init_traversal(self.0) } + } + fn init_traversal(&mut self, cookie: ()) -> () { + unsafe extern "C" { + fn vtk_collection_init_traversal(sself: *mut core::ffi::c_void, cookie: ()); + } + unsafe { vtk_collection_init_traversal(self.0, cookie) } + } + fn get_next_item_as_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_get_next_item_as_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_get_next_item_as_object(self.0) } + } + fn get_item_as_object(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_get_item_as_object( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_get_item_as_object(self.0, i) } + } + fn get_next_item_as_object(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_get_next_item_as_object( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_get_next_item_as_object(self.0, cookie) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_new_iterator(self.0) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_register(self.0, o) } + } +} +impl VtkCollectionIterator for vtkCollectionIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_iterator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_iterator_new(self.0) } + } + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_iterator_set_collection( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_iterator_set_collection(self.0, p0) } + } + fn get_collection(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_get_collection( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_iterator_get_collection(self.0) } + } + fn init_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_iterator_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_iterator_init_traversal(self.0) } + } + fn go_to_first_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_iterator_go_to_first_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_iterator_go_to_first_item(self.0) } + } + fn go_to_next_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_iterator_go_to_next_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_iterator_go_to_next_item(self.0) } + } + fn is_done_with_traversal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_collection_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_collection_iterator_is_done_with_traversal(self.0) } + } + fn get_current_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_get_current_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_iterator_get_current_object(self.0) } + } +} +impl VtkCriticalSection for vtkCriticalSection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_critical_section_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_critical_section_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_critical_section_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_critical_section_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_critical_section_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_critical_section_new_instance(self.0) } + } + fn lock(&mut self) -> () { + unsafe extern "C" { + fn vtk_critical_section_lock(sself: *mut core::ffi::c_void); + } + unsafe { vtk_critical_section_lock(self.0) } + } + fn unlock(&mut self) -> () { + unsafe extern "C" { + fn vtk_critical_section_unlock(sself: *mut core::ffi::c_void); + } + unsafe { vtk_critical_section_unlock(self.0) } + } +} +impl VtkDataArrayCollection for vtkDataArrayCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_new_instance(self.0) } + } + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_array_collection_add_item( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_collection_add_item(self.0, ds) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_get_next_item(self.0) } + } + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_get_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_get_item(self.0, i) } + } + fn get_next_data_array(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_get_next_data_array( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_get_next_data_array(self.0, cookie) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_collection_get_number_of_items(self.0) } + } +} +impl VtkDataArrayCollectionIterator for vtkDataArrayCollectionIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_iterator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_iterator_new(self.0) } + } + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_set_collection( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_collection_iterator_set_collection(self.0, p0) } + } + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_set_collection( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_collection_iterator_set_collection(self.0, p0) } + } + fn get_data_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_get_data_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_iterator_get_data_array(self.0) } + } +} +impl VtkDataArraySelection for vtkDataArraySelection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_selection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_selection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_selection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_selection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_selection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_selection_new(self.0) } + } + fn enable_array(&mut self, name: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_enable_array( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ); + } + unsafe { vtk_data_array_selection_enable_array(self.0, name) } + } + fn disable_array(&mut self, name: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_disable_array( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ); + } + unsafe { vtk_data_array_selection_disable_array(self.0, name) } + } + fn array_is_enabled(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_array_is_enabled( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_array_is_enabled(self.0, name) } + } + fn array_exists(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_array_exists( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_array_exists(self.0, name) } + } + fn enable_all_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_enable_all_arrays(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_array_selection_enable_all_arrays(self.0) } + } + fn disable_all_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_disable_all_arrays( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_selection_disable_all_arrays(self.0) } + } + fn get_number_of_arrays(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_number_of_arrays( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_number_of_arrays(self.0) } + } + fn get_number_of_arrays_enabled(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_number_of_arrays_enabled( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_number_of_arrays_enabled(self.0) } + } + fn get_array_name(&mut self, index: core::ffi::c_int) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_data_array_selection_get_array_name( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_data_array_selection_get_array_name(self.0, index) } + } + fn get_array_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_array_index( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_array_index(self.0, name) } + } + fn get_enabled_array_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_enabled_array_index( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_enabled_array_index(self.0, name) } + } + fn get_array_setting(&mut self, index: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_array_setting( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_array_setting(self.0, index) } + } + fn get_array_setting(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_array_setting( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_array_setting(self.0, name) } + } + fn set_array_setting( + &mut self, + name: core::ffi::c_char, + setting: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_set_array_setting( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + setting: core::ffi::c_int, + ); + } + unsafe { vtk_data_array_selection_set_array_setting(self.0, name, setting) } + } + fn remove_all_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_remove_all_arrays(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_array_selection_remove_all_arrays(self.0) } + } + fn add_array(&mut self, name: core::ffi::c_char, state: bool) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_add_array( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + state: bool, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_add_array(self.0, name, state) } + } + fn remove_array_by_index(&mut self, index: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_remove_array_by_index( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ); + } + unsafe { vtk_data_array_selection_remove_array_by_index(self.0, index) } + } + fn remove_array_by_name(&mut self, name: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_remove_array_by_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ); + } + unsafe { vtk_data_array_selection_remove_array_by_name(self.0, name) } + } + fn set_arrays( + &mut self, + names: core::ffi::c_char, + numArrays: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_set_arrays( + sself: *mut core::ffi::c_void, + names: core::ffi::c_char, + numArrays: core::ffi::c_int, + ); + } + unsafe { vtk_data_array_selection_set_arrays(self.0, names, numArrays) } + } + fn set_arrays_with_default( + &mut self, + names: core::ffi::c_char, + numArrays: core::ffi::c_int, + defaultStatus: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_set_arrays_with_default( + sself: *mut core::ffi::c_void, + names: core::ffi::c_char, + numArrays: core::ffi::c_int, + defaultStatus: core::ffi::c_int, + ); + } + unsafe { + vtk_data_array_selection_set_arrays_with_default( + self.0, + names, + numArrays, + defaultStatus, + ) + } + } + fn copy_selections(&mut self, selections: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_copy_selections( + sself: *mut core::ffi::c_void, + selections: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_selection_copy_selections(self.0, selections) } + } + fn union(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_union( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_selection_union(self.0, other) } + } + fn union(&mut self, other: *mut core::ffi::c_void, skipModified: bool) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_union( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + skipModified: bool, + ); + } + unsafe { vtk_data_array_selection_union(self.0, other, skipModified) } + } + fn set_unknown_array_setting(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_set_unknown_array_setting( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_data_array_selection_set_unknown_array_setting(self.0, _arg) } + } + fn get_unknown_array_setting(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_unknown_array_setting( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_unknown_array_setting(self.0) } + } +} +impl VtkDebugLeaks for vtkDebugLeaks { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_debug_leaks_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_debug_leaks_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_debug_leaks_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_debug_leaks_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_debug_leaks_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_debug_leaks_new_instance(self.0) } + } + fn construct_class(&mut self, object: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_debug_leaks_construct_class( + sself: *mut core::ffi::c_void, + object: *mut core::ffi::c_void, + ); + } + unsafe { vtk_debug_leaks_construct_class(self.0, object) } + } + fn construct_class(&mut self, className: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_debug_leaks_construct_class( + sself: *mut core::ffi::c_void, + className: core::ffi::c_char, + ); + } + unsafe { vtk_debug_leaks_construct_class(self.0, className) } + } + fn destruct_class(&mut self, object: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_debug_leaks_destruct_class( + sself: *mut core::ffi::c_void, + object: *mut core::ffi::c_void, + ); + } + unsafe { vtk_debug_leaks_destruct_class(self.0, object) } + } + fn destruct_class(&mut self, className: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_debug_leaks_destruct_class( + sself: *mut core::ffi::c_void, + className: core::ffi::c_char, + ); + } + unsafe { vtk_debug_leaks_destruct_class(self.0, className) } + } + fn print_current_leaks(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_debug_leaks_print_current_leaks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_debug_leaks_print_current_leaks(self.0) } + } + fn get_exit_error(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_debug_leaks_get_exit_error( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_debug_leaks_get_exit_error(self.0) } + } + fn set_exit_error(&mut self, p0: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_debug_leaks_set_exit_error( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ); + } + unsafe { vtk_debug_leaks_set_exit_error(self.0, p0) } + } + fn set_debug_leaks_observer(&mut self, observer: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_debug_leaks_set_debug_leaks_observer( + sself: *mut core::ffi::c_void, + observer: *mut core::ffi::c_void, + ); + } + unsafe { vtk_debug_leaks_set_debug_leaks_observer(self.0, observer) } + } + fn get_debug_leaks_observer(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_debug_leaks_get_debug_leaks_observer( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_debug_leaks_get_debug_leaks_observer(self.0) } + } +} +impl VtkDoubleArray for vtkDoubleArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_double_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_double_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_double_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_double_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_double_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_double_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_double_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_double_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_double_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_double_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_double_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ); + } + unsafe { vtk_double_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_double_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ); + } + unsafe { vtk_double_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_double_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_double, + ); + } + unsafe { vtk_double_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_double_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_double_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_double_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_double; + } + unsafe { vtk_double_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_double_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_double, + ); + } + unsafe { vtk_double_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_double_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_double_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_double_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_double, + ); + } + unsafe { vtk_double_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_double_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_double_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_double_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_double_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_double_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_double_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_double_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_double_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_double_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_double_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_double, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_double_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_double, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_double_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_double, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_double_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_double, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_double_array_set_array(self.0, array, size, save, deleteMethod) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_double_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_double_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_double_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_double_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_double_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_double_array_get_data_type_value_max(self.0) } + } +} +impl VtkDynamicLoader for vtkDynamicLoader { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_dynamic_loader_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_dynamic_loader_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_dynamic_loader_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_dynamic_loader_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_dynamic_loader_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_dynamic_loader_new_instance(self.0) } + } + fn open_library(&mut self, p0: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_dynamic_loader_open_library( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_dynamic_loader_open_library(self.0, p0) } + } + fn open_library( + &mut self, + p0: core::ffi::c_char, + p1: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_dynamic_loader_open_library( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + p1: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_dynamic_loader_open_library(self.0, p0, p1) } + } + fn close_library(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_dynamic_loader_close_library( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_dynamic_loader_close_library(self.0, p0) } + } + fn get_symbol_address( + &mut self, + p0: *mut core::ffi::c_void, + p1: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_dynamic_loader_get_symbol_address( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_dynamic_loader_get_symbol_address(self.0, p0, p1) } + } + fn lib_prefix(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_dynamic_loader_lib_prefix( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_dynamic_loader_lib_prefix(self.0) } + } + fn lib_extension(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_dynamic_loader_lib_extension( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_dynamic_loader_lib_extension(self.0) } + } + fn last_error(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_dynamic_loader_last_error( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_dynamic_loader_last_error(self.0) } + } +} +impl VtkEventDataDevice3D for vtkEventDataDevice3D { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_device_3_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_device_3_d_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_device_3_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_device_3_d_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_device_3_d_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_device_3_d_new(self.0) } + } + fn get_world_position(&mut self, v: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_event_data_device_3_d_get_world_position( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ); + } + unsafe { vtk_event_data_device_3_d_get_world_position(self.0, v) } + } + fn get_world_position(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_event_data_device_3_d_get_world_position( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_event_data_device_3_d_get_world_position(self.0) } + } + fn set_world_position(&mut self, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_event_data_device_3_d_set_world_position( + sself: *mut core::ffi::c_void, + p: core::ffi::c_double, + ); + } + unsafe { vtk_event_data_device_3_d_set_world_position(self.0, p) } + } + fn get_world_direction(&mut self, v: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_event_data_device_3_d_get_world_direction( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ); + } + unsafe { vtk_event_data_device_3_d_get_world_direction(self.0, v) } + } + fn get_world_direction(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_event_data_device_3_d_get_world_direction( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_event_data_device_3_d_get_world_direction(self.0) } + } + fn set_world_direction(&mut self, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_event_data_device_3_d_set_world_direction( + sself: *mut core::ffi::c_void, + p: core::ffi::c_double, + ); + } + unsafe { vtk_event_data_device_3_d_set_world_direction(self.0, p) } + } + fn get_world_orientation(&mut self, v: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_event_data_device_3_d_get_world_orientation( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ); + } + unsafe { vtk_event_data_device_3_d_get_world_orientation(self.0, v) } + } + fn get_world_orientation(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_event_data_device_3_d_get_world_orientation( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_event_data_device_3_d_get_world_orientation(self.0) } + } + fn set_world_orientation(&mut self, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_event_data_device_3_d_set_world_orientation( + sself: *mut core::ffi::c_void, + p: core::ffi::c_double, + ); + } + unsafe { vtk_event_data_device_3_d_set_world_orientation(self.0, p) } + } + fn get_track_pad_position(&mut self, v: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_event_data_device_3_d_get_track_pad_position( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ); + } + unsafe { vtk_event_data_device_3_d_get_track_pad_position(self.0, v) } + } + fn get_track_pad_position(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_event_data_device_3_d_get_track_pad_position( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_event_data_device_3_d_get_track_pad_position(self.0) } + } + fn set_track_pad_position(&mut self, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_event_data_device_3_d_set_track_pad_position( + sself: *mut core::ffi::c_void, + p: core::ffi::c_double, + ); + } + unsafe { vtk_event_data_device_3_d_set_track_pad_position(self.0, p) } + } + fn set_track_pad_position( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_event_data_device_3_d_set_track_pad_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_event_data_device_3_d_set_track_pad_position(self.0, x, y) } + } +} +impl VtkEventDataForDevice for vtkEventDataForDevice { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_for_device_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_for_device_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_for_device_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_for_device_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_for_device_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_for_device_new(self.0) } + } + fn get_device(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_for_device_get_device( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_for_device_get_device(self.0) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_for_device_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_for_device_get_input(self.0) } + } + fn get_action(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_for_device_get_action( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_for_device_get_action(self.0) } + } + fn set_device(&mut self, v: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_event_data_for_device_set_device( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + ); + } + unsafe { vtk_event_data_for_device_set_device(self.0, v) } + } + fn set_input(&mut self, v: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_event_data_for_device_set_input( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + ); + } + unsafe { vtk_event_data_for_device_set_input(self.0, v) } + } + fn set_action(&mut self, v: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_event_data_for_device_set_action( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + ); + } + unsafe { vtk_event_data_for_device_set_action(self.0, v) } + } + fn device_matches(&mut self, val: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_event_data_for_device_device_matches( + sself: *mut core::ffi::c_void, + val: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_event_data_for_device_device_matches(self.0, val) } + } +} +impl VtkEventForwarderCommand for vtkEventForwarderCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_forwarder_command_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_forwarder_command_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_forwarder_command_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_forwarder_command_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_forwarder_command_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_forwarder_command_new(self.0) } + } + fn execute( + &mut self, + caller: *mut core::ffi::c_void, + eid: core::ffi::c_ulong, + callData: (), + ) -> () { + unsafe extern "C" { + fn vtk_event_forwarder_command_execute( + sself: *mut core::ffi::c_void, + caller: *mut core::ffi::c_void, + eid: core::ffi::c_ulong, + callData: (), + ); + } + unsafe { vtk_event_forwarder_command_execute(self.0, caller, eid, callData) } + } + fn set_target(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_event_forwarder_command_set_target( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_event_forwarder_command_set_target(self.0, obj) } + } + fn get_target(&mut self) -> *mut () { + unsafe extern "C" { + fn vtk_event_forwarder_command_get_target( + sself: *mut core::ffi::c_void, + ) -> *mut (); + } + unsafe { vtk_event_forwarder_command_get_target(self.0) } + } +} +impl VtkFileOutputWindow for vtkFileOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_file_output_window_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_file_output_window_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_file_output_window_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_file_output_window_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_file_output_window_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_file_output_window_new(self.0) } + } + fn display_text(&mut self, p0: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_file_output_window_display_text( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ); + } + unsafe { vtk_file_output_window_display_text(self.0, p0) } + } + fn set_file_name(&mut self, _arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_file_output_window_set_file_name( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { vtk_file_output_window_set_file_name(self.0, _arg) } + } + fn get_file_name(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_file_output_window_get_file_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_file_output_window_get_file_name(self.0) } + } + fn set_flush(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_file_output_window_set_flush( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_file_output_window_set_flush(self.0, _arg) } + } + fn get_flush(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_file_output_window_get_flush( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_file_output_window_get_flush(self.0) } + } + fn flush_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_file_output_window_flush_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_file_output_window_flush_on(self.0) } + } + fn flush_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_file_output_window_flush_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_file_output_window_flush_off(self.0) } + } + fn set_append(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_file_output_window_set_append( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_file_output_window_set_append(self.0, _arg) } + } + fn get_append(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_file_output_window_get_append( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_file_output_window_get_append(self.0) } + } + fn append_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_file_output_window_append_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_file_output_window_append_on(self.0) } + } + fn append_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_file_output_window_append_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_file_output_window_append_off(self.0) } + } +} +impl VtkFloatArray for vtkFloatArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_float_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_float_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_float_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_float_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_float_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_float_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_float_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_float_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_float_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_float_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_float_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ); + } + unsafe { vtk_float_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_float_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ); + } + unsafe { vtk_float_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_float_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_float, + ); + } + unsafe { vtk_float_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_float, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_float_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_float, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_float_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_float_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_float; + } + unsafe { vtk_float_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_float_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_float, + ); + } + unsafe { vtk_float_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_float_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_float_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_float_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_float, + ); + } + unsafe { vtk_float_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_float) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_float_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_float, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_float_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_float { + unsafe extern "C" { + fn vtk_float_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_float; + } + unsafe { vtk_float_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_float { + unsafe extern "C" { + fn vtk_float_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_float; + } + unsafe { vtk_float_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_float { + unsafe extern "C" { + fn vtk_float_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_float; + } + unsafe { vtk_float_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_float { + unsafe extern "C" { + fn vtk_float_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_float; + } + unsafe { vtk_float_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_float, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_float_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_float, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_float_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_float, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_float_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_float, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_float_array_set_array(self.0, array, size, save, deleteMethod) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_float_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_float_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_float_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_float; + } + unsafe { vtk_float_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_float_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_float; + } + unsafe { vtk_float_array_get_data_type_value_max(self.0) } + } +} +impl VtkGarbageCollector for vtkGarbageCollector { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_garbage_collector_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_garbage_collector_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_garbage_collector_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_garbage_collector_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_garbage_collector_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_garbage_collector_new(self.0) } + } + fn collect(&mut self) -> () { + unsafe extern "C" { + fn vtk_garbage_collector_collect(sself: *mut core::ffi::c_void); + } + unsafe { vtk_garbage_collector_collect(self.0) } + } + fn collect(&mut self, root: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_garbage_collector_collect( + sself: *mut core::ffi::c_void, + root: *mut core::ffi::c_void, + ); + } + unsafe { vtk_garbage_collector_collect(self.0, root) } + } + fn deferred_collection_push(&mut self) -> () { + unsafe extern "C" { + fn vtk_garbage_collector_deferred_collection_push( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_garbage_collector_deferred_collection_push(self.0) } + } + fn deferred_collection_pop(&mut self) -> () { + unsafe extern "C" { + fn vtk_garbage_collector_deferred_collection_pop( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_garbage_collector_deferred_collection_pop(self.0) } + } + fn set_global_debug_flag(&mut self, flag: bool) -> () { + unsafe extern "C" { + fn vtk_garbage_collector_set_global_debug_flag( + sself: *mut core::ffi::c_void, + flag: bool, + ); + } + unsafe { vtk_garbage_collector_set_global_debug_flag(self.0, flag) } + } + fn get_global_debug_flag(&mut self) -> bool { + unsafe extern "C" { + fn vtk_garbage_collector_get_global_debug_flag( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_garbage_collector_get_global_debug_flag(self.0) } + } +} +impl VtkIdList for vtkIdList { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_id_list_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_id_list_initialize(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + strategy: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_id_list_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + strategy: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_id_list_allocate(self.0, sz, strategy) } + } + fn get_number_of_ids(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_get_number_of_ids( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_list_get_number_of_ids(self.0) } + } + fn get_id(&mut self, i: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_get_id( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_list_get_id(self.0, i) } + } + fn find_id_location(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_find_id_location( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_list_find_id_location(self.0, id) } + } + fn set_number_of_ids(&mut self, number: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_id_list_set_number_of_ids( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_list_set_number_of_ids(self.0, number) } + } + fn set_id(&mut self, i: core::ffi::c_uchar, vtkid: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_id_list_set_id( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + vtkid: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_list_set_id(self.0, i, vtkid) } + } + fn insert_id(&mut self, i: core::ffi::c_uchar, vtkid: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_id_list_insert_id( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + vtkid: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_list_insert_id(self.0, i, vtkid) } + } + fn insert_next_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_insert_next_id( + sself: *mut core::ffi::c_void, + vtkid: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_list_insert_next_id(self.0, vtkid) } + } + fn insert_unique_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_insert_unique_id( + sself: *mut core::ffi::c_void, + vtkid: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_list_insert_unique_id(self.0, vtkid) } + } + fn sort(&mut self) -> () { + unsafe extern "C" { + fn vtk_id_list_sort(sself: *mut core::ffi::c_void); + } + unsafe { vtk_id_list_sort(self.0) } + } + fn fill(&mut self, value: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_id_list_fill( + sself: *mut core::ffi::c_void, + value: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_list_fill(self.0, value) } + } + fn get_pointer(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_get_pointer( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_id_list_get_pointer(self.0, i) } + } + fn write_pointer( + &mut self, + i: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_write_pointer( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_id_list_write_pointer(self.0, i, number) } + } + fn set_array(&mut self, array: core::ffi::c_uchar, size: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_id_list_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_list_set_array(self.0, array, size) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_id_list_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_id_list_reset(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_id_list_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_id_list_squeeze(self.0) } + } + fn deep_copy(&mut self, ids: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_id_list_deep_copy( + sself: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_id_list_deep_copy(self.0, ids) } + } + fn delete_id(&mut self, vtkid: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_id_list_delete_id( + sself: *mut core::ffi::c_void, + vtkid: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_list_delete_id(self.0, vtkid) } + } + fn is_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_is_id( + sself: *mut core::ffi::c_void, + vtkid: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_list_is_id(self.0, vtkid) } + } + fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_id_list_intersect_with( + sself: *mut core::ffi::c_void, + otherIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_id_list_intersect_with(self.0, otherIds) } + } + fn resize(&mut self, sz: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_resize( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_id_list_resize(self.0, sz) } + } + fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_id_list_intersect_with( + sself: *mut core::ffi::c_void, + otherIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_id_list_intersect_with(self.0, otherIds) } + } + fn begin(&mut self) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_begin( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_id_list_begin(self.0) } + } + fn end(&mut self) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_end(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_id_list_end(self.0) } + } + fn begin(&mut self) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_begin( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_id_list_begin(self.0) } + } + fn end(&mut self) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_list_end( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_id_list_end(self.0) } + } +} +impl VtkIdListCollection for vtkIdListCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_new_instance(self.0) } + } + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_id_list_collection_add_item( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_id_list_collection_add_item(self.0, ds) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_get_next_item(self.0) } + } + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_get_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_get_item(self.0, i) } + } + fn get_next_id_list(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_get_next_id_list( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_get_next_id_list(self.0, cookie) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_id_list_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_id_list_collection_get_number_of_items(self.0) } + } +} +impl VtkIdTypeArray for vtkIdTypeArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_type_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_type_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_type_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_type_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_type_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_type_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_type_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_type_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_id_type_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_id_type_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_id_type_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_type_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_id_type_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_type_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_id_type_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_type_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_type_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_type_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_type_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_type_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_id_type_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_type_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_id_type_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_id_type_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_id_type_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_uchar, + ); + } + unsafe { vtk_id_type_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_type_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_type_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_type_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_id_type_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_type_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_id_type_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_type_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_id_type_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_type_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_id_type_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_id_type_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_id_type_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_id_type_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_id_type_array_set_array(self.0, array, size, save, deleteMethod) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_type_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_type_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_type_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_type_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_id_type_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_id_type_array_get_data_type_value_max(self.0) } + } +} +impl VtkInformation for vtkInformation { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_new_instance(self.0) } + } + fn modified(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_modified(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_modified(self.0) } + } + fn modified(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_modified( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_modified(self.0, key) } + } + fn clear(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_clear(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_clear(self.0) } + } + fn get_number_of_keys(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_get_number_of_keys( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_get_number_of_keys(self.0) } + } + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_copy( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy(self.0, from, deep) } + } + fn append(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_append(self.0, from, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entries( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entries( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entries(self.0, from, key, deep) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_set(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_int, + ); + } + unsafe { vtk_information_set(self.0, key, value) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_get(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_uchar, + ); + } + unsafe { vtk_information_set(self.0, key, value) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_information_get(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { vtk_information_set(self.0, key, value) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_information_get(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void, value: vtkVariant) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: vtkVariant, + ); + } + unsafe { vtk_information_set(self.0, key, value) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> vtkVariant { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> vtkVariant; + } + unsafe { vtk_information_get(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_int, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: core::ffi::c_int, + length: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_int, + length: core::ffi::c_int, + ); + } + unsafe { vtk_information_set(self.0, key, value, length) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: core::ffi::c_int, + value2: core::ffi::c_int, + value3: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value1: core::ffi::c_int, + value2: core::ffi::c_int, + value3: core::ffi::c_int, + ); + } + unsafe { vtk_information_set(self.0, key, value1, value2, value3) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: core::ffi::c_int, + value2: core::ffi::c_int, + value3: core::ffi::c_int, + value4: core::ffi::c_int, + value5: core::ffi::c_int, + value6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value1: core::ffi::c_int, + value2: core::ffi::c_int, + value3: core::ffi::c_int, + value4: core::ffi::c_int, + value5: core::ffi::c_int, + value6: core::ffi::c_int, + ); + } + unsafe { + vtk_information_set( + self.0, + key, + value1, + value2, + value3, + value4, + value5, + value6, + ) + } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_information_get(self.0, key) } + } + fn get( + &mut self, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_get(self.0, key, idx) } + } + fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_int, + ); + } + unsafe { vtk_information_get(self.0, key, value) } + } + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_length( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_length(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_char, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: core::ffi::c_char, + idx: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_char, + idx: core::ffi::c_int, + ); + } + unsafe { vtk_information_set(self.0, key, value, idx) } + } + fn append(&mut self, key: *mut core::ffi::c_void, value: &str) -> () { + let c_value = std::ffi::CString::new(value).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *const core::ffi::c_char, + ); + } + unsafe { vtk_information_append(self.0, key, c_value.as_ptr()) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: &str, + idx: core::ffi::c_int, + ) -> () { + let c_value = std::ffi::CString::new(value).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *const core::ffi::c_char, + idx: core::ffi::c_int, + ); + } + unsafe { vtk_information_set(self.0, key, c_value.as_ptr(), idx) } + } + fn get( + &mut self, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_information_get(self.0, key, idx) } + } + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_length( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_length(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: core::ffi::c_int, + length: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_int, + length: core::ffi::c_int, + ); + } + unsafe { vtk_information_set(self.0, key, value, length) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_information_get(self.0, key) } + } + fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_int, + ); + } + unsafe { vtk_information_get(self.0, key, value) } + } + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_length( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_length(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_ulong) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_ulong, + ); + } + unsafe { vtk_information_set(self.0, key, value) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_information_get(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: core::ffi::c_double, + length: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_double, + length: core::ffi::c_int, + ); + } + unsafe { vtk_information_set(self.0, key, value, length) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: core::ffi::c_double, + value2: core::ffi::c_double, + value3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value1: core::ffi::c_double, + value2: core::ffi::c_double, + value3: core::ffi::c_double, + ); + } + unsafe { vtk_information_set(self.0, key, value1, value2, value3) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: core::ffi::c_double, + value2: core::ffi::c_double, + value3: core::ffi::c_double, + value4: core::ffi::c_double, + value5: core::ffi::c_double, + value6: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value1: core::ffi::c_double, + value2: core::ffi::c_double, + value3: core::ffi::c_double, + value4: core::ffi::c_double, + value5: core::ffi::c_double, + value6: core::ffi::c_double, + ); + } + unsafe { + vtk_information_set( + self.0, + key, + value1, + value2, + value3, + value4, + value5, + value6, + ) + } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_information_get(self.0, key) } + } + fn get( + &mut self, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_information_get(self.0, key, idx) } + } + fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { vtk_information_get(self.0, key, value) } + } + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_length( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_length(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn append(&mut self, key: *mut core::ffi::c_void, value: vtkVariant) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: vtkVariant, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: vtkVariant, + length: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: vtkVariant, + length: core::ffi::c_int, + ); + } + unsafe { vtk_information_set(self.0, key, value, length) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: vtkVariant, + value2: vtkVariant, + value3: vtkVariant, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value1: vtkVariant, + value2: vtkVariant, + value3: vtkVariant, + ); + } + unsafe { vtk_information_set(self.0, key, value1, value2, value3) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value1: vtkVariant, + value2: vtkVariant, + value3: vtkVariant, + value4: vtkVariant, + value5: vtkVariant, + value6: vtkVariant, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value1: vtkVariant, + value2: vtkVariant, + value3: vtkVariant, + value4: vtkVariant, + value5: vtkVariant, + value6: vtkVariant, + ); + } + unsafe { + vtk_information_set( + self.0, + key, + value1, + value2, + value3, + value4, + value5, + value6, + ) + } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> *const vtkVariant { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *const vtkVariant; + } + unsafe { vtk_information_get(self.0, key) } + } + fn get(&mut self, key: *mut core::ffi::c_void, idx: core::ffi::c_int) -> vtkVariant { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> vtkVariant; + } + unsafe { vtk_information_get(self.0, key, idx) } + } + fn get(&mut self, key: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_get(self.0, key, value) } + } + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_length( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_length(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + length: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + length: core::ffi::c_int, + ); + } + unsafe { vtk_information_set(self.0, key, value, length) } + } + fn remove( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key, value) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut &mut vtkInformationKey { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut &mut vtkInformationKey; + } + unsafe { vtk_information_get(self.0, key) } + } + fn get( + &mut self, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get(self.0, key, idx) } + } + fn get(&mut self, key: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_get(self.0, key, value) } + } + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_length( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_length(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn set(&mut self, key: *mut core::ffi::c_void, p1: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + p1: core::ffi::c_char, + ); + } + unsafe { vtk_information_set(self.0, key, p1) } + } + fn set(&mut self, key: *mut core::ffi::c_void, p1: &str) -> () { + let c_p1 = std::ffi::CString::new(p1).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + p1: *const core::ffi::c_char, + ); + } + unsafe { vtk_information_set(self.0, key, c_p1.as_ptr()) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_information_get(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_set(self.0, key, p1) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_set(self.0, key, p1) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_set(self.0, key, p1) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn append( + &mut self, + key: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append(self.0, key, data) } + } + fn set( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ); + } + unsafe { vtk_information_set(self.0, key, value, idx) } + } + fn get( + &mut self, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get(self.0, key, idx) } + } + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_length( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_length(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn remove( + &mut self, + key: *mut core::ffi::c_void, + objectToRemove: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + objectToRemove: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key, objectToRemove) } + } + fn remove( + &mut self, + key: *mut core::ffi::c_void, + indexToRemove: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + indexToRemove: core::ffi::c_int, + ); + } + unsafe { vtk_information_remove(self.0, key, indexToRemove) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_set(self.0, key, p1) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_register(self.0, o) } + } + fn set_request(&mut self, request: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_set_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_set_request(self.0, request) } + } + fn get_request(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_request( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_request(self.0) } + } +} +impl VtkInformationIterator for vtkInformationIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_iterator_new_instance(self.0) } + } + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_iterator_set_information( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_iterator_set_information(self.0, p0) } + } + fn get_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_iterator_get_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_iterator_get_information(self.0) } + } + fn set_information_weak(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_iterator_set_information_weak( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_iterator_set_information_weak(self.0, p0) } + } + fn init_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_iterator_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_iterator_init_traversal(self.0) } + } + fn go_to_first_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_iterator_go_to_first_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_iterator_go_to_first_item(self.0) } + } + fn go_to_next_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_iterator_go_to_next_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_iterator_go_to_next_item(self.0) } + } + fn is_done_with_traversal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_iterator_is_done_with_traversal(self.0) } + } + fn get_current_key(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_iterator_get_current_key( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_iterator_get_current_key(self.0) } + } +} +impl VtkInformationKeyLookup for vtkInformationKeyLookup { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_key_lookup_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_key_lookup_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_key_lookup_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_key_lookup_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_key_lookup_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_key_lookup_new_instance(self.0) } + } + fn find(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_location = std::ffi::CString::new(location).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_information_key_lookup_find( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + location: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_information_key_lookup_find(self.0, c_name.as_ptr(), c_location.as_ptr()) + } + } +} +impl VtkInformationVector for vtkInformationVector { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_vector_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_vector_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_vector_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_vector_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_vector_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_vector_new_instance(self.0) } + } + fn get_number_of_information_objects(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_vector_get_number_of_information_objects( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_vector_get_number_of_information_objects(self.0) } + } + fn set_number_of_information_objects(&mut self, n: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_vector_set_number_of_information_objects( + sself: *mut core::ffi::c_void, + n: core::ffi::c_int, + ); + } + unsafe { vtk_information_vector_set_number_of_information_objects(self.0, n) } + } + fn set_information_object( + &mut self, + index: core::ffi::c_int, + info: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_vector_set_information_object( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_vector_set_information_object(self.0, index, info) } + } + fn get_information_object( + &mut self, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_vector_get_information_object( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_vector_get_information_object(self.0, index) } + } + fn append(&mut self, info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_vector_append( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_vector_append(self.0, info) } + } + fn remove(&mut self, info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_vector_remove( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_vector_remove(self.0, info) } + } + fn remove(&mut self, idx: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_vector_remove( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ); + } + unsafe { vtk_information_vector_remove(self.0, idx) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_vector_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_vector_register(self.0, o) } + } + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_vector_copy( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_vector_copy(self.0, from, deep) } + } +} +impl VtkIntArray for vtkIntArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_int_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_int_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_int_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_int_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_int_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_int_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_int_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_int_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_int_array_get_data_type(self.0) } + } + fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_int_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_int, + ); + } + unsafe { vtk_int_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_int_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_int, + ); + } + unsafe { vtk_int_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_int_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_int, + ); + } + unsafe { vtk_int_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_int_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_int_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_int_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_int_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_int, + ); + } + unsafe { vtk_int_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_int_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_int_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_int_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_int, + ); + } + unsafe { vtk_int_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_int_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_int_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_int_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_int_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_int_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_int_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_int, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_int_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_int, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_int_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_int, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_int_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_int, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_int_array_set_array(self.0, array, size, save, deleteMethod) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_int_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_int_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_int_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_int_array_get_data_type_value_max(self.0) } + } +} +impl VtkLongArray for vtkLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_long_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_long_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_long, + ) -> () { + unsafe extern "C" { + fn vtk_long_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_long, + ); + } + unsafe { vtk_long_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_long, + ) -> () { + unsafe extern "C" { + fn vtk_long_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_long, + ); + } + unsafe { vtk_long_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_long, + ) -> () { + unsafe extern "C" { + fn vtk_long_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_long, + ); + } + unsafe { vtk_long_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_long, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_long, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_long_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_long { + unsafe extern "C" { + fn vtk_long_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_long; + } + unsafe { vtk_long_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_long) -> () { + unsafe extern "C" { + fn vtk_long_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_long, + ); + } + unsafe { vtk_long_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_long_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_long_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_long) -> () { + unsafe extern "C" { + fn vtk_long_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_long, + ); + } + unsafe { vtk_long_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_long) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_long, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_long_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_long { + unsafe extern "C" { + fn vtk_long_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_long; + } + unsafe { vtk_long_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_long { + unsafe extern "C" { + fn vtk_long_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_long; + } + unsafe { vtk_long_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_long { + unsafe extern "C" { + fn vtk_long_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_long; + } + unsafe { vtk_long_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_long { + unsafe extern "C" { + fn vtk_long_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_long; + } + unsafe { vtk_long_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_long, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_long_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_long, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_long_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_long, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_long_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_long, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_long_array_set_array(self.0, array, size, save, deleteMethod) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_long { + unsafe extern "C" { + fn vtk_long_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_long; + } + unsafe { vtk_long_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_long { + unsafe extern "C" { + fn vtk_long_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_long; + } + unsafe { vtk_long_array_get_data_type_value_max(self.0) } + } +} +impl VtkLongLongArray for vtkLongLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_long_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_long_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_long_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_long_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_long_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_long_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_long_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_long_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_long_long_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_long_long_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_long_long_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ); + } + unsafe { vtk_long_long_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_long_long_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ); + } + unsafe { vtk_long_long_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_long_long_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ); + } + unsafe { vtk_long_long_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_long_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_long_long_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_long_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_long_long_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_long_long_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_uchar, + ); + } + unsafe { vtk_long_long_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_long_long_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_long_long_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_long_long_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_uchar, + ); + } + unsafe { vtk_long_long_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_long_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_long_long_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_long_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_long_long_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_long_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_long_long_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_long_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_long_long_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_long_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_long_long_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_long_long_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_long_long_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_long_long_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_long_long_array_set_array(self.0, array, size, save, deleteMethod) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_long_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_long_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_long_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_long_long_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_long_long_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_long_long_array_get_data_type_value_max(self.0) } + } +} +impl VtkLookupTable for vtkLookupTable { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lookup_table_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lookup_table_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lookup_table_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lookup_table_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lookup_table_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lookup_table_new_instance(self.0) } + } + fn is_opaque(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_is_opaque( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_is_opaque(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_allocate(self.0, sz, ext) } + } + fn build(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_build(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_build(self.0) } + } + fn force_build(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_force_build(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_force_build(self.0) } + } + fn build_special_colors(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_build_special_colors(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_build_special_colors(self.0) } + } + fn set_ramp(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_ramp( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_lookup_table_set_ramp(self.0, _arg) } + } + fn set_ramp_to_linear(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_ramp_to_linear(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_ramp_to_linear(self.0) } + } + fn set_ramp_to_s_curve(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_ramp_to_s_curve(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_ramp_to_s_curve(self.0) } + } + fn set_ramp_to_sqrt(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_ramp_to_sqrt(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_ramp_to_sqrt(self.0) } + } + fn get_ramp(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_get_ramp( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_get_ramp(self.0) } + } + fn set_scale(&mut self, scale: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_scale( + sself: *mut core::ffi::c_void, + scale: core::ffi::c_int, + ); + } + unsafe { vtk_lookup_table_set_scale(self.0, scale) } + } + fn set_scale_to_linear(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_scale_to_linear(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_scale_to_linear(self.0) } + } + fn set_scale_to_log_10(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_scale_to_log_10(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_scale_to_log_10(self.0) } + } + fn get_scale(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_get_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_get_scale(self.0) } + } + fn set_table_range(&mut self, r: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_table_range( + sself: *mut core::ffi::c_void, + r: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_table_range(self.0, r) } + } + fn set_table_range( + &mut self, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_table_range( + sself: *mut core::ffi::c_void, + min: core::ffi::c_double, + max: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_table_range(self.0, min, max) } + } + fn get_table_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_table_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_table_range(self.0) } + } + fn get_table_range(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_table_range( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_table_range(self.0, data) } + } + fn set_hue_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_hue_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_hue_range(self.0, _arg1, _arg2) } + } + fn set_hue_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_hue_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_hue_range(self.0, _arg) } + } + fn get_hue_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_hue_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_hue_range(self.0) } + } + fn get_hue_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_hue_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_hue_range(self.0, _arg1, _arg2) } + } + fn get_hue_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_hue_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_hue_range(self.0, _arg) } + } + fn set_saturation_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_saturation_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_saturation_range(self.0, _arg1, _arg2) } + } + fn set_saturation_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_saturation_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_saturation_range(self.0, _arg) } + } + fn get_saturation_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_saturation_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_saturation_range(self.0) } + } + fn get_saturation_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_saturation_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_saturation_range(self.0, _arg1, _arg2) } + } + fn get_saturation_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_saturation_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_saturation_range(self.0, _arg) } + } + fn set_value_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_value_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_value_range(self.0, _arg1, _arg2) } + } + fn set_value_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_value_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_value_range(self.0, _arg) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_value_range(self.0) } + } + fn get_value_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_value_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_value_range(self.0, _arg1, _arg2) } + } + fn get_value_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_value_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_value_range(self.0, _arg) } + } + fn set_alpha_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_alpha_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_alpha_range(self.0, _arg1, _arg2) } + } + fn set_alpha_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_alpha_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_alpha_range(self.0, _arg) } + } + fn get_alpha_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_alpha_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_alpha_range(self.0) } + } + fn get_alpha_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_alpha_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_alpha_range(self.0, _arg1, _arg2) } + } + fn get_alpha_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_alpha_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_alpha_range(self.0, _arg) } + } + fn set_nan_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_nan_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_nan_color(self.0, _arg1, _arg2, _arg3, _arg4) } + } + fn set_nan_color(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_nan_color( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_nan_color(self.0, _arg) } + } + fn get_nan_color(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_nan_color( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_nan_color(self.0) } + } + fn get_nan_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_nan_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_nan_color(self.0, _arg1, _arg2, _arg3, _arg4) } + } + fn get_nan_color(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_nan_color( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_nan_color(self.0, _arg) } + } + fn get_nan_color_as_unsigned_chars(&mut self) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_lookup_table_get_nan_color_as_unsigned_chars( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_lookup_table_get_nan_color_as_unsigned_chars(self.0) } + } + fn get_color_as_unsigned_chars( + &mut self, + colorIn: core::ffi::c_double, + colorOut: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_color_as_unsigned_chars( + sself: *mut core::ffi::c_void, + colorIn: core::ffi::c_double, + colorOut: core::ffi::c_uchar, + ); + } + unsafe { + vtk_lookup_table_get_color_as_unsigned_chars(self.0, colorIn, colorOut) + } + } + fn set_below_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_below_range_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ); + } + unsafe { + vtk_lookup_table_set_below_range_color(self.0, _arg1, _arg2, _arg3, _arg4) + } + } + fn set_below_range_color(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_below_range_color( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_below_range_color(self.0, _arg) } + } + fn get_below_range_color(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_below_range_color( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_below_range_color(self.0) } + } + fn get_below_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_below_range_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ); + } + unsafe { + vtk_lookup_table_get_below_range_color(self.0, _arg1, _arg2, _arg3, _arg4) + } + } + fn get_below_range_color(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_below_range_color( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_below_range_color(self.0, _arg) } + } + fn set_use_below_range_color(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_use_below_range_color( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_lookup_table_set_use_below_range_color(self.0, _arg) } + } + fn get_use_below_range_color(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_get_use_below_range_color( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_get_use_below_range_color(self.0) } + } + fn use_below_range_color_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_use_below_range_color_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_use_below_range_color_on(self.0) } + } + fn use_below_range_color_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_use_below_range_color_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_use_below_range_color_off(self.0) } + } + fn set_above_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_above_range_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ); + } + unsafe { + vtk_lookup_table_set_above_range_color(self.0, _arg1, _arg2, _arg3, _arg4) + } + } + fn set_above_range_color(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_above_range_color( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_above_range_color(self.0, _arg) } + } + fn get_above_range_color(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_above_range_color( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_above_range_color(self.0) } + } + fn get_above_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_above_range_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ); + } + unsafe { + vtk_lookup_table_get_above_range_color(self.0, _arg1, _arg2, _arg3, _arg4) + } + } + fn get_above_range_color(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_above_range_color( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_above_range_color(self.0, _arg) } + } + fn set_use_above_range_color(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_use_above_range_color( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_lookup_table_set_use_above_range_color(self.0, _arg) } + } + fn get_use_above_range_color(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_get_use_above_range_color( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_get_use_above_range_color(self.0) } + } + fn use_above_range_color_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_use_above_range_color_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_use_above_range_color_on(self.0) } + } + fn use_above_range_color_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_use_above_range_color_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_use_above_range_color_off(self.0) } + } + fn map_value(&mut self, v: core::ffi::c_double) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_lookup_table_map_value( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_lookup_table_map_value(self.0, v) } + } + fn get_color(&mut self, v: core::ffi::c_double, rgb: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_color( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + rgb: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_color(self.0, v, rgb) } + } + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_opacity( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_opacity(self.0, v) } + } + fn get_index(&mut self, v: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_lookup_table_get_index( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_lookup_table_get_index(self.0, v) } + } + fn set_number_of_table_values(&mut self, number: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_number_of_table_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ); + } + unsafe { vtk_lookup_table_set_number_of_table_values(self.0, number) } + } + fn get_number_of_table_values(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_lookup_table_get_number_of_table_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_lookup_table_get_number_of_table_values(self.0) } + } + fn set_table_value( + &mut self, + indx: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_table_value( + sself: *mut core::ffi::c_void, + indx: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_table_value(self.0, indx, rgba) } + } + fn set_table_value( + &mut self, + indx: core::ffi::c_uchar, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_table_value( + sself: *mut core::ffi::c_void, + indx: core::ffi::c_uchar, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_table_value(self.0, indx, r, g, b, a) } + } + fn get_table_value(&mut self, indx: core::ffi::c_uchar) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_table_value( + sself: *mut core::ffi::c_void, + indx: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_table_value(self.0, indx) } + } + fn get_table_value( + &mut self, + indx: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_table_value( + sself: *mut core::ffi::c_void, + indx: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_table_value(self.0, indx, rgba) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_lookup_table_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_lookup_table_get_pointer(self.0, id) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_lookup_table_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_lookup_table_write_pointer(self.0, id, number) } + } + fn get_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_range(self.0) } + } + fn get_log_range( + &mut self, + range: core::ffi::c_double, + log_range: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_log_range( + sself: *mut core::ffi::c_void, + range: core::ffi::c_double, + log_range: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_log_range(self.0, range, log_range) } + } + fn apply_log_scale( + &mut self, + v: core::ffi::c_double, + range: core::ffi::c_double, + log_range: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_apply_log_scale( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + range: core::ffi::c_double, + log_range: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_lookup_table_apply_log_scale(self.0, v, range, log_range) } + } + fn set_number_of_colors(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_number_of_colors( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_lookup_table_set_number_of_colors(self.0, _arg) } + } + fn get_number_of_colors_min_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_lookup_table_get_number_of_colors_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_lookup_table_get_number_of_colors_min_value(self.0) } + } + fn get_number_of_colors_max_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_lookup_table_get_number_of_colors_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_lookup_table_get_number_of_colors_max_value(self.0) } + } + fn get_number_of_colors(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_lookup_table_get_number_of_colors( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_lookup_table_get_number_of_colors(self.0) } + } + fn set_table(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_table( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_lookup_table_set_table(self.0, p0) } + } + fn get_table(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lookup_table_get_table( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lookup_table_get_table(self.0) } + } + fn map_scalars_through_table_2( + &mut self, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_map_scalars_through_table_2( + sself: *mut core::ffi::c_void, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ); + } + unsafe { + vtk_lookup_table_map_scalars_through_table_2( + self.0, + input, + output, + inputDataType, + numberOfValues, + inputIncrement, + outputFormat, + ) + } + } + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_lookup_table_deep_copy( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_lookup_table_deep_copy(self.0, obj) } + } + fn using_log_scale(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_using_log_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_using_log_scale(self.0) } + } + fn get_indexed_color( + &mut self, + idx: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_get_indexed_color( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_get_indexed_color(self.0, idx, rgba) } + } +} +impl VtkMath for vtkMath { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_math_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_math_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_math_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_math_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_math_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_math_new_instance(self.0) } + } + fn pi(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_pi(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_pi(self.0) } + } + fn radians_from_degrees( + &mut self, + degrees: core::ffi::c_float, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_radians_from_degrees( + sself: *mut core::ffi::c_void, + degrees: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_radians_from_degrees(self.0, degrees) } + } + fn radians_from_degrees( + &mut self, + degrees: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_radians_from_degrees( + sself: *mut core::ffi::c_void, + degrees: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_radians_from_degrees(self.0, degrees) } + } + fn degrees_from_radians( + &mut self, + radians: core::ffi::c_float, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_degrees_from_radians( + sself: *mut core::ffi::c_void, + radians: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_degrees_from_radians(self.0, radians) } + } + fn degrees_from_radians( + &mut self, + radians: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_degrees_from_radians( + sself: *mut core::ffi::c_void, + radians: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_degrees_from_radians(self.0, radians) } + } + fn round(&mut self, f: core::ffi::c_float) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_round( + sself: *mut core::ffi::c_void, + f: core::ffi::c_float, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_round(self.0, f) } + } + fn round(&mut self, f: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_round( + sself: *mut core::ffi::c_void, + f: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_round(self.0, f) } + } + fn floor(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_floor( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_floor(self.0, x) } + } + fn ceil(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_ceil( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_ceil(self.0, x) } + } + fn ceil_log_2(&mut self, x: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_ceil_log_2( + sself: *mut core::ffi::c_void, + x: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_ceil_log_2(self.0, x) } + } + fn is_power_of_two(&mut self, x: core::ffi::c_ulonglong) -> bool { + unsafe extern "C" { + fn vtk_math_is_power_of_two( + sself: *mut core::ffi::c_void, + x: core::ffi::c_ulonglong, + ) -> bool; + } + unsafe { vtk_math_is_power_of_two(self.0, x) } + } + fn nearest_power_of_two(&mut self, x: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_nearest_power_of_two( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_nearest_power_of_two(self.0, x) } + } + fn factorial(&mut self, N: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_math_factorial( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_math_factorial(self.0, N) } + } + fn binomial( + &mut self, + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_math_binomial( + sself: *mut core::ffi::c_void, + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_math_binomial(self.0, m, n) } + } + fn begin_combination( + &mut self, + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_begin_combination( + sself: *mut core::ffi::c_void, + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_math_begin_combination(self.0, m, n) } + } + fn next_combination( + &mut self, + m: core::ffi::c_int, + n: core::ffi::c_int, + combination: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_next_combination( + sself: *mut core::ffi::c_void, + m: core::ffi::c_int, + n: core::ffi::c_int, + combination: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_next_combination(self.0, m, n, combination) } + } + fn free_combination(&mut self, combination: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_math_free_combination( + sself: *mut core::ffi::c_void, + combination: core::ffi::c_int, + ); + } + unsafe { vtk_math_free_combination(self.0, combination) } + } + fn random_seed(&mut self, s: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_math_random_seed(sself: *mut core::ffi::c_void, s: core::ffi::c_int); + } + unsafe { vtk_math_random_seed(self.0, s) } + } + fn get_seed(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_get_seed(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_math_get_seed(self.0) } + } + fn random(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_random(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_random(self.0) } + } + fn random( + &mut self, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_random( + sself: *mut core::ffi::c_void, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_random(self.0, min, max) } + } + fn gaussian(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_gaussian(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_gaussian(self.0) } + } + fn gaussian( + &mut self, + mean: core::ffi::c_double, + std: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_gaussian( + sself: *mut core::ffi::c_void, + mean: core::ffi::c_double, + std: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_gaussian(self.0, mean, std) } + } + fn assign(&mut self, a: core::ffi::c_double, b: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_assign( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + ); + } + unsafe { vtk_math_assign(self.0, a, b) } + } + fn add( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_add( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ); + } + unsafe { vtk_math_add(self.0, a, b, c) } + } + fn add( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_add( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ); + } + unsafe { vtk_math_add(self.0, a, b, c) } + } + fn subtract( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_subtract( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ); + } + unsafe { vtk_math_subtract(self.0, a, b, c) } + } + fn subtract( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_subtract( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ); + } + unsafe { vtk_math_subtract(self.0, a, b, c) } + } + fn multiply_scalar(&mut self, a: core::ffi::c_float, s: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_math_multiply_scalar( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + s: core::ffi::c_float, + ); + } + unsafe { vtk_math_multiply_scalar(self.0, a, s) } + } + fn multiply_scalar_2_d( + &mut self, + a: core::ffi::c_float, + s: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_multiply_scalar_2_d( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + s: core::ffi::c_float, + ); + } + unsafe { vtk_math_multiply_scalar_2_d(self.0, a, s) } + } + fn multiply_scalar(&mut self, a: core::ffi::c_double, s: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_multiply_scalar( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + s: core::ffi::c_double, + ); + } + unsafe { vtk_math_multiply_scalar(self.0, a, s) } + } + fn multiply_scalar_2_d( + &mut self, + a: core::ffi::c_double, + s: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_multiply_scalar_2_d( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + s: core::ffi::c_double, + ); + } + unsafe { vtk_math_multiply_scalar_2_d(self.0, a, s) } + } + fn dot( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_dot( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + b: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_dot(self.0, a, b) } + } + fn dot( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_dot( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_dot(self.0, a, b) } + } + fn outer( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_outer( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ); + } + unsafe { vtk_math_outer(self.0, a, b, c) } + } + fn outer( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_outer( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ); + } + unsafe { vtk_math_outer(self.0, a, b, c) } + } + fn cross( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_cross( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + b: core::ffi::c_float, + c: core::ffi::c_float, + ); + } + unsafe { vtk_math_cross(self.0, a, b, c) } + } + fn cross( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_cross( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ); + } + unsafe { vtk_math_cross(self.0, a, b, c) } + } + fn norm( + &mut self, + x: core::ffi::c_float, + n: core::ffi::c_int, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_norm( + sself: *mut core::ffi::c_void, + x: core::ffi::c_float, + n: core::ffi::c_int, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_norm(self.0, x, n) } + } + fn norm( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_norm( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_norm(self.0, x, n) } + } + fn norm(&mut self, v: core::ffi::c_float) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_norm( + sself: *mut core::ffi::c_void, + v: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_norm(self.0, v) } + } + fn norm(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_norm( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_norm(self.0, v) } + } + fn normalize(&mut self, v: core::ffi::c_float) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_normalize( + sself: *mut core::ffi::c_void, + v: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_normalize(self.0, v) } + } + fn normalize(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_normalize( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_normalize(self.0, v) } + } + fn perpendiculars( + &mut self, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + theta: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_perpendiculars( + sself: *mut core::ffi::c_void, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + theta: core::ffi::c_double, + ); + } + unsafe { vtk_math_perpendiculars(self.0, v1, v2, v3, theta) } + } + fn perpendiculars( + &mut self, + v1: core::ffi::c_float, + v2: core::ffi::c_float, + v3: core::ffi::c_float, + theta: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_perpendiculars( + sself: *mut core::ffi::c_void, + v1: core::ffi::c_float, + v2: core::ffi::c_float, + v3: core::ffi::c_float, + theta: core::ffi::c_double, + ); + } + unsafe { vtk_math_perpendiculars(self.0, v1, v2, v3, theta) } + } + fn project_vector( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + projection: core::ffi::c_float, + ) -> bool { + unsafe extern "C" { + fn vtk_math_project_vector( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + b: core::ffi::c_float, + projection: core::ffi::c_float, + ) -> bool; + } + unsafe { vtk_math_project_vector(self.0, a, b, projection) } + } + fn project_vector( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + projection: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_math_project_vector( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + projection: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_math_project_vector(self.0, a, b, projection) } + } + fn project_vector_2_d( + &mut self, + a: core::ffi::c_float, + b: core::ffi::c_float, + projection: core::ffi::c_float, + ) -> bool { + unsafe extern "C" { + fn vtk_math_project_vector_2_d( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + b: core::ffi::c_float, + projection: core::ffi::c_float, + ) -> bool; + } + unsafe { vtk_math_project_vector_2_d(self.0, a, b, projection) } + } + fn project_vector_2_d( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + projection: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_math_project_vector_2_d( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + projection: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_math_project_vector_2_d(self.0, a, b, projection) } + } + fn distance_2_between_points( + &mut self, + p1: core::ffi::c_float, + p2: core::ffi::c_float, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_distance_2_between_points( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_float, + p2: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_distance_2_between_points(self.0, p1, p2) } + } + fn distance_2_between_points( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_distance_2_between_points( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_distance_2_between_points(self.0, p1, p2) } + } + fn angle_between_vectors( + &mut self, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_angle_between_vectors( + sself: *mut core::ffi::c_void, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_angle_between_vectors(self.0, v1, v2) } + } + fn signed_angle_between_vectors( + &mut self, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + vn: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_signed_angle_between_vectors( + sself: *mut core::ffi::c_void, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + vn: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_signed_angle_between_vectors(self.0, v1, v2, vn) } + } + fn gaussian_amplitude( + &mut self, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_gaussian_amplitude( + sself: *mut core::ffi::c_void, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_gaussian_amplitude(self.0, variance, distanceFromMean) } + } + fn gaussian_amplitude( + &mut self, + mean: core::ffi::c_double, + variance: core::ffi::c_double, + position: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_gaussian_amplitude( + sself: *mut core::ffi::c_void, + mean: core::ffi::c_double, + variance: core::ffi::c_double, + position: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_gaussian_amplitude(self.0, mean, variance, position) } + } + fn gaussian_weight( + &mut self, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_gaussian_weight( + sself: *mut core::ffi::c_void, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_gaussian_weight(self.0, variance, distanceFromMean) } + } + fn gaussian_weight( + &mut self, + mean: core::ffi::c_double, + variance: core::ffi::c_double, + position: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_gaussian_weight( + sself: *mut core::ffi::c_void, + mean: core::ffi::c_double, + variance: core::ffi::c_double, + position: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_gaussian_weight(self.0, mean, variance, position) } + } + fn dot_2_d( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_dot_2_d( + sself: *mut core::ffi::c_void, + x: core::ffi::c_float, + y: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_dot_2_d(self.0, x, y) } + } + fn dot_2_d( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_dot_2_d( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_dot_2_d(self.0, x, y) } + } + fn outer_2_d( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + A: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_outer_2_d( + sself: *mut core::ffi::c_void, + x: core::ffi::c_float, + y: core::ffi::c_float, + A: core::ffi::c_float, + ); + } + unsafe { vtk_math_outer_2_d(self.0, x, y, A) } + } + fn outer_2_d( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + A: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_outer_2_d( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + A: core::ffi::c_double, + ); + } + unsafe { vtk_math_outer_2_d(self.0, x, y, A) } + } + fn norm_2_d(&mut self, x: core::ffi::c_float) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_norm_2_d( + sself: *mut core::ffi::c_void, + x: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_norm_2_d(self.0, x) } + } + fn norm_2_d(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_norm_2_d( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_norm_2_d(self.0, x) } + } + fn normalize_2_d(&mut self, v: core::ffi::c_float) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_normalize_2_d( + sself: *mut core::ffi::c_void, + v: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_normalize_2_d(self.0, v) } + } + fn normalize_2_d(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_normalize_2_d( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_normalize_2_d(self.0, v) } + } + fn determinant_2_x_2( + &mut self, + c1: core::ffi::c_float, + c2: core::ffi::c_float, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_determinant_2_x_2( + sself: *mut core::ffi::c_void, + c1: core::ffi::c_float, + c2: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_determinant_2_x_2(self.0, c1, c2) } + } + fn determinant_2_x_2( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + d: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_determinant_2_x_2( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + d: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_determinant_2_x_2(self.0, a, b, c, d) } + } + fn determinant_2_x_2( + &mut self, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_determinant_2_x_2( + sself: *mut core::ffi::c_void, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_determinant_2_x_2(self.0, c1, c2) } + } + fn lu_factor_3_x_3(&mut self, A: core::ffi::c_float, index: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_math_lu_factor_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + index: core::ffi::c_int, + ); + } + unsafe { vtk_math_lu_factor_3_x_3(self.0, A, index) } + } + fn lu_factor_3_x_3( + &mut self, + A: core::ffi::c_double, + index: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_math_lu_factor_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + index: core::ffi::c_int, + ); + } + unsafe { vtk_math_lu_factor_3_x_3(self.0, A, index) } + } + fn lu_solve_3_x_3( + &mut self, + A: core::ffi::c_float, + index: core::ffi::c_int, + x: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_lu_solve_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + index: core::ffi::c_int, + x: core::ffi::c_float, + ); + } + unsafe { vtk_math_lu_solve_3_x_3(self.0, A, index, x) } + } + fn lu_solve_3_x_3( + &mut self, + A: core::ffi::c_double, + index: core::ffi::c_int, + x: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_lu_solve_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + index: core::ffi::c_int, + x: core::ffi::c_double, + ); + } + unsafe { vtk_math_lu_solve_3_x_3(self.0, A, index, x) } + } + fn linear_solve_3_x_3( + &mut self, + A: core::ffi::c_float, + x: core::ffi::c_float, + y: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_linear_solve_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + x: core::ffi::c_float, + y: core::ffi::c_float, + ); + } + unsafe { vtk_math_linear_solve_3_x_3(self.0, A, x, y) } + } + fn linear_solve_3_x_3( + &mut self, + A: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_linear_solve_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_math_linear_solve_3_x_3(self.0, A, x, y) } + } + fn multiply_3_x_3( + &mut self, + A: core::ffi::c_float, + v: core::ffi::c_float, + u: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_multiply_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + v: core::ffi::c_float, + u: core::ffi::c_float, + ); + } + unsafe { vtk_math_multiply_3_x_3(self.0, A, v, u) } + } + fn multiply_3_x_3( + &mut self, + A: core::ffi::c_double, + v: core::ffi::c_double, + u: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_multiply_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + v: core::ffi::c_double, + u: core::ffi::c_double, + ); + } + unsafe { vtk_math_multiply_3_x_3(self.0, A, v, u) } + } + fn multiply_3_x_3( + &mut self, + A: core::ffi::c_float, + B: core::ffi::c_float, + C: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_multiply_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + B: core::ffi::c_float, + C: core::ffi::c_float, + ); + } + unsafe { vtk_math_multiply_3_x_3(self.0, A, B, C) } + } + fn multiply_3_x_3( + &mut self, + A: core::ffi::c_double, + B: core::ffi::c_double, + C: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_multiply_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + B: core::ffi::c_double, + C: core::ffi::c_double, + ); + } + unsafe { vtk_math_multiply_3_x_3(self.0, A, B, C) } + } + fn multiply_matrix( + &mut self, + A: core::ffi::c_double, + B: core::ffi::c_double, + rowA: core::ffi::c_uint, + colA: core::ffi::c_uint, + rowB: core::ffi::c_uint, + colB: core::ffi::c_uint, + C: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_multiply_matrix( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + B: core::ffi::c_double, + rowA: core::ffi::c_uint, + colA: core::ffi::c_uint, + rowB: core::ffi::c_uint, + colB: core::ffi::c_uint, + C: core::ffi::c_double, + ); + } + unsafe { vtk_math_multiply_matrix(self.0, A, B, rowA, colA, rowB, colB, C) } + } + fn transpose_3_x_3(&mut self, A: core::ffi::c_float, AT: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_math_transpose_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + AT: core::ffi::c_float, + ); + } + unsafe { vtk_math_transpose_3_x_3(self.0, A, AT) } + } + fn transpose_3_x_3( + &mut self, + A: core::ffi::c_double, + AT: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_transpose_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + AT: core::ffi::c_double, + ); + } + unsafe { vtk_math_transpose_3_x_3(self.0, A, AT) } + } + fn invert_3_x_3(&mut self, A: core::ffi::c_float, AI: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_math_invert_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + AI: core::ffi::c_float, + ); + } + unsafe { vtk_math_invert_3_x_3(self.0, A, AI) } + } + fn invert_3_x_3(&mut self, A: core::ffi::c_double, AI: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_invert_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + AI: core::ffi::c_double, + ); + } + unsafe { vtk_math_invert_3_x_3(self.0, A, AI) } + } + fn identity_3_x_3(&mut self, A: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_math_identity_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + ); + } + unsafe { vtk_math_identity_3_x_3(self.0, A) } + } + fn identity_3_x_3(&mut self, A: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_identity_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + ); + } + unsafe { vtk_math_identity_3_x_3(self.0, A) } + } + fn determinant_3_x_3(&mut self, A: core::ffi::c_float) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_determinant_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_determinant_3_x_3(self.0, A) } + } + fn determinant_3_x_3(&mut self, A: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_determinant_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_determinant_3_x_3(self.0, A) } + } + fn determinant_3_x_3( + &mut self, + c1: core::ffi::c_float, + c2: core::ffi::c_float, + c3: core::ffi::c_float, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_determinant_3_x_3( + sself: *mut core::ffi::c_void, + c1: core::ffi::c_float, + c2: core::ffi::c_float, + c3: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_determinant_3_x_3(self.0, c1, c2, c3) } + } + fn determinant_3_x_3( + &mut self, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_determinant_3_x_3( + sself: *mut core::ffi::c_void, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_determinant_3_x_3(self.0, c1, c2, c3) } + } + fn determinant_3_x_3( + &mut self, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + b1: core::ffi::c_double, + b2: core::ffi::c_double, + b3: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_determinant_3_x_3( + sself: *mut core::ffi::c_void, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + b1: core::ffi::c_double, + b2: core::ffi::c_double, + b3: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_determinant_3_x_3(self.0, a1, a2, a3, b1, b2, b3, c1, c2, c3) } + } + fn quaternion_to_matrix_3_x_3( + &mut self, + quat: core::ffi::c_float, + A: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_quaternion_to_matrix_3_x_3( + sself: *mut core::ffi::c_void, + quat: core::ffi::c_float, + A: core::ffi::c_float, + ); + } + unsafe { vtk_math_quaternion_to_matrix_3_x_3(self.0, quat, A) } + } + fn quaternion_to_matrix_3_x_3( + &mut self, + quat: core::ffi::c_double, + A: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_quaternion_to_matrix_3_x_3( + sself: *mut core::ffi::c_void, + quat: core::ffi::c_double, + A: core::ffi::c_double, + ); + } + unsafe { vtk_math_quaternion_to_matrix_3_x_3(self.0, quat, A) } + } + fn matrix_3_x_3_to_quaternion( + &mut self, + A: core::ffi::c_float, + quat: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_matrix_3_x_3_to_quaternion( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + quat: core::ffi::c_float, + ); + } + unsafe { vtk_math_matrix_3_x_3_to_quaternion(self.0, A, quat) } + } + fn matrix_3_x_3_to_quaternion( + &mut self, + A: core::ffi::c_double, + quat: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_matrix_3_x_3_to_quaternion( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + quat: core::ffi::c_double, + ); + } + unsafe { vtk_math_matrix_3_x_3_to_quaternion(self.0, A, quat) } + } + fn multiply_quaternion( + &mut self, + q1: core::ffi::c_float, + q2: core::ffi::c_float, + q: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_multiply_quaternion( + sself: *mut core::ffi::c_void, + q1: core::ffi::c_float, + q2: core::ffi::c_float, + q: core::ffi::c_float, + ); + } + unsafe { vtk_math_multiply_quaternion(self.0, q1, q2, q) } + } + fn multiply_quaternion( + &mut self, + q1: core::ffi::c_double, + q2: core::ffi::c_double, + q: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_multiply_quaternion( + sself: *mut core::ffi::c_void, + q1: core::ffi::c_double, + q2: core::ffi::c_double, + q: core::ffi::c_double, + ); + } + unsafe { vtk_math_multiply_quaternion(self.0, q1, q2, q) } + } + fn rotate_vector_by_normalized_quaternion( + &mut self, + v: core::ffi::c_float, + q: core::ffi::c_float, + r: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_rotate_vector_by_normalized_quaternion( + sself: *mut core::ffi::c_void, + v: core::ffi::c_float, + q: core::ffi::c_float, + r: core::ffi::c_float, + ); + } + unsafe { vtk_math_rotate_vector_by_normalized_quaternion(self.0, v, q, r) } + } + fn rotate_vector_by_normalized_quaternion( + &mut self, + v: core::ffi::c_double, + q: core::ffi::c_double, + r: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_rotate_vector_by_normalized_quaternion( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + q: core::ffi::c_double, + r: core::ffi::c_double, + ); + } + unsafe { vtk_math_rotate_vector_by_normalized_quaternion(self.0, v, q, r) } + } + fn rotate_vector_by_wxyz( + &mut self, + v: core::ffi::c_float, + q: core::ffi::c_float, + r: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_rotate_vector_by_wxyz( + sself: *mut core::ffi::c_void, + v: core::ffi::c_float, + q: core::ffi::c_float, + r: core::ffi::c_float, + ); + } + unsafe { vtk_math_rotate_vector_by_wxyz(self.0, v, q, r) } + } + fn rotate_vector_by_wxyz( + &mut self, + v: core::ffi::c_double, + q: core::ffi::c_double, + r: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_rotate_vector_by_wxyz( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + q: core::ffi::c_double, + r: core::ffi::c_double, + ); + } + unsafe { vtk_math_rotate_vector_by_wxyz(self.0, v, q, r) } + } + fn orthogonalize_3_x_3( + &mut self, + A: core::ffi::c_float, + B: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_orthogonalize_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + B: core::ffi::c_float, + ); + } + unsafe { vtk_math_orthogonalize_3_x_3(self.0, A, B) } + } + fn orthogonalize_3_x_3( + &mut self, + A: core::ffi::c_double, + B: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_orthogonalize_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + B: core::ffi::c_double, + ); + } + unsafe { vtk_math_orthogonalize_3_x_3(self.0, A, B) } + } + fn diagonalize_3_x_3( + &mut self, + A: core::ffi::c_float, + w: core::ffi::c_float, + V: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_diagonalize_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + w: core::ffi::c_float, + V: core::ffi::c_float, + ); + } + unsafe { vtk_math_diagonalize_3_x_3(self.0, A, w, V) } + } + fn diagonalize_3_x_3( + &mut self, + A: core::ffi::c_double, + w: core::ffi::c_double, + V: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_diagonalize_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + w: core::ffi::c_double, + V: core::ffi::c_double, + ); + } + unsafe { vtk_math_diagonalize_3_x_3(self.0, A, w, V) } + } + fn singular_value_decomposition_3_x_3( + &mut self, + A: core::ffi::c_float, + U: core::ffi::c_float, + w: core::ffi::c_float, + VT: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_singular_value_decomposition_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_float, + U: core::ffi::c_float, + w: core::ffi::c_float, + VT: core::ffi::c_float, + ); + } + unsafe { vtk_math_singular_value_decomposition_3_x_3(self.0, A, U, w, VT) } + } + fn singular_value_decomposition_3_x_3( + &mut self, + A: core::ffi::c_double, + U: core::ffi::c_double, + w: core::ffi::c_double, + VT: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_singular_value_decomposition_3_x_3( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + U: core::ffi::c_double, + w: core::ffi::c_double, + VT: core::ffi::c_double, + ); + } + unsafe { vtk_math_singular_value_decomposition_3_x_3(self.0, A, U, w, VT) } + } + fn solve_linear_system_gepp_2_x_2( + &mut self, + a00: core::ffi::c_double, + a01: core::ffi::c_double, + a10: core::ffi::c_double, + a11: core::ffi::c_double, + b0: core::ffi::c_double, + b1: core::ffi::c_double, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_solve_linear_system_gepp_2_x_2( + sself: *mut core::ffi::c_void, + a00: core::ffi::c_double, + a01: core::ffi::c_double, + a10: core::ffi::c_double, + a11: core::ffi::c_double, + b0: core::ffi::c_double, + b1: core::ffi::c_double, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_math_solve_linear_system_gepp_2_x_2( + self.0, + a00, + a01, + a10, + a11, + b0, + b1, + x0, + x1, + ) + } + } + fn solve_linear_system( + &mut self, + A: core::ffi::c_double, + x: core::ffi::c_double, + size: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_solve_linear_system( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + x: core::ffi::c_double, + size: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_solve_linear_system(self.0, A, x, size) } + } + fn invert_matrix( + &mut self, + A: core::ffi::c_double, + AI: core::ffi::c_double, + size: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_invert_matrix( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + AI: core::ffi::c_double, + size: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_invert_matrix(self.0, A, AI, size) } + } + fn invert_matrix( + &mut self, + A: core::ffi::c_double, + AI: core::ffi::c_double, + size: core::ffi::c_int, + tmp1Size: core::ffi::c_int, + tmp2Size: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_invert_matrix( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + AI: core::ffi::c_double, + size: core::ffi::c_int, + tmp1Size: core::ffi::c_int, + tmp2Size: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_invert_matrix(self.0, A, AI, size, tmp1Size, tmp2Size) } + } + fn lu_factor_linear_system( + &mut self, + A: core::ffi::c_double, + index: core::ffi::c_int, + size: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_lu_factor_linear_system( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + index: core::ffi::c_int, + size: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_lu_factor_linear_system(self.0, A, index, size) } + } + fn lu_factor_linear_system( + &mut self, + A: core::ffi::c_double, + index: core::ffi::c_int, + size: core::ffi::c_int, + tmpSize: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_lu_factor_linear_system( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + index: core::ffi::c_int, + size: core::ffi::c_int, + tmpSize: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_lu_factor_linear_system(self.0, A, index, size, tmpSize) } + } + fn lu_solve_linear_system( + &mut self, + A: core::ffi::c_double, + index: core::ffi::c_int, + x: core::ffi::c_double, + size: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_math_lu_solve_linear_system( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + index: core::ffi::c_int, + x: core::ffi::c_double, + size: core::ffi::c_int, + ); + } + unsafe { vtk_math_lu_solve_linear_system(self.0, A, index, x, size) } + } + fn estimate_matrix_condition( + &mut self, + A: core::ffi::c_double, + size: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_estimate_matrix_condition( + sself: *mut core::ffi::c_void, + A: core::ffi::c_double, + size: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_estimate_matrix_condition(self.0, A, size) } + } + fn jacobi( + &mut self, + a: core::ffi::c_float, + w: core::ffi::c_float, + v: core::ffi::c_float, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_jacobi( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + w: core::ffi::c_float, + v: core::ffi::c_float, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_jacobi(self.0, a, w, v) } + } + fn jacobi( + &mut self, + a: core::ffi::c_double, + w: core::ffi::c_double, + v: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_jacobi( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + w: core::ffi::c_double, + v: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_jacobi(self.0, a, w, v) } + } + fn jacobi_n( + &mut self, + a: core::ffi::c_float, + n: core::ffi::c_int, + w: core::ffi::c_float, + v: core::ffi::c_float, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_jacobi_n( + sself: *mut core::ffi::c_void, + a: core::ffi::c_float, + n: core::ffi::c_int, + w: core::ffi::c_float, + v: core::ffi::c_float, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_jacobi_n(self.0, a, n, w, v) } + } + fn jacobi_n( + &mut self, + a: core::ffi::c_double, + n: core::ffi::c_int, + w: core::ffi::c_double, + v: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_jacobi_n( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + n: core::ffi::c_int, + w: core::ffi::c_double, + v: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_jacobi_n(self.0, a, n, w, v) } + } + fn solve_homogeneous_least_squares( + &mut self, + numberOfSamples: core::ffi::c_int, + xt: core::ffi::c_double, + xOrder: core::ffi::c_int, + mt: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_solve_homogeneous_least_squares( + sself: *mut core::ffi::c_void, + numberOfSamples: core::ffi::c_int, + xt: core::ffi::c_double, + xOrder: core::ffi::c_int, + mt: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_math_solve_homogeneous_least_squares( + self.0, + numberOfSamples, + xt, + xOrder, + mt, + ) + } + } + fn solve_least_squares( + &mut self, + numberOfSamples: core::ffi::c_int, + xt: core::ffi::c_double, + xOrder: core::ffi::c_int, + yt: core::ffi::c_double, + yOrder: core::ffi::c_int, + mt: core::ffi::c_double, + checkHomogeneous: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_solve_least_squares( + sself: *mut core::ffi::c_void, + numberOfSamples: core::ffi::c_int, + xt: core::ffi::c_double, + xOrder: core::ffi::c_int, + yt: core::ffi::c_double, + yOrder: core::ffi::c_int, + mt: core::ffi::c_double, + checkHomogeneous: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_math_solve_least_squares( + self.0, + numberOfSamples, + xt, + xOrder, + yt, + yOrder, + mt, + checkHomogeneous, + ) + } + } + fn rgb_to_hsv(&mut self, rgb: core::ffi::c_float, hsv: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_math_rgb_to_hsv( + sself: *mut core::ffi::c_void, + rgb: core::ffi::c_float, + hsv: core::ffi::c_float, + ); + } + unsafe { vtk_math_rgb_to_hsv(self.0, rgb, hsv) } + } + fn rgb_to_hsv( + &mut self, + r: core::ffi::c_float, + g: core::ffi::c_float, + b: core::ffi::c_float, + h: core::ffi::c_float, + s: core::ffi::c_float, + v: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_rgb_to_hsv( + sself: *mut core::ffi::c_void, + r: core::ffi::c_float, + g: core::ffi::c_float, + b: core::ffi::c_float, + h: core::ffi::c_float, + s: core::ffi::c_float, + v: core::ffi::c_float, + ); + } + unsafe { vtk_math_rgb_to_hsv(self.0, r, g, b, h, s, v) } + } + fn rgb_to_hsv(&mut self, rgb: core::ffi::c_double, hsv: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_rgb_to_hsv( + sself: *mut core::ffi::c_void, + rgb: core::ffi::c_double, + hsv: core::ffi::c_double, + ); + } + unsafe { vtk_math_rgb_to_hsv(self.0, rgb, hsv) } + } + fn rgb_to_hsv( + &mut self, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + h: core::ffi::c_double, + s: core::ffi::c_double, + v: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_rgb_to_hsv( + sself: *mut core::ffi::c_void, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + h: core::ffi::c_double, + s: core::ffi::c_double, + v: core::ffi::c_double, + ); + } + unsafe { vtk_math_rgb_to_hsv(self.0, r, g, b, h, s, v) } + } + fn hsv_to_rgb(&mut self, hsv: core::ffi::c_float, rgb: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_math_hsv_to_rgb( + sself: *mut core::ffi::c_void, + hsv: core::ffi::c_float, + rgb: core::ffi::c_float, + ); + } + unsafe { vtk_math_hsv_to_rgb(self.0, hsv, rgb) } + } + fn hsv_to_rgb( + &mut self, + h: core::ffi::c_float, + s: core::ffi::c_float, + v: core::ffi::c_float, + r: core::ffi::c_float, + g: core::ffi::c_float, + b: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_math_hsv_to_rgb( + sself: *mut core::ffi::c_void, + h: core::ffi::c_float, + s: core::ffi::c_float, + v: core::ffi::c_float, + r: core::ffi::c_float, + g: core::ffi::c_float, + b: core::ffi::c_float, + ); + } + unsafe { vtk_math_hsv_to_rgb(self.0, h, s, v, r, g, b) } + } + fn hsv_to_rgb(&mut self, hsv: core::ffi::c_double, rgb: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_hsv_to_rgb( + sself: *mut core::ffi::c_void, + hsv: core::ffi::c_double, + rgb: core::ffi::c_double, + ); + } + unsafe { vtk_math_hsv_to_rgb(self.0, hsv, rgb) } + } + fn hsv_to_rgb( + &mut self, + h: core::ffi::c_double, + s: core::ffi::c_double, + v: core::ffi::c_double, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_hsv_to_rgb( + sself: *mut core::ffi::c_void, + h: core::ffi::c_double, + s: core::ffi::c_double, + v: core::ffi::c_double, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + ); + } + unsafe { vtk_math_hsv_to_rgb(self.0, h, s, v, r, g, b) } + } + fn lab_to_xyz(&mut self, lab: core::ffi::c_double, xyz: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_lab_to_xyz( + sself: *mut core::ffi::c_void, + lab: core::ffi::c_double, + xyz: core::ffi::c_double, + ); + } + unsafe { vtk_math_lab_to_xyz(self.0, lab, xyz) } + } + fn lab_to_xyz( + &mut self, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_lab_to_xyz( + sself: *mut core::ffi::c_void, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_math_lab_to_xyz(self.0, L, a, b, x, y, z) } + } + fn xyz_to_lab(&mut self, xyz: core::ffi::c_double, lab: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_xyz_to_lab( + sself: *mut core::ffi::c_void, + xyz: core::ffi::c_double, + lab: core::ffi::c_double, + ); + } + unsafe { vtk_math_xyz_to_lab(self.0, xyz, lab) } + } + fn xyz_to_lab( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_xyz_to_lab( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + ); + } + unsafe { vtk_math_xyz_to_lab(self.0, x, y, z, L, a, b) } + } + fn xyz_to_rgb(&mut self, xyz: core::ffi::c_double, rgb: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_xyz_to_rgb( + sself: *mut core::ffi::c_void, + xyz: core::ffi::c_double, + rgb: core::ffi::c_double, + ); + } + unsafe { vtk_math_xyz_to_rgb(self.0, xyz, rgb) } + } + fn xyz_to_rgb( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_xyz_to_rgb( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + ); + } + unsafe { vtk_math_xyz_to_rgb(self.0, x, y, z, r, g, b) } + } + fn rgb_to_xyz(&mut self, rgb: core::ffi::c_double, xyz: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_rgb_to_xyz( + sself: *mut core::ffi::c_void, + rgb: core::ffi::c_double, + xyz: core::ffi::c_double, + ); + } + unsafe { vtk_math_rgb_to_xyz(self.0, rgb, xyz) } + } + fn rgb_to_xyz( + &mut self, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_rgb_to_xyz( + sself: *mut core::ffi::c_void, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_math_rgb_to_xyz(self.0, r, g, b, x, y, z) } + } + fn rgb_to_lab(&mut self, rgb: core::ffi::c_double, lab: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_rgb_to_lab( + sself: *mut core::ffi::c_void, + rgb: core::ffi::c_double, + lab: core::ffi::c_double, + ); + } + unsafe { vtk_math_rgb_to_lab(self.0, rgb, lab) } + } + fn rgb_to_lab( + &mut self, + red: core::ffi::c_double, + green: core::ffi::c_double, + blue: core::ffi::c_double, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_rgb_to_lab( + sself: *mut core::ffi::c_void, + red: core::ffi::c_double, + green: core::ffi::c_double, + blue: core::ffi::c_double, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + ); + } + unsafe { vtk_math_rgb_to_lab(self.0, red, green, blue, L, a, b) } + } + fn lab_to_rgb(&mut self, lab: core::ffi::c_double, rgb: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_lab_to_rgb( + sself: *mut core::ffi::c_void, + lab: core::ffi::c_double, + rgb: core::ffi::c_double, + ); + } + unsafe { vtk_math_lab_to_rgb(self.0, lab, rgb) } + } + fn lab_to_rgb( + &mut self, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + red: core::ffi::c_double, + green: core::ffi::c_double, + blue: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_lab_to_rgb( + sself: *mut core::ffi::c_void, + L: core::ffi::c_double, + a: core::ffi::c_double, + b: core::ffi::c_double, + red: core::ffi::c_double, + green: core::ffi::c_double, + blue: core::ffi::c_double, + ); + } + unsafe { vtk_math_lab_to_rgb(self.0, L, a, b, red, green, blue) } + } + fn uninitialize_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_math_uninitialize_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_math_uninitialize_bounds(self.0, bounds) } + } + fn are_bounds_initialized( + &mut self, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_are_bounds_initialized( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_are_bounds_initialized(self.0, bounds) } + } + fn clamp_value( + &mut self, + value: core::ffi::c_double, + range: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_clamp_value( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + range: core::ffi::c_double, + ); + } + unsafe { vtk_math_clamp_value(self.0, value, range) } + } + fn clamp_value( + &mut self, + value: core::ffi::c_double, + range: core::ffi::c_double, + clamped_value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_clamp_value( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + range: core::ffi::c_double, + clamped_value: core::ffi::c_double, + ); + } + unsafe { vtk_math_clamp_value(self.0, value, range, clamped_value) } + } + fn clamp_values( + &mut self, + values: core::ffi::c_double, + nb_values: core::ffi::c_int, + range: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_clamp_values( + sself: *mut core::ffi::c_void, + values: core::ffi::c_double, + nb_values: core::ffi::c_int, + range: core::ffi::c_double, + ); + } + unsafe { vtk_math_clamp_values(self.0, values, nb_values, range) } + } + fn clamp_values( + &mut self, + values: core::ffi::c_double, + nb_values: core::ffi::c_int, + range: core::ffi::c_double, + clamped_values: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_math_clamp_values( + sself: *mut core::ffi::c_void, + values: core::ffi::c_double, + nb_values: core::ffi::c_int, + range: core::ffi::c_double, + clamped_values: core::ffi::c_double, + ); + } + unsafe { + vtk_math_clamp_values(self.0, values, nb_values, range, clamped_values) + } + } + fn clamp_and_normalize_value( + &mut self, + value: core::ffi::c_double, + range: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_clamp_and_normalize_value( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + range: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_clamp_and_normalize_value(self.0, value, range) } + } + fn get_scalar_type_fitting_range( + &mut self, + range_min: core::ffi::c_double, + range_max: core::ffi::c_double, + scale: core::ffi::c_double, + shift: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_get_scalar_type_fitting_range( + sself: *mut core::ffi::c_void, + range_min: core::ffi::c_double, + range_max: core::ffi::c_double, + scale: core::ffi::c_double, + shift: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_math_get_scalar_type_fitting_range( + self.0, + range_min, + range_max, + scale, + shift, + ) + } + } + fn get_adjusted_scalar_range( + &mut self, + array: *mut core::ffi::c_void, + comp: core::ffi::c_int, + range: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_get_adjusted_scalar_range( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + comp: core::ffi::c_int, + range: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_get_adjusted_scalar_range(self.0, array, comp, range) } + } + fn extent_is_within_other_extent( + &mut self, + extent1: core::ffi::c_int, + extent2: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_extent_is_within_other_extent( + sself: *mut core::ffi::c_void, + extent1: core::ffi::c_int, + extent2: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_extent_is_within_other_extent(self.0, extent1, extent2) } + } + fn bounds_is_within_other_bounds( + &mut self, + bounds1: core::ffi::c_double, + bounds2: core::ffi::c_double, + delta: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_bounds_is_within_other_bounds( + sself: *mut core::ffi::c_void, + bounds1: core::ffi::c_double, + bounds2: core::ffi::c_double, + delta: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_math_bounds_is_within_other_bounds(self.0, bounds1, bounds2, delta) + } + } + fn point_is_within_bounds( + &mut self, + point: core::ffi::c_double, + bounds: core::ffi::c_double, + delta: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_point_is_within_bounds( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + bounds: core::ffi::c_double, + delta: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_point_is_within_bounds(self.0, point, bounds, delta) } + } + fn plane_intersects_aabb( + &mut self, + bounds: core::ffi::c_double, + normal: core::ffi::c_double, + point: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_plane_intersects_aabb( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + normal: core::ffi::c_double, + point: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_plane_intersects_aabb(self.0, bounds, normal, point) } + } + fn solve_3_point_circle( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_solve_3_point_circle( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_solve_3_point_circle(self.0, p1, p2, p3, center) } + } + fn inf(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_inf(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_inf(self.0) } + } + fn neg_inf(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_neg_inf(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_neg_inf(self.0) } + } + fn nan(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_nan(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_nan(self.0) } + } + fn is_inf(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_is_inf( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_is_inf(self.0, x) } + } + fn is_nan(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_is_nan( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_is_nan(self.0, x) } + } + fn is_finite(&mut self, x: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_math_is_finite( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_math_is_finite(self.0, x) } + } + fn quadratic_root( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + min: core::ffi::c_double, + max: core::ffi::c_double, + u: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_quadratic_root( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + min: core::ffi::c_double, + max: core::ffi::c_double, + u: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_quadratic_root(self.0, a, b, c, min, max, u) } + } +} +impl VtkMersenneTwister for vtkMersenneTwister { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mersenne_twister_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mersenne_twister_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mersenne_twister_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mersenne_twister_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mersenne_twister_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mersenne_twister_new_instance(self.0) } + } + fn initialize(&mut self, seed: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_mersenne_twister_initialize( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_uint, + ); + } + unsafe { vtk_mersenne_twister_initialize(self.0, seed) } + } + fn initialize_new_sequence( + &mut self, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_mersenne_twister_initialize_new_sequence( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> core::ffi::c_uint; + } + unsafe { vtk_mersenne_twister_initialize_new_sequence(self.0, seed, p) } + } + fn initialize_sequence( + &mut self, + id: core::ffi::c_uint, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_mersenne_twister_initialize_sequence( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uint, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ); + } + unsafe { vtk_mersenne_twister_initialize_sequence(self.0, id, seed, p) } + } + fn get_value(&mut self, id: core::ffi::c_uint) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_mersenne_twister_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uint, + ) -> core::ffi::c_double; + } + unsafe { vtk_mersenne_twister_get_value(self.0, id) } + } + fn get_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_mersenne_twister_get_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_mersenne_twister_get_value(self.0) } + } + fn next(&mut self, id: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_mersenne_twister_next( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uint, + ); + } + unsafe { vtk_mersenne_twister_next(self.0, id) } + } + fn next(&mut self) -> () { + unsafe extern "C" { + fn vtk_mersenne_twister_next(sself: *mut core::ffi::c_void); + } + unsafe { vtk_mersenne_twister_next(self.0) } + } +} +impl VtkMinimalStandardRandomSequence for vtkMinimalStandardRandomSequence { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_minimal_standard_random_sequence_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_minimal_standard_random_sequence_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_minimal_standard_random_sequence_new_instance(self.0) } + } + fn initialize(&mut self, seed: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_initialize( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_uint, + ); + } + unsafe { vtk_minimal_standard_random_sequence_initialize(self.0, seed) } + } + fn set_seed(&mut self, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_set_seed( + sself: *mut core::ffi::c_void, + value: core::ffi::c_int, + ); + } + unsafe { vtk_minimal_standard_random_sequence_set_seed(self.0, value) } + } + fn set_seed_only(&mut self, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_set_seed_only( + sself: *mut core::ffi::c_void, + value: core::ffi::c_int, + ); + } + unsafe { vtk_minimal_standard_random_sequence_set_seed_only(self.0, value) } + } + fn get_seed(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_get_seed( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_minimal_standard_random_sequence_get_seed(self.0) } + } + fn get_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_get_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_minimal_standard_random_sequence_get_value(self.0) } + } + fn next(&mut self) -> () { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_next(sself: *mut core::ffi::c_void); + } + unsafe { vtk_minimal_standard_random_sequence_next(self.0) } + } + fn get_range_value( + &mut self, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_get_range_value( + sself: *mut core::ffi::c_void, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_minimal_standard_random_sequence_get_range_value( + self.0, + rangeMin, + rangeMax, + ) + } + } + fn get_next_range_value( + &mut self, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_get_next_range_value( + sself: *mut core::ffi::c_void, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_minimal_standard_random_sequence_get_next_range_value( + self.0, + rangeMin, + rangeMax, + ) + } + } +} +impl VtkMultiThreader for vtkMultiThreader { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_threader_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_threader_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_threader_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_threader_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_threader_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_threader_new_instance(self.0) } + } + fn set_number_of_threads(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_multi_threader_set_number_of_threads( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_multi_threader_set_number_of_threads(self.0, _arg) } + } + fn get_number_of_threads_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_number_of_threads_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_number_of_threads_min_value(self.0) } + } + fn get_number_of_threads_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_number_of_threads_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_number_of_threads_max_value(self.0) } + } + fn get_number_of_threads(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_number_of_threads( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_number_of_threads(self.0) } + } + fn get_global_static_maximum_number_of_threads(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_global_static_maximum_number_of_threads( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_global_static_maximum_number_of_threads(self.0) } + } + fn set_global_maximum_number_of_threads(&mut self, val: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_multi_threader_set_global_maximum_number_of_threads( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ); + } + unsafe { vtk_multi_threader_set_global_maximum_number_of_threads(self.0, val) } + } + fn get_global_maximum_number_of_threads(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_global_maximum_number_of_threads( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_global_maximum_number_of_threads(self.0) } + } + fn set_global_default_number_of_threads(&mut self, val: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_multi_threader_set_global_default_number_of_threads( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ); + } + unsafe { vtk_multi_threader_set_global_default_number_of_threads(self.0, val) } + } + fn get_global_default_number_of_threads(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_global_default_number_of_threads( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_global_default_number_of_threads(self.0) } + } + fn single_method_execute(&mut self) -> () { + unsafe extern "C" { + fn vtk_multi_threader_single_method_execute(sself: *mut core::ffi::c_void); + } + unsafe { vtk_multi_threader_single_method_execute(self.0) } + } + fn multiple_method_execute(&mut self) -> () { + unsafe extern "C" { + fn vtk_multi_threader_multiple_method_execute(sself: *mut core::ffi::c_void); + } + unsafe { vtk_multi_threader_multiple_method_execute(self.0) } + } + fn set_single_method(&mut self, p0: *mut core::ffi::c_void, data: ()) -> () { + unsafe extern "C" { + fn vtk_multi_threader_set_single_method( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + data: (), + ); + } + unsafe { vtk_multi_threader_set_single_method(self.0, p0, data) } + } + fn set_multiple_method( + &mut self, + index: core::ffi::c_int, + p1: *mut core::ffi::c_void, + data: (), + ) -> () { + unsafe extern "C" { + fn vtk_multi_threader_set_multiple_method( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + p1: *mut core::ffi::c_void, + data: (), + ); + } + unsafe { vtk_multi_threader_set_multiple_method(self.0, index, p1, data) } + } + fn spawn_thread( + &mut self, + p0: *mut core::ffi::c_void, + data: (), + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_spawn_thread( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + data: (), + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_spawn_thread(self.0, p0, data) } + } + fn terminate_thread(&mut self, threadId: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_multi_threader_terminate_thread( + sself: *mut core::ffi::c_void, + threadId: core::ffi::c_int, + ); + } + unsafe { vtk_multi_threader_terminate_thread(self.0, threadId) } + } + fn is_thread_active(&mut self, threadId: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_is_thread_active( + sself: *mut core::ffi::c_void, + threadId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_is_thread_active(self.0, threadId) } + } + fn get_current_thread_id(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_threader_get_current_thread_id( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_threader_get_current_thread_id(self.0) } + } + fn threads_equal( + &mut self, + t1: *mut core::ffi::c_void, + t2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_threads_equal( + sself: *mut core::ffi::c_void, + t1: *mut core::ffi::c_void, + t2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_threads_equal(self.0, t1, t2) } + } +} +impl VtkObject for vtkObject { + fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_is_type_of( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_is_type_of(self.0, type_) } + } + fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_is_a( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_is_a(self.0, type_) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_new_instance(self.0) } + } + fn get_number_of_generations_from_base_type( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_object_get_number_of_generations_from_base_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_object_get_number_of_generations_from_base_type(self.0, type_) } + } + fn get_number_of_generations_from_base( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_object_get_number_of_generations_from_base( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_char, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_object_get_number_of_generations_from_base(self.0, type_) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_new(self.0) } + } + fn debug_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_debug_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_debug_on(self.0) } + } + fn debug_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_debug_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_debug_off(self.0) } + } + fn get_debug(&mut self) -> bool { + unsafe extern "C" { + fn vtk_object_get_debug(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_object_get_debug(self.0) } + } + fn set_debug(&mut self, debugFlag: bool) -> () { + unsafe extern "C" { + fn vtk_object_set_debug(sself: *mut core::ffi::c_void, debugFlag: bool); + } + unsafe { vtk_object_set_debug(self.0, debugFlag) } + } + fn break_on_error(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_break_on_error(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_break_on_error(self.0) } + } + fn modified(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_modified(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_modified(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_object_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_object_get_m_time(self.0) } + } + fn set_global_warning_display(&mut self, val: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_object_set_global_warning_display( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ); + } + unsafe { vtk_object_set_global_warning_display(self.0, val) } + } + fn global_warning_display_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_global_warning_display_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_global_warning_display_on(self.0) } + } + fn global_warning_display_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_global_warning_display_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_global_warning_display_off(self.0) } + } + fn get_global_warning_display(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_get_global_warning_display( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_get_global_warning_display(self.0) } + } + fn add_observer( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + priority: core::ffi::c_float, + ) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_object_add_observer( + sself: *mut core::ffi::c_void, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + priority: core::ffi::c_float, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_object_add_observer(self.0, event, p1, priority) } + } + fn add_observer( + &mut self, + event: core::ffi::c_char, + p1: *mut core::ffi::c_void, + priority: core::ffi::c_float, + ) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_object_add_observer( + sself: *mut core::ffi::c_void, + event: core::ffi::c_char, + p1: *mut core::ffi::c_void, + priority: core::ffi::c_float, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_object_add_observer(self.0, event, p1, priority) } + } + fn get_command(&mut self, tag: core::ffi::c_ulong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_get_command( + sself: *mut core::ffi::c_void, + tag: core::ffi::c_ulong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_get_command(self.0, tag) } + } + fn remove_observer(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_object_remove_observer( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_object_remove_observer(self.0, p0) } + } + fn remove_observers( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_object_remove_observers( + sself: *mut core::ffi::c_void, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_object_remove_observers(self.0, event, p1) } + } + fn remove_observers( + &mut self, + event: core::ffi::c_char, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_object_remove_observers( + sself: *mut core::ffi::c_void, + event: core::ffi::c_char, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_object_remove_observers(self.0, event, p1) } + } + fn has_observer( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_has_observer( + sself: *mut core::ffi::c_void, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_has_observer(self.0, event, p1) } + } + fn has_observer( + &mut self, + event: core::ffi::c_char, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_has_observer( + sself: *mut core::ffi::c_void, + event: core::ffi::c_char, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_has_observer(self.0, event, p1) } + } + fn remove_observer(&mut self, tag: core::ffi::c_ulong) -> () { + unsafe extern "C" { + fn vtk_object_remove_observer( + sself: *mut core::ffi::c_void, + tag: core::ffi::c_ulong, + ); + } + unsafe { vtk_object_remove_observer(self.0, tag) } + } + fn remove_observers(&mut self, event: core::ffi::c_ulong) -> () { + unsafe extern "C" { + fn vtk_object_remove_observers( + sself: *mut core::ffi::c_void, + event: core::ffi::c_ulong, + ); + } + unsafe { vtk_object_remove_observers(self.0, event) } + } + fn remove_observers(&mut self, event: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_object_remove_observers( + sself: *mut core::ffi::c_void, + event: core::ffi::c_char, + ); + } + unsafe { vtk_object_remove_observers(self.0, event) } + } + fn remove_all_observers(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_remove_all_observers(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_remove_all_observers(self.0) } + } + fn has_observer(&mut self, event: core::ffi::c_ulong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_has_observer( + sself: *mut core::ffi::c_void, + event: core::ffi::c_ulong, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_has_observer(self.0, event) } + } + fn has_observer(&mut self, event: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_has_observer( + sself: *mut core::ffi::c_void, + event: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_has_observer(self.0, event) } + } + fn invoke_event( + &mut self, + event: core::ffi::c_ulong, + callData: (), + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_invoke_event( + sself: *mut core::ffi::c_void, + event: core::ffi::c_ulong, + callData: (), + ) -> core::ffi::c_int; + } + unsafe { vtk_object_invoke_event(self.0, event, callData) } + } + fn invoke_event( + &mut self, + event: core::ffi::c_char, + callData: (), + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_invoke_event( + sself: *mut core::ffi::c_void, + event: core::ffi::c_char, + callData: (), + ) -> core::ffi::c_int; + } + unsafe { vtk_object_invoke_event(self.0, event, callData) } + } + fn invoke_event(&mut self, event: core::ffi::c_ulong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_invoke_event( + sself: *mut core::ffi::c_void, + event: core::ffi::c_ulong, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_invoke_event(self.0, event) } + } + fn invoke_event(&mut self, event: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_invoke_event( + sself: *mut core::ffi::c_void, + event: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_invoke_event(self.0, event) } + } +} +impl VtkObjectFactoryCollection for vtkObjectFactoryCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_factory_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_factory_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_factory_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_factory_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_factory_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_factory_collection_new(self.0) } + } + fn add_item(&mut self, t: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_object_factory_collection_add_item( + sself: *mut core::ffi::c_void, + t: *mut core::ffi::c_void, + ); + } + unsafe { vtk_object_factory_collection_add_item(self.0, t) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_factory_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_factory_collection_get_next_item(self.0) } + } + fn get_next_object_factory(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_factory_collection_get_next_object_factory( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_factory_collection_get_next_object_factory(self.0, cookie) } + } +} +impl VtkOldStyleCallbackCommand for vtkOldStyleCallbackCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_old_style_callback_command_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_old_style_callback_command_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_old_style_callback_command_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_old_style_callback_command_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_old_style_callback_command_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_old_style_callback_command_new(self.0) } + } + fn execute( + &mut self, + invoker: *mut core::ffi::c_void, + eid: core::ffi::c_ulong, + calldata: (), + ) -> () { + unsafe extern "C" { + fn vtk_old_style_callback_command_execute( + sself: *mut core::ffi::c_void, + invoker: *mut core::ffi::c_void, + eid: core::ffi::c_ulong, + calldata: (), + ); + } + unsafe { vtk_old_style_callback_command_execute(self.0, invoker, eid, calldata) } + } + fn set_client_data(&mut self, cd: ()) -> () { + unsafe extern "C" { + fn vtk_old_style_callback_command_set_client_data( + sself: *mut core::ffi::c_void, + cd: (), + ); + } + unsafe { vtk_old_style_callback_command_set_client_data(self.0, cd) } + } + fn set_callback(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_old_style_callback_command_set_callback( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_old_style_callback_command_set_callback(self.0, f) } + } + fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_old_style_callback_command_set_client_data_delete_callback( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_old_style_callback_command_set_client_data_delete_callback(self.0, f) + } + } +} +impl VtkOutputWindow for vtkOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_output_window_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_output_window_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_output_window_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_output_window_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_output_window_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_output_window_new(self.0) } + } + fn get_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_output_window_get_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_output_window_get_instance(self.0) } + } + fn set_instance(&mut self, instance: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_output_window_set_instance( + sself: *mut core::ffi::c_void, + instance: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_set_instance(self.0, instance) } + } + fn display_text(&mut self, p0: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_output_window_display_text( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ); + } + unsafe { vtk_output_window_display_text(self.0, p0) } + } + fn display_error_text(&mut self, p0: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_output_window_display_error_text( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ); + } + unsafe { vtk_output_window_display_error_text(self.0, p0) } + } + fn display_warning_text(&mut self, p0: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_output_window_display_warning_text( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ); + } + unsafe { vtk_output_window_display_warning_text(self.0, p0) } + } + fn display_generic_warning_text(&mut self, p0: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_output_window_display_generic_warning_text( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ); + } + unsafe { vtk_output_window_display_generic_warning_text(self.0, p0) } + } + fn display_debug_text(&mut self, p0: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_output_window_display_debug_text( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ); + } + unsafe { vtk_output_window_display_debug_text(self.0, p0) } + } + fn prompt_user_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_prompt_user_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_output_window_prompt_user_on(self.0) } + } + fn prompt_user_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_prompt_user_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_output_window_prompt_user_off(self.0) } + } + fn set_prompt_user(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_output_window_set_prompt_user( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_output_window_set_prompt_user(self.0, _arg) } + } + fn set_use_std_error_for_all_messages(&mut self, p0: bool) -> () { + unsafe extern "C" { + fn vtk_output_window_set_use_std_error_for_all_messages( + sself: *mut core::ffi::c_void, + p0: bool, + ); + } + unsafe { vtk_output_window_set_use_std_error_for_all_messages(self.0, p0) } + } + fn get_use_std_error_for_all_messages(&mut self) -> bool { + unsafe extern "C" { + fn vtk_output_window_get_use_std_error_for_all_messages( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_output_window_get_use_std_error_for_all_messages(self.0) } + } + fn use_std_error_for_all_messages_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_use_std_error_for_all_messages_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_use_std_error_for_all_messages_on(self.0) } + } + fn use_std_error_for_all_messages_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_use_std_error_for_all_messages_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_use_std_error_for_all_messages_off(self.0) } + } + fn set_display_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_output_window_set_display_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_output_window_set_display_mode(self.0, _arg) } + } + fn get_display_mode_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_output_window_get_display_mode_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_output_window_get_display_mode_min_value(self.0) } + } + fn get_display_mode_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_output_window_get_display_mode_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_output_window_get_display_mode_max_value(self.0) } + } + fn get_display_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_output_window_get_display_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_output_window_get_display_mode(self.0) } + } + fn set_display_mode_to_default(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_set_display_mode_to_default( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_set_display_mode_to_default(self.0) } + } + fn set_display_mode_to_never(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_set_display_mode_to_never( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_set_display_mode_to_never(self.0) } + } + fn set_display_mode_to_always(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_set_display_mode_to_always( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_set_display_mode_to_always(self.0) } + } + fn set_display_mode_to_always_std_err(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_set_display_mode_to_always_std_err( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_set_display_mode_to_always_std_err(self.0) } + } +} +impl VtkOverrideInformationCollection for vtkOverrideInformationCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_override_information_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_override_information_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_override_information_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_override_information_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_override_information_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_override_information_collection_new(self.0) } + } + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_override_information_collection_add_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_override_information_collection_add_item(self.0, p0) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_override_information_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_override_information_collection_get_next_item(self.0) } + } + fn get_next_override_information(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_override_information_collection_get_next_override_information( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_override_information_collection_get_next_override_information( + self.0, + cookie, + ) + } + } +} +impl VtkPoints for vtkPoints { + fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_new( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_new(self.0, dataType) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_initialize(self.0) } + } + fn set_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_set_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_set_data(self.0, p0) } + } + fn get_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_get_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_get_data(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_get_data_type(self.0) } + } + fn set_data_type(&mut self, dataType: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + ); + } + unsafe { vtk_points_set_data_type(self.0, dataType) } + } + fn set_data_type_to_bit(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_bit(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_bit(self.0) } + } + fn set_data_type_to_char(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_char(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_char(self.0) } + } + fn set_data_type_to_unsigned_char(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_unsigned_char(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_unsigned_char(self.0) } + } + fn set_data_type_to_short(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_short(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_short(self.0) } + } + fn set_data_type_to_unsigned_short(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_unsigned_short(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_unsigned_short(self.0) } + } + fn set_data_type_to_int(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_int(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_int(self.0) } + } + fn set_data_type_to_unsigned_int(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_unsigned_int(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_unsigned_int(self.0) } + } + fn set_data_type_to_long(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_long(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_long(self.0) } + } + fn set_data_type_to_unsigned_long(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_unsigned_long(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_unsigned_long(self.0) } + } + fn set_data_type_to_float(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_float(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_float(self.0) } + } + fn set_data_type_to_double(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_double(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_double(self.0) } + } + fn get_void_pointer(&mut self, id: core::ffi::c_int) -> *mut () { + unsafe extern "C" { + fn vtk_points_get_void_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ) -> *mut (); + } + unsafe { vtk_points_get_void_pointer(self.0, id) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_reset(self.0) } + } + fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_deep_copy( + sself: *mut core::ffi::c_void, + ad: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_deep_copy(self.0, ad) } + } + fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_shallow_copy( + sself: *mut core::ffi::c_void, + ad: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_shallow_copy(self.0, ad) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_points_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_points_get_actual_memory_size(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_points_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_points_get_number_of_points(self.0) } + } + fn get_point(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_points_get_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_points_get_point(self.0, id) } + } + fn get_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_points_get_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + ); + } + unsafe { vtk_points_get_point(self.0, id, x) } + } + fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_points_set_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_float, + ); + } + unsafe { vtk_points_set_point(self.0, id, x) } + } + fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_points_set_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + ); + } + unsafe { vtk_points_set_point(self.0, id, x) } + } + fn set_point( + &mut self, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_points_set_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_points_set_point(self.0, id, x, y, z) } + } + fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_points_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_float, + ); + } + unsafe { vtk_points_insert_point(self.0, id, x) } + } + fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_points_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + ); + } + unsafe { vtk_points_insert_point(self.0, id, x) } + } + fn insert_point( + &mut self, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_points_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_points_insert_point(self.0, id, x, y, z) } + } + fn insert_points( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_points_insert_points( + sself: *mut core::ffi::c_void, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_insert_points(self.0, dstIds, srcIds, source) } + } + fn insert_points( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_points_insert_points( + sself: *mut core::ffi::c_void, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_insert_points(self.0, dstStart, n, srcStart, source) } + } + fn insert_next_point(&mut self, x: core::ffi::c_float) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_points_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_float, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_points_insert_next_point(self.0, x) } + } + fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_points_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_points_insert_next_point(self.0, x) } + } + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_points_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_points_insert_next_point(self.0, x, y, z) } + } + fn set_number_of_points(&mut self, numPoints: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_points_set_number_of_points( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_uchar, + ); + } + unsafe { vtk_points_set_number_of_points(self.0, numPoints) } + } + fn resize(&mut self, numPoints: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_resize( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_resize(self.0, numPoints) } + } + fn get_points( + &mut self, + ptId: *mut core::ffi::c_void, + outPoints: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_points_get_points( + sself: *mut core::ffi::c_void, + ptId: *mut core::ffi::c_void, + outPoints: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_get_points(self.0, ptId, outPoints) } + } + fn compute_bounds(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_compute_bounds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_compute_bounds(self.0) } + } + fn get_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_points_get_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_points_get_bounds(self.0) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_points_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_points_get_bounds(self.0, bounds) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_points_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_points_get_m_time(self.0) } + } + fn modified(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_modified(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_modified(self.0) } + } +} +impl VtkPoints2D for vtkPoints2D { + fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_2_d_new( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_2_d_new(self.0, dataType) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_2_d_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_2_d_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_2_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_2_d_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_2_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_2_d_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_2_d_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_2_d_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_initialize(self.0) } + } + fn set_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_set_data(self.0, p0) } + } + fn get_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_2_d_get_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_2_d_get_data(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_2_d_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_2_d_get_data_type(self.0) } + } + fn set_data_type(&mut self, dataType: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + ); + } + unsafe { vtk_points_2_d_set_data_type(self.0, dataType) } + } + fn set_data_type_to_bit(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_bit(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_bit(self.0) } + } + fn set_data_type_to_char(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_char(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_char(self.0) } + } + fn set_data_type_to_unsigned_char(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_unsigned_char( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_set_data_type_to_unsigned_char(self.0) } + } + fn set_data_type_to_short(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_short(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_short(self.0) } + } + fn set_data_type_to_unsigned_short(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_unsigned_short( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_set_data_type_to_unsigned_short(self.0) } + } + fn set_data_type_to_int(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_int(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_int(self.0) } + } + fn set_data_type_to_unsigned_int(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_unsigned_int( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_set_data_type_to_unsigned_int(self.0) } + } + fn set_data_type_to_long(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_long(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_long(self.0) } + } + fn set_data_type_to_unsigned_long(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_unsigned_long( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_set_data_type_to_unsigned_long(self.0) } + } + fn set_data_type_to_float(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_float(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_float(self.0) } + } + fn set_data_type_to_double(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_double(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_double(self.0) } + } + fn get_void_pointer(&mut self, id: core::ffi::c_int) -> *mut () { + unsafe extern "C" { + fn vtk_points_2_d_get_void_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ) -> *mut (); + } + unsafe { vtk_points_2_d_get_void_pointer(self.0, id) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_reset(self.0) } + } + fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_2_d_deep_copy( + sself: *mut core::ffi::c_void, + ad: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_deep_copy(self.0, ad) } + } + fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_2_d_shallow_copy( + sself: *mut core::ffi::c_void, + ad: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_shallow_copy(self.0, ad) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_points_2_d_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_points_2_d_get_actual_memory_size(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_points_2_d_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_points_2_d_get_number_of_points(self.0) } + } + fn get_point(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_points_2_d_get_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_points_2_d_get_point(self.0, id) } + } + fn get_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_points_2_d_get_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + ); + } + unsafe { vtk_points_2_d_get_point(self.0, id, x) } + } + fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_float, + ); + } + unsafe { vtk_points_2_d_set_point(self.0, id, x) } + } + fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + ); + } + unsafe { vtk_points_2_d_set_point(self.0, id, x) } + } + fn set_point( + &mut self, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_points_2_d_set_point(self.0, id, x, y) } + } + fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_points_2_d_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_float, + ); + } + unsafe { vtk_points_2_d_insert_point(self.0, id, x) } + } + fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_points_2_d_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + ); + } + unsafe { vtk_points_2_d_insert_point(self.0, id, x) } + } + fn insert_point( + &mut self, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_points_2_d_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_points_2_d_insert_point(self.0, id, x, y) } + } + fn insert_next_point(&mut self, x: core::ffi::c_float) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_points_2_d_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_float, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_points_2_d_insert_next_point(self.0, x) } + } + fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_points_2_d_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_points_2_d_insert_next_point(self.0, x) } + } + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_points_2_d_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_points_2_d_insert_next_point(self.0, x, y) } + } + fn remove_point(&mut self, id: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_points_2_d_remove_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ); + } + unsafe { vtk_points_2_d_remove_point(self.0, id) } + } + fn set_number_of_points(&mut self, numPoints: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_number_of_points( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_uchar, + ); + } + unsafe { vtk_points_2_d_set_number_of_points(self.0, numPoints) } + } + fn resize(&mut self, numPoints: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_2_d_resize( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_2_d_resize(self.0, numPoints) } + } + fn get_points( + &mut self, + ptId: *mut core::ffi::c_void, + fp: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_points_2_d_get_points( + sself: *mut core::ffi::c_void, + ptId: *mut core::ffi::c_void, + fp: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_get_points(self.0, ptId, fp) } + } + fn compute_bounds(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_compute_bounds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_compute_bounds(self.0) } + } + fn get_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_points_2_d_get_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_points_2_d_get_bounds(self.0) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_points_2_d_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_points_2_d_get_bounds(self.0, bounds) } + } +} +impl VtkPriorityQueue for vtkPriorityQueue { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_priority_queue_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_priority_queue_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_priority_queue_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_priority_queue_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_priority_queue_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_priority_queue_new_instance(self.0) } + } + fn allocate(&mut self, sz: core::ffi::c_uchar, ext: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_priority_queue_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ); + } + unsafe { vtk_priority_queue_allocate(self.0, sz, ext) } + } + fn insert(&mut self, priority: core::ffi::c_double, id: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_priority_queue_insert( + sself: *mut core::ffi::c_void, + priority: core::ffi::c_double, + id: core::ffi::c_uchar, + ); + } + unsafe { vtk_priority_queue_insert(self.0, priority, id) } + } + fn pop( + &mut self, + location: core::ffi::c_uchar, + priority: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_priority_queue_pop( + sself: *mut core::ffi::c_void, + location: core::ffi::c_uchar, + priority: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_priority_queue_pop(self.0, location, priority) } + } + fn pop(&mut self, location: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_priority_queue_pop( + sself: *mut core::ffi::c_void, + location: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_priority_queue_pop(self.0, location) } + } + fn peek( + &mut self, + location: core::ffi::c_uchar, + priority: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_priority_queue_peek( + sself: *mut core::ffi::c_void, + location: core::ffi::c_uchar, + priority: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_priority_queue_peek(self.0, location, priority) } + } + fn peek(&mut self, location: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_priority_queue_peek( + sself: *mut core::ffi::c_void, + location: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_priority_queue_peek(self.0, location) } + } + fn delete_id(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_priority_queue_delete_id( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_double; + } + unsafe { vtk_priority_queue_delete_id(self.0, id) } + } + fn get_priority(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_priority_queue_get_priority( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_double; + } + unsafe { vtk_priority_queue_get_priority(self.0, id) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_priority_queue_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_priority_queue_get_number_of_items(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_priority_queue_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_priority_queue_reset(self.0) } + } +} +impl VtkRandomPool for vtkRandomPool { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_pool_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_pool_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_pool_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_pool_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_pool_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_pool_new_instance(self.0) } + } + fn set_sequence(&mut self, seq: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_random_pool_set_sequence( + sself: *mut core::ffi::c_void, + seq: *mut core::ffi::c_void, + ); + } + unsafe { vtk_random_pool_set_sequence(self.0, seq) } + } + fn get_sequence(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_pool_get_sequence( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_pool_get_sequence(self.0) } + } + fn set_size(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_random_pool_set_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_random_pool_set_size(self.0, _arg) } + } + fn get_size_min_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_random_pool_get_size_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_random_pool_get_size_min_value(self.0) } + } + fn get_size_max_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_random_pool_get_size_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_random_pool_get_size_max_value(self.0) } + } + fn get_size(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_random_pool_get_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_random_pool_get_size(self.0) } + } + fn set_number_of_components(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_random_pool_set_number_of_components( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_random_pool_set_number_of_components(self.0, _arg) } + } + fn get_number_of_components_min_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_random_pool_get_number_of_components_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_random_pool_get_number_of_components_min_value(self.0) } + } + fn get_number_of_components_max_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_random_pool_get_number_of_components_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_random_pool_get_number_of_components_max_value(self.0) } + } + fn get_number_of_components(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_random_pool_get_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_random_pool_get_number_of_components(self.0) } + } + fn get_total_size(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_random_pool_get_total_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_random_pool_get_total_size(self.0) } + } + fn generate_pool(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_pool_generate_pool( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_random_pool_generate_pool(self.0) } + } + fn get_pool(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_pool_get_pool( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_random_pool_get_pool(self.0) } + } + fn get_value(&mut self, i: core::ffi::c_uchar) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_pool_get_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + ) -> core::ffi::c_double; + } + unsafe { vtk_random_pool_get_value(self.0, i) } + } + fn get_value( + &mut self, + i: core::ffi::c_uchar, + compNum: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_pool_get_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + compNum: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_random_pool_get_value(self.0, i, compNum) } + } + fn populate_data_array( + &mut self, + da: *mut core::ffi::c_void, + minRange: core::ffi::c_double, + maxRange: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_random_pool_populate_data_array( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + minRange: core::ffi::c_double, + maxRange: core::ffi::c_double, + ); + } + unsafe { vtk_random_pool_populate_data_array(self.0, da, minRange, maxRange) } + } + fn populate_data_array( + &mut self, + da: *mut core::ffi::c_void, + compNumber: core::ffi::c_int, + minRange: core::ffi::c_double, + maxRange: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_random_pool_populate_data_array( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + compNumber: core::ffi::c_int, + minRange: core::ffi::c_double, + maxRange: core::ffi::c_double, + ); + } + unsafe { + vtk_random_pool_populate_data_array( + self.0, + da, + compNumber, + minRange, + maxRange, + ) + } + } + fn set_chunk_size(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_random_pool_set_chunk_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_random_pool_set_chunk_size(self.0, _arg) } + } + fn get_chunk_size_min_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_random_pool_get_chunk_size_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_random_pool_get_chunk_size_min_value(self.0) } + } + fn get_chunk_size_max_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_random_pool_get_chunk_size_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_random_pool_get_chunk_size_max_value(self.0) } + } + fn get_chunk_size(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_random_pool_get_chunk_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_random_pool_get_chunk_size(self.0) } + } +} +impl VtkReferenceCount for vtkReferenceCount { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reference_count_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reference_count_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reference_count_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reference_count_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reference_count_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reference_count_new_instance(self.0) } + } +} +impl VtkScalarsToColors for vtkScalarsToColors { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_new(self.0) } + } + fn is_opaque(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_is_opaque( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_is_opaque(self.0) } + } + fn is_opaque( + &mut self, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_is_opaque( + sself: *mut core::ffi::c_void, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_is_opaque(self.0, scalars, colorMode, component) } + } + fn build(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_build(sself: *mut core::ffi::c_void); + } + unsafe { vtk_scalars_to_colors_build(self.0) } + } + fn get_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_scalars_to_colors_get_range(self.0) } + } + fn set_range(&mut self, min: core::ffi::c_double, max: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_range( + sself: *mut core::ffi::c_void, + min: core::ffi::c_double, + max: core::ffi::c_double, + ); + } + unsafe { vtk_scalars_to_colors_set_range(self.0, min, max) } + } + fn set_range(&mut self, rng: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_range( + sself: *mut core::ffi::c_void, + rng: core::ffi::c_double, + ); + } + unsafe { vtk_scalars_to_colors_set_range(self.0, rng) } + } + fn map_value(&mut self, v: core::ffi::c_double) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_scalars_to_colors_map_value( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_scalars_to_colors_map_value(self.0, v) } + } + fn get_color(&mut self, v: core::ffi::c_double, rgb: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_color( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + rgb: core::ffi::c_double, + ); + } + unsafe { vtk_scalars_to_colors_get_color(self.0, v, rgb) } + } + fn get_color(&mut self, v: core::ffi::c_double) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_color( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_scalars_to_colors_get_color(self.0, v) } + } + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_opacity( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_scalars_to_colors_get_opacity(self.0, v) } + } + fn get_luminance(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_luminance( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_scalars_to_colors_get_luminance(self.0, x) } + } + fn set_alpha(&mut self, alpha: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_alpha( + sself: *mut core::ffi::c_void, + alpha: core::ffi::c_double, + ); + } + unsafe { vtk_scalars_to_colors_set_alpha(self.0, alpha) } + } + fn get_alpha(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_alpha( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_scalars_to_colors_get_alpha(self.0) } + } + fn map_scalars( + &mut self, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_map_scalars( + sself: *mut core::ffi::c_void, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_scalars_to_colors_map_scalars( + self.0, + scalars, + colorMode, + component, + outputFormat, + ) + } + } + fn map_scalars( + &mut self, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_map_scalars( + sself: *mut core::ffi::c_void, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_scalars_to_colors_map_scalars( + self.0, + scalars, + colorMode, + component, + outputFormat, + ) + } + } + fn set_vector_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_mode(self.0, _arg) } + } + fn get_vector_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_vector_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_get_vector_mode(self.0) } + } + fn set_vector_mode_to_magnitude(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_mode_to_magnitude( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_mode_to_magnitude(self.0) } + } + fn set_vector_mode_to_component(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_mode_to_component( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_mode_to_component(self.0) } + } + fn set_vector_mode_to_rgb_colors(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_mode_to_rgb_colors( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_mode_to_rgb_colors(self.0) } + } + fn set_vector_component(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_component( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_component(self.0, _arg) } + } + fn get_vector_component(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_vector_component( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_get_vector_component(self.0) } + } + fn set_vector_size(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_size(self.0, _arg) } + } + fn get_vector_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_vector_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_get_vector_size(self.0) } + } + fn map_vectors_through_table( + &mut self, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + vectorComponent: core::ffi::c_int, + vectorSize: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_map_vectors_through_table( + sself: *mut core::ffi::c_void, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + vectorComponent: core::ffi::c_int, + vectorSize: core::ffi::c_int, + ); + } + unsafe { + vtk_scalars_to_colors_map_vectors_through_table( + self.0, + input, + output, + inputDataType, + numberOfValues, + inputIncrement, + outputFormat, + vectorComponent, + vectorSize, + ) + } + } + fn map_vectors_through_table( + &mut self, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_map_vectors_through_table( + sself: *mut core::ffi::c_void, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ); + } + unsafe { + vtk_scalars_to_colors_map_vectors_through_table( + self.0, + input, + output, + inputDataType, + numberOfValues, + inputIncrement, + outputFormat, + ) + } + } + fn map_scalars_through_table( + &mut self, + scalars: *mut core::ffi::c_void, + output: core::ffi::c_uchar, + outputFormat: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_map_scalars_through_table( + sself: *mut core::ffi::c_void, + scalars: *mut core::ffi::c_void, + output: core::ffi::c_uchar, + outputFormat: core::ffi::c_int, + ); + } + unsafe { + vtk_scalars_to_colors_map_scalars_through_table( + self.0, + scalars, + output, + outputFormat, + ) + } + } + fn map_scalars_through_table( + &mut self, + scalars: *mut core::ffi::c_void, + output: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_map_scalars_through_table( + sself: *mut core::ffi::c_void, + scalars: *mut core::ffi::c_void, + output: core::ffi::c_uchar, + ); + } + unsafe { + vtk_scalars_to_colors_map_scalars_through_table(self.0, scalars, output) + } + } + fn map_scalars_through_table( + &mut self, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_map_scalars_through_table( + sself: *mut core::ffi::c_void, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ); + } + unsafe { + vtk_scalars_to_colors_map_scalars_through_table( + self.0, + input, + output, + inputDataType, + numberOfValues, + inputIncrement, + outputFormat, + ) + } + } + fn map_scalars_through_table_2( + &mut self, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_map_scalars_through_table_2( + sself: *mut core::ffi::c_void, + input: (), + output: core::ffi::c_uchar, + inputDataType: core::ffi::c_int, + numberOfValues: core::ffi::c_int, + inputIncrement: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ); + } + unsafe { + vtk_scalars_to_colors_map_scalars_through_table_2( + self.0, + input, + output, + inputDataType, + numberOfValues, + inputIncrement, + outputFormat, + ) + } + } + fn deep_copy(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_deep_copy( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_scalars_to_colors_deep_copy(self.0, o) } + } + fn using_log_scale(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_using_log_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_using_log_scale(self.0) } + } + fn get_number_of_available_colors(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_number_of_available_colors( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_scalars_to_colors_get_number_of_available_colors(self.0) } + } + fn set_annotations( + &mut self, + values: *mut core::ffi::c_void, + annotations: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_annotations( + sself: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + annotations: *mut core::ffi::c_void, + ); + } + unsafe { vtk_scalars_to_colors_set_annotations(self.0, values, annotations) } + } + fn get_annotated_values(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_annotated_values( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_get_annotated_values(self.0) } + } + fn get_annotations(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_annotations( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_get_annotations(self.0) } + } + fn set_annotation( + &mut self, + value: *mut core::ffi::c_void, + annotation: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_annotation( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + annotation: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_scalars_to_colors_set_annotation(self.0, value, annotation) } + } + fn set_annotation( + &mut self, + value: *mut core::ffi::c_void, + annotation: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_annotation( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + annotation: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_scalars_to_colors_set_annotation(self.0, value, annotation) } + } + fn get_number_of_annotated_values(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_number_of_annotated_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_scalars_to_colors_get_number_of_annotated_values(self.0) } + } + fn get_annotated_value( + &mut self, + idx: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_annotated_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_get_annotated_value(self.0, idx) } + } + fn get_annotation(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_annotation( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_get_annotation(self.0, idx) } + } + fn get_annotation_color( + &mut self, + val: vtkVariant, + rgba: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_annotation_color( + sself: *mut core::ffi::c_void, + val: vtkVariant, + rgba: core::ffi::c_double, + ); + } + unsafe { vtk_scalars_to_colors_get_annotation_color(self.0, val, rgba) } + } + fn get_annotated_value_index( + &mut self, + val: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_annotated_value_index( + sself: *mut core::ffi::c_void, + val: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_scalars_to_colors_get_annotated_value_index(self.0, val) } + } + fn get_annotated_value_index_internal( + &mut self, + val: vtkVariant, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_annotated_value_index_internal( + sself: *mut core::ffi::c_void, + val: vtkVariant, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_scalars_to_colors_get_annotated_value_index_internal(self.0, val) } + } + fn get_indexed_color( + &mut self, + i: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_indexed_color( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + rgba: core::ffi::c_double, + ); + } + unsafe { vtk_scalars_to_colors_get_indexed_color(self.0, i, rgba) } + } + fn remove_annotation(&mut self, value: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_scalars_to_colors_remove_annotation( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_scalars_to_colors_remove_annotation(self.0, value) } + } + fn reset_annotations(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_reset_annotations(sself: *mut core::ffi::c_void); + } + unsafe { vtk_scalars_to_colors_reset_annotations(self.0) } + } + fn set_indexed_lookup(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_indexed_lookup( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_scalars_to_colors_set_indexed_lookup(self.0, _arg) } + } + fn get_indexed_lookup(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_indexed_lookup( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_get_indexed_lookup(self.0) } + } + fn indexed_lookup_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_indexed_lookup_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_scalars_to_colors_indexed_lookup_on(self.0) } + } + fn indexed_lookup_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_indexed_lookup_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_scalars_to_colors_indexed_lookup_off(self.0) } + } +} +impl VtkShortArray for vtkShortArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_short_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_short_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_short_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_short_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_short_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_short_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_short_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_short_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_short_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_short_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_short, + ) -> () { + unsafe extern "C" { + fn vtk_short_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_short, + ); + } + unsafe { vtk_short_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_short, + ) -> () { + unsafe extern "C" { + fn vtk_short_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_short, + ); + } + unsafe { vtk_short_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_short, + ) -> () { + unsafe extern "C" { + fn vtk_short_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_short, + ); + } + unsafe { vtk_short_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_short, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_short_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_short, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_short_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_short { + unsafe extern "C" { + fn vtk_short_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_short; + } + unsafe { vtk_short_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_short) -> () { + unsafe extern "C" { + fn vtk_short_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_short, + ); + } + unsafe { vtk_short_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_short_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_short_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_short) -> () { + unsafe extern "C" { + fn vtk_short_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_short, + ); + } + unsafe { vtk_short_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_short) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_short_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_short, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_short_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_short { + unsafe extern "C" { + fn vtk_short_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_short; + } + unsafe { vtk_short_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_short { + unsafe extern "C" { + fn vtk_short_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_short; + } + unsafe { vtk_short_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_short { + unsafe extern "C" { + fn vtk_short_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_short; + } + unsafe { vtk_short_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_short { + unsafe extern "C" { + fn vtk_short_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_short; + } + unsafe { vtk_short_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_short, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_short_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_short, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_short_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_short, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_short_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_short, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_short_array_set_array(self.0, array, size, save, deleteMethod) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_short_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_short_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_short { + unsafe extern "C" { + fn vtk_short_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_short; + } + unsafe { vtk_short_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_short { + unsafe extern "C" { + fn vtk_short_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_short; + } + unsafe { vtk_short_array_get_data_type_value_max(self.0) } + } +} +impl VtkSignedCharArray for vtkSignedCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_signed_char_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_signed_char_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_signed_char_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_signed_char_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_signed_char_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_signed_char_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_signed_char_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_signed_char_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_signed_char_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_signed_char_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_signed_char_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ); + } + unsafe { vtk_signed_char_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_signed_char_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ); + } + unsafe { vtk_signed_char_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_signed_char_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_char, + ); + } + unsafe { vtk_signed_char_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_char, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_signed_char_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_char, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_signed_char_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_char { + unsafe extern "C" { + fn vtk_signed_char_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_char; + } + unsafe { vtk_signed_char_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_signed_char_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_char, + ); + } + unsafe { vtk_signed_char_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_signed_char_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_signed_char_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_signed_char_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_char, + ); + } + unsafe { vtk_signed_char_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_signed_char_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_char, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_signed_char_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_signed_char_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_signed_char_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_signed_char_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_signed_char_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_signed_char_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_signed_char_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_signed_char_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_signed_char_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_signed_char_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_signed_char_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_signed_char_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_char, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { + vtk_signed_char_array_set_array(self.0, array, size, save, deleteMethod) + } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_signed_char_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_signed_char_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_char { + unsafe extern "C" { + fn vtk_signed_char_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_char; + } + unsafe { vtk_signed_char_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_char { + unsafe extern "C" { + fn vtk_signed_char_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_char; + } + unsafe { vtk_signed_char_array_get_data_type_value_max(self.0) } + } +} +impl VtkSortDataArray for vtkSortDataArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_data_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_data_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_data_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_data_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_data_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_data_array_new_instance(self.0) } + } + fn sort(&mut self, keys: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort( + sself: *mut core::ffi::c_void, + keys: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sort_data_array_sort(self.0, keys) } + } + fn sort(&mut self, keys: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort( + sself: *mut core::ffi::c_void, + keys: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sort_data_array_sort(self.0, keys) } + } + fn sort(&mut self, keys: *mut core::ffi::c_void, dir: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort( + sself: *mut core::ffi::c_void, + keys: *mut core::ffi::c_void, + dir: core::ffi::c_int, + ); + } + unsafe { vtk_sort_data_array_sort(self.0, keys, dir) } + } + fn sort(&mut self, keys: *mut core::ffi::c_void, dir: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort( + sself: *mut core::ffi::c_void, + keys: *mut core::ffi::c_void, + dir: core::ffi::c_int, + ); + } + unsafe { vtk_sort_data_array_sort(self.0, keys, dir) } + } + fn sort( + &mut self, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort( + sself: *mut core::ffi::c_void, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sort_data_array_sort(self.0, keys, values) } + } + fn sort( + &mut self, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort( + sself: *mut core::ffi::c_void, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sort_data_array_sort(self.0, keys, values) } + } + fn sort( + &mut self, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + dir: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort( + sself: *mut core::ffi::c_void, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + dir: core::ffi::c_int, + ); + } + unsafe { vtk_sort_data_array_sort(self.0, keys, values, dir) } + } + fn sort( + &mut self, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + dir: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort( + sself: *mut core::ffi::c_void, + keys: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + dir: core::ffi::c_int, + ); + } + unsafe { vtk_sort_data_array_sort(self.0, keys, values, dir) } + } + fn sort_array_by_component( + &mut self, + arr: *mut core::ffi::c_void, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort_array_by_component( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + k: core::ffi::c_int, + ); + } + unsafe { vtk_sort_data_array_sort_array_by_component(self.0, arr, k) } + } + fn sort_array_by_component( + &mut self, + arr: *mut core::ffi::c_void, + k: core::ffi::c_int, + dir: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort_array_by_component( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + k: core::ffi::c_int, + dir: core::ffi::c_int, + ); + } + unsafe { vtk_sort_data_array_sort_array_by_component(self.0, arr, k, dir) } + } + fn initialize_sort_indices( + &mut self, + numKeys: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_sort_data_array_initialize_sort_indices( + sself: *mut core::ffi::c_void, + numKeys: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_sort_data_array_initialize_sort_indices(self.0, numKeys) } + } + fn generate_sort_indices( + &mut self, + dataType: core::ffi::c_int, + dataIn: (), + numKeys: core::ffi::c_uchar, + numComp: core::ffi::c_int, + k: core::ffi::c_int, + idx: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_generate_sort_indices( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + dataIn: (), + numKeys: core::ffi::c_uchar, + numComp: core::ffi::c_int, + k: core::ffi::c_int, + idx: core::ffi::c_uchar, + ); + } + unsafe { + vtk_sort_data_array_generate_sort_indices( + self.0, + dataType, + dataIn, + numKeys, + numComp, + k, + idx, + ) + } + } + fn shuffle_array( + &mut self, + idx: core::ffi::c_uchar, + dataType: core::ffi::c_int, + numKeys: core::ffi::c_uchar, + numComp: core::ffi::c_int, + arr: *mut core::ffi::c_void, + dataIn: (), + dir: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_shuffle_array( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + dataType: core::ffi::c_int, + numKeys: core::ffi::c_uchar, + numComp: core::ffi::c_int, + arr: *mut core::ffi::c_void, + dataIn: (), + dir: core::ffi::c_int, + ); + } + unsafe { + vtk_sort_data_array_shuffle_array( + self.0, + idx, + dataType, + numKeys, + numComp, + arr, + dataIn, + dir, + ) + } + } + fn shuffle_id_list( + &mut self, + idx: core::ffi::c_uchar, + sze: core::ffi::c_uchar, + arrayIn: *mut core::ffi::c_void, + dataIn: core::ffi::c_uchar, + dir: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_shuffle_id_list( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + sze: core::ffi::c_uchar, + arrayIn: *mut core::ffi::c_void, + dataIn: core::ffi::c_uchar, + dir: core::ffi::c_int, + ); + } + unsafe { + vtk_sort_data_array_shuffle_id_list(self.0, idx, sze, arrayIn, dataIn, dir) + } + } +} +impl VtkStringArray for vtkStringArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_new_instance(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_get_data_type(self.0) } + } + fn is_numeric(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_is_numeric( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_is_numeric(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_string_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_string_array_initialize(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_get_data_type_size(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_string_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_string_array_squeeze(self.0) } + } + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_resize( + sself: *mut core::ffi::c_void, + numTuples: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_resize(self.0, numTuples) } + } + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_set_tuple(self.0, i, j, source) } + } + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_insert_tuple(self.0, i, j, source) } + } + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_insert_tuples( + sself: *mut core::ffi::c_void, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_insert_tuples(self.0, dstIds, srcIds, source) } + } + fn insert_tuples( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_insert_tuples( + sself: *mut core::ffi::c_void, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_insert_tuples(self.0, dstStart, n, srcStart, source) } + } + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_string_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_string_array_insert_next_tuple(self.0, j, source) } + } + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_interpolate_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_string_array_interpolate_tuple(self.0, i, ptIndices, source, weights) + } + } + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_interpolate_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ); + } + unsafe { + vtk_string_array_interpolate_tuple(self.0, i, id1, source1, id2, source2, t) + } + } + fn get_tuples( + &mut self, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_get_tuples( + sself: *mut core::ffi::c_void, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_get_tuples(self.0, ptIds, output) } + } + fn get_tuples( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + output: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_get_tuples( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + output: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_get_tuples(self.0, p1, p2, output) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_allocate(self.0, sz, ext) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> vtkStdString { + unsafe extern "C" { + fn vtk_string_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> vtkStdString; + } + unsafe { vtk_string_array_get_value(self.0, id) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_get_value(self.0, id) } + } + fn set_value( + &mut self, + id: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_set_value(self.0, id, value) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_string_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_char, + ); + } + unsafe { vtk_string_array_set_value(self.0, id, value) } + } + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_string_array_set_number_of_tuples( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ); + } + unsafe { vtk_string_array_set_number_of_tuples(self.0, number) } + } + fn get_number_of_values(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_string_array_get_number_of_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_string_array_get_number_of_values(self.0) } + } + fn get_number_of_element_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_get_number_of_element_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_get_number_of_element_components(self.0) } + } + fn get_element_component_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_get_element_component_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_get_element_component_size(self.0) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_string_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_insert_value(self.0, id, f) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, val: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_string_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + val: core::ffi::c_char, + ); + } + unsafe { vtk_string_array_insert_value(self.0, id, val) } + } + fn set_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_set_variant_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_set_variant_value(self.0, idx, value) } + } + fn insert_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_insert_variant_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_insert_variant_value(self.0, idx, value) } + } + fn insert_next_value(&mut self, f: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_string_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_string_array_insert_next_value(self.0, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_string_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_char, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_string_array_insert_next_value(self.0, f) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_get_pointer(self.0, id) } + } + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut () { + unsafe extern "C" { + fn vtk_string_array_get_void_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut (); + } + unsafe { vtk_string_array_get_void_pointer(self.0, id) } + } + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_string_array_deep_copy( + sself: *mut core::ffi::c_void, + aa: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_deep_copy(self.0, aa) } + } + fn set_array( + &mut self, + array: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_set_array( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_string_array_set_array(self.0, array, size, save, deleteMethod) } + } + fn set_void_array( + &mut self, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_set_void_array( + sself: *mut core::ffi::c_void, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_string_array_set_void_array(self.0, array, size, save) } + } + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_string_array_set_array_free_function( + sself: *mut core::ffi::c_void, + callback: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_set_array_free_function(self.0, callback) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_string_array_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_string_array_get_actual_memory_size(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_new_iterator(self.0) } + } + fn get_data_size(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_string_array_get_data_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_string_array_get_data_size(self.0) } + } + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_string_array_lookup_value( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_string_array_lookup_value(self.0, value) } + } + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_lookup_value( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_lookup_value(self.0, value, ids) } + } + fn lookup_value(&mut self, value: vtkStdString) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_string_array_lookup_value( + sself: *mut core::ffi::c_void, + value: vtkStdString, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_string_array_lookup_value(self.0, value) } + } + fn lookup_value(&mut self, value: vtkStdString, ids: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_string_array_lookup_value( + sself: *mut core::ffi::c_void, + value: vtkStdString, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_lookup_value(self.0, value, ids) } + } + fn lookup_value(&mut self, value: core::ffi::c_char) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_string_array_lookup_value( + sself: *mut core::ffi::c_void, + value: core::ffi::c_char, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_string_array_lookup_value(self.0, value) } + } + fn lookup_value( + &mut self, + value: core::ffi::c_char, + ids: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_lookup_value( + sself: *mut core::ffi::c_void, + value: core::ffi::c_char, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_lookup_value(self.0, value, ids) } + } + fn data_changed(&mut self) -> () { + unsafe extern "C" { + fn vtk_string_array_data_changed(sself: *mut core::ffi::c_void); + } + unsafe { vtk_string_array_data_changed(self.0) } + } + fn data_element_changed(&mut self, id: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_string_array_data_element_changed( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ); + } + unsafe { vtk_string_array_data_element_changed(self.0, id) } + } + fn clear_lookup(&mut self) -> () { + unsafe extern "C" { + fn vtk_string_array_clear_lookup(sself: *mut core::ffi::c_void); + } + unsafe { vtk_string_array_clear_lookup(self.0) } + } +} +impl VtkStringOutputWindow for vtkStringOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_output_window_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_output_window_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_output_window_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_output_window_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_output_window_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_output_window_new(self.0) } + } + fn display_text(&mut self, p0: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_string_output_window_display_text( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ); + } + unsafe { vtk_string_output_window_display_text(self.0, p0) } + } + fn get_output(&mut self) -> &str { + unsafe extern "C" { + fn vtk_string_output_window_get_output( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_string_output_window_get_output(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} +impl VtkTimePointUtility for vtkTimePointUtility { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_time_point_utility_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_time_point_utility_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_time_point_utility_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_time_point_utility_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_time_point_utility_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_time_point_utility_new_instance(self.0) } + } + fn date_to_time_point( + &mut self, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + ) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_time_point_utility_date_to_time_point( + sself: *mut core::ffi::c_void, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + } + unsafe { vtk_time_point_utility_date_to_time_point(self.0, year, month, day) } + } + fn time_to_time_point( + &mut self, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_time_point_utility_time_to_time_point( + sself: *mut core::ffi::c_void, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + } + unsafe { + vtk_time_point_utility_time_to_time_point( + self.0, + hour, + minute, + second, + millis, + ) + } + } + fn date_time_to_time_point( + &mut self, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + sec: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_time_point_utility_date_time_to_time_point( + sself: *mut core::ffi::c_void, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + sec: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + } + unsafe { + vtk_time_point_utility_date_time_to_time_point( + self.0, + year, + month, + day, + hour, + minute, + sec, + millis, + ) + } + } + fn get_date( + &mut self, + time: core::ffi::c_ulonglong, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_time_point_utility_get_date( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + ); + } + unsafe { vtk_time_point_utility_get_date(self.0, time, year, month, day) } + } + fn get_time( + &mut self, + time: core::ffi::c_ulonglong, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_time_point_utility_get_time( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ); + } + unsafe { + vtk_time_point_utility_get_time(self.0, time, hour, minute, second, millis) + } + } + fn get_date_time( + &mut self, + time: core::ffi::c_ulonglong, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_time_point_utility_get_date_time( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ); + } + unsafe { + vtk_time_point_utility_get_date_time( + self.0, + time, + year, + month, + day, + hour, + minute, + second, + millis, + ) + } + } + fn get_year(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_year( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_year(self.0, time) } + } + fn get_month(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_month( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_month(self.0, time) } + } + fn get_day(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_day( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_day(self.0, time) } + } + fn get_hour(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_hour( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_hour(self.0, time) } + } + fn get_minute(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_minute( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_minute(self.0, time) } + } + fn get_second(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_second( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_second(self.0, time) } + } + fn get_millisecond(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_millisecond( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_millisecond(self.0, time) } + } + fn iso_8601_to_time_point( + &mut self, + str: core::ffi::c_char, + ok: bool, + ) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_time_point_utility_iso_8601_to_time_point( + sself: *mut core::ffi::c_void, + str: core::ffi::c_char, + ok: bool, + ) -> core::ffi::c_ulonglong; + } + unsafe { vtk_time_point_utility_iso_8601_to_time_point(self.0, str, ok) } + } + fn time_point_to_iso_8601( + &mut self, + p0: core::ffi::c_ulonglong, + format: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_time_point_utility_time_point_to_iso_8601( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_ulonglong, + format: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_time_point_utility_time_point_to_iso_8601(self.0, p0, format) } + } +} +impl VtkTypeFloat32Array for vtkTypeFloat32Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_32_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_32_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_32_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_32_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_32_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_32_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_32_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_32_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeFloat64Array for vtkTypeFloat64Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_64_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_64_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_64_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_64_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_64_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_64_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_64_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_64_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeInt16Array for vtkTypeInt16Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_16_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_16_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_16_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_16_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_16_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_16_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_16_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_16_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeInt32Array for vtkTypeInt32Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_32_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_32_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_32_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_32_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_32_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_32_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_32_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_32_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeInt64Array for vtkTypeInt64Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_64_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_64_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_64_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_64_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_64_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_64_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_64_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_64_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeInt8Array for vtkTypeInt8Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_8_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_8_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_8_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_8_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_8_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_8_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_8_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_8_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeUInt16Array for vtkTypeUInt16Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_16_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_16_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_16_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_16_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_16_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_16_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_16_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_16_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeUInt32Array for vtkTypeUInt32Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_32_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_32_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_32_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_32_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_32_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_32_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_32_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_32_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeUInt64Array for vtkTypeUInt64Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_64_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_64_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_64_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_64_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_64_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_64_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_64_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_64_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeUInt8Array for vtkTypeUInt8Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_8_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_8_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_8_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_8_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_8_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_8_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_8_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_8_array_fast_down_cast(self.0, source) } + } +} +impl VtkUnicodeStringArray for vtkUnicodeStringArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unicode_string_array_initialize(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_get_data_type(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_get_data_type_size(self.0) } + } + fn get_element_component_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_get_element_component_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_get_element_component_size(self.0) } + } + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_set_number_of_tuples( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ); + } + unsafe { vtk_unicode_string_array_set_number_of_tuples(self.0, number) } + } + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_set_tuple(self.0, i, j, source) } + } + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_insert_tuple(self.0, i, j, source) } + } + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_tuples( + sself: *mut core::ffi::c_void, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_insert_tuples(self.0, dstIds, srcIds, source) } + } + fn insert_tuples( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_tuples( + sself: *mut core::ffi::c_void, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unicode_string_array_insert_tuples(self.0, dstStart, n, srcStart, source) + } + } + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unicode_string_array_insert_next_tuple(self.0, j, source) } + } + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut () { + unsafe extern "C" { + fn vtk_unicode_string_array_get_void_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut (); + } + unsafe { vtk_unicode_string_array_get_void_pointer(self.0, id) } + } + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_interpolate_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_unicode_string_array_interpolate_tuple( + self.0, + i, + ptIndices, + source, + weights, + ) + } + } + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_interpolate_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ); + } + unsafe { + vtk_unicode_string_array_interpolate_tuple( + self.0, + i, + id1, + source1, + id2, + source2, + t, + ) + } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unicode_string_array_squeeze(self.0) } + } + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_resize( + sself: *mut core::ffi::c_void, + numTuples: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_resize(self.0, numTuples) } + } + fn set_void_array( + &mut self, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_set_void_array( + sself: *mut core::ffi::c_void, + array: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_unicode_string_array_set_void_array(self.0, array, size, save) } + } + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_set_array_free_function( + sself: *mut core::ffi::c_void, + callback: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_set_array_free_function(self.0, callback) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unicode_string_array_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_unicode_string_array_get_actual_memory_size(self.0) } + } + fn is_numeric(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_is_numeric( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_is_numeric(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_new_iterator(self.0) } + } + fn get_variant_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_get_variant_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_get_variant_value(self.0, idx) } + } + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unicode_string_array_lookup_value( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unicode_string_array_lookup_value(self.0, value) } + } + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_lookup_value( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_lookup_value(self.0, value, ids) } + } + fn set_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_set_variant_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_set_variant_value(self.0, idx, value) } + } + fn insert_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_variant_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_insert_variant_value(self.0, idx, value) } + } + fn data_changed(&mut self) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_data_changed(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unicode_string_array_data_changed(self.0) } + } + fn clear_lookup(&mut self) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_clear_lookup(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unicode_string_array_clear_lookup(self.0) } + } + fn insert_next_value(&mut self, p0: vtkUnicodeString) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_next_value( + sself: *mut core::ffi::c_void, + p0: vtkUnicodeString, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unicode_string_array_insert_next_value(self.0, p0) } + } + fn insert_value(&mut self, idx: core::ffi::c_uchar, p1: vtkUnicodeString) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + p1: vtkUnicodeString, + ); + } + unsafe { vtk_unicode_string_array_insert_value(self.0, idx, p1) } + } + fn set_value(&mut self, i: core::ffi::c_uchar, p1: vtkUnicodeString) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_set_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + p1: vtkUnicodeString, + ); + } + unsafe { vtk_unicode_string_array_set_value(self.0, i, p1) } + } + fn get_value(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_get_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_get_value(self.0, i) } + } + fn insert_next_utf_8_value(&mut self, p0: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_next_utf_8_value( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ); + } + unsafe { vtk_unicode_string_array_insert_next_utf_8_value(self.0, p0) } + } + fn set_utf_8_value(&mut self, i: core::ffi::c_uchar, p1: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_set_utf_8_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + p1: core::ffi::c_char, + ); + } + unsafe { vtk_unicode_string_array_set_utf_8_value(self.0, i, p1) } + } + fn get_utf_8_value(&mut self, i: core::ffi::c_uchar) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_unicode_string_array_get_utf_8_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_unicode_string_array_get_utf_8_value(self.0, i) } + } +} +impl VtkUnsignedCharArray for vtkUnsignedCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_char_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_char_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_char_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_char_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_char_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_char_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_char_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_char_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unsigned_char_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ); + } + unsafe { vtk_unsigned_char_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_char_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ); + } + unsafe { vtk_unsigned_char_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_char_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uchar, + ); + } + unsafe { vtk_unsigned_char_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_unsigned_char_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_uchar, + ); + } + unsafe { vtk_unsigned_char_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_unsigned_char_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_unsigned_char_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_unsigned_char_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_uchar, + ); + } + unsafe { vtk_unsigned_char_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_char_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_unsigned_char_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_char_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_uchar, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { + vtk_unsigned_char_array_set_array(self.0, array, size, save, deleteMethod) + } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_char_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_char_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_get_data_type_value_max(self.0) } + } +} +impl VtkUnsignedIntArray for vtkUnsignedIntArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_int_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_int_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_int_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_int_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_int_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_int_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_int_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_int_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unsigned_int_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uint, + ); + } + unsafe { vtk_unsigned_int_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_int_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uint, + ); + } + unsafe { vtk_unsigned_int_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_int_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_uint, + ); + } + unsafe { vtk_unsigned_int_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_uint, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_int_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_uint, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_int_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_uint; + } + unsafe { vtk_unsigned_int_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_unsigned_int_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_uint, + ); + } + unsafe { vtk_unsigned_int_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_unsigned_int_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_unsigned_int_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_unsigned_int_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_uint, + ); + } + unsafe { vtk_unsigned_int_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_uint) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_int_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_uint, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_int_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uint { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_uint; + } + unsafe { vtk_unsigned_int_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_uint { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_uint; + } + unsafe { vtk_unsigned_int_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uint { + unsafe extern "C" { + fn vtk_unsigned_int_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uint; + } + unsafe { vtk_unsigned_int_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uint { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uint; + } + unsafe { vtk_unsigned_int_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_uint, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_int_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_uint, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_unsigned_int_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_uint, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_int_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_uint, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { + vtk_unsigned_int_array_set_array(self.0, array, size, save, deleteMethod) + } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_int_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_int_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_unsigned_int_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_unsigned_int_array_get_data_type_value_max(self.0) } + } +} +impl VtkUnsignedLongArray for vtkUnsignedLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unsigned_long_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulong, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulong, + ); + } + unsafe { vtk_unsigned_long_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulong, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulong, + ); + } + unsafe { vtk_unsigned_long_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulong, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulong, + ); + } + unsafe { vtk_unsigned_long_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_ulong, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_long_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_ulong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_long_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_unsigned_long_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_ulong) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_ulong, + ); + } + unsafe { vtk_unsigned_long_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_unsigned_long_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_unsigned_long_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ulong) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_ulong, + ); + } + unsafe { vtk_unsigned_long_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_ulong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_long_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_ulong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_long_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_ulong; + } + unsafe { vtk_unsigned_long_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_ulong; + } + unsafe { vtk_unsigned_long_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unsigned_long_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ulong; + } + unsafe { vtk_unsigned_long_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ulong; + } + unsafe { vtk_unsigned_long_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_ulong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_ulong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_unsigned_long_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_ulong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_ulong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { + vtk_unsigned_long_array_set_array(self.0, array, size, save, deleteMethod) + } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_unsigned_long_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_unsigned_long_array_get_data_type_value_max(self.0) } + } +} +impl VtkUnsignedLongLongArray for vtkUnsignedLongLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_long_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_long_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_long_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_long_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unsigned_long_long_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulonglong, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulonglong, + ); + } + unsafe { vtk_unsigned_long_long_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulonglong, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulonglong, + ); + } + unsafe { vtk_unsigned_long_long_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulonglong, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ulonglong, + ); + } + unsafe { vtk_unsigned_long_long_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_ulonglong, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_ulonglong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_long_long_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_ulonglong; + } + unsafe { vtk_unsigned_long_long_array_get_value(self.0, id) } + } + fn set_value( + &mut self, + id: core::ffi::c_uchar, + value: core::ffi::c_ulonglong, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_ulonglong, + ); + } + unsafe { vtk_unsigned_long_long_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_unsigned_long_long_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ulonglong) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_ulonglong, + ); + } + unsafe { vtk_unsigned_long_long_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_ulonglong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_ulonglong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_long_long_array_insert_next_value(self.0, f) } + } + fn get_value_range( + &mut self, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_ulonglong; + } + unsafe { vtk_unsigned_long_long_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_ulonglong; + } + unsafe { vtk_unsigned_long_long_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ulonglong; + } + unsafe { vtk_unsigned_long_long_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ulonglong; + } + unsafe { vtk_unsigned_long_long_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_ulonglong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_ulonglong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_unsigned_long_long_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_ulonglong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_ulonglong, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { + vtk_unsigned_long_long_array_set_array( + self.0, + array, + size, + save, + deleteMethod, + ) + } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_long_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulonglong; + } + unsafe { vtk_unsigned_long_long_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulonglong; + } + unsafe { vtk_unsigned_long_long_array_get_data_type_value_max(self.0) } + } +} +impl VtkUnsignedShortArray for vtkUnsignedShortArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_short_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_short_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_short_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_short_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_short_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_short_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_short_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_short_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unsigned_short_array_get_data_type(self.0) } + } + fn get_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ushort, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ushort, + ); + } + unsafe { vtk_unsigned_short_array_get_typed_tuple(self.0, i, tuple) } + } + fn set_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ushort, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_short_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ushort, + ); + } + unsafe { vtk_unsigned_short_array_set_typed_tuple(self.0, i, tuple) } + } + fn insert_typed_tuple( + &mut self, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ushort, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_short_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + tuple: core::ffi::c_ushort, + ); + } + unsafe { vtk_unsigned_short_array_insert_typed_tuple(self.0, i, tuple) } + } + fn insert_next_typed_tuple( + &mut self, + tuple: core::ffi::c_ushort, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_short_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: core::ffi::c_ushort, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_short_array_insert_next_typed_tuple(self.0, tuple) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> core::ffi::c_ushort; + } + unsafe { vtk_unsigned_short_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_ushort) -> () { + unsafe extern "C" { + fn vtk_unsigned_short_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: core::ffi::c_ushort, + ); + } + unsafe { vtk_unsigned_short_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_unsigned_short_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_unsigned_short_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ushort) -> () { + unsafe extern "C" { + fn vtk_unsigned_short_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + f: core::ffi::c_ushort, + ); + } + unsafe { vtk_unsigned_short_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_ushort) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_short_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_ushort, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_short_array_insert_next_value(self.0, f) } + } + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_value_range( + sself: *mut core::ffi::c_void, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_ushort; + } + unsafe { vtk_unsigned_short_array_get_value_range(self.0, comp) } + } + fn get_value_range(&mut self) -> *mut core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_value_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_ushort; + } + unsafe { vtk_unsigned_short_array_get_value_range(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_unsigned_short_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ushort; + } + unsafe { vtk_unsigned_short_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_ushort; + } + unsafe { vtk_unsigned_short_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + array: core::ffi::c_ushort, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_short_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_ushort, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_unsigned_short_array_set_array(self.0, array, size, save) } + } + fn set_array( + &mut self, + array: core::ffi::c_ushort, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_short_array_set_array( + sself: *mut core::ffi::c_void, + array: core::ffi::c_ushort, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { + vtk_unsigned_short_array_set_array(self.0, array, size, save, deleteMethod) + } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_short_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_short_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ushort; + } + unsafe { vtk_unsigned_short_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ushort; + } + unsafe { vtk_unsigned_short_array_get_data_type_value_max(self.0) } + } +} +impl VtkVariantArray for vtkVariantArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_variant_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_variant_array_initialize(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_get_data_type(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_get_data_type_size(self.0) } + } + fn get_element_component_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_get_element_component_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_get_element_component_size(self.0) } + } + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_number_of_tuples( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ); + } + unsafe { vtk_variant_array_set_number_of_tuples(self.0, number) } + } + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_set_tuple(self.0, i, j, source) } + } + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_insert_tuple(self.0, i, j, source) } + } + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_insert_tuples( + sself: *mut core::ffi::c_void, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_insert_tuples(self.0, dstIds, srcIds, source) } + } + fn insert_tuples( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_insert_tuples( + sself: *mut core::ffi::c_void, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_insert_tuples(self.0, dstStart, n, srcStart, source) } + } + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_variant_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_variant_array_insert_next_tuple(self.0, j, source) } + } + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut () { + unsafe extern "C" { + fn vtk_variant_array_get_void_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut (); + } + unsafe { vtk_variant_array_get_void_pointer(self.0, id) } + } + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_variant_array_deep_copy( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_deep_copy(self.0, da) } + } + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_interpolate_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_variant_array_interpolate_tuple(self.0, i, ptIndices, source, weights) + } + } + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_interpolate_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ); + } + unsafe { + vtk_variant_array_interpolate_tuple(self.0, i, id1, source1, id2, source2, t) + } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_variant_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_variant_array_squeeze(self.0) } + } + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_resize( + sself: *mut core::ffi::c_void, + numTuples: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_resize(self.0, numTuples) } + } + fn set_void_array( + &mut self, + arr: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_void_array( + sself: *mut core::ffi::c_void, + arr: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + ); + } + unsafe { vtk_variant_array_set_void_array(self.0, arr, size, save) } + } + fn set_void_array( + &mut self, + arr: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteM: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_void_array( + sself: *mut core::ffi::c_void, + arr: (), + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteM: core::ffi::c_int, + ); + } + unsafe { vtk_variant_array_set_void_array(self.0, arr, size, save, deleteM) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_variant_array_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_variant_array_get_actual_memory_size(self.0) } + } + fn is_numeric(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_is_numeric( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_is_numeric(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_new_iterator(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_get_value(self.0, id) } + } + fn set_value( + &mut self, + id: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_set_value(self.0, id, value) } + } + fn insert_value( + &mut self, + id: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_insert_value(self.0, id, value) } + } + fn set_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_variant_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_set_variant_value(self.0, idx, value) } + } + fn insert_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_insert_variant_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_insert_variant_value(self.0, idx, value) } + } + fn insert_next_value( + &mut self, + value: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_variant_array_insert_next_value( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_variant_array_insert_next_value(self.0, value) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + arr: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_array( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_variant_array_set_array(self.0, arr, size, save, deleteMethod) } + } + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_array_free_function( + sself: *mut core::ffi::c_void, + callback: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_set_array_free_function(self.0, callback) } + } + fn get_number_of_values(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_variant_array_get_number_of_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_variant_array_get_number_of_values(self.0) } + } + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_variant_array_lookup_value( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_variant_array_lookup_value(self.0, value) } + } + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_lookup_value( + sself: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_lookup_value(self.0, value, ids) } + } + fn data_changed(&mut self) -> () { + unsafe extern "C" { + fn vtk_variant_array_data_changed(sself: *mut core::ffi::c_void); + } + unsafe { vtk_variant_array_data_changed(self.0) } + } + fn data_element_changed(&mut self, id: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_variant_array_data_element_changed( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ); + } + unsafe { vtk_variant_array_data_element_changed(self.0, id) } + } + fn clear_lookup(&mut self) -> () { + unsafe extern "C" { + fn vtk_variant_array_clear_lookup(sself: *mut core::ffi::c_void); + } + unsafe { vtk_variant_array_clear_lookup(self.0) } + } +} +impl VtkVersion for vtkVersion { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_version_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_version_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_version_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_version_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_version_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_version_new_instance(self.0) } + } + fn get_vtk_version(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_version_get_vtk_version( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_version_get_vtk_version(self.0) } + } + fn get_vtk_version_full(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_version_get_vtk_version_full( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_version_get_vtk_version_full(self.0) } + } + fn get_vtk_major_version(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_version_get_vtk_major_version( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_version_get_vtk_major_version(self.0) } + } + fn get_vtk_minor_version(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_version_get_vtk_minor_version( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_version_get_vtk_minor_version(self.0) } + } + fn get_vtk_build_version(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_version_get_vtk_build_version( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_version_get_vtk_build_version(self.0) } + } + fn get_vtk_source_version(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_version_get_vtk_source_version( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_version_get_vtk_source_version(self.0) } + } +} +impl VtkVoidArray for vtkVoidArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_void_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_void_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_void_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_void_array_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_void_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_void_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_void_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_void_array_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_void_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_void_array_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_void_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_void_array_initialize(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_void_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_void_array_get_data_type(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_void_array_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_void_array_get_data_type_size(self.0) } + } + fn set_number_of_pointers(&mut self, number: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_void_array_set_number_of_pointers( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ); + } + unsafe { vtk_void_array_set_number_of_pointers(self.0, number) } + } + fn get_number_of_pointers(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_void_array_get_number_of_pointers( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_void_array_get_number_of_pointers(self.0) } + } + fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut () { + unsafe extern "C" { + fn vtk_void_array_get_void_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut (); + } + unsafe { vtk_void_array_get_void_pointer(self.0, id) } + } + fn set_void_pointer(&mut self, id: core::ffi::c_uchar, ptr: ()) -> () { + unsafe extern "C" { + fn vtk_void_array_set_void_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ptr: (), + ); + } + unsafe { vtk_void_array_set_void_pointer(self.0, id, ptr) } + } + fn insert_void_pointer(&mut self, i: core::ffi::c_uchar, ptr: ()) -> () { + unsafe extern "C" { + fn vtk_void_array_insert_void_pointer( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + ptr: (), + ); + } + unsafe { vtk_void_array_insert_void_pointer(self.0, i, ptr) } + } + fn insert_next_void_pointer(&mut self, tuple: ()) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_void_array_insert_next_void_pointer( + sself: *mut core::ffi::c_void, + tuple: (), + ) -> core::ffi::c_uchar; + } + unsafe { vtk_void_array_insert_next_void_pointer(self.0, tuple) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_void_array_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_void_array_reset(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_void_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_void_array_squeeze(self.0) } + } + fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut &mut () { + unsafe extern "C" { + fn vtk_void_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ) -> *mut &mut (); + } + unsafe { vtk_void_array_get_pointer(self.0, id) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut &mut () { + unsafe extern "C" { + fn vtk_void_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + number: core::ffi::c_uchar, + ) -> *mut &mut (); + } + unsafe { vtk_void_array_write_pointer(self.0, id, number) } + } + fn deep_copy(&mut self, va: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_void_array_deep_copy( + sself: *mut core::ffi::c_void, + va: *mut core::ffi::c_void, + ); + } + unsafe { vtk_void_array_deep_copy(self.0, va) } + } +} +impl VtkWeakReference for vtkWeakReference { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_weak_reference_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_weak_reference_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_weak_reference_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_weak_reference_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_weak_reference_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_weak_reference_new(self.0) } + } + fn set(&mut self, object: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_weak_reference_set( + sself: *mut core::ffi::c_void, + object: *mut core::ffi::c_void, + ); + } + unsafe { vtk_weak_reference_set(self.0, object) } + } + fn get(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_weak_reference_get( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_weak_reference_get(self.0) } + } +} +impl VtkXMLFileOutputWindow for vtkXMLFileOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_file_output_window_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_file_output_window_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_file_output_window_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_file_output_window_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_file_output_window_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_file_output_window_new(self.0) } + } + fn display_text(&mut self, p0: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_xml_file_output_window_display_text( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ); + } + unsafe { vtk_xml_file_output_window_display_text(self.0, p0) } + } + fn display_tag(&mut self, p0: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_xml_file_output_window_display_tag( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_char, + ); + } + unsafe { vtk_xml_file_output_window_display_tag(self.0, p0) } + } +} /// a seqin an animation. /// /// @@ -117,38 +24491,6 @@ fn test_vtkArchiver_create_drop() { let new_obj = vtkArchiver(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } -pub trait VtkArchiver { - fn set_archive_name(&self, name: &str); - fn get_archive_name(&self) -> &str; -} -impl VtkArchiver for vtkArchiver { - fn set_archive_name(&self, name: &str) { - unsafe extern "C" { - fn vtkArchiver_set_archive_name( - sself: *mut core::ffi::c_void, - name: *const core::ffi::c_char, - ); - } - let c_name = std::ffi::CString::new(name).expect("CString::new failed"); - unsafe { vtkArchiver_set_archive_name(self.0, c_name.as_ptr()) } - } - fn get_archive_name(&self) -> &str { - unsafe extern "C" { - fn vtkArchiver_get_archive_name( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { vtkArchiver_get_archive_name(self.0) }; - if ptr.is_null() { return ""; } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } -} -#[test] -fn test_vtkArchiver_set_archive_name() { - let obj = vtkArchiver::new(); - obj.set_archive_name("my_archive"); - assert_eq!(obj.get_archive_name(), "my_archive"); -} /// dynamic, self-adjusting array of bits /// /// @@ -761,24 +25103,14 @@ fn test_vtkDataArrayCollectionIterator_create_drop() { let new_obj = vtkDataArrayCollectionIterator(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } -/// Store on/off settings for data arrays, etc. -/// +/// Store on/off settings for data arrays for a vtkSource. /// -/// vtkDataArraySelection is intended to be used by algorithms that want to -/// expose a API that allow the user to enable/disable a collection of entities, -/// such as arrays. Readers, for example, can use vtkDataArraySelection to let -/// the user choose which array to read from the file. /// -/// Originally intended for selecting data arrays (hence the name), this class -/// can be used for letting users choose other items too, for example, -/// vtkIOSSReader uses vtkDataArraySelection to let users choose -/// which blocks to read. -/// -/// Unlike most other vtkObject subclasses, vtkDataArraySelection has public API -/// that need not modify the MTime for the object. These M-Time non-modifying -/// methods are typically intended for use within the algorithm or reader to -/// populate the vtkDataArraySelection instance with available array names and -/// their default values. +/// vtkDataArraySelection can be used by vtkSource subclasses to store +/// on/off settings for whether each vtkDataArray in its input should +/// be passed in the source's output. This is primarily intended to +/// allow file readers to configure what data arrays are read from the +/// file. #[allow(non_camel_case_types)] pub struct vtkDataArraySelection(*mut core::ffi::c_void); impl vtkDataArraySelection { @@ -1269,7 +25601,14 @@ fn test_vtkFloatArray_create_drop() { /// \code /// /// public: -/// bool UsesGarbageCollector() const override { return true; } +/// void Register(vtkObjectBase* o) override +/// { +/// this->RegisterInternal(o, true); +/// } +/// void UnRegister(vtkObjectBase* o) override +/// { +/// this->UnRegisterInternal(o, true); +/// } /// /// protected: /// @@ -3641,6 +27980,58 @@ fn test_vtkTypeUInt8Array_create_drop() { let new_obj = vtkTypeUInt8Array(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } +/// Subclass of vtkAbstractArray that holds vtkUnicodeStrings +/// +/// +/// +/// +/// @par Thanks: +/// Developed by Timothy M. Shead (tshead@sandia.gov) at Sandia National Laboratories. +#[allow(non_camel_case_types)] +pub struct vtkUnicodeStringArray(*mut core::ffi::c_void); +impl vtkUnicodeStringArray { + /// Creates a new [vtkUnicodeStringArray] wrapped inside `vtkNew` + #[doc(alias = "vtkUnicodeStringArray")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkUnicodeStringArray_new() -> *mut core::ffi::c_void; + } + Self(unsafe { &mut *vtkUnicodeStringArray_new() }) + } + #[cfg(test)] + unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtkUnicodeStringArray_get_ptr( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtkUnicodeStringArray_get_ptr(self.0) } + } +} +impl std::default::Default for vtkUnicodeStringArray { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkUnicodeStringArray { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkUnicodeStringArray_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkUnicodeStringArray_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkUnicodeStringArray_create_drop() { + let obj = vtkUnicodeStringArray::new(); + let ptr = obj.0; + assert!(!ptr.is_null()); + assert!(unsafe { !obj._get_ptr().is_null() }); + drop(obj); + let new_obj = vtkUnicodeStringArray(ptr); + assert!(unsafe { new_obj._get_ptr().is_null() }); +} /// dynamic, self-adjusting array of unsigned char /// /// diff --git a/vtk-rs-9.1/src/vtkCommonDataModel.rs b/vtk-rs-9.1/src/vtkCommonDataModel.rs index e802577..87d8e1b 100644 --- a/vtk-rs-9.1/src/vtkCommonDataModel.rs +++ b/vtk-rs-9.1/src/vtkCommonDataModel.rs @@ -1,3 +1,70850 @@ +pub trait VtkAMRBox { + fn invalidate(&mut self) -> (); + fn empty_dimension(&mut self, i: core::ffi::c_int) -> bool; + fn set_dimensions( + &mut self, + ilo: core::ffi::c_int, + jlo: core::ffi::c_int, + klo: core::ffi::c_int, + ihi: core::ffi::c_int, + jhi: core::ffi::c_int, + khi: core::ffi::c_int, + desc: core::ffi::c_int, + ) -> (); + fn set_dimensions( + &mut self, + lo: core::ffi::c_int, + hi: core::ffi::c_int, + desc: core::ffi::c_int, + ) -> (); + fn set_dimensions(&mut self, dims: core::ffi::c_int, desc: core::ffi::c_int) -> (); + fn get_dimensions(&mut self, lo: core::ffi::c_int, hi: core::ffi::c_int) -> (); + fn get_dimensions(&mut self, dims: core::ffi::c_int) -> (); + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; + fn get_number_of_cells(&mut self, num: core::ffi::c_int) -> (); + fn get_number_of_nodes(&mut self, ext: core::ffi::c_int) -> (); + fn get_number_of_nodes(&mut self) -> core::ffi::c_uchar; + fn compute_dimension(&mut self) -> core::ffi::c_int; + fn get_lo_corner(&mut self) -> *const core::ffi::c_int; + fn get_hi_corner(&mut self) -> *const core::ffi::c_int; + fn get_valid_hi_corner(&mut self, hi: core::ffi::c_int) -> (); + fn empty(&mut self) -> bool; + fn is_invalid(&mut self) -> bool; + fn serialize( + &mut self, + buffer: core::ffi::c_uchar, + bytesize: core::ffi::c_uchar, + ) -> (); + fn serialize(&mut self, buffer: core::ffi::c_int) -> (); + fn deserialize( + &mut self, + buffer: core::ffi::c_uchar, + bytesize: core::ffi::c_uchar, + ) -> (); + fn does_box_intersect_along_dimension( + &mut self, + other: vtkAMRBox, + q: core::ffi::c_int, + ) -> bool; + fn does_intersect(&mut self, other: vtkAMRBox) -> bool; + fn coarsen(&mut self, r: core::ffi::c_int) -> (); + fn refine(&mut self, r: core::ffi::c_int) -> (); + fn grow(&mut self, byN: core::ffi::c_int) -> (); + fn shrink(&mut self, byN: core::ffi::c_int) -> (); + fn shift( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn shift(&mut self, I: core::ffi::c_int) -> (); + fn intersect(&mut self, other: vtkAMRBox) -> bool; + fn contains( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> bool; + fn contains(&mut self, I: core::ffi::c_int) -> bool; + fn contains(&mut self, p0: vtkAMRBox) -> bool; + fn get_ghost_vector(&mut self, r: core::ffi::c_int, nghost: core::ffi::c_int) -> (); + fn remove_ghosts(&mut self, r: core::ffi::c_int) -> (); + fn get_bytesize(&mut self) -> core::ffi::c_uchar; + fn get_cell_linear_index( + &mut self, + box_: vtkAMRBox, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + imageDimension: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_bounds( + &mut self, + box_: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + bounds: core::ffi::c_double, + ) -> (); + fn get_box_origin( + &mut self, + box_: vtkAMRBox, + X0: core::ffi::c_double, + spacing: core::ffi::c_double, + x0: core::ffi::c_double, + ) -> (); + fn has_point( + &mut self, + box_: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> bool; + fn compute_structured_coordinates( + &mut self, + box_: vtkAMRBox, + dataOrigin: core::ffi::c_double, + h: core::ffi::c_double, + x: core::ffi::c_double, + ijk: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; +} +pub trait VtkAMRDataInternals { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn insert(&mut self, index: core::ffi::c_uint, grid: *mut core::ffi::c_void) -> (); + fn get_data_set( + &mut self, + compositeIndex: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn empty(&mut self) -> bool; + fn get_number_of_blocks(&mut self) -> core::ffi::c_uint; + fn get_block(&mut self, i: core::ffi::c_uint) -> Block; + fn get_all_blocks(&mut self) -> Vec; +} +pub trait VtkAMRInformation { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + numLevels: core::ffi::c_int, + blocksPerLevel: core::ffi::c_int, + ) -> (); + fn get_grid_description(&mut self) -> core::ffi::c_int; + fn set_grid_description(&mut self, description: core::ffi::c_int) -> (); + fn get_origin(&mut self, origin: core::ffi::c_double) -> (); + fn get_origin(&mut self) -> *mut core::ffi::c_double; + fn set_origin(&mut self, origin: core::ffi::c_double) -> (); + fn get_number_of_levels(&mut self) -> core::ffi::c_uint; + fn get_number_of_data_sets(&mut self, level: core::ffi::c_uint) -> core::ffi::c_uint; + fn get_total_number_of_blocks(&mut self) -> core::ffi::c_uint; + fn get_index( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> core::ffi::c_int; + fn compute_index_pair( + &mut self, + index: core::ffi::c_uint, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> (); + fn get_bounds(&mut self) -> *const core::ffi::c_double; + fn get_bounds( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + bb: core::ffi::c_double, + ) -> (); + fn get_origin( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + origin: core::ffi::c_double, + ) -> bool; + fn get_spacing( + &mut self, + level: core::ffi::c_uint, + spacing: core::ffi::c_double, + ) -> (); + fn has_spacing(&mut self, level: core::ffi::c_uint) -> bool; + fn set_amr_box( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + box_: vtkAMRBox, + ) -> (); + fn get_amr_box( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> vtkAMRBox; + fn get_coarsened_amr_box( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + box_: *mut core::ffi::c_void, + ) -> bool; + fn get_amr_block_source_index( + &mut self, + index: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_amr_block_source_index( + &mut self, + index: core::ffi::c_int, + sourceId: core::ffi::c_int, + ) -> (); + fn generate_refinement_ratio(&mut self) -> (); + fn has_refinement_ratio(&mut self) -> bool; + fn set_refinement_ratio( + &mut self, + level: core::ffi::c_uint, + ratio: core::ffi::c_int, + ) -> (); + fn get_refinement_ratio(&mut self, level: core::ffi::c_uint) -> core::ffi::c_int; + fn set_spacing(&mut self, level: core::ffi::c_uint, h: core::ffi::c_double) -> (); + fn has_children_information(&mut self) -> bool; + fn get_parents( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + numParents: core::ffi::c_uint, + ) -> *mut core::ffi::c_uint; + fn get_children( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + numChildren: core::ffi::c_uint, + ) -> *mut core::ffi::c_uint; + fn print_parent_child_info( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> (); + fn generate_parent_child_information(&mut self) -> (); + fn audit(&mut self) -> bool; + fn find_cell( + &mut self, + q: core::ffi::c_double, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + cellIdx: core::ffi::c_int, + ) -> bool; + fn find_grid( + &mut self, + q: core::ffi::c_double, + level: core::ffi::c_int, + gridId: core::ffi::c_uint, + ) -> bool; + fn find_grid( + &mut self, + q: core::ffi::c_double, + level: core::ffi::c_uint, + gridId: core::ffi::c_uint, + ) -> bool; + fn get_num_blocks(&mut self) -> Vec; + fn get_children_at_level( + &mut self, + i: core::ffi::c_uint, + ) -> Vec>; + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); +} +pub trait VtkAMRUtilities { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn strip_ghost_layers( + &mut self, + ghostedAMRData: *mut core::ffi::c_void, + strippedAMRData: *mut core::ffi::c_void, + ) -> (); + fn has_partially_overlapping_ghost_cells( + &mut self, + amr: *mut core::ffi::c_void, + ) -> bool; + fn blank_cells(&mut self, amr: *mut core::ffi::c_void) -> (); +} +pub trait VtkAbstractCellLinks { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn build_links(&mut self, data: *mut core::ffi::c_void) -> (); + fn initialize(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn compute_type( + &mut self, + maxPtId: core::ffi::c_uchar, + maxCellId: core::ffi::c_uchar, + ca: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_type(&mut self) -> core::ffi::c_int; + fn select_cells( + &mut self, + minMaxDegree: core::ffi::c_uchar, + cellSelection: core::ffi::c_uchar, + ) -> (); + fn set_sequential_processing(&mut self, _arg: bool) -> (); + fn get_sequential_processing(&mut self) -> bool; + fn sequential_processing_on(&mut self) -> (); + fn sequential_processing_off(&mut self) -> (); +} +pub trait VtkAbstractCellLocator: VtkLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_cells_per_node(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_cells_per_node_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_cells_per_node_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_cells_per_node(&mut self) -> core::ffi::c_int; + fn set_cache_cell_bounds(&mut self, _arg: core::ffi::c_int) -> (); + fn get_cache_cell_bounds(&mut self) -> core::ffi::c_int; + fn cache_cell_bounds_on(&mut self) -> (); + fn cache_cell_bounds_off(&mut self) -> (); + fn set_retain_cell_lists(&mut self, _arg: core::ffi::c_int) -> (); + fn get_retain_cell_lists(&mut self) -> core::ffi::c_int; + fn retain_cell_lists_on(&mut self) -> (); + fn retain_cell_lists_off(&mut self) -> (); + fn set_lazy_evaluation(&mut self, _arg: core::ffi::c_int) -> (); + fn get_lazy_evaluation(&mut self) -> core::ffi::c_int; + fn lazy_evaluation_on(&mut self) -> (); + fn lazy_evaluation_off(&mut self) -> (); + fn set_use_existing_search_structure(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_existing_search_structure(&mut self) -> core::ffi::c_int; + fn use_existing_search_structure_on(&mut self) -> (); + fn use_existing_search_structure_off(&mut self) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + points: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + ) -> (); + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + ) -> (); + fn find_closest_point_within_radius( + &mut self, + x: core::ffi::c_double, + radius: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + x: core::ffi::c_double, + radius: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + x: core::ffi::c_double, + radius: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + inside: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn find_cells_within_bounds( + &mut self, + bbox: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ) -> (); + fn find_cells_along_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tolerance: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ) -> (); + fn find_cell(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_cell( + &mut self, + x: core::ffi::c_double, + tol2: core::ffi::c_double, + GenCell: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn inside_cell_bounds( + &mut self, + x: core::ffi::c_double, + cell_ID: core::ffi::c_uchar, + ) -> bool; +} +pub trait VtkAbstractElectronicData: VtkDataObject { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_number_of_m_os(&mut self) -> core::ffi::c_uchar; + fn get_number_of_electrons(&mut self) -> core::ffi::c_uchar; + fn get_mo(&mut self, orbitalNumber: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_electron_density(&mut self) -> *mut core::ffi::c_void; + fn get_homo(&mut self) -> *mut core::ffi::c_void; + fn get_lumo(&mut self) -> *mut core::ffi::c_void; + fn get_homo_orbital_number(&mut self) -> core::ffi::c_uchar; + fn get_lumo_orbital_number(&mut self) -> core::ffi::c_uchar; + fn is_homo(&mut self, orbitalNumber: core::ffi::c_uchar) -> bool; + fn is_lumo(&mut self, orbitalNumber: core::ffi::c_uchar) -> bool; + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn get_padding(&mut self) -> core::ffi::c_double; +} +pub trait VtkAbstractPointLocator: VtkLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_bounds(&mut self, p0: core::ffi::c_double) -> (); + fn get_number_of_buckets(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkAdjacentVertexIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> (); + fn get_graph(&mut self) -> *mut core::ffi::c_void; + fn get_vertex(&mut self) -> core::ffi::c_uchar; + fn next(&mut self) -> core::ffi::c_uchar; + fn has_next(&mut self) -> bool; +} +pub trait VtkAngularPeriodicDataArray: VtkPeriodicDataArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_angle(&mut self, angle: core::ffi::c_double) -> (); + fn get_angle(&mut self) -> core::ffi::c_double; + fn set_center(&mut self, center: core::ffi::c_double) -> (); + fn get_center(&mut self) -> *mut core::ffi::c_double; + fn get_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_center(&mut self, _arg: core::ffi::c_double) -> (); + fn set_axis(&mut self, axis: core::ffi::c_int) -> (); + fn get_axis(&mut self) -> core::ffi::c_int; + fn set_axis_to_x(&mut self) -> (); + fn set_axis_to_y(&mut self) -> (); + fn set_axis_to_z(&mut self) -> (); +} +pub trait VtkAnimationScene { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_play_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn set_mode_to_sequence(&mut self) -> (); + fn set_mode_to_real_time(&mut self) -> (); + fn get_play_mode(&mut self) -> core::ffi::c_int; + fn set_frame_rate(&mut self, _arg: core::ffi::c_double) -> (); + fn get_frame_rate(&mut self) -> core::ffi::c_double; + fn add_cue(&mut self, cue: *mut core::ffi::c_void) -> (); + fn remove_cue(&mut self, cue: *mut core::ffi::c_void) -> (); + fn remove_all_cues(&mut self) -> (); + fn get_number_of_cues(&mut self) -> core::ffi::c_int; + fn play(&mut self) -> (); + fn stop(&mut self) -> (); + fn set_loop(&mut self, _arg: core::ffi::c_int) -> (); + fn get_loop(&mut self) -> core::ffi::c_int; + fn set_animation_time(&mut self, time: core::ffi::c_double) -> (); + fn set_time_mode(&mut self, mode: core::ffi::c_int) -> (); + fn is_in_play(&mut self) -> core::ffi::c_int; +} +pub trait VtkAnnotation: VtkDataObject { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_selection(&mut self) -> *mut core::ffi::c_void; + fn set_selection(&mut self, selection: *mut core::ffi::c_void) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn label(&mut self) -> *mut core::ffi::c_void; + fn color(&mut self) -> *mut core::ffi::c_void; + fn opacity(&mut self) -> *mut core::ffi::c_void; + fn icon_index(&mut self) -> *mut core::ffi::c_void; + fn enable(&mut self) -> *mut core::ffi::c_void; + fn hide(&mut self) -> *mut core::ffi::c_void; + fn data(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkAnnotationLayers: VtkDataObject { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn set_current_annotation(&mut self, ann: *mut core::ffi::c_void) -> (); + fn get_current_annotation(&mut self) -> *mut core::ffi::c_void; + fn set_current_selection(&mut self, sel: *mut core::ffi::c_void) -> (); + fn get_current_selection(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_annotations(&mut self) -> core::ffi::c_uint; + fn get_annotation(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn add_annotation(&mut self, ann: *mut core::ffi::c_void) -> (); + fn remove_annotation(&mut self, ann: *mut core::ffi::c_void) -> (); + fn initialize(&mut self) -> (); + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkArrayData: VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn add_array(&mut self, p0: *mut core::ffi::c_void) -> (); + fn clear_arrays(&mut self) -> (); + fn get_number_of_arrays(&mut self) -> core::ffi::c_uchar; + fn get_array(&mut self, index: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_array_by_name(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); +} +pub trait VtkAtom { + fn get_id(&mut self) -> core::ffi::c_uchar; + fn get_molecule(&mut self) -> *mut core::ffi::c_void; + fn get_atomic_number(&mut self) -> core::ffi::c_ushort; + fn set_atomic_number(&mut self, atomicNum: core::ffi::c_ushort) -> (); + fn get_position(&mut self, pos: core::ffi::c_float) -> (); + fn get_position(&mut self, pos: core::ffi::c_double) -> (); + fn set_position(&mut self, pos: core::ffi::c_float) -> (); + fn set_position( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + z: core::ffi::c_float, + ) -> (); + fn get_position(&mut self) -> *mut core::ffi::c_void; + fn set_position(&mut self, pos: vtkVector3f) -> (); +} +pub trait VtkAttributesErrorMetric: VtkGenericSubdivisionErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_absolute_attribute_tolerance(&mut self) -> core::ffi::c_double; + fn set_absolute_attribute_tolerance(&mut self, value: core::ffi::c_double) -> (); + fn get_attribute_tolerance(&mut self) -> core::ffi::c_double; + fn set_attribute_tolerance(&mut self, value: core::ffi::c_double) -> (); + fn requires_edge_subdivision( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_error( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkBSPCuts: VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn create_cuts( + &mut self, + bounds: core::ffi::c_double, + ncuts: core::ffi::c_int, + dim: core::ffi::c_int, + coord: core::ffi::c_double, + lower: core::ffi::c_int, + upper: core::ffi::c_int, + lowerDataCoord: core::ffi::c_double, + upperDataCoord: core::ffi::c_double, + npoints: core::ffi::c_int, + ) -> (); + fn create_cuts(&mut self, kd: *mut core::ffi::c_void) -> (); + fn get_kd_node_tree(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_cuts(&mut self) -> core::ffi::c_int; + fn get_arrays( + &mut self, + len: core::ffi::c_int, + dim: core::ffi::c_int, + coord: core::ffi::c_double, + lower: core::ffi::c_int, + upper: core::ffi::c_int, + lowerDataCoord: core::ffi::c_double, + upperDataCoord: core::ffi::c_double, + npoints: core::ffi::c_int, + ) -> core::ffi::c_int; + fn equals( + &mut self, + other: *mut core::ffi::c_void, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int; + fn print_tree(&mut self) -> (); + fn print_arrays(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); +} +pub trait VtkBSPIntersections { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_cuts(&mut self, cuts: *mut core::ffi::c_void) -> (); + fn get_cuts(&mut self) -> *mut core::ffi::c_void; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> core::ffi::c_int; + fn get_number_of_regions(&mut self) -> core::ffi::c_int; + fn get_region_bounds( + &mut self, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_region_data_bounds( + &mut self, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersects_box( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersects_box( + &mut self, + regionId: core::ffi::c_int, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + y0: core::ffi::c_double, + y1: core::ffi::c_double, + z0: core::ffi::c_double, + z1: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersects_box( + &mut self, + ids: core::ffi::c_int, + len: core::ffi::c_int, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersects_box( + &mut self, + ids: core::ffi::c_int, + len: core::ffi::c_int, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + y0: core::ffi::c_double, + y1: core::ffi::c_double, + z0: core::ffi::c_double, + z1: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersects_sphere_2( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersects_sphere_2( + &mut self, + ids: core::ffi::c_int, + len: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersects_cell( + &mut self, + regionId: core::ffi::c_int, + cell: *mut core::ffi::c_void, + cellRegion: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersects_cell( + &mut self, + ids: core::ffi::c_int, + len: core::ffi::c_int, + cell: *mut core::ffi::c_void, + cellRegion: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_compute_intersections_using_data_bounds(&mut self) -> core::ffi::c_int; + fn set_compute_intersections_using_data_bounds(&mut self, c: core::ffi::c_int) -> (); + fn compute_intersections_using_data_bounds_on(&mut self) -> (); + fn compute_intersections_using_data_bounds_off(&mut self) -> (); +} +pub trait VtkBezierCurve: VtkHigherOrderCurve + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierHexahedron: VtkHigherOrderHexahedron + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> (); + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierInterpolation: VtkHigherOrderInterpolation { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn flatten_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + coord: vtkVector3i, + ) -> core::ffi::c_int; + fn flatten_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + coord: vtkVector3i, + ) -> core::ffi::c_int; + fn unflatten_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + flat: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn un_flatten_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + flat: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn de_casteljau_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn de_casteljau_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn de_casteljau_simplex_deriv( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn de_casteljau_simplex_deriv( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn evaluate_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> (); + fn evaluate_shape_and_gradient( + &mut self, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + grad: core::ffi::c_double, + ) -> (); + fn tensor_1_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_1_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_2_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_2_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_3_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_3_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_3_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ) -> (); + fn wedge_shape_functions( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> (); + fn wedge_shape_derivatives( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn wedge_evaluate( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldAtPCoords: core::ffi::c_double, + ) -> (); + fn wedge_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkBezierQuadrilateral: VtkHigherOrderQuadrilateral + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> (); + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierTetra: VtkHigherOrderTetra + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierTriangle: VtkHigherOrderTriangle + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierWedge: VtkHigherOrderWedge + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> (); + fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void; + fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBiQuadraticQuad: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkBiQuadraticQuadraticHexahedron: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkBiQuadraticQuadraticWedge: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkBiQuadraticTriangle: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkBond { + fn get_id(&mut self) -> core::ffi::c_uchar; + fn get_molecule(&mut self) -> *mut core::ffi::c_void; + fn get_begin_atom_id(&mut self) -> core::ffi::c_uchar; + fn get_end_atom_id(&mut self) -> core::ffi::c_uchar; + fn get_begin_atom(&mut self) -> *mut core::ffi::c_void; + fn get_end_atom(&mut self) -> *mut core::ffi::c_void; + fn get_begin_atom(&mut self) -> *mut core::ffi::c_void; + fn get_end_atom(&mut self) -> *mut core::ffi::c_void; + fn get_order(&mut self) -> core::ffi::c_ushort; + fn get_length(&mut self) -> core::ffi::c_double; +} +pub trait VtkBoundingBox { + fn set_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn compute_bounds( + &mut self, + pts: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ) -> (); + fn compute_bounds( + &mut self, + pts: *mut core::ffi::c_void, + ptUses: core::ffi::c_uchar, + bounds: core::ffi::c_double, + ) -> (); + fn compute_bounds(&mut self, pts: *mut core::ffi::c_void) -> (); + fn compute_bounds( + &mut self, + pts: *mut core::ffi::c_void, + ptUses: core::ffi::c_uchar, + ) -> (); + fn compute_local_bounds( + &mut self, + points: *mut core::ffi::c_void, + u: core::ffi::c_double, + v: core::ffi::c_double, + w: core::ffi::c_double, + outputBounds: core::ffi::c_double, + ) -> (); + fn set_min_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_min_point(&mut self, p: core::ffi::c_double) -> (); + fn set_max_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_max_point(&mut self, p: core::ffi::c_double) -> (); + fn is_valid(&mut self) -> core::ffi::c_int; + fn is_valid(&mut self, bounds: core::ffi::c_double) -> core::ffi::c_int; + fn add_point(&mut self, p: core::ffi::c_double) -> (); + fn add_point( + &mut self, + px: core::ffi::c_double, + py: core::ffi::c_double, + pz: core::ffi::c_double, + ) -> (); + fn add_box(&mut self, bbox: vtkBoundingBox) -> (); + fn add_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn is_subset_of(&mut self, bbox: vtkBoundingBox) -> bool; + fn intersect_box(&mut self, bbox: vtkBoundingBox) -> core::ffi::c_int; + fn intersects(&mut self, bbox: vtkBoundingBox) -> core::ffi::c_int; + fn intersect_plane( + &mut self, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + ) -> bool; + fn intersects_sphere( + &mut self, + center: core::ffi::c_double, + squaredRadius: core::ffi::c_double, + ) -> bool; + fn intersects_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> bool; + fn compute_inner_dimension(&mut self) -> core::ffi::c_int; + fn contains(&mut self, bbox: vtkBoundingBox) -> core::ffi::c_int; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn get_bound(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn get_min_point(&mut self) -> *const core::ffi::c_double; + fn get_min_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn get_min_point(&mut self, x: core::ffi::c_double) -> (); + fn get_max_point(&mut self) -> *const core::ffi::c_double; + fn get_max_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn get_max_point(&mut self, x: core::ffi::c_double) -> (); + fn get_corner(&mut self, corner: core::ffi::c_int, p: core::ffi::c_double) -> (); + fn contains_point(&mut self, p: core::ffi::c_double) -> core::ffi::c_int; + fn contains_point( + &mut self, + px: core::ffi::c_double, + py: core::ffi::c_double, + pz: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_center(&mut self, center: core::ffi::c_double) -> (); + fn get_lengths(&mut self, lengths: core::ffi::c_double) -> (); + fn get_length(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn get_max_length(&mut self) -> core::ffi::c_double; + fn get_diagonal_length(&mut self) -> core::ffi::c_double; + fn inflate(&mut self, delta: core::ffi::c_double) -> (); + fn inflate( + &mut self, + deltaX: core::ffi::c_double, + deltaY: core::ffi::c_double, + deltaZ: core::ffi::c_double, + ) -> (); + fn inflate(&mut self) -> (); + fn scale(&mut self, s: core::ffi::c_double) -> (); + fn scale( + &mut self, + sx: core::ffi::c_double, + sy: core::ffi::c_double, + sz: core::ffi::c_double, + ) -> (); + fn scale_about_center(&mut self, s: core::ffi::c_double) -> (); + fn scale_about_center(&mut self, s: core::ffi::c_double) -> (); + fn scale_about_center( + &mut self, + sx: core::ffi::c_double, + sy: core::ffi::c_double, + sz: core::ffi::c_double, + ) -> (); + fn compute_divisions( + &mut self, + totalBins: core::ffi::c_uchar, + bounds: core::ffi::c_double, + divs: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn clamp_divisions( + &mut self, + targetBins: core::ffi::c_uchar, + divs: core::ffi::c_int, + ) -> (); + fn reset(&mut self) -> (); +} +pub trait VtkBox: VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn set_x_min(&mut self, p: core::ffi::c_double) -> (); + fn set_x_min( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn get_x_min(&mut self, p: core::ffi::c_double) -> (); + fn get_x_min( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_x_max(&mut self, p: core::ffi::c_double) -> (); + fn set_x_max( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn get_x_max(&mut self, p: core::ffi::c_double) -> (); + fn get_x_max( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn set_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn add_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn intersect_box( + &mut self, + bounds: core::ffi::c_double, + origin: core::ffi::c_double, + dir: core::ffi::c_double, + coord: core::ffi::c_double, + t: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_char; + fn intersect_with_line( + &mut self, + bounds: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + plane1: core::ffi::c_int, + plane2: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersect_with_infinite_line( + &mut self, + bounds: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + plane1: core::ffi::c_int, + plane2: core::ffi::c_int, + ) -> bool; + fn intersect_with_plane( + &mut self, + bounds: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_with_plane( + &mut self, + bounds: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + xout: core::ffi::c_double, + ) -> core::ffi::c_int; + fn is_box_in_frustum( + &mut self, + planes: core::ffi::c_double, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; +} +pub trait VtkCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + p: *mut core::ffi::c_void, + ) -> (); + fn initialize(&mut self, npts: core::ffi::c_int, p: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, c: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, c: *mut core::ffi::c_void) -> (); + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn is_linear(&mut self) -> core::ffi::c_int; + fn requires_initialization(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn is_explicit_cell(&mut self) -> core::ffi::c_int; + fn requires_explicit_face_representation(&mut self) -> core::ffi::c_int; + fn set_faces(&mut self, faces: core::ffi::c_uchar) -> (); + fn get_faces(&mut self) -> *mut core::ffi::c_uchar; + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_point_ids(&mut self) -> *mut core::ffi::c_void; + fn get_point_id(&mut self, ptId: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; + fn compute_bounding_sphere( + &mut self, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersect_with_cell( + &mut self, + other: *mut core::ffi::c_void, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_with_cell( + &mut self, + other: *mut core::ffi::c_void, + boudingBox: vtkBoundingBox, + otherBoundingBox: vtkBoundingBox, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_length_2(&mut self) -> core::ffi::c_double; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + fn is_primary_cell(&mut self) -> core::ffi::c_int; + fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weight: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkCell3D: VtkCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> (); + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn is_inside_out(&mut self) -> bool; + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; + fn set_merge_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_merge_tolerance_min_value(&mut self) -> core::ffi::c_double; + fn get_merge_tolerance_max_value(&mut self) -> core::ffi::c_double; + fn get_merge_tolerance(&mut self) -> core::ffi::c_double; +} +pub trait VtkCellArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_uchar, + maxCellSize: core::ffi::c_uchar, + ) -> bool; + fn allocate_exact( + &mut self, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool; + fn allocate_copy(&mut self, other: *mut core::ffi::c_void) -> bool; + fn resize_exact( + &mut self, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool; + fn initialize(&mut self) -> (); + fn reset(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn is_valid(&mut self) -> bool; + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; + fn get_number_of_offsets(&mut self) -> core::ffi::c_uchar; + fn get_number_of_connectivity_ids(&mut self) -> core::ffi::c_uchar; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn set_data( + &mut self, + offsets: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + ) -> bool; + fn set_data( + &mut self, + cellSize: core::ffi::c_uchar, + connectivity: *mut core::ffi::c_void, + ) -> bool; + fn is_storage_64_bit(&mut self) -> bool; + fn is_storage_shareable(&mut self) -> bool; + fn use_32_bit_storage(&mut self) -> (); + fn use_64_bit_storage(&mut self) -> (); + fn use_default_storage(&mut self) -> (); + fn can_convert_to_32_bit_storage(&mut self) -> bool; + fn can_convert_to_64_bit_storage(&mut self) -> bool; + fn can_convert_to_default_storage(&mut self) -> bool; + fn convert_to_32_bit_storage(&mut self) -> bool; + fn convert_to_64_bit_storage(&mut self) -> bool; + fn convert_to_default_storage(&mut self) -> bool; + fn convert_to_smallest_storage(&mut self) -> bool; + fn get_offsets_array(&mut self) -> *mut core::ffi::c_void; + fn get_offsets_array_32(&mut self) -> *mut core::ffi::c_void; + fn get_offsets_array_64(&mut self) -> *mut core::ffi::c_void; + fn get_connectivity_array(&mut self) -> *mut core::ffi::c_void; + fn get_connectivity_array_32(&mut self) -> *mut core::ffi::c_void; + fn get_connectivity_array_64(&mut self) -> *mut core::ffi::c_void; + fn is_homogeneous(&mut self) -> core::ffi::c_uchar; + fn init_traversal(&mut self) -> (); + fn get_next_cell( + &mut self, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn get_next_cell(&mut self, pts: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + cellSize: core::ffi::c_uchar, + cellPoints: core::ffi::c_uchar, + ) -> (); + fn get_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + pts: *mut core::ffi::c_void, + ) -> (); + fn get_cell_size(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn insert_next_cell(&mut self, cell: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn insert_next_cell( + &mut self, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn insert_next_cell(&mut self, pts: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn insert_next_cell( + &mut self, + cell: std::collections::LinkedList, + ) -> core::ffi::c_uchar; + fn insert_next_cell(&mut self, npts: core::ffi::c_int) -> core::ffi::c_uchar; + fn insert_cell_point(&mut self, id: core::ffi::c_uchar) -> (); + fn update_cell_count(&mut self, npts: core::ffi::c_int) -> (); + fn get_traversal_cell_id(&mut self) -> core::ffi::c_uchar; + fn set_traversal_cell_id(&mut self, cellId: core::ffi::c_uchar) -> (); + fn reverse_cell_at_id(&mut self, cellId: core::ffi::c_uchar) -> (); + fn replace_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + list: *mut core::ffi::c_void, + ) -> (); + fn replace_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + cellSize: core::ffi::c_uchar, + cellPoints: core::ffi::c_uchar, + ) -> (); + fn replace_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + cell: std::collections::LinkedList, + ) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn deep_copy(&mut self, ca: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, ca: *mut core::ffi::c_void) -> (); + fn append( + &mut self, + src: *mut core::ffi::c_void, + pointOffset: core::ffi::c_uchar, + ) -> (); + fn export_legacy_format(&mut self, data: *mut core::ffi::c_void) -> (); + fn import_legacy_format(&mut self, data: *mut core::ffi::c_void) -> (); + fn import_legacy_format( + &mut self, + data: core::ffi::c_uchar, + len: core::ffi::c_uchar, + ) -> (); + fn append_legacy_format( + &mut self, + data: *mut core::ffi::c_void, + ptOffset: core::ffi::c_uchar, + ) -> (); + fn append_legacy_format( + &mut self, + data: core::ffi::c_uchar, + len: core::ffi::c_uchar, + ptOffset: core::ffi::c_uchar, + ) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn set_number_of_cells(&mut self, p0: core::ffi::c_uchar) -> (); + fn estimate_size( + &mut self, + numCells: core::ffi::c_uchar, + maxPtsPerCell: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn get_size(&mut self) -> core::ffi::c_uchar; + fn get_number_of_connectivity_entries(&mut self) -> core::ffi::c_uchar; + fn get_cell( + &mut self, + loc: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_cell(&mut self, loc: core::ffi::c_uchar, pts: *mut core::ffi::c_void) -> (); + fn get_insert_location(&mut self, npts: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_traversal_location(&mut self) -> core::ffi::c_uchar; + fn get_traversal_location(&mut self, npts: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn set_traversal_location(&mut self, loc: core::ffi::c_uchar) -> (); + fn reverse_cell(&mut self, loc: core::ffi::c_uchar) -> (); + fn replace_cell( + &mut self, + loc: core::ffi::c_uchar, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> (); + fn set_cells( + &mut self, + ncells: core::ffi::c_uchar, + cells: *mut core::ffi::c_void, + ) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCellArrayIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_cell_array(&mut self) -> *mut core::ffi::c_void; + fn go_to_cell(&mut self, cellId: core::ffi::c_uchar) -> (); + fn get_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + numCellPts: core::ffi::c_uchar, + cellPts: core::ffi::c_uchar, + ) -> (); + fn get_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_cell_at_id(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn go_to_first_cell(&mut self) -> (); + fn go_to_next_cell(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> bool; + fn get_current_cell_id(&mut self) -> core::ffi::c_uchar; + fn get_current_cell( + &mut self, + cellSize: core::ffi::c_uchar, + cellPoints: core::ffi::c_uchar, + ) -> (); + fn get_current_cell(&mut self, ids: *mut core::ffi::c_void) -> (); + fn get_current_cell(&mut self) -> *mut core::ffi::c_void; + fn replace_current_cell(&mut self, list: *mut core::ffi::c_void) -> (); + fn replace_current_cell( + &mut self, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn reverse_current_cell(&mut self) -> (); +} +pub trait VtkCellData: VtkDataSetAttributes + VtkFieldData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCellIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn init_traversal(&mut self) -> (); + fn go_to_next_cell(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> bool; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_cell_id(&mut self) -> core::ffi::c_uchar; + fn get_point_ids(&mut self) -> *mut core::ffi::c_void; + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn get_faces(&mut self) -> *mut core::ffi::c_void; + fn get_cell(&mut self, cell: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_number_of_faces(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkCellLinks: VtkAbstractCellLinks { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn build_links(&mut self, data: *mut core::ffi::c_void) -> (); + fn allocate(&mut self, numLinks: core::ffi::c_uchar, ext: core::ffi::c_uchar) -> (); + fn initialize(&mut self) -> (); + fn get_link(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_ncells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_cells(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn select_cells( + &mut self, + minMaxDegree: core::ffi::c_uchar, + cellSelection: core::ffi::c_uchar, + ) -> (); + fn insert_next_point(&mut self, numLinks: core::ffi::c_int) -> core::ffi::c_uchar; + fn insert_next_cell_reference( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> (); + fn delete_point(&mut self, ptId: core::ffi::c_uchar) -> (); + fn remove_cell_reference( + &mut self, + cellId: core::ffi::c_uchar, + ptId: core::ffi::c_uchar, + ) -> (); + fn add_cell_reference( + &mut self, + cellId: core::ffi::c_uchar, + ptId: core::ffi::c_uchar, + ) -> (); + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_uchar, + size: core::ffi::c_int, + ) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); +} +pub trait VtkCellLocator: VtkAbstractCellLocator + VtkLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_cells_per_bucket(&mut self, N: core::ffi::c_int) -> (); + fn get_number_of_cells_per_bucket(&mut self) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + ) -> (); + fn find_closest_point_within_radius( + &mut self, + x: core::ffi::c_double, + radius: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + inside: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn get_cells(&mut self, bucket: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_buckets(&mut self) -> core::ffi::c_int; + fn find_cells_along_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tolerance: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ) -> (); + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn build_locator_if_needed(&mut self) -> (); + fn force_build_locator(&mut self) -> (); + fn build_locator_internal(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkCellLocatorStrategy: VtkFindCellStrategy { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn set_cell_locator(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_cell_locator(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCellTypes { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn insert_cell( + &mut self, + id: core::ffi::c_uchar, + type_: core::ffi::c_uchar, + loc: core::ffi::c_uchar, + ) -> (); + fn insert_next_cell( + &mut self, + type_: core::ffi::c_uchar, + loc: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn set_cell_types( + &mut self, + ncells: core::ffi::c_uchar, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + ) -> (); + fn set_cell_types( + &mut self, + ncells: core::ffi::c_uchar, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + ) -> (); + fn get_cell_location(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn delete_cell(&mut self, cellId: core::ffi::c_uchar) -> (); + fn get_number_of_types(&mut self) -> core::ffi::c_uchar; + fn is_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int; + fn insert_next_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_class_name_from_type_id( + &mut self, + typeId: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn get_type_id_from_class_name( + &mut self, + classname: core::ffi::c_char, + ) -> core::ffi::c_int; + fn is_linear(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void; + fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkClosestNPointsStrategy: VtkClosestPointStrategy + VtkFindCellStrategy { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn set_closest_n_points(&mut self, _arg: core::ffi::c_int) -> (); + fn get_closest_n_points_min_value(&mut self) -> core::ffi::c_int; + fn get_closest_n_points_max_value(&mut self) -> core::ffi::c_int; + fn get_closest_n_points(&mut self) -> core::ffi::c_int; +} +pub trait VtkClosestPointStrategy: VtkFindCellStrategy { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn set_point_locator(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_point_locator(&mut self) -> *mut core::ffi::c_void; + fn select_cell( + &mut self, + self_: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkColor3 { + fn set(&mut self, red: T, green: T, blue: T) -> (); + fn set_red(&mut self, red: T) -> (); + fn get_red(&mut self) -> T; + fn set_green(&mut self, green: T) -> (); + fn get_green(&mut self) -> T; + fn set_blue(&mut self, blue: T) -> (); + fn get_blue(&mut self) -> T; +} +pub trait VtkColor3d: VtkColor3 { + fn set( + &mut self, + red: core::ffi::c_double, + green: core::ffi::c_double, + blue: core::ffi::c_double, + ) -> (); + fn set_red(&mut self, red: core::ffi::c_double) -> (); + fn get_red(&mut self) -> core::ffi::c_double; + fn set_green(&mut self, green: core::ffi::c_double) -> (); + fn get_green(&mut self) -> core::ffi::c_double; + fn set_blue(&mut self, blue: core::ffi::c_double) -> (); + fn get_blue(&mut self) -> core::ffi::c_double; + fn get_data(&mut self) -> *mut core::ffi::c_double; + fn get_data(&mut self) -> *const core::ffi::c_double; +} +pub trait VtkColor3f: VtkColor3 { + fn set( + &mut self, + red: core::ffi::c_float, + green: core::ffi::c_float, + blue: core::ffi::c_float, + ) -> (); + fn set_red(&mut self, red: core::ffi::c_float) -> (); + fn get_red(&mut self) -> core::ffi::c_float; + fn set_green(&mut self, green: core::ffi::c_float) -> (); + fn get_green(&mut self) -> core::ffi::c_float; + fn set_blue(&mut self, blue: core::ffi::c_float) -> (); + fn get_blue(&mut self) -> core::ffi::c_float; + fn get_data(&mut self) -> *mut core::ffi::c_float; + fn get_data(&mut self) -> *const core::ffi::c_float; +} +pub trait VtkColor3ub: VtkColor3 { + fn set( + &mut self, + red: core::ffi::c_uchar, + green: core::ffi::c_uchar, + blue: core::ffi::c_uchar, + ) -> (); + fn set_red(&mut self, red: core::ffi::c_uchar) -> (); + fn get_red(&mut self) -> core::ffi::c_uchar; + fn set_green(&mut self, green: core::ffi::c_uchar) -> (); + fn get_green(&mut self) -> core::ffi::c_uchar; + fn set_blue(&mut self, blue: core::ffi::c_uchar) -> (); + fn get_blue(&mut self) -> core::ffi::c_uchar; + fn get_data(&mut self) -> *mut core::ffi::c_uchar; + fn get_data(&mut self) -> *const core::ffi::c_uchar; +} +pub trait VtkColor4 { + fn set(&mut self, red: T, green: T, blue: T) -> (); + fn set(&mut self, red: T, green: T, blue: T, alpha: T) -> (); + fn set_red(&mut self, red: T) -> (); + fn get_red(&mut self) -> T; + fn set_green(&mut self, green: T) -> (); + fn get_green(&mut self) -> T; + fn set_blue(&mut self, blue: T) -> (); + fn get_blue(&mut self) -> T; + fn set_alpha(&mut self, alpha: T) -> (); + fn get_alpha(&mut self) -> T; +} +pub trait VtkColor4d: VtkColor4 { + fn set( + &mut self, + red: core::ffi::c_double, + green: core::ffi::c_double, + blue: core::ffi::c_double, + ) -> (); + fn set( + &mut self, + red: core::ffi::c_double, + green: core::ffi::c_double, + blue: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> (); + fn set_red(&mut self, red: core::ffi::c_double) -> (); + fn get_red(&mut self) -> core::ffi::c_double; + fn set_green(&mut self, green: core::ffi::c_double) -> (); + fn get_green(&mut self) -> core::ffi::c_double; + fn set_blue(&mut self, blue: core::ffi::c_double) -> (); + fn get_blue(&mut self) -> core::ffi::c_double; + fn set_alpha(&mut self, alpha: core::ffi::c_double) -> (); + fn get_alpha(&mut self) -> core::ffi::c_double; + fn get_data(&mut self) -> *mut core::ffi::c_double; + fn get_data(&mut self) -> *const core::ffi::c_double; +} +pub trait VtkColor4f: VtkColor4 { + fn set( + &mut self, + red: core::ffi::c_float, + green: core::ffi::c_float, + blue: core::ffi::c_float, + ) -> (); + fn set( + &mut self, + red: core::ffi::c_float, + green: core::ffi::c_float, + blue: core::ffi::c_float, + alpha: core::ffi::c_float, + ) -> (); + fn set_red(&mut self, red: core::ffi::c_float) -> (); + fn get_red(&mut self) -> core::ffi::c_float; + fn set_green(&mut self, green: core::ffi::c_float) -> (); + fn get_green(&mut self) -> core::ffi::c_float; + fn set_blue(&mut self, blue: core::ffi::c_float) -> (); + fn get_blue(&mut self) -> core::ffi::c_float; + fn set_alpha(&mut self, alpha: core::ffi::c_float) -> (); + fn get_alpha(&mut self) -> core::ffi::c_float; + fn get_data(&mut self) -> *mut core::ffi::c_float; + fn get_data(&mut self) -> *const core::ffi::c_float; +} +pub trait VtkColor4ub: VtkColor4 { + fn set( + &mut self, + red: core::ffi::c_uchar, + green: core::ffi::c_uchar, + blue: core::ffi::c_uchar, + ) -> (); + fn set( + &mut self, + red: core::ffi::c_uchar, + green: core::ffi::c_uchar, + blue: core::ffi::c_uchar, + alpha: core::ffi::c_uchar, + ) -> (); + fn set_red(&mut self, red: core::ffi::c_uchar) -> (); + fn get_red(&mut self) -> core::ffi::c_uchar; + fn set_green(&mut self, green: core::ffi::c_uchar) -> (); + fn get_green(&mut self) -> core::ffi::c_uchar; + fn set_blue(&mut self, blue: core::ffi::c_uchar) -> (); + fn get_blue(&mut self) -> core::ffi::c_uchar; + fn set_alpha(&mut self, alpha: core::ffi::c_uchar) -> (); + fn get_alpha(&mut self) -> core::ffi::c_uchar; + fn get_data(&mut self) -> *mut core::ffi::c_uchar; + fn get_data(&mut self) -> *const core::ffi::c_uchar; +} +pub trait VtkCompositeDataIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_data_set(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn init_traversal(&mut self) -> (); + fn init_reverse_traversal(&mut self) -> (); + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; + fn get_current_data_object(&mut self) -> *mut core::ffi::c_void; + fn get_current_meta_data(&mut self) -> *mut core::ffi::c_void; + fn has_current_meta_data(&mut self) -> core::ffi::c_int; + fn set_skip_empty_nodes(&mut self, _arg: core::ffi::c_int) -> (); + fn get_skip_empty_nodes(&mut self) -> core::ffi::c_int; + fn skip_empty_nodes_on(&mut self) -> (); + fn skip_empty_nodes_off(&mut self) -> (); + fn get_current_flat_index(&mut self) -> core::ffi::c_uint; + fn get_reverse(&mut self) -> core::ffi::c_int; +} +pub trait VtkCompositeDataSet: VtkDataObject { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn copy_structure(&mut self, input: *mut core::ffi::c_void) -> (); + fn set_data_set( + &mut self, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ) -> (); + fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn name(&mut self) -> *mut core::ffi::c_void; + fn current_process_can_load_block(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCone: VtkImplicitFunction { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); + fn set_angle(&mut self, _arg: core::ffi::c_double) -> (); + fn get_angle_min_value(&mut self) -> core::ffi::c_double; + fn get_angle_max_value(&mut self) -> core::ffi::c_double; + fn get_angle(&mut self) -> core::ffi::c_double; +} +pub trait VtkConvexPointSet: VtkCell3D + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn has_fixed_topology(&mut self) -> core::ffi::c_int; + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; + fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn requires_initialization(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn is_primary_cell(&mut self) -> core::ffi::c_int; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> (); +} +pub trait VtkCubicLine: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkCylinder: VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_center(&mut self, _arg: core::ffi::c_double) -> (); + fn get_center(&mut self) -> *mut core::ffi::c_double; + fn get_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_center(&mut self, _arg: core::ffi::c_double) -> (); + fn set_axis( + &mut self, + ax: core::ffi::c_double, + ay: core::ffi::c_double, + az: core::ffi::c_double, + ) -> (); + fn set_axis(&mut self, a: core::ffi::c_double) -> (); + fn get_axis(&mut self) -> *mut core::ffi::c_double; + fn get_axis( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_axis(&mut self, _arg: core::ffi::c_double) -> (); +} +pub trait VtkDataAssembly { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn initialize_from_xml(&mut self, xmlcontents: core::ffi::c_char) -> bool; + fn serialize_to_xml(&mut self, indent: *mut core::ffi::c_void) -> &str; + fn get_root_node(&mut self) -> core::ffi::c_int; + fn set_root_node_name(&mut self, name: core::ffi::c_char) -> (); + fn get_root_node_name(&mut self) -> *const core::ffi::c_char; + fn add_node( + &mut self, + name: core::ffi::c_char, + parent: core::ffi::c_int, + ) -> core::ffi::c_int; + fn add_nodes( + &mut self, + names: Vec, + parent: core::ffi::c_int, + ) -> Vec; + fn add_subtree( + &mut self, + parent: core::ffi::c_int, + other: *mut core::ffi::c_void, + otherParent: core::ffi::c_int, + ) -> core::ffi::c_int; + fn remove_node(&mut self, id: core::ffi::c_int) -> bool; + fn set_node_name(&mut self, id: core::ffi::c_int, name: core::ffi::c_char) -> (); + fn get_node_name(&mut self, id: core::ffi::c_int) -> *const core::ffi::c_char; + fn get_node_path(&mut self, id: core::ffi::c_int) -> &str; + fn get_first_node_by_path(&mut self, path: core::ffi::c_char) -> core::ffi::c_int; + fn add_data_set_index( + &mut self, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool; + fn add_data_set_indices( + &mut self, + id: core::ffi::c_int, + dataset_indices: Vec, + ) -> bool; + fn add_data_set_index_range( + &mut self, + id: core::ffi::c_int, + index_start: core::ffi::c_uint, + count: core::ffi::c_int, + ) -> bool; + fn remove_data_set_index( + &mut self, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool; + fn remove_all_data_set_indices( + &mut self, + id: core::ffi::c_int, + traverse_subtree: bool, + ) -> bool; + fn find_first_node_with_name( + &mut self, + name: core::ffi::c_char, + traversal_order: core::ffi::c_int, + ) -> core::ffi::c_int; + fn find_nodes_with_name( + &mut self, + name: core::ffi::c_char, + sort_order: core::ffi::c_int, + ) -> Vec; + fn get_child_nodes( + &mut self, + parent: core::ffi::c_int, + traverse_subtree: bool, + traversal_order: core::ffi::c_int, + ) -> Vec; + fn get_number_of_children(&mut self, parent: core::ffi::c_int) -> core::ffi::c_int; + fn get_child( + &mut self, + parent: core::ffi::c_int, + index: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_child_index( + &mut self, + parent: core::ffi::c_int, + child: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parent(&mut self, id: core::ffi::c_int) -> core::ffi::c_int; + fn has_attribute(&mut self, id: core::ffi::c_int, name: core::ffi::c_char) -> bool; + fn set_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_char, + ) -> (); + fn set_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> (); + fn set_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uint, + ) -> (); + fn set_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uchar, + ) -> (); + fn get_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_char, + ) -> bool; + fn get_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> bool; + fn get_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uint, + ) -> bool; + fn get_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uchar, + ) -> bool; + fn get_attribute_or_default( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_char, + ) -> *const core::ffi::c_char; + fn get_attribute_or_default( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_attribute_or_default( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_uint, + ) -> core::ffi::c_uint; + fn get_attribute_or_default( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn visit( + &mut self, + visitor: *mut core::ffi::c_void, + traversal_order: core::ffi::c_int, + ) -> (); + fn visit( + &mut self, + id: core::ffi::c_int, + visitor: *mut core::ffi::c_void, + traversal_order: core::ffi::c_int, + ) -> (); + fn get_data_set_indices( + &mut self, + id: core::ffi::c_int, + traverse_subtree: bool, + traversal_order: core::ffi::c_int, + ) -> Vec; + fn get_data_set_indices( + &mut self, + ids: Vec, + traverse_subtree: bool, + traversal_order: core::ffi::c_int, + ) -> Vec; + fn select_nodes( + &mut self, + path_queries: Vec, + traversal_order: core::ffi::c_int, + ) -> Vec; + fn remap_data_set_indices( + &mut self, + mapping: std::collections::HashMap, + remove_unmapped: bool, + ) -> bool; + fn subset_copy( + &mut self, + other: *mut core::ffi::c_void, + selected_branches: Vec, + ) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn is_node_name_valid(&mut self, name: core::ffi::c_char) -> bool; + fn make_valid_node_name(&mut self, name: core::ffi::c_char) -> &str; + fn is_node_name_reserved(&mut self, name: core::ffi::c_char) -> bool; +} +pub trait VtkDataAssemblyUtilities { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn hierarchy_name(&mut self) -> *const core::ffi::c_char; + fn generate_hierarchy( + &mut self, + input: *mut core::ffi::c_void, + hierarchy: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> bool; + fn get_selected_composite_ids( + &mut self, + selectors: Vec, + hierarchyOrAssembly: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + leaf_nodes_only: bool, + ) -> Vec; + fn get_selector_for_composite_id( + &mut self, + id: core::ffi::c_uint, + hierarchy: *mut core::ffi::c_void, + ) -> &str; + fn get_selectors_for_composite_ids( + &mut self, + ids: Vec, + hierarchy: *mut core::ffi::c_void, + ) -> Vec; +} +pub trait VtkDataAssemblyVisitor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_information(&mut self) -> *mut core::ffi::c_void; + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn initialize(&mut self) -> (); + fn release_data(&mut self) -> (); + fn get_data_released(&mut self) -> core::ffi::c_int; + fn set_global_release_data_flag(&mut self, val: core::ffi::c_int) -> (); + fn global_release_data_flag_on(&mut self) -> (); + fn global_release_data_flag_off(&mut self) -> (); + fn get_global_release_data_flag(&mut self) -> core::ffi::c_int; + fn set_field_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_field_data(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_update_time(&mut self) -> core::ffi::c_ulong; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn copy_information_from_pipeline(&mut self, info: *mut core::ffi::c_void) -> (); + fn copy_information_to_pipeline(&mut self, info: *mut core::ffi::c_void) -> (); + fn get_active_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_named_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn remove_named_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: core::ffi::c_char, + ) -> (); + fn set_active_attribute( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeName: core::ffi::c_char, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_active_attribute_info( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + name: core::ffi::c_char, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + numTuples: core::ffi::c_int, + ) -> (); + fn set_point_data_active_scalar_info( + &mut self, + info: *mut core::ffi::c_void, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ) -> (); + fn data_has_been_generated(&mut self) -> (); + fn prepare_for_new_data(&mut self) -> (); + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn crop(&mut self, updateExtent: core::ffi::c_int) -> (); + fn get_attributes(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_ghost_array(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_attributes_as_field_data( + &mut self, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_attribute_type_for_array( + &mut self, + arr: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_association_type_as_string( + &mut self, + associationType: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn get_association_type_from_string( + &mut self, + associationName: core::ffi::c_char, + ) -> core::ffi::c_int; + fn data_type_name(&mut self) -> *mut core::ffi::c_void; + fn data_object(&mut self) -> *mut core::ffi::c_void; + fn data_extent_type(&mut self) -> *mut core::ffi::c_void; + fn data_extent(&mut self) -> *mut core::ffi::c_void; + fn all_pieces_extent(&mut self) -> *mut core::ffi::c_void; + fn data_piece_number(&mut self) -> *mut core::ffi::c_void; + fn data_number_of_pieces(&mut self) -> *mut core::ffi::c_void; + fn data_number_of_ghost_levels(&mut self) -> *mut core::ffi::c_void; + fn data_time_step(&mut self) -> *mut core::ffi::c_void; + fn point_data_vector(&mut self) -> *mut core::ffi::c_void; + fn cell_data_vector(&mut self) -> *mut core::ffi::c_void; + fn vertex_data_vector(&mut self) -> *mut core::ffi::c_void; + fn edge_data_vector(&mut self) -> *mut core::ffi::c_void; + fn field_array_type(&mut self) -> *mut core::ffi::c_void; + fn field_association(&mut self) -> *mut core::ffi::c_void; + fn field_attribute_type(&mut self) -> *mut core::ffi::c_void; + fn field_active_attribute(&mut self) -> *mut core::ffi::c_void; + fn field_number_of_components(&mut self) -> *mut core::ffi::c_void; + fn field_number_of_tuples(&mut self) -> *mut core::ffi::c_void; + fn field_operation(&mut self) -> *mut core::ffi::c_void; + fn field_range(&mut self) -> *mut core::ffi::c_void; + fn piece_extent(&mut self) -> *mut core::ffi::c_void; + fn field_name(&mut self) -> *mut core::ffi::c_void; + fn origin(&mut self) -> *mut core::ffi::c_void; + fn spacing(&mut self) -> *mut core::ffi::c_void; + fn direction(&mut self) -> *mut core::ffi::c_void; + fn bounding_box(&mut self) -> *mut core::ffi::c_void; + fn sil(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkDataObjectCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_next_data_object(&mut self, cookie: ()) -> *mut core::ffi::c_void; + fn get_number_of_items(&mut self) -> core::ffi::c_int; +} +pub trait VtkDataObjectTree: VtkCompositeDataSet + VtkDataObject { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new_tree_iterator(&mut self) -> *mut core::ffi::c_void; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn set_data_set( + &mut self, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ) -> (); + fn set_data_set_from( + &mut self, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ) -> (); + fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkDataObjectTreeIterator: VtkCompositeDataIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; + fn get_current_data_object(&mut self) -> *mut core::ffi::c_void; + fn get_current_meta_data(&mut self) -> *mut core::ffi::c_void; + fn has_current_meta_data(&mut self) -> core::ffi::c_int; + fn get_current_flat_index(&mut self) -> core::ffi::c_uint; + fn set_visit_only_leaves(&mut self, _arg: core::ffi::c_int) -> (); + fn get_visit_only_leaves(&mut self) -> core::ffi::c_int; + fn visit_only_leaves_on(&mut self) -> (); + fn visit_only_leaves_off(&mut self) -> (); + fn set_traverse_sub_tree(&mut self, _arg: core::ffi::c_int) -> (); + fn get_traverse_sub_tree(&mut self) -> core::ffi::c_int; + fn traverse_sub_tree_on(&mut self) -> (); + fn traverse_sub_tree_off(&mut self) -> (); +} +pub trait VtkDataObjectTypes { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_class_name_from_type_id( + &mut self, + typeId: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn get_type_id_from_class_name( + &mut self, + classname: core::ffi::c_char, + ) -> core::ffi::c_int; + fn new_data_object( + &mut self, + classname: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn new_data_object(&mut self, typeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn type_id_is_a( + &mut self, + typeId: core::ffi::c_int, + targetTypeId: core::ffi::c_int, + ) -> bool; + fn get_common_base_type_id( + &mut self, + typeA: core::ffi::c_int, + typeB: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkDataSet: VtkDataObject { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn copy_attributes(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; + fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn new_cell_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cell( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_cell_order_and_rational_weights( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> (); + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> (); + fn get_cell_bounds( + &mut self, + cellId: core::ffi::c_uchar, + bounds: core::ffi::c_double, + ) -> (); + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> (); + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn find_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_and_get_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn get_cell_data(&mut self) -> *mut core::ffi::c_void; + fn get_point_data(&mut self) -> *mut core::ffi::c_void; + fn squeeze(&mut self) -> (); + fn compute_bounds(&mut self) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_center(&mut self) -> *mut core::ffi::c_double; + fn get_center(&mut self, center: core::ffi::c_double) -> (); + fn get_length(&mut self) -> core::ffi::c_double; + fn initialize(&mut self) -> (); + fn get_scalar_range(&mut self, range: core::ffi::c_double) -> (); + fn get_scalar_range(&mut self) -> *mut core::ffi::c_double; + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn check_attributes(&mut self) -> core::ffi::c_int; + fn generate_ghost_array(&mut self, zeroExt: core::ffi::c_int) -> (); + fn generate_ghost_array(&mut self, zeroExt: core::ffi::c_int, cellOnly: bool) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn has_any_ghost_cells(&mut self) -> bool; + fn has_any_ghost_points(&mut self) -> bool; + fn has_any_blank_cells(&mut self) -> bool; + fn has_any_blank_points(&mut self) -> bool; + fn get_point_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn update_point_ghost_array_cache(&mut self) -> (); + fn allocate_point_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn get_cell_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn update_cell_ghost_array_cache(&mut self) -> (); + fn allocate_cell_ghost_array(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkDataSetAttributes: VtkFieldData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn update(&mut self) -> (); + fn deep_copy(&mut self, pd: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, pd: *mut core::ffi::c_void) -> (); + fn ghost_array_name(&mut self) -> *const core::ffi::c_char; + fn set_scalars(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_scalars(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_scalars(&mut self) -> *mut core::ffi::c_void; + fn set_vectors(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_vectors(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_vectors(&mut self) -> *mut core::ffi::c_void; + fn set_normals(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_normals(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_normals(&mut self) -> *mut core::ffi::c_void; + fn set_tangents(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_tangents(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_tangents(&mut self) -> *mut core::ffi::c_void; + fn set_t_coords(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_t_coords(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_t_coords(&mut self) -> *mut core::ffi::c_void; + fn set_tensors(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_tensors(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_tensors(&mut self) -> *mut core::ffi::c_void; + fn set_global_ids(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_global_ids(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_global_ids(&mut self) -> *mut core::ffi::c_void; + fn set_pedigree_ids(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_pedigree_ids(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_pedigree_ids(&mut self) -> *mut core::ffi::c_void; + fn set_rational_weights(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_rational_weights( + &mut self, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; + fn set_higher_order_degrees( + &mut self, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_active_higher_order_degrees( + &mut self, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + fn get_higher_order_degrees(&mut self) -> *mut core::ffi::c_void; + fn get_scalars(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_vectors(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_normals(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_tangents(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_t_coords(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_tensors(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_global_ids(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_pedigree_ids(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_rational_weights( + &mut self, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn get_higher_order_degrees( + &mut self, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set_active_attribute( + &mut self, + name: core::ffi::c_char, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_active_attribute( + &mut self, + index: core::ffi::c_int, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_attribute_indices(&mut self, indexArray: core::ffi::c_int) -> (); + fn is_array_an_attribute(&mut self, idx: core::ffi::c_int) -> core::ffi::c_int; + fn set_attribute( + &mut self, + aa: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_attribute( + &mut self, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_abstract_attribute( + &mut self, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_attribute_type_as_string( + &mut self, + attributeType: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn get_long_attribute_type_as_string( + &mut self, + attributeType: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn set_copy_attribute( + &mut self, + index: core::ffi::c_int, + value: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> (); + fn get_copy_attribute( + &mut self, + index: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_copy_scalars(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_scalars(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_scalars_on(&mut self) -> (); + fn copy_scalars_off(&mut self) -> (); + fn set_copy_vectors(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_vectors(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_vectors_on(&mut self) -> (); + fn copy_vectors_off(&mut self) -> (); + fn set_copy_normals(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_normals(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_normals_on(&mut self) -> (); + fn copy_normals_off(&mut self) -> (); + fn set_copy_tangents(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_tangents(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_tangents_on(&mut self) -> (); + fn copy_tangents_off(&mut self) -> (); + fn set_copy_t_coords(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_t_coords(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_t_coords_on(&mut self) -> (); + fn copy_t_coords_off(&mut self) -> (); + fn set_copy_tensors(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_tensors(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_tensors_on(&mut self) -> (); + fn copy_tensors_off(&mut self) -> (); + fn set_copy_global_ids( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> (); + fn get_copy_global_ids(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_global_ids_on(&mut self) -> (); + fn copy_global_ids_off(&mut self) -> (); + fn set_copy_pedigree_ids( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> (); + fn get_copy_pedigree_ids(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_pedigree_ids_on(&mut self) -> (); + fn copy_pedigree_ids_off(&mut self) -> (); + fn set_copy_rational_weights( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> (); + fn get_copy_rational_weights(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_rational_weights_on(&mut self) -> (); + fn copy_rational_weights_off(&mut self) -> (); + fn set_copy_higher_order_degrees( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> (); + fn get_copy_higher_order_degrees( + &mut self, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + fn copy_higher_order_degrees_on(&mut self) -> (); + fn copy_higher_order_degrees_off(&mut self) -> (); + fn copy_all_on(&mut self, ctype: core::ffi::c_int) -> (); + fn copy_all_off(&mut self, ctype: core::ffi::c_int) -> (); + fn pass_data(&mut self, fd: *mut core::ffi::c_void) -> (); + fn copy_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> (); + fn copy_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + shallowCopyArrays: core::ffi::c_int, + ) -> (); + fn setup_for_copy(&mut self, pd: *mut core::ffi::c_void) -> (); + fn copy_structured_data( + &mut self, + inDsa: *mut core::ffi::c_void, + inExt: core::ffi::c_int, + outExt: core::ffi::c_int, + setSize: bool, + ) -> (); + fn copy_data( + &mut self, + fromPd: *mut core::ffi::c_void, + fromId: core::ffi::c_uchar, + toId: core::ffi::c_uchar, + ) -> (); + fn copy_data( + &mut self, + fromPd: *mut core::ffi::c_void, + fromIds: *mut core::ffi::c_void, + toIds: *mut core::ffi::c_void, + ) -> (); + fn copy_data( + &mut self, + fromPd: *mut core::ffi::c_void, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + ) -> (); + fn copy_tuple( + &mut self, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromId: core::ffi::c_uchar, + toId: core::ffi::c_uchar, + ) -> (); + fn copy_tuples( + &mut self, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromIds: *mut core::ffi::c_void, + toIds: *mut core::ffi::c_void, + ) -> (); + fn copy_tuples( + &mut self, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + ) -> (); + fn interpolate_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> (); + fn interpolate_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + shallowCopyArrays: core::ffi::c_int, + ) -> (); + fn interpolate_point( + &mut self, + fromPd: *mut core::ffi::c_void, + toId: core::ffi::c_uchar, + ids: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_edge( + &mut self, + fromPd: *mut core::ffi::c_void, + toId: core::ffi::c_uchar, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + t: core::ffi::c_double, + ) -> (); + fn interpolate_time( + &mut self, + from1: *mut core::ffi::c_void, + from2: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + t: core::ffi::c_double, + ) -> (); + fn copy_allocate( + &mut self, + list: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> (); + fn copy_data( + &mut self, + list: *mut core::ffi::c_void, + dsa: *mut core::ffi::c_void, + idx: core::ffi::c_int, + fromId: core::ffi::c_uchar, + toId: core::ffi::c_uchar, + ) -> (); + fn copy_data( + &mut self, + list: *mut core::ffi::c_void, + dsa: *mut core::ffi::c_void, + idx: core::ffi::c_int, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + ) -> (); + fn interpolate_allocate( + &mut self, + list: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> (); + fn interpolate_point( + &mut self, + list: *mut core::ffi::c_void, + fromPd: *mut core::ffi::c_void, + idx: core::ffi::c_int, + toId: core::ffi::c_uchar, + ids: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); +} +pub trait VtkDataSetAttributesFieldList { + fn reset(&mut self) -> (); + fn initialize_field_list(&mut self, dsa: *mut core::ffi::c_void) -> (); + fn intersect_field_list(&mut self, dsa: *mut core::ffi::c_void) -> (); + fn union_field_list(&mut self, dsa: *mut core::ffi::c_void) -> (); + fn copy_allocate( + &mut self, + output: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> (); + fn copy_data( + &mut self, + inputIndex: core::ffi::c_int, + input: *mut core::ffi::c_void, + fromId: core::ffi::c_uchar, + output: *mut core::ffi::c_void, + toId: core::ffi::c_uchar, + ) -> (); + fn copy_data( + &mut self, + inputIndex: core::ffi::c_int, + input: *mut core::ffi::c_void, + inputStart: core::ffi::c_uchar, + numValues: core::ffi::c_uchar, + output: *mut core::ffi::c_void, + outStart: core::ffi::c_uchar, + ) -> (); + fn interpolate_point( + &mut self, + inputIndex: core::ffi::c_int, + input: *mut core::ffi::c_void, + inputIds: *mut core::ffi::c_void, + weights: core::ffi::c_double, + output: *mut core::ffi::c_void, + toId: core::ffi::c_uchar, + ) -> (); +} +pub trait VtkDataSetCellIterator: VtkCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_done_with_traversal(&mut self) -> bool; + fn get_cell_id(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkDataSetCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_next_data_set(&mut self) -> *mut core::ffi::c_void; + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_data_set(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_next_data_set(&mut self, cookie: ()) -> *mut core::ffi::c_void; + fn get_number_of_items(&mut self) -> core::ffi::c_int; +} +pub trait VtkDirectedAcyclicGraph: VtkDirectedGraph + VtkGraph + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkDirectedGraph: VtkGraph + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool; +} +pub trait VtkDistributedGraphHelper { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_owner(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_vertex_index(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_edge_owner(&mut self, e_id: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_edge_index(&mut self, e_id: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn make_distributed_id( + &mut self, + owner: core::ffi::c_int, + local: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn set_vertex_pedigree_id_distribution( + &mut self, + Func: *mut core::ffi::c_void, + userData: (), + ) -> (); + fn get_vertex_owner_by_pedigree_id( + &mut self, + pedigreeId: vtkVariant, + ) -> core::ffi::c_uchar; + fn synchronize(&mut self) -> (); + fn clone(&mut self) -> *mut core::ffi::c_void; + fn distributedvertexids(&mut self) -> *mut core::ffi::c_void; + fn distributededgeids(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkEdgeListIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_graph(&mut self) -> *mut core::ffi::c_void; + fn set_graph(&mut self, graph: *mut core::ffi::c_void) -> (); + fn next(&mut self) -> *mut core::ffi::c_void; + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void; + fn has_next(&mut self) -> bool; +} +pub trait VtkEdgeTable { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn init_edge_insertion( + &mut self, + numPoints: core::ffi::c_uchar, + storeAttributes: core::ffi::c_int, + ) -> core::ffi::c_int; + fn insert_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn insert_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + attributeId: core::ffi::c_uchar, + ) -> (); + fn insert_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ptr: (), + ) -> (); + fn is_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn is_edge(&mut self, p1: core::ffi::c_uchar, p2: core::ffi::c_uchar, ptr: ()) -> (); + fn init_point_insertion( + &mut self, + newPts: *mut core::ffi::c_void, + estSize: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn insert_unique_point( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_uchar; + fn init_traversal(&mut self) -> (); + fn get_next_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_next_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ptr: (), + ) -> core::ffi::c_int; + fn reset(&mut self) -> (); +} +pub trait VtkEmptyCell: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkExplicitStructuredGrid: VtkPointSet + VtkDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> (); + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_data_dimension(&mut self) -> core::ffi::c_int; + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn set_dimensions(&mut self, dim: core::ffi::c_int) -> (); + fn get_dimensions(&mut self, dim: core::ffi::c_int) -> (); + fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn set_extent( + &mut self, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> (); + fn set_extent(&mut self, extent: core::ffi::c_int) -> (); + fn get_extent(&mut self) -> *mut core::ffi::c_int; + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn set_cells(&mut self, cells: *mut core::ffi::c_void) -> (); + fn get_cells(&mut self) -> *mut core::ffi::c_void; + fn build_links(&mut self) -> (); + fn get_links(&mut self) -> *mut core::ffi::c_void; + fn get_cell_points(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + neighbors: core::ffi::c_uchar, + wholeExtent: core::ffi::c_int, + ) -> (); + fn compute_cell_structured_coords( + &mut self, + cellId: core::ffi::c_uchar, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + adjustForExtent: bool, + ) -> (); + fn compute_cell_id( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + adjustForExtent: bool, + ) -> core::ffi::c_uchar; + fn compute_faces_connectivity_flags_array(&mut self) -> (); + fn set_faces_connectivity_flags_array_name(&mut self, _arg: core::ffi::c_char) -> (); + fn get_faces_connectivity_flags_array_name(&mut self) -> *mut core::ffi::c_char; + fn blank_cell(&mut self, cellId: core::ffi::c_uchar) -> (); + fn un_blank_cell(&mut self, cellId: core::ffi::c_uchar) -> (); + fn has_any_blank_cells(&mut self) -> bool; + fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn is_cell_ghost(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn has_any_ghost_cells(&mut self) -> bool; + fn crop(&mut self, updateExtent: core::ffi::c_int) -> (); + fn crop( + &mut self, + input: *mut core::ffi::c_void, + updateExtent: core::ffi::c_int, + generateOriginalCellIds: bool, + ) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn check_and_reorder_faces(&mut self) -> (); +} +pub trait VtkExtractStructuredGridHelper { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output_whole_extent(&mut self) -> *mut core::ffi::c_int; + fn get_output_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn get_output_whole_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn initialize( + &mut self, + voi: core::ffi::c_int, + wholeExt: core::ffi::c_int, + sampleRate: core::ffi::c_int, + includeBoundary: bool, + ) -> (); + fn is_valid(&mut self) -> bool; + fn get_size(&mut self, dim: core::ffi::c_int) -> core::ffi::c_int; + fn get_mapped_index( + &mut self, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_mapped_index_from_extent_value( + &mut self, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_mapped_extent_value( + &mut self, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_mapped_extent_value_from_index( + &mut self, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int; + fn compute_begin_and_end( + &mut self, + inExt: core::ffi::c_int, + voi: core::ffi::c_int, + begin: core::ffi::c_int, + end: core::ffi::c_int, + ) -> (); + fn copy_points_and_point_data( + &mut self, + inExt: core::ffi::c_int, + outExt: core::ffi::c_int, + pd: *mut core::ffi::c_void, + inpnts: *mut core::ffi::c_void, + outPD: *mut core::ffi::c_void, + outpnts: *mut core::ffi::c_void, + ) -> (); + fn copy_cell_data( + &mut self, + inExt: core::ffi::c_int, + outExt: core::ffi::c_int, + cd: *mut core::ffi::c_void, + outCD: *mut core::ffi::c_void, + ) -> (); + fn get_partitioned_voi( + &mut self, + globalVOI: core::ffi::c_int, + partitionedExtent: core::ffi::c_int, + sampleRate: core::ffi::c_int, + includeBoundary: bool, + partitionedVOI: core::ffi::c_int, + ) -> (); + fn get_partitioned_output_extent( + &mut self, + globalVOI: core::ffi::c_int, + partitionedVOI: core::ffi::c_int, + outputWholeExtent: core::ffi::c_int, + sampleRate: core::ffi::c_int, + includeBoundary: bool, + partitionedOutputExtent: core::ffi::c_int, + ) -> (); +} +pub trait VtkFieldData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> (); + fn allocate_arrays(&mut self, num: core::ffi::c_int) -> (); + fn get_number_of_arrays(&mut self) -> core::ffi::c_int; + fn add_array(&mut self, array: *mut core::ffi::c_void) -> core::ffi::c_int; + fn null_data(&mut self, id: core::ffi::c_uchar) -> (); + fn remove_array(&mut self, name: core::ffi::c_char) -> (); + fn remove_array(&mut self, index: core::ffi::c_int) -> (); + fn get_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_array( + &mut self, + arrayName: core::ffi::c_char, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_array(&mut self, arrayName: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_abstract_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_abstract_array( + &mut self, + arrayName: core::ffi::c_char, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_abstract_array( + &mut self, + arrayName: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn has_array(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_array_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char; + fn pass_data(&mut self, fd: *mut core::ffi::c_void) -> (); + fn copy_field_on(&mut self, name: core::ffi::c_char) -> (); + fn copy_field_off(&mut self, name: core::ffi::c_char) -> (); + fn copy_all_on(&mut self, unused: core::ffi::c_int) -> (); + fn copy_all_off(&mut self, unused: core::ffi::c_int) -> (); + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn get_field( + &mut self, + ptId: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ) -> (); + fn get_array_containing_component( + &mut self, + i: core::ffi::c_int, + arrayComp: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar; + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; +} +pub trait VtkFindCellStrategy { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; +} +pub trait VtkGenericAdaptorCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_id(&mut self) -> core::ffi::c_uchar; + fn is_in_data_set(&mut self) -> core::ffi::c_int; + fn get_type(&mut self) -> core::ffi::c_int; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn get_geometry_order(&mut self) -> core::ffi::c_int; + fn is_geometry_linear(&mut self) -> core::ffi::c_int; + fn get_attribute_order(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_highest_order_attribute( + &mut self, + ac: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn is_attribute_linear(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int; + fn is_primary(&mut self) -> core::ffi::c_int; + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn get_number_of_boundaries(&mut self, dim: core::ffi::c_int) -> core::ffi::c_int; + fn get_number_of_dof_nodes(&mut self) -> core::ffi::c_int; + fn get_point_iterator(&mut self, it: *mut core::ffi::c_void) -> (); + fn new_cell_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_boundary_iterator( + &mut self, + boundaries: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ) -> (); + fn count_neighbors(&mut self, boundary: *mut core::ffi::c_void) -> core::ffi::c_int; + fn count_edge_neighbors(&mut self, sharing: core::ffi::c_int) -> (); + fn get_neighbors( + &mut self, + boundary: *mut core::ffi::c_void, + neighbors: *mut core::ffi::c_void, + ) -> (); + fn find_closest_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + boundary: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + ) -> (); + fn interpolate_tuple( + &mut self, + a: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + val: core::ffi::c_double, + ) -> (); + fn interpolate_tuple( + &mut self, + c: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + val: core::ffi::c_double, + ) -> (); + fn contour( + &mut self, + values: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + attributes: *mut core::ffi::c_void, + tess: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + outCd: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + secondaryPd: *mut core::ffi::c_void, + secondaryCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + f: *mut core::ffi::c_void, + attributes: *mut core::ffi::c_void, + tess: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + outCd: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + secondaryPd: *mut core::ffi::c_void, + secondaryCd: *mut core::ffi::c_void, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + attribute: *mut core::ffi::c_void, + derivs: core::ffi::c_double, + ) -> (); + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_length_2(&mut self) -> core::ffi::c_double; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double; + fn tessellate( + &mut self, + attributes: *mut core::ffi::c_void, + tess: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + cd: *mut core::ffi::c_void, + types: *mut core::ffi::c_void, + ) -> (); + fn is_face_on_boundary(&mut self, faceId: core::ffi::c_uchar) -> core::ffi::c_int; + fn is_on_boundary(&mut self) -> core::ffi::c_int; + fn get_point_ids(&mut self, id: core::ffi::c_uchar) -> (); + fn triangulate_face( + &mut self, + attributes: *mut core::ffi::c_void, + tess: *mut core::ffi::c_void, + index: core::ffi::c_int, + points: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + cd: *mut core::ffi::c_void, + ) -> (); + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_number_of_vertices_on_face( + &mut self, + faceId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; +} +pub trait VtkGenericAttribute { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_name(&mut self) -> *const core::ffi::c_char; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn get_centering(&mut self) -> core::ffi::c_int; + fn get_type(&mut self) -> core::ffi::c_int; + fn get_component_type(&mut self) -> core::ffi::c_int; + fn get_size(&mut self) -> core::ffi::c_uchar; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_range(&mut self, component: core::ffi::c_int) -> *mut core::ffi::c_double; + fn get_range( + &mut self, + component: core::ffi::c_int, + range: core::ffi::c_double, + ) -> (); + fn get_max_norm(&mut self) -> core::ffi::c_double; + fn get_tuple(&mut self, c: *mut core::ffi::c_void) -> *mut core::ffi::c_double; + fn get_tuple(&mut self, c: *mut core::ffi::c_void, tuple: core::ffi::c_double) -> (); + fn get_tuple(&mut self, c: *mut core::ffi::c_void) -> *mut core::ffi::c_double; + fn get_tuple(&mut self, c: *mut core::ffi::c_void, tuple: core::ffi::c_double) -> (); + fn get_tuple(&mut self, p: *mut core::ffi::c_void) -> *mut core::ffi::c_double; + fn get_tuple(&mut self, p: *mut core::ffi::c_void, tuple: core::ffi::c_double) -> (); + fn get_component( + &mut self, + i: core::ffi::c_int, + c: *mut core::ffi::c_void, + values: core::ffi::c_double, + ) -> (); + fn get_component( + &mut self, + i: core::ffi::c_int, + p: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); +} +pub trait VtkGenericAttributeCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_attributes(&mut self) -> core::ffi::c_int; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn get_number_of_point_centered_components(&mut self) -> core::ffi::c_int; + fn get_max_number_of_components(&mut self) -> core::ffi::c_int; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn is_empty(&mut self) -> core::ffi::c_int; + fn get_attribute(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn find_attribute(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_attribute_index(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; + fn insert_next_attribute(&mut self, a: *mut core::ffi::c_void) -> (); + fn insert_attribute(&mut self, i: core::ffi::c_int, a: *mut core::ffi::c_void) -> (); + fn remove_attribute(&mut self, i: core::ffi::c_int) -> (); + fn reset(&mut self) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn get_active_attribute(&mut self) -> core::ffi::c_int; + fn get_active_component(&mut self) -> core::ffi::c_int; + fn set_active_attribute( + &mut self, + attribute: core::ffi::c_int, + component: core::ffi::c_int, + ) -> (); + fn get_number_of_attributes_to_interpolate(&mut self) -> core::ffi::c_int; + fn get_attributes_to_interpolate(&mut self) -> *mut core::ffi::c_int; + fn has_attribute( + &mut self, + size: core::ffi::c_int, + attributes: core::ffi::c_int, + attribute: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_attributes_to_interpolate( + &mut self, + size: core::ffi::c_int, + attributes: core::ffi::c_int, + ) -> (); + fn set_attributes_to_interpolate_to_all(&mut self) -> (); +} +pub trait VtkGenericCell: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_points(&mut self, points: *mut core::ffi::c_void) -> (); + fn set_point_ids(&mut self, pointIds: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, c: *mut core::ffi::c_void) -> (); + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn set_cell_type(&mut self, cellType: core::ffi::c_int) -> (); + fn set_cell_type_to_empty_cell(&mut self) -> (); + fn set_cell_type_to_vertex(&mut self) -> (); + fn set_cell_type_to_poly_vertex(&mut self) -> (); + fn set_cell_type_to_line(&mut self) -> (); + fn set_cell_type_to_poly_line(&mut self) -> (); + fn set_cell_type_to_triangle(&mut self) -> (); + fn set_cell_type_to_triangle_strip(&mut self) -> (); + fn set_cell_type_to_polygon(&mut self) -> (); + fn set_cell_type_to_pixel(&mut self) -> (); + fn set_cell_type_to_quad(&mut self) -> (); + fn set_cell_type_to_tetra(&mut self) -> (); + fn set_cell_type_to_voxel(&mut self) -> (); + fn set_cell_type_to_hexahedron(&mut self) -> (); + fn set_cell_type_to_wedge(&mut self) -> (); + fn set_cell_type_to_pyramid(&mut self) -> (); + fn set_cell_type_to_pentagonal_prism(&mut self) -> (); + fn set_cell_type_to_hexagonal_prism(&mut self) -> (); + fn set_cell_type_to_polyhedron(&mut self) -> (); + fn set_cell_type_to_convex_point_set(&mut self) -> (); + fn set_cell_type_to_quadratic_edge(&mut self) -> (); + fn set_cell_type_to_cubic_line(&mut self) -> (); + fn set_cell_type_to_quadratic_triangle(&mut self) -> (); + fn set_cell_type_to_bi_quadratic_triangle(&mut self) -> (); + fn set_cell_type_to_quadratic_quad(&mut self) -> (); + fn set_cell_type_to_quadratic_polygon(&mut self) -> (); + fn set_cell_type_to_quadratic_tetra(&mut self) -> (); + fn set_cell_type_to_quadratic_hexahedron(&mut self) -> (); + fn set_cell_type_to_quadratic_wedge(&mut self) -> (); + fn set_cell_type_to_quadratic_pyramid(&mut self) -> (); + fn set_cell_type_to_quadratic_linear_quad(&mut self) -> (); + fn set_cell_type_to_bi_quadratic_quad(&mut self) -> (); + fn set_cell_type_to_quadratic_linear_wedge(&mut self) -> (); + fn set_cell_type_to_bi_quadratic_quadratic_wedge(&mut self) -> (); + fn set_cell_type_to_tri_quadratic_hexahedron(&mut self) -> (); + fn set_cell_type_to_tri_quadratic_pyramid(&mut self) -> (); + fn set_cell_type_to_bi_quadratic_quadratic_hexahedron(&mut self) -> (); + fn set_cell_type_to_lagrange_triangle(&mut self) -> (); + fn set_cell_type_to_lagrange_tetra(&mut self) -> (); + fn set_cell_type_to_lagrange_curve(&mut self) -> (); + fn set_cell_type_to_lagrange_quadrilateral(&mut self) -> (); + fn set_cell_type_to_lagrange_hexahedron(&mut self) -> (); + fn set_cell_type_to_lagrange_wedge(&mut self) -> (); + fn set_cell_type_to_bezier_triangle(&mut self) -> (); + fn set_cell_type_to_bezier_tetra(&mut self) -> (); + fn set_cell_type_to_bezier_curve(&mut self) -> (); + fn set_cell_type_to_bezier_quadrilateral(&mut self) -> (); + fn set_cell_type_to_bezier_hexahedron(&mut self) -> (); + fn set_cell_type_to_bezier_wedge(&mut self) -> (); + fn instantiate_cell(&mut self, cellType: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_representative_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkGenericCellIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn begin(&mut self) -> (); + fn is_at_end(&mut self) -> core::ffi::c_int; + fn new_cell(&mut self) -> *mut core::ffi::c_void; + fn get_cell(&mut self, c: *mut core::ffi::c_void) -> (); + fn get_cell(&mut self) -> *mut core::ffi::c_void; + fn next(&mut self) -> (); +} +pub trait VtkGenericCellTessellator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn tessellate_face( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn tessellate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn set_error_metrics(&mut self, someErrorMetrics: *mut core::ffi::c_void) -> (); + fn get_error_metrics(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, ds: *mut core::ffi::c_void) -> (); + fn init_error_metrics(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_measurement(&mut self) -> core::ffi::c_int; + fn set_measurement(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_errors(&mut self, errors: core::ffi::c_double) -> (); +} +pub trait VtkGenericDataSet: VtkDataObject { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_number_of_cells(&mut self, dim: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> (); + fn new_cell_iterator(&mut self, dim: core::ffi::c_int) -> *mut core::ffi::c_void; + fn new_boundary_iterator( + &mut self, + dim: core::ffi::c_int, + exteriorOnly: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn new_point_iterator(&mut self) -> *mut core::ffi::c_void; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn find_point(&mut self, x: core::ffi::c_double, p: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn compute_bounds(&mut self) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_center(&mut self) -> *mut core::ffi::c_double; + fn get_center(&mut self, center: core::ffi::c_double) -> (); + fn get_length(&mut self) -> core::ffi::c_double; + fn get_attributes(&mut self) -> *mut core::ffi::c_void; + fn get_attributes(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_tessellator(&mut self, tessellator: *mut core::ffi::c_void) -> (); + fn get_tessellator(&mut self) -> *mut core::ffi::c_void; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_estimated_size(&mut self) -> core::ffi::c_uchar; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkGenericEdgeTable { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn insert_edge( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ref_: core::ffi::c_int, + ptId: core::ffi::c_uchar, + ) -> (); + fn insert_edge( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ref_: core::ffi::c_int, + ) -> (); + fn remove_edge( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn check_edge( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn increment_edge_reference_count( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn check_edge_reference_count( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn initialize(&mut self, start: core::ffi::c_uchar) -> (); + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn set_number_of_components(&mut self, count: core::ffi::c_int) -> (); + fn check_point(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_int; + fn check_point( + &mut self, + ptId: core::ffi::c_uchar, + point: core::ffi::c_double, + scalar: core::ffi::c_double, + ) -> core::ffi::c_int; + fn insert_point( + &mut self, + ptId: core::ffi::c_uchar, + point: core::ffi::c_double, + ) -> (); + fn insert_point_and_scalar( + &mut self, + ptId: core::ffi::c_uchar, + pt: core::ffi::c_double, + s: core::ffi::c_double, + ) -> (); + fn remove_point(&mut self, ptId: core::ffi::c_uchar) -> (); + fn increment_point_reference_count(&mut self, ptId: core::ffi::c_uchar) -> (); + fn dump_table(&mut self) -> (); + fn load_factor(&mut self) -> (); +} +pub trait VtkGenericInterpolatedVelocityField { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn function_values( + &mut self, + x: core::ffi::c_double, + f: core::ffi::c_double, + ) -> core::ffi::c_int; + fn add_data_set(&mut self, dataset: *mut core::ffi::c_void) -> (); + fn clear_last_cell(&mut self) -> (); + fn get_last_cell(&mut self) -> *mut core::ffi::c_void; + fn get_last_local_coordinates( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_caching(&mut self) -> core::ffi::c_int; + fn set_caching(&mut self, _arg: core::ffi::c_int) -> (); + fn caching_on(&mut self) -> (); + fn caching_off(&mut self) -> (); + fn get_cache_hit(&mut self) -> core::ffi::c_int; + fn get_cache_miss(&mut self) -> core::ffi::c_int; + fn get_vectors_selection(&mut self) -> *mut core::ffi::c_char; + fn select_vectors(&mut self, fieldName: core::ffi::c_char) -> (); + fn get_last_data_set(&mut self) -> *mut core::ffi::c_void; + fn copy_parameters(&mut self, from: *mut core::ffi::c_void) -> (); +} +pub trait VtkGenericPointIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn begin(&mut self) -> (); + fn is_at_end(&mut self) -> core::ffi::c_int; + fn next(&mut self) -> (); + fn get_position(&mut self) -> *mut core::ffi::c_double; + fn get_position(&mut self, x: core::ffi::c_double) -> (); + fn get_id(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkGenericSubdivisionErrorMetric { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn requires_edge_subdivision( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_error( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_double; + fn set_generic_cell(&mut self, cell: *mut core::ffi::c_void) -> (); + fn get_generic_cell(&mut self) -> *mut core::ffi::c_void; + fn set_data_set(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkGeometricErrorMetric: VtkGenericSubdivisionErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_absolute_geometric_tolerance(&mut self) -> core::ffi::c_double; + fn set_absolute_geometric_tolerance(&mut self, value: core::ffi::c_double) -> (); + fn set_relative_geometric_tolerance( + &mut self, + value: core::ffi::c_double, + ds: *mut core::ffi::c_void, + ) -> (); + fn requires_edge_subdivision( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_error( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_relative(&mut self) -> core::ffi::c_int; +} +pub trait VtkGraph: VtkDataObject { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_data(&mut self) -> *mut core::ffi::c_void; + fn get_edge_data(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn set_points(&mut self, points: *mut core::ffi::c_void) -> (); + fn compute_bounds(&mut self) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn get_out_edges(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> (); + fn get_degree(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_out_degree(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_out_edge( + &mut self, + v: core::ffi::c_uchar, + index: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_out_edge( + &mut self, + v: core::ffi::c_uchar, + index: core::ffi::c_uchar, + e: *mut core::ffi::c_void, + ) -> (); + fn get_in_edges(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> (); + fn get_in_degree(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_in_edge( + &mut self, + v: core::ffi::c_uchar, + index: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_in_edge( + &mut self, + v: core::ffi::c_uchar, + index: core::ffi::c_uchar, + e: *mut core::ffi::c_void, + ) -> (); + fn get_adjacent_vertices( + &mut self, + v: core::ffi::c_uchar, + it: *mut core::ffi::c_void, + ) -> (); + fn get_edges(&mut self, it: *mut core::ffi::c_void) -> (); + fn get_number_of_edges(&mut self) -> core::ffi::c_uchar; + fn get_vertices(&mut self, it: *mut core::ffi::c_void) -> (); + fn get_number_of_vertices(&mut self) -> core::ffi::c_uchar; + fn set_distributed_graph_helper(&mut self, helper: *mut core::ffi::c_void) -> (); + fn get_distributed_graph_helper(&mut self) -> *mut core::ffi::c_void; + fn find_vertex(&mut self, pedigreeID: vtkVariant) -> core::ffi::c_uchar; + fn shallow_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn copy_structure(&mut self, g: *mut core::ffi::c_void) -> (); + fn checked_shallow_copy(&mut self, g: *mut core::ffi::c_void) -> bool; + fn checked_deep_copy(&mut self, g: *mut core::ffi::c_void) -> bool; + fn squeeze(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn reorder_out_vertices( + &mut self, + v: core::ffi::c_uchar, + vertices: *mut core::ffi::c_void, + ) -> (); + fn is_same_structure(&mut self, other: *mut core::ffi::c_void) -> bool; + fn get_source_vertex(&mut self, e: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_target_vertex(&mut self, e: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn set_edge_points( + &mut self, + e: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_double, + ) -> (); + fn get_edge_points( + &mut self, + e: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_double, + ) -> (); + fn get_number_of_edge_points(&mut self, e: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_edge_point( + &mut self, + e: core::ffi::c_uchar, + i: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + fn clear_edge_points(&mut self, e: core::ffi::c_uchar) -> (); + fn set_edge_point( + &mut self, + e: core::ffi::c_uchar, + i: core::ffi::c_uchar, + x: core::ffi::c_double, + ) -> (); + fn set_edge_point( + &mut self, + e: core::ffi::c_uchar, + i: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn add_edge_point(&mut self, e: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn add_edge_point( + &mut self, + e: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn shallow_copy_edge_points(&mut self, g: *mut core::ffi::c_void) -> (); + fn deep_copy_edge_points(&mut self, g: *mut core::ffi::c_void) -> (); + fn get_graph_internals(&mut self, modifying: bool) -> *mut core::ffi::c_void; + fn get_induced_edges( + &mut self, + verts: *mut core::ffi::c_void, + edges: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar; + fn dump(&mut self) -> (); + fn get_edge_id( + &mut self, + a: core::ffi::c_uchar, + b: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn to_directed_graph(&mut self, g: *mut core::ffi::c_void) -> bool; + fn to_undirected_graph(&mut self, g: *mut core::ffi::c_void) -> bool; +} +pub trait VtkGraphEdge { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_source(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_source(&mut self) -> core::ffi::c_uchar; + fn set_target(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_target(&mut self) -> core::ffi::c_uchar; + fn set_id(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_id(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkGraphInternals { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn remove_edge_from_out_list( + &mut self, + e: core::ffi::c_uchar, + outEdges: Vec, + ) -> (); + fn remove_edge_from_in_list( + &mut self, + e: core::ffi::c_uchar, + inEdges: Vec, + ) -> (); + fn replace_edge_from_out_list( + &mut self, + from: core::ffi::c_uchar, + to: core::ffi::c_uchar, + outEdges: Vec, + ) -> (); + fn replace_edge_from_in_list( + &mut self, + from: core::ffi::c_uchar, + to: core::ffi::c_uchar, + inEdges: Vec, + ) -> (); +} +pub trait VtkHexagonalPrism: VtkCell3D + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkHexahedron: VtkCell3D + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkHierarchicalBoxDataIterator: VtkUniformGridAMRDataIterator + VtkCompositeDataIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHierarchicalBoxDataSet: VtkOverlappingAMR + VtkUniformGridAMR + VtkCompositeDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkHigherOrderCurve: VtkNonLinearCell + VtkCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn set_parametric_coords(&mut self) -> (); + fn get_parametric_center(&mut self, center: core::ffi::c_double) -> core::ffi::c_int; + fn get_order(&mut self) -> *const core::ffi::c_int; + fn get_order(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn sub_cell_coordinates_from_id( + &mut self, + ijk: *mut core::ffi::c_void, + subId: core::ffi::c_int, + ) -> bool; + fn sub_cell_coordinates_from_id( + &mut self, + i: core::ffi::c_int, + subId: core::ffi::c_int, + ) -> bool; + fn point_index_from_ijk( + &mut self, + i: core::ffi::c_int, + p1: core::ffi::c_int, + p2: core::ffi::c_int, + ) -> core::ffi::c_int; + fn transform_approx_to_cell_params( + &mut self, + subCell: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> bool; +} +pub trait VtkHigherOrderHexahedron: VtkNonLinearCell + VtkCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn set_parametric_coords(&mut self) -> (); + fn get_parametric_center(&mut self, center: core::ffi::c_double) -> core::ffi::c_int; + fn set_order_from_cell_data( + &mut self, + cell_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + cell_id: core::ffi::c_uchar, + ) -> (); + fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_uchar) -> (); + fn set_order( + &mut self, + s: core::ffi::c_int, + t: core::ffi::c_int, + u: core::ffi::c_int, + ) -> (); + fn get_order(&mut self) -> *const core::ffi::c_int; + fn get_order(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn sub_cell_coordinates_from_id( + &mut self, + ijk: *mut core::ffi::c_void, + subId: core::ffi::c_int, + ) -> bool; + fn sub_cell_coordinates_from_id( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + subId: core::ffi::c_int, + ) -> bool; + fn point_index_from_ijk( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + order: core::ffi::c_int, + ) -> core::ffi::c_int; + fn point_index_from_ijk( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> core::ffi::c_int; + fn transform_approx_to_cell_params( + &mut self, + subCell: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> bool; + fn transform_face_to_cell_params( + &mut self, + bdyFace: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> bool; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; + fn get_interp(&mut self) -> *mut core::ffi::c_void; + fn node_numbering_mapping_from_vtk_8_to_9( + &mut self, + order: core::ffi::c_int, + node_id_vtk8: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; +} +pub trait VtkHigherOrderInterpolation { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn tensor_1_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + function_evaluate_shape_functions: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn tensor_1_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + function_evaluate_shape_and_gradient: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn tensor_2_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + function_evaluate_shape_functions: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn tensor_2_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + function_evaluate_shape_and_gradient: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn tensor_3_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + function_evaluate_shape_functions: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn tensor_3_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + function_evaluate_shape_and_gradient: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn tensor_3_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ) -> (); + fn tensor_3_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + function_evaluate_shape_and_gradient: *mut core::ffi::c_void, + ) -> (); + fn wedge_shape_functions( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + tri: *mut core::ffi::c_void, + function_evaluate_shape_functions: *mut core::ffi::c_void, + ) -> (); + fn wedge_shape_derivatives( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + tri: *mut core::ffi::c_void, + function_evaluate_shape_and_gradient: *mut core::ffi::c_void, + ) -> (); + fn jacobian_inverse( + &mut self, + points: *mut core::ffi::c_void, + derivs: core::ffi::c_double, + inverse: core::ffi::c_double, + ) -> core::ffi::c_int; + fn jacobian_inverse_wedge( + &mut self, + points: *mut core::ffi::c_void, + derivs: core::ffi::c_double, + inverse: core::ffi::c_double, + ) -> core::ffi::c_int; + fn wedge_evaluate( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldAtPCoords: core::ffi::c_double, + ) -> (); + fn wedge_evaluate( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldAtPCoords: core::ffi::c_double, + tri: *mut core::ffi::c_void, + function_evaluate_shape_functions: *mut core::ffi::c_void, + ) -> (); + fn wedge_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ) -> (); + fn wedge_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + tri: *mut core::ffi::c_void, + function_evaluate_shape_and_gradient: *mut core::ffi::c_void, + ) -> (); + fn get_parametric_hex_coordinates( + &mut self, + vertexId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_point_indices_bounding_hex_edge( + &mut self, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_varying_parameter_of_hex_edge( + &mut self, + edgeId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_fixed_parameters_of_hex_edge( + &mut self, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_point_indices_bounding_hex_face( + &mut self, + faceId: core::ffi::c_int, + ) -> *const core::ffi::c_int; + fn get_edge_indices_bounding_hex_face( + &mut self, + faceId: core::ffi::c_int, + ) -> *const core::ffi::c_int; + fn get_varying_parameters_of_hex_face( + &mut self, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_fixed_parameter_of_hex_face( + &mut self, + faceId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_wedge_coordinates( + &mut self, + vertexId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_point_indices_bounding_wedge_edge( + &mut self, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_varying_parameter_of_wedge_edge( + &mut self, + edgeId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_fixed_parameters_of_wedge_edge( + &mut self, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_point_indices_bounding_wedge_face( + &mut self, + faceId: core::ffi::c_int, + ) -> *const core::ffi::c_int; + fn get_edge_indices_bounding_wedge_face( + &mut self, + faceId: core::ffi::c_int, + ) -> *const core::ffi::c_int; + fn get_varying_parameters_of_wedge_face( + &mut self, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_fixed_parameter_of_wedge_face( + &mut self, + faceId: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkHigherOrderQuadrilateral: VtkNonLinearCell + VtkCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn set_parametric_coords(&mut self) -> (); + fn get_parametric_center(&mut self, center: core::ffi::c_double) -> core::ffi::c_int; + fn set_order_from_cell_data( + &mut self, + cell_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + cell_id: core::ffi::c_uchar, + ) -> (); + fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_uchar) -> (); + fn set_order(&mut self, s: core::ffi::c_int, t: core::ffi::c_int) -> (); + fn get_order(&mut self) -> *const core::ffi::c_int; + fn get_order(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn sub_cell_coordinates_from_id( + &mut self, + ijk: *mut core::ffi::c_void, + subId: core::ffi::c_int, + ) -> bool; + fn sub_cell_coordinates_from_id( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + subId: core::ffi::c_int, + ) -> bool; + fn point_index_from_ijk( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> core::ffi::c_int; + fn point_index_from_ijk( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + order: core::ffi::c_int, + ) -> core::ffi::c_int; + fn transform_approx_to_cell_params( + &mut self, + subCell: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> bool; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHigherOrderTetra: VtkNonLinearCell + VtkCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn set_parametric_coords(&mut self) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_order(&mut self) -> core::ffi::c_uchar; + fn compute_order(&mut self) -> core::ffi::c_uchar; + fn compute_order(&mut self, nPoints: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn to_barycentric_index( + &mut self, + index: core::ffi::c_uchar, + bindex: core::ffi::c_uchar, + ) -> (); + fn to_index(&mut self, bindex: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn barycentric_index( + &mut self, + index: core::ffi::c_uchar, + bindex: core::ffi::c_uchar, + order: core::ffi::c_uchar, + ) -> (); + fn index( + &mut self, + bindex: core::ffi::c_uchar, + order: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHigherOrderTriangle: VtkNonLinearCell + VtkCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn set_parametric_coords(&mut self) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_order(&mut self) -> core::ffi::c_uchar; + fn compute_order(&mut self) -> core::ffi::c_uchar; + fn to_barycentric_index( + &mut self, + index: core::ffi::c_uchar, + bindex: core::ffi::c_uchar, + ) -> (); + fn to_index(&mut self, bindex: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn barycentric_index( + &mut self, + index: core::ffi::c_uchar, + bindex: core::ffi::c_uchar, + order: core::ffi::c_uchar, + ) -> (); + fn index( + &mut self, + bindex: core::ffi::c_uchar, + order: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn eta( + &mut self, + n: core::ffi::c_uchar, + chi: core::ffi::c_uchar, + sigma: core::ffi::c_double, + ) -> core::ffi::c_double; + fn eta( + &mut self, + n: core::ffi::c_uchar, + chi: core::ffi::c_uchar, + sigma: core::ffi::c_double, + ) -> core::ffi::c_double; + fn d_eta( + &mut self, + n: core::ffi::c_uchar, + chi: core::ffi::c_uchar, + sigma: core::ffi::c_double, + ) -> core::ffi::c_double; + fn deta( + &mut self, + n: core::ffi::c_uchar, + chi: core::ffi::c_uchar, + sigma: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHigherOrderWedge: VtkNonLinearCell + VtkCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn set_parametric_coords(&mut self) -> (); + fn get_parametric_center(&mut self, center: core::ffi::c_double) -> core::ffi::c_int; + fn set_order_from_cell_data( + &mut self, + cell_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + cell_id: core::ffi::c_uchar, + ) -> (); + fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_uchar) -> (); + fn set_order( + &mut self, + s: core::ffi::c_int, + t: core::ffi::c_int, + u: core::ffi::c_int, + numPts: core::ffi::c_uchar, + ) -> (); + fn get_order(&mut self) -> *const core::ffi::c_int; + fn get_order(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn sub_cell_coordinates_from_id( + &mut self, + ijk: *mut core::ffi::c_void, + subId: core::ffi::c_int, + ) -> bool; + fn sub_cell_coordinates_from_id( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + subId: core::ffi::c_int, + ) -> bool; + fn point_index_from_ijk( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + order: core::ffi::c_int, + ) -> core::ffi::c_int; + fn point_index_from_ijk( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> core::ffi::c_int; + fn transform_approx_to_cell_params( + &mut self, + subCell: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> bool; + fn transform_face_to_cell_params( + &mut self, + bdyFace: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> bool; + fn get_number_of_approximating_wedges( + &mut self, + order: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_number_of_approximating_wedges(&mut self) -> core::ffi::c_int; + fn get_bdy_quad(&mut self) -> *mut core::ffi::c_void; + fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void; + fn get_bdy_tri(&mut self) -> *mut core::ffi::c_void; + fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interp(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHyperTree { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + branchFactor: core::ffi::c_uchar, + dimension: core::ffi::c_uchar, + numberOfChildren: core::ffi::c_uchar, + ) -> (); + fn initialize_for_reader( + &mut self, + numberOfLevels: core::ffi::c_uchar, + nbVertices: core::ffi::c_uchar, + nbVerticesOfLastLevel: core::ffi::c_uchar, + isParent: *mut core::ffi::c_void, + isMasked: *mut core::ffi::c_void, + outIsMasked: *mut core::ffi::c_void, + ) -> (); + fn build_from_breadth_first_order_descriptor( + &mut self, + descriptor: *mut core::ffi::c_void, + numberOfBits: core::ffi::c_uchar, + startIndex: core::ffi::c_uchar, + ) -> (); + fn compute_breadth_first_order_descriptor( + &mut self, + inputMask: *mut core::ffi::c_void, + numberOfVerticesPerDepth: *mut core::ffi::c_void, + descriptor: *mut core::ffi::c_void, + breadthFirstIdMap: *mut core::ffi::c_void, + ) -> (); + fn copy_structure(&mut self, ht: *mut core::ffi::c_void) -> (); + fn freeze(&mut self, mode: core::ffi::c_char) -> *mut core::ffi::c_void; + fn set_tree_index(&mut self, treeIndex: core::ffi::c_uchar) -> (); + fn get_tree_index(&mut self) -> core::ffi::c_uchar; + fn get_number_of_levels(&mut self) -> core::ffi::c_uint; + fn get_number_of_vertices(&mut self) -> core::ffi::c_uchar; + fn get_number_of_nodes(&mut self) -> core::ffi::c_uchar; + fn get_number_of_leaves(&mut self) -> core::ffi::c_uchar; + fn get_branch_factor(&mut self) -> core::ffi::c_int; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn get_scale(&mut self, s: core::ffi::c_double) -> (); + fn get_scale(&mut self, d: core::ffi::c_uint) -> core::ffi::c_double; + fn create_instance( + &mut self, + branchFactor: core::ffi::c_uchar, + dimension: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong; + fn get_actual_memory_size(&mut self) -> core::ffi::c_uint; + fn is_global_index_implicit(&mut self) -> bool; + fn set_global_index_start(&mut self, start: core::ffi::c_uchar) -> (); + fn get_global_index_start(&mut self) -> core::ffi::c_uchar; + fn set_global_index_from_local( + &mut self, + index: core::ffi::c_uchar, + global: core::ffi::c_uchar, + ) -> (); + fn get_global_index_from_local( + &mut self, + index: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_global_node_index_max(&mut self) -> core::ffi::c_uchar; + fn is_leaf(&mut self, index: core::ffi::c_uchar) -> bool; + fn subdivide_leaf( + &mut self, + index: core::ffi::c_uchar, + level: core::ffi::c_uint, + ) -> (); + fn is_terminal_node(&mut self, index: core::ffi::c_uchar) -> bool; + fn get_elder_child_index( + &mut self, + index_parent: core::ffi::c_uint, + ) -> core::ffi::c_uchar; + fn get_elder_child_index_array( + &mut self, + nbElements: usize, + ) -> *const core::ffi::c_uint; + fn has_scales(&mut self) -> bool; +} +pub trait VtkHyperTreeCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_tree(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_uchar; + fn is_leaf(&mut self) -> bool; + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn get_child_index(&mut self) -> core::ffi::c_int; + fn to_root(&mut self) -> (); + fn to_parent(&mut self) -> (); + fn to_child(&mut self, child: core::ffi::c_int) -> (); + fn to_same_vertex(&mut self, other: *mut core::ffi::c_void) -> (); + fn is_equal(&mut self, other: *mut core::ffi::c_void) -> bool; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn same_tree(&mut self, other: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_number_of_children(&mut self) -> core::ffi::c_int; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkHyperTreeGrid: VtkDataObject { + fn levels(&mut self) -> *mut core::ffi::c_void; + fn dimension(&mut self) -> *mut core::ffi::c_void; + fn orientation(&mut self) -> *mut core::ffi::c_void; + fn sizes(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_mode_squeeze(&mut self, _arg: core::ffi::c_char) -> (); + fn get_mode_squeeze(&mut self) -> *mut core::ffi::c_char; + fn squeeze(&mut self) -> (); + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> (); + fn copy_empty_structure(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_dimensions(&mut self, dims: core::ffi::c_uint) -> (); + fn set_dimensions(&mut self, dims: core::ffi::c_int) -> (); + fn set_dimensions( + &mut self, + i: core::ffi::c_uint, + j: core::ffi::c_uint, + k: core::ffi::c_uint, + ) -> (); + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn get_dimensions(&mut self) -> *const core::ffi::c_uint; + fn get_dimensions(&mut self, dim: core::ffi::c_int) -> (); + fn get_dimensions(&mut self, dim: core::ffi::c_uint) -> (); + fn set_extent(&mut self, extent: core::ffi::c_int) -> (); + fn set_extent( + &mut self, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ) -> (); + fn get_extent(&mut self) -> *mut core::ffi::c_int; + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn get_cell_dims(&mut self) -> *const core::ffi::c_uint; + fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> (); + fn get_cell_dims(&mut self, cellDims: core::ffi::c_uint) -> (); + fn get_dimension(&mut self) -> core::ffi::c_uint; + fn get_1_d_axis(&mut self, axis: core::ffi::c_uint) -> (); + fn get_2_d_axes(&mut self, axis1: core::ffi::c_uint, axis2: core::ffi::c_uint) -> (); + fn get_axes(&mut self) -> *const core::ffi::c_uint; + fn get_number_of_children(&mut self) -> core::ffi::c_uint; + fn set_transposed_root_indexing(&mut self, _arg: bool) -> (); + fn get_transposed_root_indexing(&mut self) -> bool; + fn set_indexing_mode_to_kji(&mut self) -> (); + fn set_indexing_mode_to_ijk(&mut self) -> (); + fn get_orientation(&mut self) -> core::ffi::c_uint; + fn get_freeze_state(&mut self) -> bool; + fn set_branch_factor(&mut self, p0: core::ffi::c_uint) -> (); + fn get_branch_factor(&mut self) -> core::ffi::c_uint; + fn get_max_number_of_trees(&mut self) -> core::ffi::c_uchar; + fn get_number_of_vertices(&mut self) -> core::ffi::c_uchar; + fn get_number_of_non_empty_trees(&mut self) -> core::ffi::c_uchar; + fn get_number_of_leaves(&mut self) -> core::ffi::c_uchar; + fn get_number_of_levels(&mut self, p0: core::ffi::c_uchar) -> core::ffi::c_uint; + fn get_number_of_levels(&mut self) -> core::ffi::c_uint; + fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_x_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_y_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_y_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_z_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_z_coordinates(&mut self) -> *mut core::ffi::c_void; + fn copy_coordinates(&mut self, output: vtkHyperTreeGrid) -> (); + fn set_fixed_coordinates( + &mut self, + axis: core::ffi::c_uint, + value: core::ffi::c_double, + ) -> (); + fn set_mask(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_mask(&mut self) -> *mut core::ffi::c_void; + fn has_mask(&mut self) -> bool; + fn set_has_interface(&mut self, _arg: bool) -> (); + fn get_has_interface(&mut self) -> bool; + fn has_interface_on(&mut self) -> (); + fn has_interface_off(&mut self) -> (); + fn set_interface_normals_name(&mut self, _arg: core::ffi::c_char) -> (); + fn get_interface_normals_name(&mut self) -> *mut core::ffi::c_char; + fn set_interface_intercepts_name(&mut self, _arg: core::ffi::c_char) -> (); + fn get_interface_intercepts_name(&mut self) -> *mut core::ffi::c_char; + fn set_depth_limiter(&mut self, _arg: core::ffi::c_uint) -> (); + fn get_depth_limiter(&mut self) -> core::ffi::c_uint; + fn initialize_oriented_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> (); + fn new_oriented_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_oriented_geometry_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> (); + fn new_oriented_geometry_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_non_oriented_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> (); + fn new_non_oriented_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_non_oriented_geometry_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> (); + fn new_non_oriented_geometry_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + fn find_non_oriented_geometry_cursor( + &mut self, + x: core::ffi::c_double, + ) -> *mut core::ffi::c_void; + fn find_dichotomic_x(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint; + fn find_dichotomic_y(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint; + fn find_dichotomic_z(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint; + fn initialize_non_oriented_von_neumann_super_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> (); + fn new_non_oriented_von_neumann_super_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_non_oriented_von_neumann_super_cursor_light( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> (); + fn new_non_oriented_von_neumann_super_cursor_light( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_non_oriented_moore_super_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> (); + fn new_non_oriented_moore_super_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_non_oriented_moore_super_cursor_light( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> (); + fn new_non_oriented_moore_super_cursor_light( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn get_tree( + &mut self, + p0: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + fn set_tree(&mut self, p0: core::ffi::c_uchar, p1: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, p0: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn recursively_initialize_pure_mask( + &mut self, + cursor: *mut core::ffi::c_void, + normale: *mut core::ffi::c_void, + ) -> bool; + fn get_pure_mask(&mut self) -> *mut core::ffi::c_void; + fn get_child_mask(&mut self, p0: core::ffi::c_uint) -> core::ffi::c_uint; + fn get_index_from_level_zero_coordinates( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> (); + fn get_shifted_level_zero_index( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> core::ffi::c_uchar; + fn get_level_zero_coordinates_from_index( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> (); + fn get_level_zero_origin_and_size_from_index( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> (); + fn get_level_zero_origin_from_index( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_double, + ) -> (); + fn get_global_node_index_max(&mut self) -> core::ffi::c_uchar; + fn initialize_local_index_node(&mut self) -> (); + fn has_any_ghost_cells(&mut self) -> bool; + fn get_ghost_cells(&mut self) -> *mut core::ffi::c_void; + fn get_tree_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn allocate_tree_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn initialize_tree_iterator(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_center(&mut self) -> *mut core::ffi::c_double; + fn get_center(&mut self, center: core::ffi::c_double) -> (); + fn get_cell_data(&mut self) -> *mut core::ffi::c_void; + fn get_attributes_as_field_data( + &mut self, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar; +} +pub trait VtkHyperTreeGridNonOrientedCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> (); + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ) -> (); + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + ) -> (); + fn get_grid(&mut self) -> *mut core::ffi::c_void; + fn has_tree(&mut self) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_uchar; + fn get_global_node_index(&mut self) -> core::ffi::c_uchar; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); + fn set_mask(&mut self, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_leaf(&mut self) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); + fn to_root(&mut self) -> (); + fn to_parent(&mut self) -> (); +} +pub trait VtkHyperTreeGridNonOrientedGeometryCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> (); + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ) -> (); + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + origin: core::ffi::c_double, + ) -> (); + fn initialize(&mut self, cursor: *mut core::ffi::c_void) -> (); + fn has_tree(&mut self) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_uchar; + fn get_global_node_index(&mut self) -> core::ffi::c_uchar; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); + fn get_origin(&mut self) -> *mut core::ffi::c_double; + fn get_size(&mut self) -> *mut core::ffi::c_double; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_point(&mut self, point: core::ffi::c_double) -> (); + fn set_mask(&mut self, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_leaf(&mut self) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); + fn to_root(&mut self) -> (); + fn to_parent(&mut self) -> (); +} +pub trait VtkHyperTreeGridNonOrientedMooreSuperCursor: VtkHyperTreeGridNonOrientedSuperCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> (); + fn get_corner_cursors( + &mut self, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool; +} +pub trait VtkHyperTreeGridNonOrientedMooreSuperCursorLight: VtkHyperTreeGridNonOrientedSuperCursorLight { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> (); + fn get_corner_cursors( + &mut self, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool; +} +pub trait VtkHyperTreeGridNonOrientedSuperCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> (); + fn get_grid(&mut self) -> *mut core::ffi::c_void; + fn has_tree(&mut self) -> bool; + fn has_tree(&mut self, icursor: core::ffi::c_uint) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_tree(&mut self, icursor: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_uchar; + fn get_vertex_id(&mut self, icursor: core::ffi::c_uint) -> core::ffi::c_uchar; + fn get_global_node_index(&mut self) -> core::ffi::c_uchar; + fn get_global_node_index( + &mut self, + icursor: core::ffi::c_uint, + ) -> core::ffi::c_uchar; + fn get_information( + &mut self, + icursor: core::ffi::c_uint, + level: core::ffi::c_uint, + leaf: bool, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); + fn get_origin(&mut self) -> *mut core::ffi::c_double; + fn get_size(&mut self) -> *mut core::ffi::c_double; + fn set_mask(&mut self, state: bool) -> (); + fn set_mask(&mut self, icursor: core::ffi::c_uint, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_masked(&mut self, icursor: core::ffi::c_uint) -> bool; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_bounds( + &mut self, + icursor: core::ffi::c_uint, + bounds: core::ffi::c_double, + ) -> (); + fn get_point(&mut self, point: core::ffi::c_double) -> (); + fn get_point( + &mut self, + icursor: core::ffi::c_uint, + point: core::ffi::c_double, + ) -> (); + fn is_leaf(&mut self) -> bool; + fn is_leaf(&mut self, icursor: core::ffi::c_uint) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn get_level(&mut self, icursor: core::ffi::c_uint) -> core::ffi::c_uint; + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); + fn to_root(&mut self) -> (); + fn to_parent(&mut self) -> (); + fn get_number_of_cursors(&mut self) -> core::ffi::c_uint; +} +pub trait VtkHyperTreeGridNonOrientedSuperCursorLight { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> (); + fn get_grid(&mut self) -> *mut core::ffi::c_void; + fn has_tree(&mut self) -> bool; + fn has_tree(&mut self, icursor: core::ffi::c_uint) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_tree(&mut self, icursor: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_uchar; + fn get_vertex_id(&mut self, icursor: core::ffi::c_uint) -> core::ffi::c_uchar; + fn get_global_node_index(&mut self) -> core::ffi::c_uchar; + fn get_global_node_index( + &mut self, + icursor: core::ffi::c_uint, + ) -> core::ffi::c_uchar; + fn get_information( + &mut self, + icursor: core::ffi::c_uint, + level: core::ffi::c_uint, + leaf: bool, + id: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); + fn get_origin(&mut self) -> *mut core::ffi::c_double; + fn get_size(&mut self) -> *mut core::ffi::c_double; + fn set_mask(&mut self, state: bool) -> (); + fn set_mask(&mut self, icursor: core::ffi::c_uint, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_masked(&mut self, icursor: core::ffi::c_uint) -> bool; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_point(&mut self, point: core::ffi::c_double) -> (); + fn is_leaf(&mut self) -> bool; + fn is_leaf(&mut self, icursor: core::ffi::c_uint) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn get_level(&mut self, icursor: core::ffi::c_uint) -> core::ffi::c_uint; + fn to_child(&mut self, p0: core::ffi::c_uchar) -> (); + fn to_root(&mut self) -> (); + fn to_parent(&mut self) -> (); + fn get_number_of_cursors(&mut self) -> core::ffi::c_uint; +} +pub trait VtkHyperTreeGridNonOrientedVonNeumannSuperCursor: VtkHyperTreeGridNonOrientedSuperCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> (); +} +pub trait VtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight: VtkHyperTreeGridNonOrientedSuperCursorLight { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> (); +} +pub trait VtkHyperTreeGridOrientedCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> (); + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + ) -> (); + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ) -> (); + fn get_grid(&mut self) -> *mut core::ffi::c_void; + fn has_tree(&mut self) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_uchar; + fn get_global_node_index(&mut self) -> core::ffi::c_uchar; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); + fn set_mask(&mut self, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_leaf(&mut self) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); +} +pub trait VtkHyperTreeGridOrientedGeometryCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> (); + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ) -> (); + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + origin: core::ffi::c_double, + ) -> (); + fn initialize(&mut self, cursor: *mut core::ffi::c_void) -> (); + fn has_tree(&mut self) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_uchar; + fn get_global_node_index(&mut self) -> core::ffi::c_uchar; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); + fn get_origin(&mut self) -> *mut core::ffi::c_double; + fn get_size(&mut self) -> *mut core::ffi::c_double; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_point(&mut self, point: core::ffi::c_double) -> (); + fn set_mask(&mut self, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_leaf(&mut self) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); +} +pub trait VtkHyperTreeGridScales { + fn get_branch_factor(&mut self) -> core::ffi::c_double; + fn get_scale(&mut self, level: core::ffi::c_uint) -> *mut core::ffi::c_double; + fn get_scale_x(&mut self, level: core::ffi::c_uint) -> core::ffi::c_double; + fn get_scale_y(&mut self, level: core::ffi::c_uint) -> core::ffi::c_double; + fn get_scale_z(&mut self, level: core::ffi::c_uint) -> core::ffi::c_double; + fn get_scale(&mut self, level: core::ffi::c_uint, scale: core::ffi::c_double) -> (); + fn get_current_fail_level(&mut self) -> core::ffi::c_uint; +} +pub trait VtkImageData: VtkDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> (); + fn find_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + seedLoc: core::ffi::c_int, + ) -> (); + fn initialize(&mut self) -> (); + fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn has_any_blank_points(&mut self) -> bool; + fn has_any_blank_cells(&mut self) -> bool; + fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> (); + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn set_dimensions(&mut self, dims: core::ffi::c_int) -> (); + fn get_dimensions(&mut self) -> *mut core::ffi::c_int; + fn get_dimensions(&mut self, dims: core::ffi::c_int) -> (); + fn get_dimensions(&mut self, dims: core::ffi::c_uchar) -> (); + fn compute_structured_coordinates( + &mut self, + x: core::ffi::c_double, + ijk: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_voxel_gradient( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + s: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ) -> (); + fn get_point_gradient( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + s: *mut core::ffi::c_void, + g: core::ffi::c_double, + ) -> (); + fn get_data_dimension(&mut self) -> core::ffi::c_int; + fn compute_point_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar; + fn compute_cell_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar; + fn set_axis_update_extent( + &mut self, + axis: core::ffi::c_int, + min: core::ffi::c_int, + max: core::ffi::c_int, + updateExtent: core::ffi::c_int, + axisUpdateExtent: core::ffi::c_int, + ) -> (); + fn get_axis_update_extent( + &mut self, + axis: core::ffi::c_int, + min: core::ffi::c_int, + max: core::ffi::c_int, + updateExtent: core::ffi::c_int, + ) -> (); + fn set_extent(&mut self, extent: core::ffi::c_int) -> (); + fn set_extent( + &mut self, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ) -> (); + fn get_extent(&mut self) -> *mut core::ffi::c_int; + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn get_scalar_type_min( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + fn get_scalar_type_min(&mut self) -> core::ffi::c_double; + fn get_scalar_type_max( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + fn get_scalar_type_max(&mut self) -> core::ffi::c_double; + fn get_scalar_size(&mut self, meta_data: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_scalar_size(&mut self) -> core::ffi::c_int; + fn get_increments(&mut self) -> *mut core::ffi::c_uchar; + fn get_increments( + &mut self, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ) -> (); + fn get_increments(&mut self, inc: core::ffi::c_uchar) -> (); + fn get_increments( + &mut self, + scalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_uchar; + fn get_increments( + &mut self, + scalars: *mut core::ffi::c_void, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ) -> (); + fn get_increments( + &mut self, + scalars: *mut core::ffi::c_void, + inc: core::ffi::c_uchar, + ) -> (); + fn get_continuous_increments( + &mut self, + extent: core::ffi::c_int, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ) -> (); + fn get_continuous_increments( + &mut self, + scalars: *mut core::ffi::c_void, + extent: core::ffi::c_int, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ) -> (); + fn get_scalar_pointer_for_extent(&mut self, extent: core::ffi::c_int) -> *mut (); + fn get_scalar_pointer(&mut self, coordinates: core::ffi::c_int) -> *mut (); + fn get_scalar_pointer( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + ) -> *mut (); + fn get_scalar_pointer(&mut self) -> *mut (); + fn get_scalar_index_for_extent( + &mut self, + extent: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn get_scalar_index(&mut self, coordinates: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_scalar_index( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn get_scalar_component_as_float( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_float; + fn set_scalar_component_from_float( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_float, + ) -> (); + fn get_scalar_component_as_double( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_double; + fn set_scalar_component_from_double( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_double, + ) -> (); + fn allocate_scalars( + &mut self, + dataType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ) -> (); + fn allocate_scalars(&mut self, pipeline_info: *mut core::ffi::c_void) -> (); + fn copy_and_cast_from( + &mut self, + inData: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> (); + fn copy_and_cast_from( + &mut self, + inData: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> (); + fn crop(&mut self, updateExtent: core::ffi::c_int) -> (); + fn get_spacing(&mut self) -> *mut core::ffi::c_double; + fn get_spacing( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_spacing(&mut self, _arg: core::ffi::c_double) -> (); + fn set_spacing( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ) -> (); + fn set_spacing(&mut self, ijk: core::ffi::c_double) -> (); + fn get_origin(&mut self) -> *mut core::ffi::c_double; + fn get_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_origin(&mut self, _arg: core::ffi::c_double) -> (); + fn set_origin( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ) -> (); + fn set_origin(&mut self, ijk: core::ffi::c_double) -> (); + fn get_direction_matrix(&mut self) -> *mut core::ffi::c_void; + fn set_direction_matrix(&mut self, m: *mut core::ffi::c_void) -> (); + fn set_direction_matrix(&mut self, elements: core::ffi::c_double) -> (); + fn set_direction_matrix( + &mut self, + e00: core::ffi::c_double, + e01: core::ffi::c_double, + e02: core::ffi::c_double, + e10: core::ffi::c_double, + e11: core::ffi::c_double, + e12: core::ffi::c_double, + e20: core::ffi::c_double, + e21: core::ffi::c_double, + e22: core::ffi::c_double, + ) -> (); + fn get_index_to_physical_matrix(&mut self) -> *mut core::ffi::c_void; + fn transform_continuous_index_to_physical_point( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + xyz: core::ffi::c_double, + ) -> (); + fn transform_continuous_index_to_physical_point( + &mut self, + ijk: core::ffi::c_double, + xyz: core::ffi::c_double, + ) -> (); + fn transform_index_to_physical_point( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + xyz: core::ffi::c_double, + ) -> (); + fn transform_index_to_physical_point( + &mut self, + ijk: core::ffi::c_int, + xyz: core::ffi::c_double, + ) -> (); + fn transform_continuous_index_to_physical_point( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + direction: core::ffi::c_double, + xyz: core::ffi::c_double, + ) -> (); + fn get_physical_to_index_matrix(&mut self) -> *mut core::ffi::c_void; + fn transform_physical_point_to_continuous_index( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ijk: core::ffi::c_double, + ) -> (); + fn transform_physical_point_to_continuous_index( + &mut self, + xyz: core::ffi::c_double, + ijk: core::ffi::c_double, + ) -> (); + fn compute_index_to_physical_matrix( + &mut self, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + direction: core::ffi::c_double, + result: core::ffi::c_double, + ) -> (); + fn transform_physical_normal_to_continuous_index( + &mut self, + xyz: core::ffi::c_double, + ijk: core::ffi::c_double, + ) -> (); + fn transform_physical_plane_to_continuous_index( + &mut self, + pplane: core::ffi::c_double, + iplane: core::ffi::c_double, + ) -> (); + fn set_scalar_type( + &mut self, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> (); + fn get_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> core::ffi::c_int; + fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool; + fn get_scalar_type(&mut self) -> core::ffi::c_int; + fn get_scalar_type_as_string(&mut self) -> *const core::ffi::c_char; + fn set_number_of_scalar_components( + &mut self, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn has_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> bool; + fn get_number_of_scalar_components(&mut self) -> core::ffi::c_int; + fn copy_information_from_pipeline( + &mut self, + information: *mut core::ffi::c_void, + ) -> (); + fn copy_information_to_pipeline( + &mut self, + information: *mut core::ffi::c_void, + ) -> (); + fn prepare_for_new_data(&mut self) -> (); + fn get_array_pointer_for_extent( + &mut self, + array: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> *mut (); + fn get_array_pointer( + &mut self, + array: *mut core::ffi::c_void, + coordinates: core::ffi::c_int, + ) -> *mut (); + fn get_tuple_index( + &mut self, + array: *mut core::ffi::c_void, + coordinates: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn get_array_increments( + &mut self, + array: *mut core::ffi::c_void, + increments: core::ffi::c_uchar, + ) -> (); + fn compute_internal_extent( + &mut self, + intExt: core::ffi::c_int, + tgtExt: core::ffi::c_int, + bnds: core::ffi::c_int, + ) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkImageIterator { + fn initialize(&mut self, id: *mut core::ffi::c_void, ext: core::ffi::c_int) -> (); + fn next_span(&mut self) -> (); + fn begin_span(&mut self) -> *mut core::ffi::c_void; + fn end_span(&mut self) -> *mut core::ffi::c_void; + fn is_at_end(&mut self) -> core::ffi::c_int; +} +pub trait VtkImageTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn transform_point_set( + &mut self, + im: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + ) -> (); + fn transform_point_set( + &mut self, + im: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + transNormals: bool, + transVectors: bool, + ) -> (); + fn translate_points( + &mut self, + t: core::ffi::c_double, + da: *mut core::ffi::c_void, + ) -> (); + fn transform_points( + &mut self, + m4: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> (); + fn transform_normals( + &mut self, + m3: *mut core::ffi::c_void, + spacing: core::ffi::c_double, + da: *mut core::ffi::c_void, + ) -> (); + fn transform_vectors( + &mut self, + m3: *mut core::ffi::c_void, + spacing: core::ffi::c_double, + da: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkImplicitBoolean: VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn add_function(&mut self, in_: *mut core::ffi::c_void) -> (); + fn remove_function(&mut self, in_: *mut core::ffi::c_void) -> (); + fn get_function(&mut self) -> *mut core::ffi::c_void; + fn set_operation_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_operation_type_min_value(&mut self) -> core::ffi::c_int; + fn get_operation_type_max_value(&mut self) -> core::ffi::c_int; + fn get_operation_type(&mut self) -> core::ffi::c_int; + fn set_operation_type_to_union(&mut self) -> (); + fn set_operation_type_to_intersection(&mut self) -> (); + fn set_operation_type_to_difference(&mut self) -> (); + fn set_operation_type_to_union_of_magnitudes(&mut self) -> (); + fn get_operation_type_as_string(&mut self) -> *const core::ffi::c_char; +} +pub trait VtkImplicitDataSet: VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn set_out_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_out_value(&mut self) -> core::ffi::c_double; + fn set_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_out_gradient(&mut self, _arg: core::ffi::c_double) -> (); + fn get_out_gradient(&mut self) -> *mut core::ffi::c_double; + fn get_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_out_gradient(&mut self, _arg: core::ffi::c_double) -> (); +} +pub trait VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn function_value( + &mut self, + input: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn function_value(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn function_value( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_double; + fn function_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); + fn function_gradient(&mut self, x: core::ffi::c_double) -> *mut core::ffi::c_double; + fn function_gradient( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn set_transform(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_transform(&mut self, elements: core::ffi::c_double) -> (); + fn get_transform(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_function( + &mut self, + input: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn evaluate_function( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); +} +pub trait VtkImplicitFunctionCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_next_implicit_function(&mut self, cookie: ()) -> *mut core::ffi::c_void; +} +pub trait VtkImplicitHalo: VtkImplicitFunction { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_center(&mut self, _arg: core::ffi::c_double) -> (); + fn get_center(&mut self) -> *mut core::ffi::c_double; + fn get_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_center(&mut self, _arg: core::ffi::c_double) -> (); + fn set_fade_out(&mut self, _arg: core::ffi::c_double) -> (); + fn get_fade_out(&mut self) -> core::ffi::c_double; +} +pub trait VtkImplicitSelectionLoop: VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn set_loop(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_loop(&mut self) -> *mut core::ffi::c_void; + fn set_automatic_normal_generation(&mut self, _arg: core::ffi::c_int) -> (); + fn get_automatic_normal_generation(&mut self) -> core::ffi::c_int; + fn automatic_normal_generation_on(&mut self) -> (); + fn automatic_normal_generation_off(&mut self) -> (); + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_normal(&mut self, _arg: core::ffi::c_double) -> (); + fn get_normal(&mut self) -> *mut core::ffi::c_double; + fn get_normal(&mut self, data: core::ffi::c_double) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkImplicitSum: VtkImplicitFunction { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn add_function( + &mut self, + in_: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ) -> (); + fn add_function(&mut self, in_: *mut core::ffi::c_void) -> (); + fn remove_all_functions(&mut self) -> (); + fn set_function_weight( + &mut self, + f: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ) -> (); + fn set_normalize_by_weight(&mut self, _arg: core::ffi::c_int) -> (); + fn get_normalize_by_weight(&mut self) -> core::ffi::c_int; + fn normalize_by_weight_on(&mut self) -> (); + fn normalize_by_weight_off(&mut self) -> (); +} +pub trait VtkImplicitVolume: VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn set_volume(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_volume(&mut self) -> *mut core::ffi::c_void; + fn set_out_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_out_value(&mut self) -> core::ffi::c_double; + fn set_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_out_gradient(&mut self, _arg: core::ffi::c_double) -> (); + fn get_out_gradient(&mut self) -> *mut core::ffi::c_double; + fn get_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_out_gradient(&mut self, _arg: core::ffi::c_double) -> (); +} +pub trait VtkImplicitWindowFunction: VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn set_implicit_function(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_implicit_function(&mut self) -> *mut core::ffi::c_void; + fn set_window_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_window_range(&mut self, _arg: core::ffi::c_double) -> (); + fn get_window_range(&mut self) -> *mut core::ffi::c_double; + fn get_window_range(&mut self, data: core::ffi::c_double) -> (); + fn set_window_values( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_window_values(&mut self, _arg: core::ffi::c_double) -> (); + fn get_window_values(&mut self) -> *mut core::ffi::c_double; + fn get_window_values(&mut self, data: core::ffi::c_double) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); +} +pub trait VtkInEdgeIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> (); + fn get_graph(&mut self) -> *mut core::ffi::c_void; + fn get_vertex(&mut self) -> core::ffi::c_uchar; + fn next(&mut self) -> *mut core::ffi::c_void; + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void; + fn has_next(&mut self) -> bool; +} +pub trait VtkIncrementalOctreeNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn get_point_id_set(&mut self) -> *mut core::ffi::c_void; + fn delete_child_nodes(&mut self) -> (); + fn set_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> (); + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_min_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_min_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_min_bounds(&mut self, _arg: core::ffi::c_double) -> (); + fn get_max_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_max_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_max_bounds(&mut self, _arg: core::ffi::c_double) -> (); + fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double; + fn is_leaf(&mut self) -> core::ffi::c_int; + fn get_child_index(&mut self, point: core::ffi::c_double) -> core::ffi::c_int; + fn get_child(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contains_point(&mut self, pnt: core::ffi::c_double) -> core::ffi::c_int; + fn contains_point_by_data(&mut self, pnt: core::ffi::c_double) -> core::ffi::c_int; + fn insert_point( + &mut self, + points: *mut core::ffi::c_void, + newPnt: core::ffi::c_double, + maxPts: core::ffi::c_int, + pntId: core::ffi::c_uchar, + ptMode: core::ffi::c_int, + ) -> core::ffi::c_int; + fn insert_point( + &mut self, + points: *mut core::ffi::c_void, + newPnt: core::ffi::c_double, + maxPts: core::ffi::c_int, + pntId: core::ffi::c_uchar, + ptMode: core::ffi::c_int, + numberOfNodes: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_distance_2_to_inner_boundary( + &mut self, + point: core::ffi::c_double, + rootNode: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + fn get_distance_2_to_boundary( + &mut self, + point: core::ffi::c_double, + rootNode: *mut core::ffi::c_void, + checkData: core::ffi::c_int, + ) -> core::ffi::c_double; + fn get_distance_2_to_boundary( + &mut self, + point: core::ffi::c_double, + closest: core::ffi::c_double, + rootNode: *mut core::ffi::c_void, + checkData: core::ffi::c_int, + ) -> core::ffi::c_double; + fn export_all_point_ids_by_insertion( + &mut self, + idList: *mut core::ffi::c_void, + ) -> (); + fn export_all_point_ids_by_direct_set( + &mut self, + pntIdx: core::ffi::c_uchar, + idList: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_levels(&mut self) -> core::ffi::c_int; + fn get_id(&mut self) -> core::ffi::c_int; + fn get_point_ids(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkIncrementalOctreePointLocator: VtkIncrementalPointLocator + VtkAbstractPointLocator + VtkLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_max_points_per_leaf(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_points_per_leaf_min_value(&mut self) -> core::ffi::c_int; + fn get_max_points_per_leaf_max_value(&mut self) -> core::ffi::c_int; + fn get_max_points_per_leaf(&mut self) -> core::ffi::c_int; + fn set_build_cubic_octree(&mut self, _arg: core::ffi::c_int) -> (); + fn get_build_cubic_octree(&mut self) -> core::ffi::c_int; + fn build_cubic_octree_on(&mut self) -> (); + fn build_cubic_octree_off(&mut self) -> (); + fn get_locator_points(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn free_search_structure(&mut self) -> (); + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn get_number_of_nodes(&mut self) -> core::ffi::c_int; + fn find_closest_inserted_point( + &mut self, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn generate_representation( + &mut self, + level: core::ffi::c_int, + polysData: *mut core::ffi::c_void, + ) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + polysData: *mut core::ffi::c_void, + UserGetBounds: *mut core::ffi::c_void, + data: (), + ) -> (); + fn build_locator(&mut self) -> (); + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + miniDist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + miniDist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_within_squared_radius( + &mut self, + radius2: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_points_within_squared_radius( + &mut self, + R2: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn init_point_insertion( + &mut self, + points: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + fn init_point_insertion( + &mut self, + points: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + estSize: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn insert_unique_point( + &mut self, + point: core::ffi::c_double, + pntId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn insert_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn insert_point_without_checking( + &mut self, + point: core::ffi::c_double, + pntId: core::ffi::c_uchar, + insert: core::ffi::c_int, + ) -> (); + fn get_root(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_levels(&mut self) -> core::ffi::c_int; +} +pub trait VtkIncrementalPointLocator: VtkAbstractPointLocator + VtkLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn find_closest_inserted_point( + &mut self, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn init_point_insertion( + &mut self, + newPts: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + fn init_point_insertion( + &mut self, + newPts: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + estSize: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn insert_unique_point( + &mut self, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn insert_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; +} +pub trait VtkInformationQuadratureSchemeDefinitionVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn clear(&mut self, info: *mut core::ffi::c_void) -> (); + fn resize(&mut self, info: *mut core::ffi::c_void, n: core::ffi::c_int) -> (); + fn size(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> (); + fn set_range( + &mut self, + info: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + from: core::ffi::c_int, + to: core::ffi::c_int, + n: core::ffi::c_int, + ) -> (); + fn get_range( + &mut self, + info: *mut core::ffi::c_void, + dest: *mut core::ffi::c_void, + from: core::ffi::c_int, + to: core::ffi::c_int, + n: core::ffi::c_int, + ) -> (); + fn get( + &mut self, + info: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); + fn save_state( + &mut self, + info: *mut core::ffi::c_void, + element: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn restore_state( + &mut self, + info: *mut core::ffi::c_void, + element: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkIntersectionCounter { + fn set_tolerance(&mut self, tol: core::ffi::c_double) -> (); + fn get_tolerance(&mut self) -> core::ffi::c_double; + fn add_intersection(&mut self, t: core::ffi::c_double) -> (); + fn reset(&mut self) -> (); + fn count_intersections(&mut self) -> core::ffi::c_int; +} +pub trait VtkIterativeClosestPointTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_source(&mut self, source: *mut core::ffi::c_void) -> (); + fn set_target(&mut self, target: *mut core::ffi::c_void) -> (); + fn get_source(&mut self) -> *mut core::ffi::c_void; + fn get_target(&mut self) -> *mut core::ffi::c_void; + fn set_locator(&mut self, locator: *mut core::ffi::c_void) -> (); + fn get_locator(&mut self) -> *mut core::ffi::c_void; + fn set_maximum_number_of_iterations(&mut self, _arg: core::ffi::c_int) -> (); + fn get_maximum_number_of_iterations(&mut self) -> core::ffi::c_int; + fn get_number_of_iterations(&mut self) -> core::ffi::c_int; + fn set_check_mean_distance(&mut self, _arg: core::ffi::c_int) -> (); + fn get_check_mean_distance(&mut self) -> core::ffi::c_int; + fn check_mean_distance_on(&mut self) -> (); + fn check_mean_distance_off(&mut self) -> (); + fn set_mean_distance_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_mean_distance_mode_min_value(&mut self) -> core::ffi::c_int; + fn get_mean_distance_mode_max_value(&mut self) -> core::ffi::c_int; + fn get_mean_distance_mode(&mut self) -> core::ffi::c_int; + fn set_mean_distance_mode_to_rms(&mut self) -> (); + fn set_mean_distance_mode_to_absolute_value(&mut self) -> (); + fn get_mean_distance_mode_as_string(&mut self) -> *const core::ffi::c_char; + fn set_maximum_mean_distance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_maximum_mean_distance(&mut self) -> core::ffi::c_double; + fn get_mean_distance(&mut self) -> core::ffi::c_double; + fn set_maximum_number_of_landmarks(&mut self, _arg: core::ffi::c_int) -> (); + fn get_maximum_number_of_landmarks(&mut self) -> core::ffi::c_int; + fn set_start_by_matching_centroids(&mut self, _arg: core::ffi::c_int) -> (); + fn get_start_by_matching_centroids(&mut self) -> core::ffi::c_int; + fn start_by_matching_centroids_on(&mut self) -> (); + fn start_by_matching_centroids_off(&mut self) -> (); + fn get_landmark_transform(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkKdNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_dim(&mut self, _arg: core::ffi::c_int) -> (); + fn get_dim(&mut self) -> core::ffi::c_int; + fn get_division_position(&mut self) -> core::ffi::c_double; + fn set_number_of_points(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn set_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> (); + fn set_bounds(&mut self, b: core::ffi::c_double) -> (); + fn get_bounds(&mut self, b: core::ffi::c_double) -> (); + fn set_data_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> (); + fn get_data_bounds(&mut self, b: core::ffi::c_double) -> (); + fn set_data_bounds(&mut self, v: core::ffi::c_float) -> (); + fn get_min_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_max_bounds(&mut self) -> *mut core::ffi::c_double; + fn set_min_bounds(&mut self, mb: core::ffi::c_double) -> (); + fn set_max_bounds(&mut self, mb: core::ffi::c_double) -> (); + fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double; + fn set_min_data_bounds(&mut self, mb: core::ffi::c_double) -> (); + fn set_max_data_bounds(&mut self, mb: core::ffi::c_double) -> (); + fn set_id(&mut self, _arg: core::ffi::c_int) -> (); + fn get_id(&mut self) -> core::ffi::c_int; + fn get_min_id(&mut self) -> core::ffi::c_int; + fn get_max_id(&mut self) -> core::ffi::c_int; + fn set_min_id(&mut self, _arg: core::ffi::c_int) -> (); + fn set_max_id(&mut self, _arg: core::ffi::c_int) -> (); + fn add_child_nodes( + &mut self, + left: *mut core::ffi::c_void, + right: *mut core::ffi::c_void, + ) -> (); + fn delete_child_nodes(&mut self) -> (); + fn get_left(&mut self) -> *mut core::ffi::c_void; + fn set_left(&mut self, left: *mut core::ffi::c_void) -> (); + fn get_right(&mut self) -> *mut core::ffi::c_void; + fn set_right(&mut self, right: *mut core::ffi::c_void) -> (); + fn get_up(&mut self) -> *mut core::ffi::c_void; + fn set_up(&mut self, up: *mut core::ffi::c_void) -> (); + fn intersects_box( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersects_sphere_2( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersects_region( + &mut self, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersects_cell( + &mut self, + cell: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + cellRegion: core::ffi::c_int, + cellBounds: core::ffi::c_double, + ) -> core::ffi::c_int; + fn contains_box( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn contains_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + boundaryPt: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + fn get_distance_2_to_inner_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_double; + fn print_node(&mut self, depth: core::ffi::c_int) -> (); + fn print_verbose_node(&mut self, depth: core::ffi::c_int) -> (); +} +pub trait VtkKdTree: VtkLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn timing_on(&mut self) -> (); + fn timing_off(&mut self) -> (); + fn set_timing(&mut self, _arg: core::ffi::c_int) -> (); + fn get_timing(&mut self) -> core::ffi::c_int; + fn set_min_cells(&mut self, _arg: core::ffi::c_int) -> (); + fn get_min_cells(&mut self) -> core::ffi::c_int; + fn get_number_of_regions_or_less(&mut self) -> core::ffi::c_int; + fn set_number_of_regions_or_less(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_regions_or_more(&mut self) -> core::ffi::c_int; + fn set_number_of_regions_or_more(&mut self, _arg: core::ffi::c_int) -> (); + fn get_fudge_factor(&mut self) -> core::ffi::c_double; + fn set_fudge_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_cuts(&mut self) -> *mut core::ffi::c_void; + fn set_cuts(&mut self, cuts: *mut core::ffi::c_void) -> (); + fn omit_x_partitioning(&mut self) -> (); + fn omit_y_partitioning(&mut self) -> (); + fn omit_z_partitioning(&mut self) -> (); + fn omit_xy_partitioning(&mut self) -> (); + fn omit_yz_partitioning(&mut self) -> (); + fn omit_zx_partitioning(&mut self) -> (); + fn omit_no_partitioning(&mut self) -> (); + fn set_data_set(&mut self, set: *mut core::ffi::c_void) -> (); + fn add_data_set(&mut self, set: *mut core::ffi::c_void) -> (); + fn remove_data_set(&mut self, index: core::ffi::c_int) -> (); + fn remove_data_set(&mut self, set: *mut core::ffi::c_void) -> (); + fn remove_all_data_sets(&mut self) -> (); + fn get_number_of_data_sets(&mut self) -> core::ffi::c_int; + fn get_data_set(&mut self, n: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn get_data_sets(&mut self) -> *mut core::ffi::c_void; + fn get_data_set_index(&mut self, set: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn set_new_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_number_of_regions(&mut self) -> core::ffi::c_int; + fn get_region_bounds( + &mut self, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> (); + fn get_region_data_bounds( + &mut self, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> (); + fn print_tree(&mut self) -> (); + fn print_verbose_tree(&mut self) -> (); + fn print_region(&mut self, id: core::ffi::c_int) -> (); + fn create_cell_lists( + &mut self, + dataSetIndex: core::ffi::c_int, + regionReqList: core::ffi::c_int, + reqListSize: core::ffi::c_int, + ) -> (); + fn create_cell_lists( + &mut self, + set: *mut core::ffi::c_void, + regionReqList: core::ffi::c_int, + reqListSize: core::ffi::c_int, + ) -> (); + fn create_cell_lists( + &mut self, + regionReqList: core::ffi::c_int, + listSize: core::ffi::c_int, + ) -> (); + fn create_cell_lists(&mut self) -> (); + fn set_include_region_boundary_cells(&mut self, _arg: core::ffi::c_int) -> (); + fn get_include_region_boundary_cells(&mut self) -> core::ffi::c_int; + fn include_region_boundary_cells_on(&mut self) -> (); + fn include_region_boundary_cells_off(&mut self) -> (); + fn delete_cell_lists(&mut self) -> (); + fn get_cell_list(&mut self, regionID: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_boundary_cell_list( + &mut self, + regionID: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_cell_lists( + &mut self, + regions: *mut core::ffi::c_void, + set: core::ffi::c_int, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn get_cell_lists( + &mut self, + regions: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn get_cell_lists( + &mut self, + regions: *mut core::ffi::c_void, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn get_region_containing_cell( + &mut self, + set: *mut core::ffi::c_void, + cellID: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn get_region_containing_cell( + &mut self, + set: core::ffi::c_int, + cellID: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn get_region_containing_cell( + &mut self, + cellID: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn all_get_region_containing_cell(&mut self) -> *mut core::ffi::c_int; + fn get_region_containing_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int; + fn build_locator(&mut self) -> (); + fn minimal_number_of_convex_sub_regions( + &mut self, + regionIdList: *mut core::ffi::c_void, + convexRegionBounds: core::ffi::c_double, + ) -> core::ffi::c_int; + fn view_order_all_regions_in_direction( + &mut self, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn view_order_regions_in_direction( + &mut self, + regionIds: *mut core::ffi::c_void, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn view_order_all_regions_from_position( + &mut self, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn view_order_regions_from_position( + &mut self, + regionIds: *mut core::ffi::c_void, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn build_locator_from_points(&mut self, pointset: *mut core::ffi::c_void) -> (); + fn build_locator_from_points(&mut self, ptArray: *mut core::ffi::c_void) -> (); + fn build_locator_from_points( + &mut self, + ptArray: *mut core::ffi::c_void, + numPtArrays: core::ffi::c_int, + ) -> (); + fn build_map_for_duplicate_points( + &mut self, + tolerance: core::ffi::c_float, + ) -> *mut core::ffi::c_void; + fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_in_region( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_in_region( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn get_points_in_region( + &mut self, + regionId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn free_search_structure(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); + fn generate_representation( + &mut self, + regionList: core::ffi::c_int, + len: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); + fn generate_representation_using_data_bounds_on(&mut self) -> (); + fn generate_representation_using_data_bounds_off(&mut self) -> (); + fn set_generate_representation_using_data_bounds( + &mut self, + _arg: core::ffi::c_int, + ) -> (); + fn get_generate_representation_using_data_bounds(&mut self) -> core::ffi::c_int; + fn new_geometry(&mut self) -> core::ffi::c_int; + fn new_geometry( + &mut self, + sets: *mut core::ffi::c_void, + numDataSets: core::ffi::c_int, + ) -> core::ffi::c_int; + fn invalidate_geometry(&mut self) -> (); + fn copy_tree(&mut self, kd: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn find_points_in_area( + &mut self, + area: core::ffi::c_double, + ids: *mut core::ffi::c_void, + clearArray: bool, + ) -> (); +} +pub trait VtkKdTreePointLocator: VtkAbstractPointLocator + VtkLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkLagrangeCurve: VtkHigherOrderCurve + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); +} +pub trait VtkLagrangeHexahedron: VtkHigherOrderHexahedron + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLagrangeInterpolation: VtkHigherOrderInterpolation { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn evaluate_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> (); + fn evaluate_shape_and_gradient( + &mut self, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + grad: core::ffi::c_double, + ) -> (); + fn tensor_1_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_1_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_2_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_2_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_3_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_3_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tensor_3_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ) -> (); + fn wedge_shape_functions( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> (); + fn wedge_shape_derivatives( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn wedge_evaluate( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldAtPCoords: core::ffi::c_double, + ) -> (); + fn wedge_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkLagrangeQuadrilateral: VtkHigherOrderQuadrilateral + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLagrangeTetra: VtkHigherOrderTetra + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLagrangeTriangle: VtkHigherOrderTriangle + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLagrangeWedge: VtkHigherOrderWedge + VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void; + fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLine: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersection( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + u: core::ffi::c_double, + v: core::ffi::c_double, + tolerance: core::ffi::c_double, + toleranceType: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersection_3_d( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + u: core::ffi::c_double, + v: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int; + fn distance_to_line( + &mut self, + x: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t: core::ffi::c_double, + closestPoint: core::ffi::c_double, + ) -> core::ffi::c_double; + fn distance_to_line( + &mut self, + x: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_double; + fn distance_between_lines( + &mut self, + l0: core::ffi::c_double, + l1: core::ffi::c_double, + m0: core::ffi::c_double, + m1: core::ffi::c_double, + closestPt1: core::ffi::c_double, + closestPt2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + ) -> core::ffi::c_double; + fn distance_between_line_segments( + &mut self, + l0: core::ffi::c_double, + l1: core::ffi::c_double, + m0: core::ffi::c_double, + m1: core::ffi::c_double, + closestPt1: core::ffi::c_double, + closestPt2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + ) -> core::ffi::c_double; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn set_max_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_level_min_value(&mut self) -> core::ffi::c_int; + fn get_max_level_max_value(&mut self) -> core::ffi::c_int; + fn get_max_level(&mut self) -> core::ffi::c_int; + fn get_level(&mut self) -> core::ffi::c_int; + fn set_automatic(&mut self, _arg: core::ffi::c_int) -> (); + fn get_automatic(&mut self) -> core::ffi::c_int; + fn automatic_on(&mut self) -> (); + fn automatic_off(&mut self) -> (); + fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tolerance_min_value(&mut self) -> core::ffi::c_double; + fn get_tolerance_max_value(&mut self) -> core::ffi::c_double; + fn get_tolerance(&mut self) -> core::ffi::c_double; + fn update(&mut self) -> (); + fn initialize(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn free_search_structure(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); + fn get_build_time(&mut self) -> core::ffi::c_ulong; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); +} +pub trait VtkMappedUnstructuredGrid: VtkUnstructuredGridBase + VtkPointSet + VtkDataSet + VtkDataObject { + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> (); + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_ids_of_cells_of_type( + &mut self, + type_: core::ffi::c_int, + array: *mut core::ffi::c_void, + ) -> (); + fn is_homogeneous(&mut self) -> core::ffi::c_int; + fn allocate( + &mut self, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ) -> (); + fn set_implementation(&mut self, impl_: *mut core::ffi::c_void) -> (); + fn get_implementation(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkMappedUnstructuredGridCellIterator: VtkCellIterator { + fn is_done_with_traversal(&mut self) -> bool; + fn get_cell_id(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkMeanValueCoordinatesInterpolator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn compute_interpolation_weights( + &mut self, + x: core::ffi::c_double, + pts: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); + fn compute_interpolation_weights( + &mut self, + x: core::ffi::c_double, + pts: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); +} +pub trait VtkMergePoints: VtkPointLocator + VtkIncrementalPointLocator + VtkAbstractPointLocator + VtkLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn insert_unique_point( + &mut self, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; +} +pub trait VtkMolecule: VtkUndirectedGraph + VtkGraph + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn append_atom(&mut self) -> *mut core::ffi::c_void; + fn append_atom( + &mut self, + atomicNumber: core::ffi::c_ushort, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> *mut core::ffi::c_void; + fn append_atom( + &mut self, + atomicNumber: core::ffi::c_ushort, + pos: vtkVector3f, + ) -> *mut core::ffi::c_void; + fn append_atom( + &mut self, + atomicNumber: core::ffi::c_ushort, + pos: core::ffi::c_double, + ) -> *mut core::ffi::c_void; + fn get_atom(&mut self, atomId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_number_of_atoms(&mut self) -> core::ffi::c_uchar; + fn append_bond( + &mut self, + atom1: core::ffi::c_uchar, + atom2: core::ffi::c_uchar, + order: core::ffi::c_ushort, + ) -> *mut core::ffi::c_void; + fn append_bond( + &mut self, + atom1: vtkAtom, + atom2: vtkAtom, + order: core::ffi::c_ushort, + ) -> *mut core::ffi::c_void; + fn get_bond(&mut self, bondId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_number_of_bonds(&mut self) -> core::ffi::c_uchar; + fn get_atom_atomic_number( + &mut self, + atomId: core::ffi::c_uchar, + ) -> core::ffi::c_ushort; + fn set_atom_atomic_number( + &mut self, + atomId: core::ffi::c_uchar, + atomicNum: core::ffi::c_ushort, + ) -> (); + fn set_atom_position(&mut self, atomId: core::ffi::c_uchar, pos: vtkVector3f) -> (); + fn set_atom_position( + &mut self, + atomId: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_atom_position( + &mut self, + atomId: core::ffi::c_uchar, + pos: core::ffi::c_double, + ) -> (); + fn get_atom_position( + &mut self, + atomId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_atom_position( + &mut self, + atomId: core::ffi::c_uchar, + pos: core::ffi::c_float, + ) -> (); + fn get_atom_position( + &mut self, + atomId: core::ffi::c_uchar, + pos: core::ffi::c_double, + ) -> (); + fn set_bond_order( + &mut self, + bondId: core::ffi::c_uchar, + order: core::ffi::c_ushort, + ) -> (); + fn get_bond_order(&mut self, bondId: core::ffi::c_uchar) -> core::ffi::c_ushort; + fn get_bond_length(&mut self, bondId: core::ffi::c_uchar) -> core::ffi::c_double; + fn get_atomic_position_array(&mut self) -> *mut core::ffi::c_void; + fn get_atomic_number_array(&mut self) -> *mut core::ffi::c_void; + fn get_bond_orders_array(&mut self) -> *mut core::ffi::c_void; + fn get_electronic_data(&mut self) -> *mut core::ffi::c_void; + fn set_electronic_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn shallow_copy_structure(&mut self, m: *mut core::ffi::c_void) -> (); + fn deep_copy_structure(&mut self, m: *mut core::ffi::c_void) -> (); + fn shallow_copy_attributes(&mut self, m: *mut core::ffi::c_void) -> (); + fn deep_copy_attributes(&mut self, m: *mut core::ffi::c_void) -> (); + fn get_plane_from_bond( + &mut self, + bond: vtkBond, + normal: vtkVector3f, + plane: *mut core::ffi::c_void, + ) -> bool; + fn get_plane_from_bond( + &mut self, + atom1: vtkAtom, + atom2: vtkAtom, + normal: vtkVector3f, + plane: *mut core::ffi::c_void, + ) -> bool; + fn has_lattice(&mut self) -> bool; + fn clear_lattice(&mut self) -> (); + fn set_lattice(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn set_lattice(&mut self, a: vtkVector3d, b: vtkVector3d, c: vtkVector3d) -> (); + fn get_lattice(&mut self) -> *mut core::ffi::c_void; + fn get_lattice( + &mut self, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ) -> (); + fn get_lattice( + &mut self, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + origin: *mut core::ffi::c_void, + ) -> (); + fn get_lattice_origin(&mut self) -> *mut core::ffi::c_void; + fn set_lattice_origin(&mut self, _arg: *mut core::ffi::c_void) -> (); + fn get_atom_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn allocate_atom_ghost_array(&mut self) -> (); + fn get_bond_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn allocate_bond_ghost_array(&mut self) -> (); + fn initialize( + &mut self, + atomPositions: *mut core::ffi::c_void, + atomicNumberArray: *mut core::ffi::c_void, + atomData: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn initialize( + &mut self, + atomPositions: *mut core::ffi::c_void, + atomData: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn initialize(&mut self, molecule: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_atom_data(&mut self) -> *mut core::ffi::c_void; + fn get_bond_data(&mut self) -> *mut core::ffi::c_void; + fn get_bond_id( + &mut self, + a: core::ffi::c_uchar, + b: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn set_atomic_number_array_name(&mut self, _arg: core::ffi::c_char) -> (); + fn get_atomic_number_array_name(&mut self) -> *mut core::ffi::c_char; + fn set_bond_orders_array_name(&mut self, _arg: core::ffi::c_char) -> (); + fn get_bond_orders_array_name(&mut self) -> *mut core::ffi::c_char; +} +pub trait VtkMultiBlockDataSet: VtkDataObjectTree + VtkCompositeDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_blocks(&mut self, numBlocks: core::ffi::c_uint) -> (); + fn get_number_of_blocks(&mut self) -> core::ffi::c_uint; + fn get_block(&mut self, blockno: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn set_block( + &mut self, + blockno: core::ffi::c_uint, + block: *mut core::ffi::c_void, + ) -> (); + fn remove_block(&mut self, blockno: core::ffi::c_uint) -> (); + fn has_meta_data(&mut self, blockno: core::ffi::c_uint) -> core::ffi::c_int; + fn get_meta_data(&mut self, blockno: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; +} +pub trait VtkMultiPieceDataSet: VtkPartitionedDataSet + VtkDataObjectTree + VtkCompositeDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_pieces(&mut self, numpieces: core::ffi::c_uint) -> (); + fn get_number_of_pieces(&mut self) -> core::ffi::c_uint; + fn get_piece(&mut self, pieceno: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_piece_as_data_object( + &mut self, + pieceno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn set_piece( + &mut self, + pieceno: core::ffi::c_uint, + piece: *mut core::ffi::c_void, + ) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkMutableDirectedGraph: VtkDirectedGraph + VtkGraph + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_vertices( + &mut self, + numVerts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn add_vertex(&mut self) -> core::ffi::c_uchar; + fn add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn add_vertex(&mut self, pedigreeId: vtkVariant) -> core::ffi::c_uchar; + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn add_edge( + &mut self, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn add_edge( + &mut self, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn lazy_add_vertex(&mut self) -> (); + fn lazy_add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> (); + fn lazy_add_vertex(&mut self, pedigreeId: vtkVariant) -> (); + fn lazy_add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> (); + fn lazy_add_edge( + &mut self, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> (); + fn lazy_add_edge( + &mut self, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> (); + fn lazy_add_edge( + &mut self, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> (); + fn add_graph_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn add_child( + &mut self, + parent: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn add_child(&mut self, parent: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn remove_vertex(&mut self, v: core::ffi::c_uchar) -> (); + fn remove_edge(&mut self, e: core::ffi::c_uchar) -> (); + fn remove_vertices(&mut self, arr: *mut core::ffi::c_void) -> (); + fn remove_edges(&mut self, arr: *mut core::ffi::c_void) -> (); +} +pub trait VtkMutableUndirectedGraph: VtkUndirectedGraph + VtkGraph + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_vertices( + &mut self, + numVerts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn add_vertex(&mut self) -> core::ffi::c_uchar; + fn add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn add_vertex(&mut self, pedigreeId: vtkVariant) -> core::ffi::c_uchar; + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn add_edge( + &mut self, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn add_edge( + &mut self, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn lazy_add_vertex(&mut self) -> (); + fn lazy_add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> (); + fn lazy_add_vertex(&mut self, pedigreeId: vtkVariant) -> (); + fn lazy_add_edge(&mut self, u: core::ffi::c_uchar, v: core::ffi::c_uchar) -> (); + fn lazy_add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> (); + fn lazy_add_edge( + &mut self, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> (); + fn lazy_add_edge( + &mut self, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> (); + fn lazy_add_edge( + &mut self, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> (); + fn add_graph_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn remove_vertex(&mut self, v: core::ffi::c_uchar) -> (); + fn remove_edge(&mut self, e: core::ffi::c_uchar) -> (); + fn remove_vertices(&mut self, arr: *mut core::ffi::c_void) -> (); + fn remove_edges(&mut self, arr: *mut core::ffi::c_void) -> (); +} +pub trait VtkNonLinearCell: VtkCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_linear(&mut self) -> core::ffi::c_int; +} +pub trait VtkNonMergingPointLocator: VtkPointLocator + VtkIncrementalPointLocator + VtkAbstractPointLocator + VtkLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_inserted_point(&mut self, p0: core::ffi::c_double) -> core::ffi::c_uchar; + fn is_inserted_point( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn insert_unique_point( + &mut self, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; +} +pub trait VtkNonOverlappingAMR: VtkUniformGridAMR + VtkCompositeDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkOctreePointLocator: VtkAbstractPointLocator + VtkLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_maximum_points_per_region(&mut self, _arg: core::ffi::c_int) -> (); + fn get_maximum_points_per_region(&mut self) -> core::ffi::c_int; + fn set_create_cubic_octants(&mut self, _arg: core::ffi::c_int) -> (); + fn get_create_cubic_octants(&mut self) -> core::ffi::c_int; + fn get_fudge_factor(&mut self) -> core::ffi::c_double; + fn set_fudge_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_number_of_leaf_nodes(&mut self) -> core::ffi::c_int; + fn get_region_bounds( + &mut self, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> (); + fn get_region_data_bounds( + &mut self, + leafNodeID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> (); + fn get_region_containing_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int; + fn build_locator(&mut self) -> (); + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_in_region( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_in_region( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_points_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn get_points_in_region( + &mut self, + leafNodeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn free_search_structure(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); + fn find_points_in_area( + &mut self, + area: core::ffi::c_double, + ids: *mut core::ffi::c_void, + clearArray: bool, + ) -> (); +} +pub trait VtkOctreePointLocatorNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points(&mut self, numberOfPoints: core::ffi::c_int) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn set_bounds(&mut self, b: core::ffi::c_double) -> (); + fn get_bounds(&mut self, b: core::ffi::c_double) -> (); + fn set_data_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn get_data_bounds(&mut self, b: core::ffi::c_double) -> (); + fn get_min_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_max_bounds(&mut self) -> *mut core::ffi::c_double; + fn set_min_bounds(&mut self, minBounds: core::ffi::c_double) -> (); + fn set_max_bounds(&mut self, maxBounds: core::ffi::c_double) -> (); + fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double; + fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double; + fn set_min_data_bounds(&mut self, minDataBounds: core::ffi::c_double) -> (); + fn set_max_data_bounds(&mut self, maxDataBounds: core::ffi::c_double) -> (); + fn get_id(&mut self) -> core::ffi::c_int; + fn get_min_id(&mut self) -> core::ffi::c_int; + fn create_child_nodes(&mut self) -> (); + fn delete_child_nodes(&mut self) -> (); + fn get_child(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn intersects_region( + &mut self, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn contains_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + boundaryPt: core::ffi::c_double, + top: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + fn get_distance_2_to_inner_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + fn get_sub_octant_index( + &mut self, + point: core::ffi::c_double, + CheckContainment: core::ffi::c_int, + ) -> core::ffi::c_int; + fn compute_octree_node_information( + &mut self, + Parent: *mut core::ffi::c_void, + NextLeafId: core::ffi::c_int, + NextMinId: core::ffi::c_int, + coordinates: core::ffi::c_float, + ) -> (); +} +pub trait VtkOrderedTriangulator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn init_triangulation( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + numPts: core::ffi::c_int, + ) -> (); + fn init_triangulation( + &mut self, + bounds: core::ffi::c_double, + numPts: core::ffi::c_int, + ) -> (); + fn insert_point( + &mut self, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + p: core::ffi::c_double, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn insert_point( + &mut self, + id: core::ffi::c_uchar, + sortid: core::ffi::c_uchar, + x: core::ffi::c_double, + p: core::ffi::c_double, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn insert_point( + &mut self, + id: core::ffi::c_uchar, + sortid: core::ffi::c_uchar, + sortid2: core::ffi::c_uchar, + x: core::ffi::c_double, + p: core::ffi::c_double, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn triangulate(&mut self) -> (); + fn template_triangulate( + &mut self, + cellType: core::ffi::c_int, + numPts: core::ffi::c_int, + numEdges: core::ffi::c_int, + ) -> (); + fn update_point_type( + &mut self, + internalId: core::ffi::c_uchar, + type_: core::ffi::c_int, + ) -> (); + fn get_point_position( + &mut self, + internalId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + fn get_point_location( + &mut self, + internalId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + fn get_point_id(&mut self, internalId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn set_use_templates(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_templates(&mut self) -> core::ffi::c_int; + fn use_templates_on(&mut self) -> (); + fn use_templates_off(&mut self) -> (); + fn set_pre_sorted(&mut self, _arg: core::ffi::c_int) -> (); + fn get_pre_sorted(&mut self) -> core::ffi::c_int; + fn pre_sorted_on(&mut self) -> (); + fn pre_sorted_off(&mut self) -> (); + fn set_use_two_sort_ids(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_two_sort_ids(&mut self) -> core::ffi::c_int; + fn use_two_sort_ids_on(&mut self) -> (); + fn use_two_sort_ids_off(&mut self) -> (); + fn get_tetras( + &mut self, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn add_tetras( + &mut self, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn add_tetras( + &mut self, + classification: core::ffi::c_int, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn add_tetras( + &mut self, + classification: core::ffi::c_int, + locator: *mut core::ffi::c_void, + outConnectivity: *mut core::ffi::c_void, + inPD: *mut core::ffi::c_void, + outPD: *mut core::ffi::c_void, + inCD: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCD: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn add_tetras( + &mut self, + classification: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn add_triangles( + &mut self, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn add_triangles( + &mut self, + id: core::ffi::c_uchar, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn init_tetra_traversal(&mut self) -> (); + fn get_next_tetra( + &mut self, + classification: core::ffi::c_int, + tet: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + tetScalars: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkOutEdgeIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> (); + fn get_graph(&mut self) -> *mut core::ffi::c_void; + fn get_vertex(&mut self) -> core::ffi::c_uchar; + fn next(&mut self) -> *mut core::ffi::c_void; + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void; + fn has_next(&mut self) -> bool; +} +pub trait VtkOverlappingAMR: VtkUniformGridAMR + VtkCompositeDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_origin(&mut self, origin: core::ffi::c_double) -> (); + fn get_origin(&mut self) -> *mut core::ffi::c_double; + fn set_spacing( + &mut self, + level: core::ffi::c_uint, + spacing: core::ffi::c_double, + ) -> (); + fn get_spacing( + &mut self, + level: core::ffi::c_uint, + spacing: core::ffi::c_double, + ) -> (); + fn set_amr_box( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + box_: vtkAMRBox, + ) -> (); + fn get_amr_box( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> vtkAMRBox; + fn get_bounds( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + bb: core::ffi::c_double, + ) -> (); + fn get_origin( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + origin: core::ffi::c_double, + ) -> (); + fn number_of_blanked_points(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_refinement_ratio( + &mut self, + level: core::ffi::c_uint, + refRatio: core::ffi::c_int, + ) -> (); + fn get_refinement_ratio(&mut self, level: core::ffi::c_uint) -> core::ffi::c_int; + fn set_amr_block_source_index( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + sourceId: core::ffi::c_int, + ) -> (); + fn get_amr_block_source_index( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> core::ffi::c_int; + fn get_refinement_ratio(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; + fn has_children_information(&mut self) -> bool; + fn generate_parent_child_information(&mut self) -> (); + fn get_parents( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + numParents: core::ffi::c_uint, + ) -> *mut core::ffi::c_uint; + fn get_children( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + numChildren: core::ffi::c_uint, + ) -> *mut core::ffi::c_uint; + fn print_parent_child_info( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> (); + fn get_bounds(&mut self, b: core::ffi::c_double) -> (); + fn find_grid( + &mut self, + q: core::ffi::c_double, + level: core::ffi::c_uint, + gridId: core::ffi::c_uint, + ) -> bool; + fn get_amr_info(&mut self) -> *mut core::ffi::c_void; + fn set_amr_info(&mut self, info: *mut core::ffi::c_void) -> (); + fn audit(&mut self) -> (); +} +pub trait VtkPartitionedDataSet: VtkDataObjectTree + VtkCompositeDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_partitions(&mut self, numPartitions: core::ffi::c_uint) -> (); + fn get_number_of_partitions(&mut self) -> core::ffi::c_uint; + fn get_partition(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_partition_as_data_object( + &mut self, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn set_partition( + &mut self, + idx: core::ffi::c_uint, + partition: *mut core::ffi::c_void, + ) -> (); + fn has_meta_data(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_int; + fn get_meta_data(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove_null_partitions(&mut self) -> (); +} +pub trait VtkPartitionedDataSetCollection: VtkDataObjectTree + VtkCompositeDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_partitioned_data_sets( + &mut self, + numDataSets: core::ffi::c_uint, + ) -> (); + fn get_number_of_partitioned_data_sets(&mut self) -> core::ffi::c_uint; + fn get_partitioned_data_set( + &mut self, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn set_partitioned_data_set( + &mut self, + idx: core::ffi::c_uint, + dataset: *mut core::ffi::c_void, + ) -> (); + fn remove_partitioned_data_set(&mut self, idx: core::ffi::c_uint) -> (); + fn set_partition( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + object: *mut core::ffi::c_void, + ) -> (); + fn get_partition( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn get_partition_as_data_object( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn get_number_of_partitions(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_uint; + fn set_number_of_partitions( + &mut self, + idx: core::ffi::c_uint, + numPartitions: core::ffi::c_uint, + ) -> (); + fn has_meta_data(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_int; + fn get_meta_data(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_data_assembly(&mut self) -> *mut core::ffi::c_void; + fn set_data_assembly(&mut self, assembly: *mut core::ffi::c_void) -> (); + fn get_composite_index(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_uint; + fn get_composite_index( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> core::ffi::c_uint; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); +} +pub trait VtkPath: VtkPointSet + VtkDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn insert_next_point( + &mut self, + pts: core::ffi::c_float, + code: core::ffi::c_int, + ) -> (); + fn insert_next_point( + &mut self, + pts: core::ffi::c_double, + code: core::ffi::c_int, + ) -> (); + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + code: core::ffi::c_int, + ) -> (); + fn set_codes(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_codes(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; + fn get_cell(&mut self, p0: core::ffi::c_uchar, p1: *mut core::ffi::c_void) -> (); + fn get_cell_points( + &mut self, + p0: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn allocate(&mut self, size: core::ffi::c_uchar, extSize: core::ffi::c_int) -> (); + fn reset(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkPentagonalPrism: VtkCell3D + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkPeriodicDataArray { + fn initialize(&mut self) -> (); + fn get_tuples( + &mut self, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn get_tuples( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + output: *mut core::ffi::c_void, + ) -> (); + fn squeeze(&mut self) -> (); + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn lookup_value( + &mut self, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> (); + fn get_variant_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn clear_lookup(&mut self) -> (); + fn get_tuple(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> (); + fn lookup_typed_value( + &mut self, + value: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn lookup_typed_value( + &mut self, + value: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ) -> (); + fn get_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_value_reference(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_typed_tuple( + &mut self, + idx: core::ffi::c_uchar, + t: *mut core::ffi::c_void, + ) -> (); + fn get_typed_component( + &mut self, + tupleIdx: core::ffi::c_uchar, + compIdx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn set_tuple(&mut self, i: core::ffi::c_uchar, source: core::ffi::c_float) -> (); + fn set_tuple(&mut self, i: core::ffi::c_uchar, source: core::ffi::c_double) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple(&mut self, i: core::ffi::c_uchar, source: core::ffi::c_float) -> (); + fn insert_tuple(&mut self, i: core::ffi::c_uchar, source: core::ffi::c_double) -> (); + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn insert_next_tuple(&mut self, source: core::ffi::c_float) -> core::ffi::c_uchar; + fn insert_next_tuple(&mut self, source: core::ffi::c_double) -> core::ffi::c_uchar; + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + ptIndices: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_tuple( + &mut self, + i: core::ffi::c_uchar, + id1: core::ffi::c_uchar, + source1: *mut core::ffi::c_void, + id2: core::ffi::c_uchar, + source2: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> (); + fn set_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_variant_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn remove_tuple(&mut self, id: core::ffi::c_uchar) -> (); + fn remove_first_tuple(&mut self) -> (); + fn remove_last_tuple(&mut self) -> (); + fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, t: Scalar) -> (); + fn set_typed_component( + &mut self, + t: core::ffi::c_uchar, + c: core::ffi::c_int, + v: *mut core::ffi::c_void, + ) -> (); + fn insert_typed_tuple(&mut self, i: core::ffi::c_uchar, t: Scalar) -> (); + fn insert_next_typed_tuple(&mut self, t: Scalar) -> core::ffi::c_uchar; + fn set_value( + &mut self, + idx: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn insert_next_value(&mut self, v: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn insert_value(&mut self, idx: core::ffi::c_uchar, v: *mut core::ffi::c_void) -> (); + fn set_normalize(&mut self, _arg: bool) -> (); + fn get_normalize(&mut self) -> bool; +} +pub trait VtkPerlinNoise: VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn set_frequency( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_frequency(&mut self, _arg: core::ffi::c_double) -> (); + fn get_frequency(&mut self) -> *mut core::ffi::c_double; + fn get_frequency(&mut self, data: core::ffi::c_double) -> (); + fn set_phase( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_phase(&mut self, _arg: core::ffi::c_double) -> (); + fn get_phase(&mut self) -> *mut core::ffi::c_double; + fn get_phase(&mut self, data: core::ffi::c_double) -> (); + fn set_amplitude(&mut self, _arg: core::ffi::c_double) -> (); + fn get_amplitude(&mut self) -> core::ffi::c_double; +} +pub trait VtkPiecewiseFunction: VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, f: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, f: *mut core::ffi::c_void) -> (); + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_size(&mut self) -> core::ffi::c_int; + fn add_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_int; + fn add_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + midpoint: core::ffi::c_double, + sharpness: core::ffi::c_double, + ) -> core::ffi::c_int; + fn remove_point_by_index(&mut self, id: usize) -> bool; + fn remove_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn remove_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_int; + fn remove_all_points(&mut self) -> (); + fn add_segment( + &mut self, + x1: core::ffi::c_double, + y1: core::ffi::c_double, + x2: core::ffi::c_double, + y2: core::ffi::c_double, + ) -> (); + fn get_value(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn get_node_value( + &mut self, + index: core::ffi::c_int, + val: core::ffi::c_double, + ) -> core::ffi::c_int; + fn set_node_value( + &mut self, + index: core::ffi::c_int, + val: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_data_pointer(&mut self) -> *mut core::ffi::c_double; + fn fill_from_data_pointer( + &mut self, + p0: core::ffi::c_int, + p1: core::ffi::c_double, + ) -> (); + fn get_range(&mut self) -> *mut core::ffi::c_double; + fn get_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn get_range(&mut self, _arg: core::ffi::c_double) -> (); + fn adjust_range(&mut self, range: core::ffi::c_double) -> core::ffi::c_int; + fn get_table( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + size: core::ffi::c_int, + table: core::ffi::c_float, + stride: core::ffi::c_int, + logIncrements: core::ffi::c_int, + ) -> (); + fn get_table( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + size: core::ffi::c_int, + table: core::ffi::c_double, + stride: core::ffi::c_int, + logIncrements: core::ffi::c_int, + ) -> (); + fn build_function_from_table( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + size: core::ffi::c_int, + table: core::ffi::c_double, + stride: core::ffi::c_int, + ) -> (); + fn set_clamping(&mut self, _arg: core::ffi::c_int) -> (); + fn get_clamping(&mut self) -> core::ffi::c_int; + fn clamping_on(&mut self) -> (); + fn clamping_off(&mut self) -> (); + fn set_use_log_scale(&mut self, _arg: bool) -> (); + fn get_use_log_scale(&mut self) -> bool; + fn use_log_scale_on(&mut self) -> (); + fn use_log_scale_off(&mut self) -> (); + fn get_type(&mut self) -> *const core::ffi::c_char; + fn get_first_non_zero_value(&mut self) -> core::ffi::c_double; + fn initialize(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_allow_duplicate_scalars(&mut self, _arg: core::ffi::c_int) -> (); + fn get_allow_duplicate_scalars(&mut self) -> core::ffi::c_int; + fn allow_duplicate_scalars_on(&mut self) -> (); + fn allow_duplicate_scalars_off(&mut self) -> (); + fn estimate_min_number_of_samples( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + ) -> core::ffi::c_int; +} +pub trait VtkPixel: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; + fn compute_bounding_sphere( + &mut self, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn compute_normal(&mut self, n: core::ffi::c_double) -> core::ffi::c_int; +} +pub trait VtkPixelExtent { + fn set_data(&mut self, ext: vtkPixelExtent) -> (); + fn clear(&mut self) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_int; + fn get_data(&mut self) -> *const core::ffi::c_int; + fn get_data_u(&mut self) -> *mut core::ffi::c_uint; + fn get_data_u(&mut self) -> *const core::ffi::c_uint; + fn get_start_index(&mut self, first: core::ffi::c_int) -> (); + fn get_start_index( + &mut self, + first: core::ffi::c_int, + origin: core::ffi::c_int, + ) -> (); + fn get_end_index(&mut self, last: core::ffi::c_int) -> (); + fn empty(&mut self) -> core::ffi::c_int; + fn contains(&mut self, other: vtkPixelExtent) -> core::ffi::c_int; + fn contains(&mut self, i: core::ffi::c_int, j: core::ffi::c_int) -> core::ffi::c_int; + fn disjoint(&mut self, other: *mut core::ffi::c_void) -> core::ffi::c_int; + fn size(&mut self) -> usize; + fn grow(&mut self, n: core::ffi::c_int) -> (); + fn grow(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); + fn grow_low(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); + fn grow_high(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); + fn shrink(&mut self, n: core::ffi::c_int) -> (); + fn shrink(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); + fn shift(&mut self) -> (); + fn shift(&mut self, ext: vtkPixelExtent) -> (); + fn shift(&mut self, n: core::ffi::c_int) -> (); + fn shift(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); + fn split(&mut self, dir: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_to_node(&mut self) -> (); + fn node_to_cell(&mut self) -> (); + fn size(&mut self, ext: vtkPixelExtent) -> usize; + fn grow( + &mut self, + inputExt: vtkPixelExtent, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn grow( + &mut self, + inputExt: vtkPixelExtent, + problemDomain: vtkPixelExtent, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn grow_low( + &mut self, + ext: vtkPixelExtent, + q: core::ffi::c_int, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn grow_high( + &mut self, + ext: vtkPixelExtent, + q: core::ffi::c_int, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn shrink( + &mut self, + inputExt: vtkPixelExtent, + problemDomain: vtkPixelExtent, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn shrink( + &mut self, + inputExt: vtkPixelExtent, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn node_to_cell(&mut self, inputExt: vtkPixelExtent) -> *mut core::ffi::c_void; + fn cell_to_node(&mut self, inputExt: vtkPixelExtent) -> *mut core::ffi::c_void; + fn shift(&mut self, ij: core::ffi::c_int, n: core::ffi::c_int) -> (); + fn shift(&mut self, ij: core::ffi::c_int, n: core::ffi::c_int) -> (); +} +pub trait VtkPixelTransfer { + fn blit( + &mut self, + ext: vtkPixelExtent, + nComps: core::ffi::c_int, + srcType: core::ffi::c_int, + srcData: (), + destType: core::ffi::c_int, + destData: (), + ) -> core::ffi::c_int; + fn blit( + &mut self, + srcWhole: vtkPixelExtent, + srcSubset: vtkPixelExtent, + destWhole: vtkPixelExtent, + destSubset: vtkPixelExtent, + nSrcComps: core::ffi::c_int, + srcType: core::ffi::c_int, + srcData: (), + nDestComps: core::ffi::c_int, + destType: core::ffi::c_int, + destData: (), + ) -> core::ffi::c_int; +} +pub trait VtkPlane: VtkImplicitFunction { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_normal(&mut self, _arg: core::ffi::c_double) -> (); + fn get_normal(&mut self) -> *mut core::ffi::c_double; + fn get_normal(&mut self, data: core::ffi::c_double) -> (); + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_origin(&mut self, _arg: core::ffi::c_double) -> (); + fn get_origin(&mut self) -> *mut core::ffi::c_double; + fn get_origin(&mut self, data: core::ffi::c_double) -> (); + fn push(&mut self, distance: core::ffi::c_double) -> (); + fn project_point( + &mut self, + x: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + xproj: core::ffi::c_double, + ) -> (); + fn project_point( + &mut self, + x: core::ffi::c_double, + xproj: core::ffi::c_double, + ) -> (); + fn project_vector( + &mut self, + v: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + vproj: core::ffi::c_double, + ) -> (); + fn project_vector( + &mut self, + v: core::ffi::c_double, + vproj: core::ffi::c_double, + ) -> (); + fn generalized_project_point( + &mut self, + x: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + xproj: core::ffi::c_double, + ) -> (); + fn generalized_project_point( + &mut self, + x: core::ffi::c_double, + xproj: core::ffi::c_double, + ) -> (); + fn evaluate( + &mut self, + normal: core::ffi::c_double, + origin: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + fn distance_to_plane( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + p0: core::ffi::c_double, + ) -> core::ffi::c_double; + fn distance_to_plane(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + n: core::ffi::c_double, + p0: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_with_finite_plane( + &mut self, + n: core::ffi::c_double, + o: core::ffi::c_double, + pOrigin: core::ffi::c_double, + px: core::ffi::c_double, + py: core::ffi::c_double, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_with_finite_plane( + &mut self, + pOrigin: core::ffi::c_double, + px: core::ffi::c_double, + py: core::ffi::c_double, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + ) -> core::ffi::c_int; + fn compute_best_fitting_plane( + &mut self, + pts: *mut core::ffi::c_void, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + ) -> bool; +} +pub trait VtkPlaneCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_next_plane(&mut self, cookie: ()) -> *mut core::ffi::c_void; + fn get_number_of_items(&mut self) -> core::ffi::c_int; +} +pub trait VtkPlanes: VtkImplicitFunction { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn set_normals(&mut self, normals: *mut core::ffi::c_void) -> (); + fn get_normals(&mut self) -> *mut core::ffi::c_void; + fn set_frustum_planes(&mut self, planes: core::ffi::c_double) -> (); + fn set_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn set_bounds( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + ) -> (); + fn get_number_of_planes(&mut self) -> core::ffi::c_int; + fn get_plane(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_plane(&mut self, i: core::ffi::c_int, plane: *mut core::ffi::c_void) -> (); +} +pub trait VtkPlanesIntersection: VtkPlanes + VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_region_vertices(&mut self, pts: *mut core::ffi::c_void) -> (); + fn set_region_vertices( + &mut self, + v: core::ffi::c_double, + nvertices: core::ffi::c_int, + ) -> (); + fn get_number_of_region_vertices(&mut self) -> core::ffi::c_int; + fn get_num_region_vertices(&mut self) -> core::ffi::c_int; + fn get_region_vertices( + &mut self, + v: core::ffi::c_double, + nvertices: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersects_region(&mut self, R: *mut core::ffi::c_void) -> core::ffi::c_int; + fn polygon_intersects_b_box( + &mut self, + bounds: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn convert_3_d_cell( + &mut self, + cell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkPointData: VtkDataSetAttributes + VtkFieldData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn null_point(&mut self, ptId: core::ffi::c_uchar) -> (); +} +pub trait VtkPointLocator: VtkIncrementalPointLocator + VtkAbstractPointLocator + VtkLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> (); + fn set_divisions(&mut self, _arg: core::ffi::c_int) -> (); + fn get_divisions(&mut self) -> *mut core::ffi::c_int; + fn get_divisions(&mut self, data: core::ffi::c_int) -> (); + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int; + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + inputDataLength: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn init_point_insertion( + &mut self, + newPts: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + fn init_point_insertion( + &mut self, + newPts: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + estNumPts: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn insert_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn insert_unique_point( + &mut self, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn find_closest_inserted_point( + &mut self, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_distributed_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ) -> (); + fn find_distributed_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ) -> (); + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn get_points_in_bucket( + &mut self, + x: core::ffi::c_double, + ijk: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkPointSet: VtkDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_editable(&mut self, _arg: bool) -> (); + fn get_editable(&mut self) -> bool; + fn editable_on(&mut self) -> (); + fn editable_off(&mut self) -> (); + fn initialize(&mut self) -> (); + fn copy_structure(&mut self, pd: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn get_cell(&mut self, p0: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cell_points( + &mut self, + p0: core::ffi::c_uchar, + idList: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + p0: core::ffi::c_uchar, + idList: *mut core::ffi::c_void, + ) -> (); + fn get_cell(&mut self, p0: core::ffi::c_uchar, cell: *mut core::ffi::c_void) -> (); + fn get_cell_type(&mut self, p0: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn build_point_locator(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn build_cell_locator(&mut self) -> (); + fn set_point_locator(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_point_locator(&mut self) -> *mut core::ffi::c_void; + fn set_cell_locator(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_cell_locator(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn compute_bounds(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkPointSetCellIterator: VtkCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_done_with_traversal(&mut self) -> bool; + fn get_cell_id(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkPointsProjectedHull { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn rectangle_intersection_x( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn rectangle_intersection_x( + &mut self, + ymin: core::ffi::c_float, + ymax: core::ffi::c_float, + zmin: core::ffi::c_float, + zmax: core::ffi::c_float, + ) -> core::ffi::c_int; + fn rectangle_intersection_x( + &mut self, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + ) -> core::ffi::c_int; + fn rectangle_intersection_y( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn rectangle_intersection_y( + &mut self, + zmin: core::ffi::c_float, + zmax: core::ffi::c_float, + xmin: core::ffi::c_float, + xmax: core::ffi::c_float, + ) -> core::ffi::c_int; + fn rectangle_intersection_y( + &mut self, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ) -> core::ffi::c_int; + fn rectangle_intersection_z( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn rectangle_intersection_z( + &mut self, + xmin: core::ffi::c_float, + xmax: core::ffi::c_float, + ymin: core::ffi::c_float, + ymax: core::ffi::c_float, + ) -> core::ffi::c_int; + fn rectangle_intersection_z( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_ccw_hull_x( + &mut self, + pts: core::ffi::c_float, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_ccw_hull_x( + &mut self, + pts: core::ffi::c_double, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_ccw_hull_y( + &mut self, + pts: core::ffi::c_float, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_ccw_hull_y( + &mut self, + pts: core::ffi::c_double, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_ccw_hull_z( + &mut self, + pts: core::ffi::c_float, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_ccw_hull_z( + &mut self, + pts: core::ffi::c_double, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_size_ccw_hull_x(&mut self) -> core::ffi::c_int; + fn get_size_ccw_hull_y(&mut self) -> core::ffi::c_int; + fn get_size_ccw_hull_z(&mut self) -> core::ffi::c_int; + fn update(&mut self) -> (); +} +pub trait VtkPolyData: VtkPointSet + VtkDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> (); + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn copy_cells( + &mut self, + pd: *mut core::ffi::c_void, + idList: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + ) -> (); + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn compute_cells_bounds(&mut self) -> (); + fn get_cells_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn squeeze(&mut self) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn get_cell_id_relative_to_cell_array( + &mut self, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn set_verts(&mut self, v: *mut core::ffi::c_void) -> (); + fn get_verts(&mut self) -> *mut core::ffi::c_void; + fn set_lines(&mut self, l: *mut core::ffi::c_void) -> (); + fn get_lines(&mut self) -> *mut core::ffi::c_void; + fn set_polys(&mut self, p: *mut core::ffi::c_void) -> (); + fn get_polys(&mut self) -> *mut core::ffi::c_void; + fn set_strips(&mut self, s: *mut core::ffi::c_void) -> (); + fn get_strips(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_verts(&mut self) -> core::ffi::c_uchar; + fn get_number_of_lines(&mut self) -> core::ffi::c_uchar; + fn get_number_of_polys(&mut self) -> core::ffi::c_uchar; + fn get_number_of_strips(&mut self) -> core::ffi::c_uchar; + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_uchar, + maxCellSize: core::ffi::c_uchar, + ) -> bool; + fn allocate_estimate( + &mut self, + numVerts: core::ffi::c_uchar, + maxVertSize: core::ffi::c_uchar, + numLines: core::ffi::c_uchar, + maxLineSize: core::ffi::c_uchar, + numPolys: core::ffi::c_uchar, + maxPolySize: core::ffi::c_uchar, + numStrips: core::ffi::c_uchar, + maxStripSize: core::ffi::c_uchar, + ) -> bool; + fn allocate_exact( + &mut self, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool; + fn allocate_exact( + &mut self, + numVerts: core::ffi::c_uchar, + vertConnSize: core::ffi::c_uchar, + numLines: core::ffi::c_uchar, + lineConnSize: core::ffi::c_uchar, + numPolys: core::ffi::c_uchar, + polyConnSize: core::ffi::c_uchar, + numStrips: core::ffi::c_uchar, + stripConnSize: core::ffi::c_uchar, + ) -> bool; + fn allocate_copy(&mut self, pd: *mut core::ffi::c_void) -> bool; + fn allocate_proportional( + &mut self, + pd: *mut core::ffi::c_void, + ratio: core::ffi::c_double, + ) -> bool; + fn allocate( + &mut self, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ) -> (); + fn allocate( + &mut self, + inPolyData: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ) -> (); + fn insert_next_cell( + &mut self, + type_: core::ffi::c_int, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn insert_next_cell( + &mut self, + type_: core::ffi::c_int, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn reset(&mut self) -> (); + fn build_cells(&mut self) -> (); + fn need_to_build_cells(&mut self) -> bool; + fn build_links(&mut self, initialSize: core::ffi::c_int) -> (); + fn delete_cells(&mut self) -> (); + fn delete_links(&mut self) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_uchar, + cells: core::ffi::c_uchar, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_ushort, + cells: core::ffi::c_uchar, + ) -> (); + fn get_cell_edge_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn is_triangle( + &mut self, + v1: core::ffi::c_int, + v2: core::ffi::c_int, + v3: core::ffi::c_int, + ) -> core::ffi::c_int; + fn is_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn is_point_used_by_cell( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn replace_cell( + &mut self, + cellId: core::ffi::c_uchar, + ids: *mut core::ffi::c_void, + ) -> (); + fn replace_cell( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> (); + fn replace_cell_point( + &mut self, + cellId: core::ffi::c_uchar, + oldPtId: core::ffi::c_uchar, + newPtId: core::ffi::c_uchar, + ) -> (); + fn reverse_cell(&mut self, cellId: core::ffi::c_uchar) -> (); + fn delete_point(&mut self, ptId: core::ffi::c_uchar) -> (); + fn delete_cell(&mut self, cellId: core::ffi::c_uchar) -> (); + fn remove_deleted_cells(&mut self) -> (); + fn insert_next_linked_point( + &mut self, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn insert_next_linked_point( + &mut self, + x: core::ffi::c_double, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn insert_next_linked_cell( + &mut self, + type_: core::ffi::c_int, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn replace_linked_cell( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> (); + fn remove_cell_reference(&mut self, cellId: core::ffi::c_uchar) -> (); + fn add_cell_reference(&mut self, cellId: core::ffi::c_uchar) -> (); + fn remove_reference_to_cell( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> (); + fn add_reference_to_cell( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> (); + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_uchar, + size: core::ffi::c_int, + ) -> (); + fn initialize(&mut self) -> (); + fn get_piece(&mut self) -> core::ffi::c_int; + fn get_number_of_pieces(&mut self) -> core::ffi::c_int; + fn get_ghost_level(&mut self) -> core::ffi::c_int; + fn remove_ghost_cells(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_scalar_field_critical_index( + &mut self, + pointId: core::ffi::c_uchar, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_scalar_field_critical_index( + &mut self, + pointId: core::ffi::c_uchar, + fieldId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_scalar_field_critical_index( + &mut self, + pointId: core::ffi::c_uchar, + fieldName: core::ffi::c_char, + ) -> core::ffi::c_int; + fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; +} +pub trait VtkPolyDataCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, pd: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_next_poly_data(&mut self, cookie: ()) -> *mut core::ffi::c_void; +} +pub trait VtkPolyLine: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn generate_sliding_normals( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn generate_sliding_normals( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + firstNormal: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; +} +pub trait VtkPolyPlane: VtkImplicitFunction { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); + fn set_poly_line(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_poly_line(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkPolyVertex: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; +} +pub trait VtkPolygon: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn compute_area(&mut self) -> core::ffi::c_double; + fn interpolate_functions( + &mut self, + x: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> (); + fn compute_normal( + &mut self, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + n: core::ffi::c_double, + ) -> (); + fn compute_normal( + &mut self, + p: *mut core::ffi::c_void, + n: core::ffi::c_double, + ) -> (); + fn compute_normal( + &mut self, + ids: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + n: core::ffi::c_double, + ) -> (); + fn compute_normal( + &mut self, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn is_convex(&mut self) -> bool; + fn is_convex( + &mut self, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> bool; + fn is_convex( + &mut self, + ids: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + ) -> bool; + fn is_convex(&mut self, p: *mut core::ffi::c_void) -> bool; + fn compute_centroid( + &mut self, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + fn compute_centroid( + &mut self, + ids: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + fn compute_area( + &mut self, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + normal: core::ffi::c_double, + ) -> core::ffi::c_double; + fn parameterize_polygon( + &mut self, + p0: core::ffi::c_double, + p10: core::ffi::c_double, + l10: core::ffi::c_double, + p20: core::ffi::c_double, + l20: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int; + fn point_in_polygon( + &mut self, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int; + fn triangulate(&mut self, outTris: *mut core::ffi::c_void) -> core::ffi::c_int; + fn non_degenerate_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn bounded_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + fn distance_to_polygon( + &mut self, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + closest: core::ffi::c_double, + ) -> core::ffi::c_double; + fn intersect_polygon_with_polygon( + &mut self, + npts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + npts2: core::ffi::c_int, + pts2: core::ffi::c_double, + bounds2: core::ffi::c_double, + tol: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_convex_2_d_cells( + &mut self, + cell1: *mut core::ffi::c_void, + cell2: *mut core::ffi::c_void, + tol: core::ffi::c_double, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_use_mvc_interpolation(&mut self) -> bool; + fn set_use_mvc_interpolation(&mut self, _arg: bool) -> (); + fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tolerance_min_value(&mut self) -> core::ffi::c_double; + fn get_tolerance_max_value(&mut self) -> core::ffi::c_double; + fn get_tolerance(&mut self) -> core::ffi::c_double; + fn ear_cut_triangulation(&mut self, measure: core::ffi::c_int) -> core::ffi::c_int; + fn ear_cut_triangulation( + &mut self, + outTris: *mut core::ffi::c_void, + measure: core::ffi::c_int, + ) -> core::ffi::c_int; + fn unbiased_ear_cut_triangulation( + &mut self, + seed: core::ffi::c_int, + measure: core::ffi::c_int, + ) -> core::ffi::c_int; + fn unbiased_ear_cut_triangulation( + &mut self, + seed: core::ffi::c_int, + outTris: *mut core::ffi::c_void, + measure: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkPolyhedron: VtkCell3D + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; + fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn requires_initialization(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn is_primary_cell(&mut self) -> core::ffi::c_int; + fn interpolate_functions( + &mut self, + x: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + x: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn requires_explicit_face_representation(&mut self) -> core::ffi::c_int; + fn is_inside( + &mut self, + x: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int; + fn is_convex(&mut self) -> bool; + fn get_poly_data(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPyramid: VtkCell3D + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; +} +pub trait VtkQuad: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; +} +pub trait VtkQuadraticEdge: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkQuadraticHexahedron: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkQuadraticLinearQuad: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array(&mut self, edgeId: core::ffi::c_uchar) -> *mut core::ffi::c_int; +} +pub trait VtkQuadraticLinearWedge: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkQuadraticPolygon: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn interpolate_functions( + &mut self, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn compute_centroid( + &mut self, + ids: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> (); + fn parameterize_polygon( + &mut self, + p0: core::ffi::c_double, + p10: core::ffi::c_double, + l10: core::ffi::c_double, + p20: core::ffi::c_double, + l20: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int; + fn point_in_polygon( + &mut self, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int; + fn triangulate(&mut self, outTris: *mut core::ffi::c_void) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn non_degenerate_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn distance_to_polygon( + &mut self, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + closest: core::ffi::c_double, + ) -> core::ffi::c_double; + fn intersect_polygon_with_polygon( + &mut self, + npts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + npts2: core::ffi::c_int, + pts2: core::ffi::c_double, + bounds2: core::ffi::c_double, + tol: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_convex_2_d_cells( + &mut self, + cell1: *mut core::ffi::c_void, + cell2: *mut core::ffi::c_void, + tol: core::ffi::c_double, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_use_mvc_interpolation(&mut self) -> bool; + fn set_use_mvc_interpolation(&mut self, _arg: bool) -> (); +} +pub trait VtkQuadraticPyramid: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkQuadraticQuad: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkQuadraticTetra: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkQuadraticTriangle: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkQuadraticWedge: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkQuadratureSchemeDefinition { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn dictionary(&mut self) -> *mut core::ffi::c_void; + fn quadrature_offset_array_name(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, other: vtkQuadratureSchemeDefinition) -> core::ffi::c_int; + fn save_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int; + fn restore_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int; + fn clear(&mut self) -> (); + fn initialize( + &mut self, + cellType: core::ffi::c_int, + numberOfNodes: core::ffi::c_int, + numberOfQuadraturePoints: core::ffi::c_int, + shapeFunctionWeights: core::ffi::c_double, + ) -> (); + fn initialize( + &mut self, + cellType: core::ffi::c_int, + numberOfNodes: core::ffi::c_int, + numberOfQuadraturePoints: core::ffi::c_int, + shapeFunctionWeights: core::ffi::c_double, + quadratureWeights: core::ffi::c_double, + ) -> (); + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_quadrature_key(&mut self) -> core::ffi::c_int; + fn get_number_of_nodes(&mut self) -> core::ffi::c_int; + fn get_number_of_quadrature_points(&mut self) -> core::ffi::c_int; + fn get_shape_function_weights(&mut self) -> *const core::ffi::c_double; + fn get_shape_function_weights( + &mut self, + quadraturePointId: core::ffi::c_int, + ) -> *const core::ffi::c_double; + fn get_quadrature_weights(&mut self) -> *const core::ffi::c_double; +} +pub trait VtkQuadric: VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); + fn set_coefficients(&mut self, a: core::ffi::c_double) -> (); + fn set_coefficients( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + a4: core::ffi::c_double, + a5: core::ffi::c_double, + a6: core::ffi::c_double, + a7: core::ffi::c_double, + a8: core::ffi::c_double, + a9: core::ffi::c_double, + ) -> (); + fn get_coefficients(&mut self) -> *mut core::ffi::c_double; + fn get_coefficients(&mut self, data: core::ffi::c_double) -> (); +} +pub trait VtkRect: VtkVector { + fn set(&mut self, x: T, y: T, width: T, height: T) -> (); + fn set_x(&mut self, x: T) -> (); + fn get_x(&mut self) -> T; + fn set_y(&mut self, y: T) -> (); + fn get_y(&mut self) -> T; + fn set_width(&mut self, width: T) -> (); + fn get_width(&mut self) -> T; + fn set_height(&mut self, height: T) -> (); + fn get_height(&mut self) -> T; + fn get_left(&mut self) -> T; + fn get_right(&mut self) -> *mut core::ffi::c_void; + fn get_top(&mut self) -> *mut core::ffi::c_void; + fn get_bottom(&mut self) -> T; + fn add_point(&mut self, point: T) -> (); + fn add_point(&mut self, x: *mut core::ffi::c_void, y: *mut core::ffi::c_void) -> (); + fn move_to(&mut self, x: *mut core::ffi::c_void, y: *mut core::ffi::c_void) -> (); + fn get_center(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkRectd: VtkRect + VtkVector { + fn set( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + width: core::ffi::c_double, + height: core::ffi::c_double, + ) -> (); + fn set_x(&mut self, x: core::ffi::c_double) -> (); + fn get_x(&mut self) -> core::ffi::c_double; + fn set_y(&mut self, y: core::ffi::c_double) -> (); + fn get_y(&mut self) -> core::ffi::c_double; + fn set_width(&mut self, width: core::ffi::c_double) -> (); + fn get_width(&mut self) -> core::ffi::c_double; + fn set_height(&mut self, height: core::ffi::c_double) -> (); + fn get_height(&mut self) -> core::ffi::c_double; + fn get_left(&mut self) -> core::ffi::c_double; + fn get_right(&mut self) -> core::ffi::c_double; + fn get_top(&mut self) -> core::ffi::c_double; + fn get_bottom(&mut self) -> core::ffi::c_double; + fn add_point(&mut self, point: core::ffi::c_double) -> (); + fn add_point(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); + fn move_to(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); + fn squared_norm(&mut self) -> core::ffi::c_double; + fn get_data(&mut self) -> *mut core::ffi::c_double; + fn get_data(&mut self) -> *const core::ffi::c_double; +} +pub trait VtkRectf: VtkRect + VtkVector { + fn set( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + width: core::ffi::c_float, + height: core::ffi::c_float, + ) -> (); + fn set_x(&mut self, x: core::ffi::c_float) -> (); + fn get_x(&mut self) -> core::ffi::c_float; + fn set_y(&mut self, y: core::ffi::c_float) -> (); + fn get_y(&mut self) -> core::ffi::c_float; + fn set_width(&mut self, width: core::ffi::c_float) -> (); + fn get_width(&mut self) -> core::ffi::c_float; + fn set_height(&mut self, height: core::ffi::c_float) -> (); + fn get_height(&mut self) -> core::ffi::c_float; + fn get_left(&mut self) -> core::ffi::c_float; + fn get_right(&mut self) -> core::ffi::c_float; + fn get_top(&mut self) -> core::ffi::c_float; + fn get_bottom(&mut self) -> core::ffi::c_float; + fn add_point(&mut self, point: core::ffi::c_float) -> (); + fn add_point(&mut self, x: core::ffi::c_float, y: core::ffi::c_float) -> (); + fn move_to(&mut self, x: core::ffi::c_float, y: core::ffi::c_float) -> (); + fn squared_norm(&mut self) -> core::ffi::c_float; + fn get_data(&mut self) -> *mut core::ffi::c_float; + fn get_data(&mut self) -> *const core::ffi::c_float; +} +pub trait VtkRecti: VtkRect + VtkVector { + fn set( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + width: core::ffi::c_int, + height: core::ffi::c_int, + ) -> (); + fn set_x(&mut self, x: core::ffi::c_int) -> (); + fn get_x(&mut self) -> core::ffi::c_int; + fn set_y(&mut self, y: core::ffi::c_int) -> (); + fn get_y(&mut self) -> core::ffi::c_int; + fn set_width(&mut self, width: core::ffi::c_int) -> (); + fn get_width(&mut self) -> core::ffi::c_int; + fn set_height(&mut self, height: core::ffi::c_int) -> (); + fn get_height(&mut self) -> core::ffi::c_int; + fn get_left(&mut self) -> core::ffi::c_int; + fn get_right(&mut self) -> core::ffi::c_int; + fn get_top(&mut self) -> core::ffi::c_int; + fn get_bottom(&mut self) -> core::ffi::c_int; + fn add_point(&mut self, point: core::ffi::c_int) -> (); + fn add_point(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); + fn move_to(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); + fn squared_norm(&mut self) -> core::ffi::c_int; + fn get_data(&mut self) -> *mut core::ffi::c_int; + fn get_data(&mut self) -> *const core::ffi::c_int; +} +pub trait VtkRectilinearGrid: VtkDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn initialize(&mut self) -> (); + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> (); + fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + seedLoc: core::ffi::c_int, + ) -> (); + fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn has_any_blank_points(&mut self) -> bool; + fn has_any_blank_cells(&mut self) -> bool; + fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> (); + fn get_points(&mut self, pnts: *mut core::ffi::c_void) -> (); + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn set_dimensions(&mut self, dim: core::ffi::c_int) -> (); + fn get_dimensions(&mut self) -> *mut core::ffi::c_int; + fn get_dimensions(&mut self, data: core::ffi::c_int) -> (); + fn get_data_dimension(&mut self) -> core::ffi::c_int; + fn compute_structured_coordinates( + &mut self, + x: core::ffi::c_double, + ijk: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn compute_point_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar; + fn compute_cell_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_point( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + p: core::ffi::c_double, + ) -> (); + fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_x_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_y_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_y_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_z_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_z_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_extent(&mut self, extent: core::ffi::c_int) -> (); + fn set_extent( + &mut self, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ) -> (); + fn get_extent(&mut self) -> *mut core::ffi::c_int; + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn crop(&mut self, updateExtent: core::ffi::c_int) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_scalar_type( + &mut self, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> (); + fn get_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> core::ffi::c_int; + fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool; + fn get_scalar_type(&mut self) -> core::ffi::c_int; + fn get_scalar_type_as_string(&mut self) -> *const core::ffi::c_char; + fn set_number_of_scalar_components( + &mut self, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn has_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> bool; + fn get_number_of_scalar_components(&mut self) -> core::ffi::c_int; +} +pub trait VtkReebGraph: VtkMutableDirectedGraph + VtkDirectedGraph + VtkGraph + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarFieldId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarFieldId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarFieldName: core::ffi::c_char, + ) -> core::ffi::c_int; + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarFieldName: core::ffi::c_char, + ) -> core::ffi::c_int; + fn stream_triangle( + &mut self, + vertex0Id: core::ffi::c_uchar, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_uchar, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_uchar, + scalar2: core::ffi::c_double, + ) -> core::ffi::c_int; + fn stream_tetrahedron( + &mut self, + vertex0Id: core::ffi::c_uchar, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_uchar, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_uchar, + scalar2: core::ffi::c_double, + vertex3Id: core::ffi::c_uchar, + scalar3: core::ffi::c_double, + ) -> core::ffi::c_int; + fn close_stream(&mut self) -> (); + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn simplify( + &mut self, + simplificationThreshold: core::ffi::c_double, + simplificationMetric: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set(&mut self, g: *mut core::ffi::c_void) -> (); +} +pub trait VtkReebGraphSimplificationMetric { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_lower_bound(&mut self, _arg: core::ffi::c_double) -> (); + fn get_lower_bound(&mut self) -> core::ffi::c_double; + fn set_upper_bound(&mut self, _arg: core::ffi::c_double) -> (); + fn get_upper_bound(&mut self) -> core::ffi::c_double; + fn compute_metric( + &mut self, + mesh: *mut core::ffi::c_void, + field: *mut core::ffi::c_void, + startCriticalPoint: core::ffi::c_uchar, + vertexList: *mut core::ffi::c_void, + endCriticalPoint: core::ffi::c_uchar, + ) -> core::ffi::c_double; +} +pub trait VtkSelection: VtkDataObject { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_number_of_nodes(&mut self) -> core::ffi::c_uint; + fn get_node(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_node(&mut self, name: &str) -> *mut core::ffi::c_void; + fn add_node(&mut self, p0: *mut core::ffi::c_void) -> &str; + fn set_node(&mut self, name: &str, p1: *mut core::ffi::c_void) -> (); + fn get_node_name_at_index(&mut self, idx: core::ffi::c_uint) -> &str; + fn remove_node(&mut self, idx: core::ffi::c_uint) -> (); + fn remove_node(&mut self, name: &str) -> (); + fn remove_node(&mut self, p0: *mut core::ffi::c_void) -> (); + fn remove_all_nodes(&mut self) -> (); + fn set_expression(&mut self, _arg: &str) -> (); + fn get_expression(&mut self) -> &str; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn union(&mut self, selection: *mut core::ffi::c_void) -> (); + fn union(&mut self, node: *mut core::ffi::c_void) -> (); + fn subtract(&mut self, selection: *mut core::ffi::c_void) -> (); + fn subtract(&mut self, node: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn dump(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkSelectionNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn set_selection_list(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_selection_list(&mut self) -> *mut core::ffi::c_void; + fn set_selection_data(&mut self, data: *mut core::ffi::c_void) -> (); + fn get_selection_data(&mut self) -> *mut core::ffi::c_void; + fn get_properties(&mut self) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn content_type(&mut self) -> *mut core::ffi::c_void; + fn set_content_type(&mut self, type_: core::ffi::c_int) -> (); + fn get_content_type(&mut self) -> core::ffi::c_int; + fn get_content_type_as_string( + &mut self, + type_: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn field_type(&mut self) -> *mut core::ffi::c_void; + fn set_field_type(&mut self, type_: core::ffi::c_int) -> (); + fn get_field_type(&mut self) -> core::ffi::c_int; + fn get_field_type_as_string( + &mut self, + type_: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn get_field_type_from_string( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_int; + fn convert_selection_field_to_attribute_type( + &mut self, + val: core::ffi::c_int, + ) -> core::ffi::c_int; + fn convert_attribute_type_to_selection_field( + &mut self, + val: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_query_string(&mut self, _arg: core::ffi::c_char) -> (); + fn get_query_string(&mut self) -> *mut core::ffi::c_char; + fn epsilon(&mut self) -> *mut core::ffi::c_void; + fn zbuffer_value(&mut self) -> *mut core::ffi::c_void; + fn containing_cells(&mut self) -> *mut core::ffi::c_void; + fn connected_layers(&mut self) -> *mut core::ffi::c_void; + fn component_number(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> *mut core::ffi::c_void; + fn pixel_count(&mut self) -> *mut core::ffi::c_void; + fn source(&mut self) -> *mut core::ffi::c_void; + fn source_id(&mut self) -> *mut core::ffi::c_void; + fn prop(&mut self) -> *mut core::ffi::c_void; + fn prop_id(&mut self) -> *mut core::ffi::c_void; + fn process_id(&mut self) -> *mut core::ffi::c_void; + fn assembly_name(&mut self) -> *mut core::ffi::c_void; + fn selectors(&mut self) -> *mut core::ffi::c_void; + fn composite_index(&mut self) -> *mut core::ffi::c_void; + fn hierarchical_level(&mut self) -> *mut core::ffi::c_void; + fn hierarchical_index(&mut self) -> *mut core::ffi::c_void; + fn indexed_vertices(&mut self) -> *mut core::ffi::c_void; + fn union_selection_list(&mut self, other: *mut core::ffi::c_void) -> (); + fn subtract_selection_list(&mut self, other: *mut core::ffi::c_void) -> (); + fn equal_properties( + &mut self, + other: *mut core::ffi::c_void, + fullcompare: bool, + ) -> bool; +} +pub trait VtkSimpleCellTessellator: VtkGenericCellTessellator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_generic_cell(&mut self) -> *mut core::ffi::c_void; + fn tessellate_face( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn tessellate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn reset(&mut self) -> (); + fn initialize(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_fixed_subdivisions(&mut self) -> core::ffi::c_int; + fn get_max_subdivision_level(&mut self) -> core::ffi::c_int; + fn get_max_adaptive_subdivisions(&mut self) -> core::ffi::c_int; + fn set_fixed_subdivisions(&mut self, level: core::ffi::c_int) -> (); + fn set_max_subdivision_level(&mut self, level: core::ffi::c_int) -> (); + fn set_subdivision_levels( + &mut self, + fixed: core::ffi::c_int, + maxLevel: core::ffi::c_int, + ) -> (); +} +pub trait VtkSmoothErrorMetric: VtkGenericSubdivisionErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_angle_tolerance(&mut self) -> core::ffi::c_double; + fn set_angle_tolerance(&mut self, value: core::ffi::c_double) -> (); + fn requires_edge_subdivision( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_error( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkSortFieldData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn sort( + &mut self, + fd: *mut core::ffi::c_void, + arrayName: core::ffi::c_char, + k: core::ffi::c_int, + returnIndices: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar; + fn sort( + &mut self, + fd: *mut core::ffi::c_void, + arrayName: core::ffi::c_char, + k: core::ffi::c_int, + returnIndices: core::ffi::c_int, + dir: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar; +} +pub trait VtkSphere: VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_center(&mut self, _arg: core::ffi::c_double) -> (); + fn get_center(&mut self) -> *mut core::ffi::c_double; + fn get_center(&mut self, data: core::ffi::c_double) -> (); + fn evaluate( + &mut self, + center: core::ffi::c_double, + R: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + fn compute_bounding_sphere( + &mut self, + pts: core::ffi::c_float, + numPts: core::ffi::c_uchar, + sphere: core::ffi::c_float, + hints: core::ffi::c_uchar, + ) -> (); + fn compute_bounding_sphere( + &mut self, + pts: core::ffi::c_double, + numPts: core::ffi::c_uchar, + sphere: core::ffi::c_double, + hints: core::ffi::c_uchar, + ) -> (); + fn compute_bounding_sphere( + &mut self, + spheres: core::ffi::c_float, + numSpheres: core::ffi::c_uchar, + sphere: core::ffi::c_float, + hints: core::ffi::c_uchar, + ) -> (); + fn compute_bounding_sphere( + &mut self, + spheres: core::ffi::c_double, + numSpheres: core::ffi::c_uchar, + sphere: core::ffi::c_double, + hints: core::ffi::c_uchar, + ) -> (); +} +pub trait VtkSpheres: VtkImplicitFunction { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn set_centers(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_centers(&mut self) -> *mut core::ffi::c_void; + fn set_radii(&mut self, radii: *mut core::ffi::c_void) -> (); + fn get_radii(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_spheres(&mut self) -> core::ffi::c_int; + fn get_sphere(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_sphere(&mut self, i: core::ffi::c_int, sphere: *mut core::ffi::c_void) -> (); +} +pub trait VtkSpline { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_parametric_range( + &mut self, + tMin: core::ffi::c_double, + tMax: core::ffi::c_double, + ) -> (); + fn set_parametric_range(&mut self, tRange: core::ffi::c_double) -> (); + fn get_parametric_range(&mut self, tRange: core::ffi::c_double) -> (); + fn set_clamp_value(&mut self, _arg: core::ffi::c_int) -> (); + fn get_clamp_value(&mut self) -> core::ffi::c_int; + fn clamp_value_on(&mut self) -> (); + fn clamp_value_off(&mut self) -> (); + fn compute(&mut self) -> (); + fn evaluate(&mut self, t: core::ffi::c_double) -> core::ffi::c_double; + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn add_point(&mut self, t: core::ffi::c_double, x: core::ffi::c_double) -> (); + fn remove_point(&mut self, t: core::ffi::c_double) -> (); + fn remove_all_points(&mut self) -> (); + fn set_closed(&mut self, _arg: core::ffi::c_int) -> (); + fn get_closed(&mut self) -> core::ffi::c_int; + fn closed_on(&mut self) -> (); + fn closed_off(&mut self) -> (); + fn set_left_constraint(&mut self, _arg: core::ffi::c_int) -> (); + fn get_left_constraint_min_value(&mut self) -> core::ffi::c_int; + fn get_left_constraint_max_value(&mut self) -> core::ffi::c_int; + fn get_left_constraint(&mut self) -> core::ffi::c_int; + fn set_right_constraint(&mut self, _arg: core::ffi::c_int) -> (); + fn get_right_constraint_min_value(&mut self) -> core::ffi::c_int; + fn get_right_constraint_max_value(&mut self) -> core::ffi::c_int; + fn get_right_constraint(&mut self) -> core::ffi::c_int; + fn set_left_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_left_value(&mut self) -> core::ffi::c_double; + fn set_right_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_right_value(&mut self) -> core::ffi::c_double; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> (); +} +pub trait VtkStaticCellLinks: VtkAbstractCellLinks { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn build_links(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_number_of_cells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_ncells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_cells(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn select_cells( + &mut self, + minMaxDegree: core::ffi::c_uchar, + cellSelection: core::ffi::c_uchar, + ) -> (); + fn initialize(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); +} +pub trait VtkStaticCellLinksTemplate { + fn initialize(&mut self) -> (); + fn build_links(&mut self, ds: *mut core::ffi::c_void) -> (); + fn build_links(&mut self, pd: *mut core::ffi::c_void) -> (); + fn build_links(&mut self, ugrid: *mut core::ffi::c_void) -> (); + fn build_links(&mut self, esgrid: *mut core::ffi::c_void) -> (); + fn serial_build_links( + &mut self, + numPts: core::ffi::c_uchar, + numCells: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + ) -> (); + fn threaded_build_links( + &mut self, + numPts: core::ffi::c_uchar, + numCells: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_cells( + &mut self, + ptId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_ncells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn matches_cell( + &mut self, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> bool; + fn get_cells(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cells( + &mut self, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + cells: *mut core::ffi::c_void, + ) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn select_cells( + &mut self, + minMaxDegree: core::ffi::c_uchar, + cellSelection: core::ffi::c_uchar, + ) -> (); + fn set_sequential_processing(&mut self, seq: core::ffi::c_int) -> (); + fn get_sequential_processing(&mut self) -> core::ffi::c_int; +} +pub trait VtkStaticCellLocator: VtkAbstractCellLocator + VtkLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> (); + fn set_divisions(&mut self, _arg: core::ffi::c_int) -> (); + fn get_divisions(&mut self) -> *mut core::ffi::c_int; + fn get_divisions(&mut self, data: core::ffi::c_int) -> (); + fn find_cell( + &mut self, + pos: core::ffi::c_double, + tol2: core::ffi::c_double, + cell: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_cell(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_cells_along_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tolerance: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ) -> (); + fn find_cells_along_plane( + &mut self, + o: core::ffi::c_double, + n: core::ffi::c_double, + tolerance: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ) -> (); + fn intersect_with_line( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + points: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar; + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar; + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar; + fn get_large_ids(&mut self) -> bool; + fn set_use_diagonal_length_tolerance(&mut self, _arg: bool) -> (); + fn get_use_diagonal_length_tolerance(&mut self) -> bool; + fn use_diagonal_length_tolerance_on(&mut self) -> (); + fn use_diagonal_length_tolerance_off(&mut self) -> (); +} +pub trait VtkStaticEdgeLocatorTemplate { + fn get_number_of_edges(&mut self) -> *mut core::ffi::c_void; + fn is_inserted_edge( + &mut self, + v0: *mut core::ffi::c_void, + v1: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkStaticPointLocator: VtkAbstractPointLocator + VtkLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int; + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> (); + fn set_divisions(&mut self, _arg: core::ffi::c_int) -> (); + fn get_divisions(&mut self) -> *mut core::ffi::c_int; + fn get_divisions(&mut self, data: core::ffi::c_int) -> (); + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + inputDataLength: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn intersect_with_line( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + lineX: core::ffi::c_double, + ptX: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn merge_points( + &mut self, + tol: core::ffi::c_double, + mergeMap: core::ffi::c_uchar, + ) -> (); + fn initialize(&mut self) -> (); + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn build_locator(&mut self, inBounds: core::ffi::c_double) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_points_in_bucket( + &mut self, + bNum: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_bucket_ids( + &mut self, + bNum: core::ffi::c_uchar, + bList: *mut core::ffi::c_void, + ) -> (); + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar; + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar; + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar; + fn get_large_ids(&mut self) -> bool; + fn get_spacing(&mut self) -> *mut core::ffi::c_double; + fn get_spacing(&mut self, spacing: core::ffi::c_double) -> (); +} +pub trait VtkStaticPointLocator2D: VtkAbstractPointLocator + VtkLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int; + fn set_divisions(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> (); + fn set_divisions(&mut self, _arg: core::ffi::c_int) -> (); + fn get_divisions(&mut self) -> *mut core::ffi::c_int; + fn get_divisions(&mut self, data: core::ffi::c_int) -> (); + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + inputDataLength: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn intersect_with_line( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + lineX: core::ffi::c_double, + ptX: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn find_close_n_bounded_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + fn merge_points( + &mut self, + tol: core::ffi::c_double, + mergeMap: core::ffi::c_uchar, + ) -> (); + fn initialize(&mut self) -> (); + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn get_number_of_points_in_bucket( + &mut self, + bNum: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_bucket_ids( + &mut self, + bNum: core::ffi::c_uchar, + bList: *mut core::ffi::c_void, + ) -> (); + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar; + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar; + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar; + fn get_large_ids(&mut self) -> bool; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_spacing(&mut self) -> *mut core::ffi::c_double; + fn get_spacing(&mut self, spacing: core::ffi::c_double) -> (); + fn get_bucket_indices(&mut self, x: core::ffi::c_double, ij: core::ffi::c_int) -> (); + fn get_bucket_index(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkStructuredData { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_dimensions( + &mut self, + inDim: core::ffi::c_int, + dim: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_extent( + &mut self, + inExt: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_data_description(&mut self, dims: core::ffi::c_int) -> core::ffi::c_int; + fn get_data_description_from_extent( + &mut self, + ext: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_data_dimension( + &mut self, + dataDescription: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_data_dimension(&mut self, ext: core::ffi::c_int) -> core::ffi::c_int; + fn get_number_of_points( + &mut self, + ext: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn get_number_of_cells( + &mut self, + ext: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn get_cell_extent_from_point_extent( + &mut self, + pntExtent: core::ffi::c_int, + cellExtent: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> (); + fn get_dimensions_from_extent( + &mut self, + ext: core::ffi::c_int, + dims: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> (); + fn is_point_visible( + &mut self, + cellId: core::ffi::c_uchar, + ghosts: *mut core::ffi::c_void, + ) -> bool; + fn is_cell_visible( + &mut self, + cellId: core::ffi::c_uchar, + dimensions: core::ffi::c_int, + dataDescription: core::ffi::c_int, + cellGhostArray: *mut core::ffi::c_void, + pointGhostArray: *mut core::ffi::c_void, + ) -> bool; + fn get_cell_dimensions_from_extent( + &mut self, + ext: core::ffi::c_int, + celldims: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> (); + fn get_cell_dimensions_from_point_dimensions( + &mut self, + pntdims: core::ffi::c_int, + cellDims: core::ffi::c_int, + ) -> (); + fn get_local_structured_coordinates( + &mut self, + ijk: core::ffi::c_int, + ext: core::ffi::c_int, + lijk: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> (); + fn get_global_structured_coordinates( + &mut self, + lijk: core::ffi::c_int, + ext: core::ffi::c_int, + ijk: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> (); + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + dataDescription: core::ffi::c_int, + dim: core::ffi::c_int, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ) -> (); + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ) -> (); + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + dim: core::ffi::c_int, + seedLoc: core::ffi::c_int, + ) -> (); + fn compute_point_id_for_extent( + &mut self, + extent: core::ffi::c_int, + ijk: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn compute_cell_id_for_extent( + &mut self, + extent: core::ffi::c_int, + ijk: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn compute_point_id( + &mut self, + dim: core::ffi::c_int, + ijk: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn compute_cell_id( + &mut self, + dim: core::ffi::c_int, + ijk: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> core::ffi::c_uchar; + fn compute_cell_structured_coords_for_extent( + &mut self, + cellIdx: core::ffi::c_uchar, + ext: core::ffi::c_int, + ijk: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> (); + fn compute_cell_structured_coords( + &mut self, + cellId: core::ffi::c_uchar, + dim: core::ffi::c_int, + ijk: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> (); + fn compute_point_structured_coords_for_extent( + &mut self, + ptId: core::ffi::c_uchar, + ext: core::ffi::c_int, + ijk: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> (); + fn compute_point_structured_coords( + &mut self, + ptId: core::ffi::c_uchar, + dim: core::ffi::c_int, + ijk: core::ffi::c_int, + dataDescription: core::ffi::c_int, + ) -> (); +} +pub trait VtkStructuredExtent { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn clamp(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> (); + fn strictly_smaller( + &mut self, + ext: core::ffi::c_int, + wholeExt: core::ffi::c_int, + ) -> bool; + fn smaller(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> bool; + fn grow(&mut self, ext: core::ffi::c_int, count: core::ffi::c_int) -> (); + fn grow( + &mut self, + ext: core::ffi::c_int, + count: core::ffi::c_int, + wholeExt: core::ffi::c_int, + ) -> (); + fn transform(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> (); + fn get_dimensions(&mut self, ext: core::ffi::c_int, dims: core::ffi::c_int) -> (); +} +pub trait VtkStructuredGrid: VtkPointSet + VtkDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_point(&mut self, ptId: core::ffi::c_uchar, p: core::ffi::c_double) -> (); + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> (); + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + seedLoc: core::ffi::c_int, + ) -> (); + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn set_dimensions(&mut self, dim: core::ffi::c_int) -> (); + fn get_dimensions(&mut self) -> *mut core::ffi::c_int; + fn get_dimensions(&mut self, dim: core::ffi::c_int) -> (); + fn get_data_dimension(&mut self) -> core::ffi::c_int; + fn set_extent(&mut self, extent: core::ffi::c_int) -> (); + fn set_extent( + &mut self, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ) -> (); + fn get_extent(&mut self) -> *mut core::ffi::c_int; + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn blank_point(&mut self, ptId: core::ffi::c_uchar) -> (); + fn un_blank_point(&mut self, ptId: core::ffi::c_uchar) -> (); + fn blank_cell(&mut self, ptId: core::ffi::c_uchar) -> (); + fn un_blank_cell(&mut self, ptId: core::ffi::c_uchar) -> (); + fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn has_any_blank_points(&mut self) -> bool; + fn has_any_blank_cells(&mut self) -> bool; + fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> (); + fn crop(&mut self, updateExtent: core::ffi::c_int) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_point( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + p: core::ffi::c_double, + adjustForExtent: bool, + ) -> (); +} +pub trait VtkStructuredPoints: VtkImageData + VtkDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkStructuredPointsCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_next_structured_points(&mut self, cookie: ()) -> *mut core::ffi::c_void; +} +pub trait VtkSuperquadric: VtkImplicitFunction { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> (); + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_center(&mut self, _arg: core::ffi::c_double) -> (); + fn get_center(&mut self) -> *mut core::ffi::c_double; + fn get_center(&mut self, data: core::ffi::c_double) -> (); + fn set_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_scale(&mut self, _arg: core::ffi::c_double) -> (); + fn get_scale(&mut self) -> *mut core::ffi::c_double; + fn get_scale(&mut self, data: core::ffi::c_double) -> (); + fn get_thickness(&mut self) -> core::ffi::c_double; + fn set_thickness(&mut self, _arg: core::ffi::c_double) -> (); + fn get_thickness_min_value(&mut self) -> core::ffi::c_double; + fn get_thickness_max_value(&mut self) -> core::ffi::c_double; + fn get_phi_roundness(&mut self) -> core::ffi::c_double; + fn set_phi_roundness(&mut self, e: core::ffi::c_double) -> (); + fn get_theta_roundness(&mut self) -> core::ffi::c_double; + fn set_theta_roundness(&mut self, e: core::ffi::c_double) -> (); + fn set_size(&mut self, _arg: core::ffi::c_double) -> (); + fn get_size(&mut self) -> core::ffi::c_double; + fn toroidal_on(&mut self) -> (); + fn toroidal_off(&mut self) -> (); + fn get_toroidal(&mut self) -> core::ffi::c_int; + fn set_toroidal(&mut self, _arg: core::ffi::c_int) -> (); +} +pub trait VtkTable: VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn dump(&mut self, colWidth: core::ffi::c_uint, rowLimit: core::ffi::c_int) -> (); + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_row_data(&mut self) -> *mut core::ffi::c_void; + fn set_row_data(&mut self, data: *mut core::ffi::c_void) -> (); + fn get_number_of_rows(&mut self) -> core::ffi::c_uchar; + fn set_number_of_rows(&mut self, p0: core::ffi::c_uchar) -> (); + fn get_row(&mut self, row: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_row(&mut self, row: core::ffi::c_uchar, values: *mut core::ffi::c_void) -> (); + fn set_row(&mut self, row: core::ffi::c_uchar, values: *mut core::ffi::c_void) -> (); + fn insert_next_blank_row( + &mut self, + default_num_val: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn insert_next_row(&mut self, values: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn remove_row(&mut self, row: core::ffi::c_uchar) -> (); + fn get_number_of_columns(&mut self) -> core::ffi::c_uchar; + fn get_column_name(&mut self, col: core::ffi::c_uchar) -> *const core::ffi::c_char; + fn get_column_by_name(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_column(&mut self, col: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn add_column(&mut self, arr: *mut core::ffi::c_void) -> (); + fn remove_column_by_name(&mut self, name: core::ffi::c_char) -> (); + fn remove_column(&mut self, col: core::ffi::c_uchar) -> (); + fn get_value( + &mut self, + row: core::ffi::c_uchar, + col: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_value_by_name( + &mut self, + row: core::ffi::c_uchar, + col: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set_value( + &mut self, + row: core::ffi::c_uchar, + col: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> (); + fn set_value_by_name( + &mut self, + row: core::ffi::c_uchar, + col: core::ffi::c_char, + value: *mut core::ffi::c_void, + ) -> (); + fn initialize(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar; +} +pub trait VtkTetra: VtkCell3D + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + fn tetra_center( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + p4: core::ffi::c_double, + center: core::ffi::c_double, + ) -> (); + fn circumsphere( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + x4: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + fn insphere( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + p4: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + fn barycentric_coords( + &mut self, + x: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + x4: core::ffi::c_double, + bcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn compute_volume( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + p4: core::ffi::c_double, + ) -> core::ffi::c_double; + fn jacobian_inverse( + &mut self, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; +} +pub trait VtkTree: VtkDirectedAcyclicGraph + VtkDirectedGraph + VtkGraph + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_root(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_child( + &mut self, + v: core::ffi::c_uchar, + i: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_children(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> (); + fn get_parent(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_parent_edge(&mut self, v: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_level(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn is_leaf(&mut self, vertex: core::ffi::c_uchar) -> bool; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn reorder_children( + &mut self, + parent: core::ffi::c_uchar, + children: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkTreeBFSIterator: VtkTreeIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkTreeDFSIterator: VtkTreeIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_mode(&mut self, mode: core::ffi::c_int) -> (); + fn get_mode(&mut self) -> core::ffi::c_int; +} +pub trait VtkTreeIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_tree(&mut self, tree: *mut core::ffi::c_void) -> (); + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn set_start_vertex(&mut self, vertex: core::ffi::c_uchar) -> (); + fn get_start_vertex(&mut self) -> core::ffi::c_uchar; + fn next(&mut self) -> core::ffi::c_uchar; + fn has_next(&mut self) -> bool; + fn restart(&mut self) -> (); +} +pub trait VtkTriQuadraticHexahedron: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkTriQuadraticPyramid: VtkNonLinearCell + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; +} +pub trait VtkTriangle: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn compute_area(&mut self) -> core::ffi::c_double; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + fn triangle_center( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + center: core::ffi::c_double, + ) -> (); + fn triangle_area( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + ) -> core::ffi::c_double; + fn circumcircle( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + fn barycentric_coords( + &mut self, + x: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + bcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn project_to_2_d( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + ) -> core::ffi::c_int; + fn compute_normal( + &mut self, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + n: core::ffi::c_double, + ) -> (); + fn compute_normal( + &mut self, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn compute_normal_direction( + &mut self, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + n: core::ffi::c_double, + ) -> (); + fn triangles_intersect( + &mut self, + p1: core::ffi::c_double, + q1: core::ffi::c_double, + r1: core::ffi::c_double, + p2: core::ffi::c_double, + q2: core::ffi::c_double, + r2: core::ffi::c_double, + ) -> core::ffi::c_int; + fn point_in_triangle( + &mut self, + x: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + tol2: core::ffi::c_double, + ) -> core::ffi::c_int; + fn compute_quadric( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + quadric: core::ffi::c_double, + ) -> (); + fn compute_quadric( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + quadric: *mut core::ffi::c_void, + ) -> (); + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; +} +pub trait VtkTriangleStrip: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn decompose_strip( + &mut self, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + tris: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkUndirectedGraph: VtkGraph + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_in_degree(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_in_edge( + &mut self, + v: core::ffi::c_uchar, + i: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_in_edge( + &mut self, + v: core::ffi::c_uchar, + i: core::ffi::c_uchar, + e: *mut core::ffi::c_void, + ) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_in_edges(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> (); + fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool; +} +pub trait VtkUniformGrid: VtkImageData + VtkDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_grid_description(&mut self) -> core::ffi::c_int; + fn initialize( + &mut self, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + ) -> core::ffi::c_int; + fn initialize( + &mut self, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + nGhosts: core::ffi::c_int, + ) -> core::ffi::c_int; + fn initialize( + &mut self, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + nGhosts: core::ffi::c_int, + ) -> core::ffi::c_int; + fn initialize( + &mut self, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + nGhostsI: core::ffi::c_int, + nGhostsJ: core::ffi::c_int, + nGhostsK: core::ffi::c_int, + ) -> core::ffi::c_int; + fn blank_point(&mut self, ptId: core::ffi::c_uchar) -> (); + fn un_blank_point(&mut self, ptId: core::ffi::c_uchar) -> (); + fn blank_point( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn un_blank_point( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn blank_cell(&mut self, ptId: core::ffi::c_uchar) -> (); + fn un_blank_cell(&mut self, ptId: core::ffi::c_uchar) -> (); + fn blank_cell( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn un_blank_cell( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn is_point_visible(&mut self, pointId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn new_image_data_copy(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkUniformGridAMR: VtkCompositeDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn initialize( + &mut self, + numLevels: core::ffi::c_int, + blocksPerLevel: core::ffi::c_int, + ) -> (); + fn set_grid_description(&mut self, gridDescription: core::ffi::c_int) -> (); + fn get_grid_description(&mut self) -> core::ffi::c_int; + fn get_number_of_levels(&mut self) -> core::ffi::c_uint; + fn get_total_number_of_blocks(&mut self) -> core::ffi::c_uint; + fn get_number_of_data_sets(&mut self, level: core::ffi::c_uint) -> core::ffi::c_uint; + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_bounds(&mut self) -> *const core::ffi::c_double; + fn get_min(&mut self, min: core::ffi::c_double) -> (); + fn get_max(&mut self, max: core::ffi::c_double) -> (); + fn set_data_set( + &mut self, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ) -> (); + fn set_data_set( + &mut self, + level: core::ffi::c_uint, + idx: core::ffi::c_uint, + grid: *mut core::ffi::c_void, + ) -> (); + fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data_set( + &mut self, + level: core::ffi::c_uint, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn get_composite_index( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> core::ffi::c_int; + fn get_level_and_index( + &mut self, + compositeIdx: core::ffi::c_uint, + level: core::ffi::c_uint, + idx: core::ffi::c_uint, + ) -> (); + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn copy_structure(&mut self, src: *mut core::ffi::c_void) -> (); + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkUniformGridAMRDataIterator: VtkCompositeDataIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_current_meta_data(&mut self) -> *mut core::ffi::c_void; + fn has_current_meta_data(&mut self) -> core::ffi::c_int; + fn get_current_data_object(&mut self) -> *mut core::ffi::c_void; + fn get_current_flat_index(&mut self) -> core::ffi::c_uint; + fn get_current_level(&mut self) -> core::ffi::c_uint; + fn get_current_index(&mut self) -> core::ffi::c_uint; + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; +} +pub trait VtkUniformHyperTreeGrid: VtkHyperTreeGrid + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_origin(&mut self, _arg: core::ffi::c_double) -> (); + fn get_origin(&mut self) -> *mut core::ffi::c_double; + fn get_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_origin(&mut self, _arg: core::ffi::c_double) -> (); + fn set_grid_scale( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> (); + fn set_grid_scale(&mut self, p0: core::ffi::c_double) -> (); + fn get_grid_scale(&mut self) -> *mut core::ffi::c_double; + fn get_grid_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_grid_scale(&mut self, _arg: core::ffi::c_double) -> (); + fn set_grid_scale(&mut self, p0: core::ffi::c_double) -> (); + fn set_x_coordinates(&mut self, XCoordinates: *mut core::ffi::c_void) -> (); + fn set_y_coordinates(&mut self, YCoordinates: *mut core::ffi::c_void) -> (); + fn set_z_coordinates(&mut self, ZCoordinates: *mut core::ffi::c_void) -> (); + fn get_level_zero_origin_from_index( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_double, + ) -> (); + fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkUnstructuredGrid: VtkUnstructuredGridBase + VtkPointSet + VtkDataSet + VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_uchar, + maxCellSize: core::ffi::c_uchar, + ) -> bool; + fn allocate_exact( + &mut self, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool; + fn allocate( + &mut self, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ) -> (); + fn reset(&mut self) -> (); + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> (); + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> (); + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_uchar, + cells: core::ffi::c_uchar, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_ushort, + cells: core::ffi::c_uchar, + ) -> (); + fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void; + fn squeeze(&mut self) -> (); + fn initialize(&mut self) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn build_links(&mut self) -> (); + fn get_cell_links(&mut self) -> *mut core::ffi::c_void; + fn get_face_stream( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_face_stream( + &mut self, + cellId: core::ffi::c_uchar, + nfaces: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + ) -> (); + fn set_cells( + &mut self, + type_: core::ffi::c_int, + cells: *mut core::ffi::c_void, + ) -> (); + fn set_cells( + &mut self, + types: core::ffi::c_int, + cells: *mut core::ffi::c_void, + ) -> (); + fn set_cells( + &mut self, + cellTypes: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + ) -> (); + fn set_cells( + &mut self, + cellTypes: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + faceLocations: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> (); + fn get_cells(&mut self) -> *mut core::ffi::c_void; + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn is_cell_boundary( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + ) -> bool; + fn insert_next_linked_cell( + &mut self, + type_: core::ffi::c_int, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn remove_reference_to_cell( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> (); + fn add_reference_to_cell( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> (); + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_uchar, + size: core::ffi::c_int, + ) -> (); + fn get_piece(&mut self) -> core::ffi::c_int; + fn get_number_of_pieces(&mut self) -> core::ffi::c_int; + fn get_ghost_level(&mut self) -> core::ffi::c_int; + fn get_ids_of_cells_of_type( + &mut self, + type_: core::ffi::c_int, + array: *mut core::ffi::c_void, + ) -> (); + fn is_homogeneous(&mut self) -> core::ffi::c_int; + fn remove_ghost_cells(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_faces(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; + fn get_faces(&mut self) -> *mut core::ffi::c_void; + fn get_face_locations(&mut self) -> *mut core::ffi::c_void; + fn initialize_faces_representation( + &mut self, + numPrevCells: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong; + fn decompose_a_polyhedron_cell( + &mut self, + polyhedronCellArray: *mut core::ffi::c_void, + nCellpts: core::ffi::c_uchar, + nCellfaces: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> (); + fn decompose_a_polyhedron_cell( + &mut self, + polyhedronCellStream: core::ffi::c_uchar, + nCellpts: core::ffi::c_uchar, + nCellfaces: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> (); + fn decompose_a_polyhedron_cell( + &mut self, + nCellFaces: core::ffi::c_uchar, + inFaceStream: core::ffi::c_uchar, + nCellpts: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> (); + fn convert_face_stream_point_ids( + &mut self, + faceStream: *mut core::ffi::c_void, + idMap: core::ffi::c_uchar, + ) -> (); + fn convert_face_stream_point_ids( + &mut self, + nfaces: core::ffi::c_uchar, + faceStream: core::ffi::c_uchar, + idMap: core::ffi::c_uchar, + ) -> (); + fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void; + fn set_cells( + &mut self, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + ) -> (); + fn set_cells( + &mut self, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + faceLocations: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkUnstructuredGridBase: VtkPointSet + VtkDataSet + VtkDataObject { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ) -> (); + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn insert_next_cell( + &mut self, + type_: core::ffi::c_int, + npts: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn insert_next_cell( + &mut self, + type_: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + fn insert_next_cell( + &mut self, + type_: core::ffi::c_int, + npts: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + nfaces: core::ffi::c_uchar, + faces: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn replace_cell( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> (); + fn get_ids_of_cells_of_type( + &mut self, + type_: core::ffi::c_int, + array: *mut core::ffi::c_void, + ) -> (); + fn is_homogeneous(&mut self) -> core::ffi::c_int; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkUnstructuredGridCellIterator: VtkCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_done_with_traversal(&mut self) -> bool; + fn get_cell_id(&mut self) -> core::ffi::c_uchar; + fn go_to_cell(&mut self, cellId: core::ffi::c_uchar) -> (); +} +pub trait VtkVector { + fn squared_norm(&mut self) -> *mut core::ffi::c_void; + fn norm(&mut self) -> core::ffi::c_double; + fn normalize(&mut self) -> core::ffi::c_double; +} +pub trait VtkVector2: VtkVector { + fn set(&mut self, x: T, y: T) -> (); + fn set_x(&mut self, x: T) -> (); + fn get_x(&mut self) -> T; + fn set_y(&mut self, y: T) -> (); + fn get_y(&mut self) -> T; + fn get_data(&mut self) -> *const T; +} +pub trait VtkVector2d: VtkVector2 + VtkVector { + fn normalized(&mut self) -> *mut core::ffi::c_void; + fn set(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); + fn set_x(&mut self, x: core::ffi::c_double) -> (); + fn get_x(&mut self) -> core::ffi::c_double; + fn set_y(&mut self, y: core::ffi::c_double) -> (); + fn get_y(&mut self) -> core::ffi::c_double; + fn squared_norm(&mut self) -> core::ffi::c_double; + fn get_data(&mut self) -> *mut core::ffi::c_double; + fn get_data(&mut self) -> *const core::ffi::c_double; +} +pub trait VtkVector2f: VtkVector2 + VtkVector { + fn normalized(&mut self) -> *mut core::ffi::c_void; + fn set(&mut self, x: core::ffi::c_float, y: core::ffi::c_float) -> (); + fn set_x(&mut self, x: core::ffi::c_float) -> (); + fn get_x(&mut self) -> core::ffi::c_float; + fn set_y(&mut self, y: core::ffi::c_float) -> (); + fn get_y(&mut self) -> core::ffi::c_float; + fn squared_norm(&mut self) -> core::ffi::c_float; + fn get_data(&mut self) -> *mut core::ffi::c_float; + fn get_data(&mut self) -> *const core::ffi::c_float; +} +pub trait VtkVector2i: VtkVector2 + VtkVector { + fn normalized(&mut self) -> *mut core::ffi::c_void; + fn set(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); + fn set_x(&mut self, x: core::ffi::c_int) -> (); + fn get_x(&mut self) -> core::ffi::c_int; + fn set_y(&mut self, y: core::ffi::c_int) -> (); + fn get_y(&mut self) -> core::ffi::c_int; + fn squared_norm(&mut self) -> core::ffi::c_int; + fn get_data(&mut self) -> *mut core::ffi::c_int; + fn get_data(&mut self) -> *const core::ffi::c_int; +} +pub trait VtkVector3: VtkVector { + fn set(&mut self, x: T, y: T, z: T) -> (); + fn set_x(&mut self, x: T) -> (); + fn get_x(&mut self) -> T; + fn set_y(&mut self, y: T) -> (); + fn get_y(&mut self) -> T; + fn set_z(&mut self, z: T) -> (); + fn get_z(&mut self) -> T; + fn get_data(&mut self) -> *const T; +} +pub trait VtkVector3d: VtkVector3 + VtkVector { + fn normalized(&mut self) -> *mut core::ffi::c_void; + fn cross(&mut self, other: vtkVector3d) -> *mut core::ffi::c_void; + fn set( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_x(&mut self, x: core::ffi::c_double) -> (); + fn get_x(&mut self) -> core::ffi::c_double; + fn set_y(&mut self, y: core::ffi::c_double) -> (); + fn get_y(&mut self) -> core::ffi::c_double; + fn set_z(&mut self, z: core::ffi::c_double) -> (); + fn get_z(&mut self) -> core::ffi::c_double; + fn squared_norm(&mut self) -> core::ffi::c_double; + fn get_data(&mut self) -> *mut core::ffi::c_double; + fn get_data(&mut self) -> *const core::ffi::c_double; +} +pub trait VtkVector3f: VtkVector3 + VtkVector { + fn normalized(&mut self) -> *mut core::ffi::c_void; + fn cross(&mut self, other: vtkVector3f) -> *mut core::ffi::c_void; + fn set( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + z: core::ffi::c_float, + ) -> (); + fn set_x(&mut self, x: core::ffi::c_float) -> (); + fn get_x(&mut self) -> core::ffi::c_float; + fn set_y(&mut self, y: core::ffi::c_float) -> (); + fn get_y(&mut self) -> core::ffi::c_float; + fn set_z(&mut self, z: core::ffi::c_float) -> (); + fn get_z(&mut self) -> core::ffi::c_float; + fn squared_norm(&mut self) -> core::ffi::c_float; + fn get_data(&mut self) -> *mut core::ffi::c_float; + fn get_data(&mut self) -> *const core::ffi::c_float; +} +pub trait VtkVector3i: VtkVector3 + VtkVector { + fn normalized(&mut self) -> *mut core::ffi::c_void; + fn cross(&mut self, other: vtkVector3i) -> *mut core::ffi::c_void; + fn set( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + ) -> (); + fn set_x(&mut self, x: core::ffi::c_int) -> (); + fn get_x(&mut self) -> core::ffi::c_int; + fn set_y(&mut self, y: core::ffi::c_int) -> (); + fn get_y(&mut self) -> core::ffi::c_int; + fn set_z(&mut self, z: core::ffi::c_int) -> (); + fn get_z(&mut self) -> core::ffi::c_int; + fn squared_norm(&mut self) -> core::ffi::c_int; + fn get_data(&mut self) -> *mut core::ffi::c_int; + fn get_data(&mut self) -> *const core::ffi::c_int; +} +pub trait VtkVector4: VtkVector { + fn set(&mut self, x: T, y: T, z: T, w: T) -> (); + fn set_x(&mut self, x: T) -> (); + fn get_x(&mut self) -> T; + fn set_y(&mut self, y: T) -> (); + fn get_y(&mut self) -> T; + fn set_z(&mut self, z: T) -> (); + fn get_z(&mut self) -> T; + fn set_w(&mut self, w: T) -> (); + fn get_w(&mut self) -> T; + fn get_data(&mut self) -> *const T; +} +pub trait VtkVector4d: VtkVector4 + VtkVector { + fn normalized(&mut self) -> *mut core::ffi::c_void; + fn set( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + w: core::ffi::c_double, + ) -> (); + fn set_x(&mut self, x: core::ffi::c_double) -> (); + fn get_x(&mut self) -> core::ffi::c_double; + fn set_y(&mut self, y: core::ffi::c_double) -> (); + fn get_y(&mut self) -> core::ffi::c_double; + fn set_z(&mut self, z: core::ffi::c_double) -> (); + fn get_z(&mut self) -> core::ffi::c_double; + fn set_w(&mut self, w: core::ffi::c_double) -> (); + fn get_w(&mut self) -> core::ffi::c_double; + fn squared_norm(&mut self) -> core::ffi::c_double; + fn get_data(&mut self) -> *mut core::ffi::c_double; + fn get_data(&mut self) -> *const core::ffi::c_double; +} +pub trait VtkVector4i: VtkVector4 + VtkVector { + fn normalized(&mut self) -> *mut core::ffi::c_void; + fn set( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + w: core::ffi::c_int, + ) -> (); + fn set_x(&mut self, x: core::ffi::c_int) -> (); + fn get_x(&mut self) -> core::ffi::c_int; + fn set_y(&mut self, y: core::ffi::c_int) -> (); + fn get_y(&mut self) -> core::ffi::c_int; + fn set_z(&mut self, z: core::ffi::c_int) -> (); + fn get_z(&mut self) -> core::ffi::c_int; + fn set_w(&mut self, w: core::ffi::c_int) -> (); + fn get_w(&mut self) -> core::ffi::c_int; + fn squared_norm(&mut self) -> core::ffi::c_int; + fn get_data(&mut self) -> *mut core::ffi::c_int; + fn get_data(&mut self) -> *const core::ffi::c_int; +} +pub trait VtkVertex: VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn inflate(&mut self, p0: core::ffi::c_double) -> core::ffi::c_int; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> (); + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); +} +pub trait VtkVertexListIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_graph(&mut self, graph: *mut core::ffi::c_void) -> (); + fn get_graph(&mut self) -> *mut core::ffi::c_void; + fn next(&mut self) -> core::ffi::c_uchar; + fn has_next(&mut self) -> bool; +} +pub trait VtkVoxel: VtkCell3D + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faces: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edges: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faces: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; + fn compute_bounding_sphere( + &mut self, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int; + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; +} +pub trait VtkWedge: VtkCell3D + VtkCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> (); + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> (); + fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int; + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> (); + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> (); + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; +} +pub trait VtkXMLDataElement { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_name(&mut self) -> *mut core::ffi::c_char; + fn set_name(&mut self, _arg: core::ffi::c_char) -> (); + fn get_id(&mut self) -> *mut core::ffi::c_char; + fn set_id(&mut self, _arg: core::ffi::c_char) -> (); + fn get_attribute(&mut self, name: core::ffi::c_char) -> *const core::ffi::c_char; + fn set_attribute(&mut self, name: core::ffi::c_char, value: core::ffi::c_char) -> (); + fn set_character_data( + &mut self, + data: core::ffi::c_char, + length: core::ffi::c_int, + ) -> (); + fn add_character_data(&mut self, c: core::ffi::c_char, length: usize) -> (); + fn get_character_data(&mut self) -> *mut core::ffi::c_char; + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_float, + ) -> core::ffi::c_int; + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_long, + ) -> core::ffi::c_int; + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_ulong, + ) -> core::ffi::c_int; + fn set_int_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> (); + fn set_float_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_float, + ) -> (); + fn set_double_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_double, + ) -> (); + fn set_unsigned_long_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_ulong, + ) -> (); + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_float, + ) -> core::ffi::c_int; + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_long, + ) -> core::ffi::c_int; + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulong, + ) -> core::ffi::c_int; + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_int, + ) -> (); + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_float, + ) -> (); + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulong, + ) -> (); + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_uchar, + ) -> core::ffi::c_int; + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_uchar, + ) -> (); + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulonglong, + ) -> (); + fn get_word_type_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_number_of_attributes(&mut self) -> core::ffi::c_int; + fn get_attribute_name(&mut self, idx: core::ffi::c_int) -> *const core::ffi::c_char; + fn get_attribute_value(&mut self, idx: core::ffi::c_int) -> *const core::ffi::c_char; + fn remove_attribute(&mut self, name: core::ffi::c_char) -> (); + fn remove_all_attributes(&mut self) -> (); + fn get_parent(&mut self) -> *mut core::ffi::c_void; + fn set_parent(&mut self, parent: *mut core::ffi::c_void) -> (); + fn get_root(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_nested_elements(&mut self) -> core::ffi::c_int; + fn get_nested_element(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn add_nested_element(&mut self, element: *mut core::ffi::c_void) -> (); + fn remove_nested_element(&mut self, p0: *mut core::ffi::c_void) -> (); + fn remove_all_nested_elements(&mut self) -> (); + fn find_nested_element(&mut self, id: core::ffi::c_char) -> *mut core::ffi::c_void; + fn find_nested_element_with_name( + &mut self, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn find_nested_element_with_name_and_id( + &mut self, + name: core::ffi::c_char, + id: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn find_nested_element_with_name_and_attribute( + &mut self, + name: core::ffi::c_char, + att_name: core::ffi::c_char, + att_value: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn lookup_element_with_name( + &mut self, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn lookup_element(&mut self, id: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_xml_byte_index(&mut self) -> core::ffi::c_uchar; + fn set_xml_byte_index(&mut self, _arg: core::ffi::c_uchar) -> (); + fn is_equal_to(&mut self, elem: *mut core::ffi::c_void) -> core::ffi::c_int; + fn deep_copy(&mut self, elem: *mut core::ffi::c_void) -> (); + fn set_attribute_encoding(&mut self, _arg: core::ffi::c_int) -> (); + fn get_attribute_encoding_min_value(&mut self) -> core::ffi::c_int; + fn get_attribute_encoding_max_value(&mut self) -> core::ffi::c_int; + fn get_attribute_encoding(&mut self) -> core::ffi::c_int; + fn print_xml(&mut self, fname: core::ffi::c_char) -> (); + fn get_character_data_width(&mut self) -> core::ffi::c_int; + fn set_character_data_width(&mut self, _arg: core::ffi::c_int) -> (); +} +impl VtkAMRDataInternals for vtkAMRDataInternals { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amr_data_internals_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amr_data_internals_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amr_data_internals_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amr_data_internals_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amr_data_internals_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amr_data_internals_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_amr_data_internals_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_amr_data_internals_initialize(self.0) } + } + fn insert(&mut self, index: core::ffi::c_uint, grid: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_amr_data_internals_insert( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uint, + grid: *mut core::ffi::c_void, + ); + } + unsafe { vtk_amr_data_internals_insert(self.0, index, grid) } + } + fn get_data_set( + &mut self, + compositeIndex: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amr_data_internals_get_data_set( + sself: *mut core::ffi::c_void, + compositeIndex: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amr_data_internals_get_data_set(self.0, compositeIndex) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_amr_data_internals_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_amr_data_internals_shallow_copy(self.0, src) } + } + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_amr_data_internals_recursive_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_amr_data_internals_recursive_shallow_copy(self.0, src) } + } + fn empty(&mut self) -> bool { + unsafe extern "C" { + fn vtk_amr_data_internals_empty(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_amr_data_internals_empty(self.0) } + } + fn get_number_of_blocks(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_amr_data_internals_get_number_of_blocks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_amr_data_internals_get_number_of_blocks(self.0) } + } + fn get_block(&mut self, i: core::ffi::c_uint) -> Block { + unsafe extern "C" { + fn vtk_amr_data_internals_get_block( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uint, + ) -> Block; + } + unsafe { vtk_amr_data_internals_get_block(self.0, i) } + } + fn get_all_blocks(&mut self) -> Vec { + unsafe extern "C" { + fn vtk_amr_data_internals_get_all_blocks( + sself: *mut core::ffi::c_void, + ) -> Vec; + } + unsafe { vtk_amr_data_internals_get_all_blocks(self.0) } + } +} +impl VtkAdjacentVertexIterator for vtkAdjacentVertexIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_adjacent_vertex_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_adjacent_vertex_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_adjacent_vertex_iterator_new_instance(self.0) } + } + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_initialize( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + ); + } + unsafe { vtk_adjacent_vertex_iterator_initialize(self.0, g, v) } + } + fn get_graph(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_get_graph( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_adjacent_vertex_iterator_get_graph(self.0) } + } + fn get_vertex(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_get_vertex( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_adjacent_vertex_iterator_get_vertex(self.0) } + } + fn next(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_next( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_adjacent_vertex_iterator_next(self.0) } + } + fn has_next(&mut self) -> bool { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_has_next( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_adjacent_vertex_iterator_has_next(self.0) } + } +} +impl VtkAnimationScene for vtkAnimationScene { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_scene_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_scene_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_scene_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_scene_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_scene_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_scene_new(self.0) } + } + fn set_play_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_play_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_animation_scene_set_play_mode(self.0, _arg) } + } + fn set_mode_to_sequence(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_mode_to_sequence(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_scene_set_mode_to_sequence(self.0) } + } + fn set_mode_to_real_time(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_mode_to_real_time(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_scene_set_mode_to_real_time(self.0) } + } + fn get_play_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_animation_scene_get_play_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_animation_scene_get_play_mode(self.0) } + } + fn set_frame_rate(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_frame_rate( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_animation_scene_set_frame_rate(self.0, _arg) } + } + fn get_frame_rate(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_scene_get_frame_rate( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_scene_get_frame_rate(self.0) } + } + fn add_cue(&mut self, cue: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_animation_scene_add_cue( + sself: *mut core::ffi::c_void, + cue: *mut core::ffi::c_void, + ); + } + unsafe { vtk_animation_scene_add_cue(self.0, cue) } + } + fn remove_cue(&mut self, cue: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_animation_scene_remove_cue( + sself: *mut core::ffi::c_void, + cue: *mut core::ffi::c_void, + ); + } + unsafe { vtk_animation_scene_remove_cue(self.0, cue) } + } + fn remove_all_cues(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_scene_remove_all_cues(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_scene_remove_all_cues(self.0) } + } + fn get_number_of_cues(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_animation_scene_get_number_of_cues( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_animation_scene_get_number_of_cues(self.0) } + } + fn play(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_scene_play(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_scene_play(self.0) } + } + fn stop(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_scene_stop(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_scene_stop(self.0) } + } + fn set_loop(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_loop( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_animation_scene_set_loop(self.0, _arg) } + } + fn get_loop(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_animation_scene_get_loop( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_animation_scene_get_loop(self.0) } + } + fn set_animation_time(&mut self, time: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_animation_time( + sself: *mut core::ffi::c_void, + time: core::ffi::c_double, + ); + } + unsafe { vtk_animation_scene_set_animation_time(self.0, time) } + } + fn set_time_mode(&mut self, mode: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_time_mode( + sself: *mut core::ffi::c_void, + mode: core::ffi::c_int, + ); + } + unsafe { vtk_animation_scene_set_time_mode(self.0, mode) } + } + fn is_in_play(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_animation_scene_is_in_play( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_animation_scene_is_in_play(self.0) } + } +} +impl VtkAnnotation for vtkAnnotation { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_new(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_annotation_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_annotation_get_data_object_type(self.0) } + } + fn get_selection(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_get_selection( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_get_selection(self.0) } + } + fn set_selection(&mut self, selection: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_set_selection( + sself: *mut core::ffi::c_void, + selection: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_set_selection(self.0, selection) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_get_data(self.0, v, i) } + } + fn label(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_label( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_label(self.0) } + } + fn color(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_color( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_color(self.0) } + } + fn opacity(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_opacity( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_opacity(self.0) } + } + fn icon_index(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_icon_index( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_icon_index(self.0) } + } + fn enable(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_enable( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_enable(self.0) } + } + fn hide(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_hide( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_hide(self.0) } + } + fn data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_data(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_annotation_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_annotation_initialize(self.0) } + } + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_shallow_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_shallow_copy(self.0, other) } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_deep_copy(self.0, other) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_annotation_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_annotation_get_m_time(self.0) } + } +} +impl VtkAnnotationLayers for vtkAnnotationLayers { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_new(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_annotation_layers_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_annotation_layers_get_data_object_type(self.0) } + } + fn set_current_annotation(&mut self, ann: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_set_current_annotation( + sself: *mut core::ffi::c_void, + ann: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_set_current_annotation(self.0, ann) } + } + fn get_current_annotation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_get_current_annotation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_get_current_annotation(self.0) } + } + fn set_current_selection(&mut self, sel: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_set_current_selection( + sself: *mut core::ffi::c_void, + sel: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_set_current_selection(self.0, sel) } + } + fn get_current_selection(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_get_current_selection( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_get_current_selection(self.0) } + } + fn get_number_of_annotations(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_annotation_layers_get_number_of_annotations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_annotation_layers_get_number_of_annotations(self.0) } + } + fn get_annotation(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_get_annotation( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_get_annotation(self.0, idx) } + } + fn add_annotation(&mut self, ann: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_add_annotation( + sself: *mut core::ffi::c_void, + ann: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_add_annotation(self.0, ann) } + } + fn remove_annotation(&mut self, ann: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_remove_annotation( + sself: *mut core::ffi::c_void, + ann: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_remove_annotation(self.0, ann) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_annotation_layers_initialize(self.0) } + } + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_shallow_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_shallow_copy(self.0, other) } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_deep_copy(self.0, other) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_get_data(self.0, v, i) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_annotation_layers_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_annotation_layers_get_m_time(self.0) } + } +} +impl VtkArrayData for vtkArrayData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_new_instance(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_get_data(self.0, v, i) } + } + fn add_array(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_array_data_add_array( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_array_data_add_array(self.0, p0) } + } + fn clear_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_array_data_clear_arrays(sself: *mut core::ffi::c_void); + } + unsafe { vtk_array_data_clear_arrays(self.0) } + } + fn get_number_of_arrays(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_array_data_get_number_of_arrays( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_array_data_get_number_of_arrays(self.0) } + } + fn get_array(&mut self, index: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_get_array( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_get_array(self.0, index) } + } + fn get_array_by_name(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_get_array_by_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_get_array_by_name(self.0, name) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_array_data_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_array_data_get_data_object_type(self.0) } + } + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_array_data_shallow_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_array_data_shallow_copy(self.0, other) } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_array_data_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_array_data_deep_copy(self.0, other) } + } +} +impl VtkAttributesErrorMetric for vtkAttributesErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_attributes_error_metric_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_attributes_error_metric_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_attributes_error_metric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_attributes_error_metric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_attributes_error_metric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_attributes_error_metric_new_instance(self.0) } + } + fn get_absolute_attribute_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_attributes_error_metric_get_absolute_attribute_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_attributes_error_metric_get_absolute_attribute_tolerance(self.0) } + } + fn set_absolute_attribute_tolerance(&mut self, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_attributes_error_metric_set_absolute_attribute_tolerance( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_attributes_error_metric_set_absolute_attribute_tolerance(self.0, value) + } + } + fn get_attribute_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_attributes_error_metric_get_attribute_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_attributes_error_metric_get_attribute_tolerance(self.0) } + } + fn set_attribute_tolerance(&mut self, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_attributes_error_metric_set_attribute_tolerance( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { vtk_attributes_error_metric_set_attribute_tolerance(self.0, value) } + } + fn requires_edge_subdivision( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_attributes_error_metric_requires_edge_subdivision( + sself: *mut core::ffi::c_void, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_attributes_error_metric_requires_edge_subdivision( + self.0, + leftPoint, + midPoint, + rightPoint, + alpha, + ) + } + } + fn get_error( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_attributes_error_metric_get_error( + sself: *mut core::ffi::c_void, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_attributes_error_metric_get_error( + self.0, + leftPoint, + midPoint, + rightPoint, + alpha, + ) + } + } +} +impl VtkBSPCuts for vtkBSPCuts { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_cuts_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_cuts_get_data_object_type(self.0) } + } + fn create_cuts( + &mut self, + bounds: core::ffi::c_double, + ncuts: core::ffi::c_int, + dim: core::ffi::c_int, + coord: core::ffi::c_double, + lower: core::ffi::c_int, + upper: core::ffi::c_int, + lowerDataCoord: core::ffi::c_double, + upperDataCoord: core::ffi::c_double, + npoints: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bsp_cuts_create_cuts( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ncuts: core::ffi::c_int, + dim: core::ffi::c_int, + coord: core::ffi::c_double, + lower: core::ffi::c_int, + upper: core::ffi::c_int, + lowerDataCoord: core::ffi::c_double, + upperDataCoord: core::ffi::c_double, + npoints: core::ffi::c_int, + ); + } + unsafe { + vtk_bsp_cuts_create_cuts( + self.0, + bounds, + ncuts, + dim, + coord, + lower, + upper, + lowerDataCoord, + upperDataCoord, + npoints, + ) + } + } + fn create_cuts(&mut self, kd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bsp_cuts_create_cuts( + sself: *mut core::ffi::c_void, + kd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bsp_cuts_create_cuts(self.0, kd) } + } + fn get_kd_node_tree(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_get_kd_node_tree( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_get_kd_node_tree(self.0) } + } + fn get_number_of_cuts(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_cuts_get_number_of_cuts( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_cuts_get_number_of_cuts(self.0) } + } + fn get_arrays( + &mut self, + len: core::ffi::c_int, + dim: core::ffi::c_int, + coord: core::ffi::c_double, + lower: core::ffi::c_int, + upper: core::ffi::c_int, + lowerDataCoord: core::ffi::c_double, + upperDataCoord: core::ffi::c_double, + npoints: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_cuts_get_arrays( + sself: *mut core::ffi::c_void, + len: core::ffi::c_int, + dim: core::ffi::c_int, + coord: core::ffi::c_double, + lower: core::ffi::c_int, + upper: core::ffi::c_int, + lowerDataCoord: core::ffi::c_double, + upperDataCoord: core::ffi::c_double, + npoints: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_cuts_get_arrays( + self.0, + len, + dim, + coord, + lower, + upper, + lowerDataCoord, + upperDataCoord, + npoints, + ) + } + } + fn equals( + &mut self, + other: *mut core::ffi::c_void, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_cuts_equals( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_cuts_equals(self.0, other, tolerance) } + } + fn print_tree(&mut self) -> () { + unsafe extern "C" { + fn vtk_bsp_cuts_print_tree(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bsp_cuts_print_tree(self.0) } + } + fn print_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_bsp_cuts_print_arrays(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bsp_cuts_print_arrays(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_get_data(self.0, v, i) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bsp_cuts_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bsp_cuts_shallow_copy(self.0, src) } + } +} +impl VtkBSPIntersections for vtkBSPIntersections { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_intersections_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_intersections_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_intersections_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_intersections_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_intersections_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_intersections_new(self.0) } + } + fn set_cuts(&mut self, cuts: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bsp_intersections_set_cuts( + sself: *mut core::ffi::c_void, + cuts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bsp_intersections_set_cuts(self.0, cuts) } + } + fn get_cuts(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_intersections_get_cuts( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_intersections_get_cuts(self.0) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_intersections_get_bounds(self.0, bounds) } + } + fn get_number_of_regions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_get_number_of_regions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_intersections_get_number_of_regions(self.0) } + } + fn get_region_bounds( + &mut self, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_get_region_bounds( + sself: *mut core::ffi::c_void, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_intersections_get_region_bounds(self.0, regionID, bounds) } + } + fn get_region_data_bounds( + &mut self, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_get_region_data_bounds( + sself: *mut core::ffi::c_void, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_intersections_get_region_data_bounds(self.0, regionID, bounds) } + } + fn intersects_box( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_intersects_box( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_intersections_intersects_box(self.0, regionId, x) } + } + fn intersects_box( + &mut self, + regionId: core::ffi::c_int, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + y0: core::ffi::c_double, + y1: core::ffi::c_double, + z0: core::ffi::c_double, + z1: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_intersects_box( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + y0: core::ffi::c_double, + y1: core::ffi::c_double, + z0: core::ffi::c_double, + z1: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_intersections_intersects_box( + self.0, + regionId, + x0, + x1, + y0, + y1, + z0, + z1, + ) + } + } + fn intersects_box( + &mut self, + ids: core::ffi::c_int, + len: core::ffi::c_int, + x: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_intersects_box( + sself: *mut core::ffi::c_void, + ids: core::ffi::c_int, + len: core::ffi::c_int, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_intersections_intersects_box(self.0, ids, len, x) } + } + fn intersects_box( + &mut self, + ids: core::ffi::c_int, + len: core::ffi::c_int, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + y0: core::ffi::c_double, + y1: core::ffi::c_double, + z0: core::ffi::c_double, + z1: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_intersects_box( + sself: *mut core::ffi::c_void, + ids: core::ffi::c_int, + len: core::ffi::c_int, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + y0: core::ffi::c_double, + y1: core::ffi::c_double, + z0: core::ffi::c_double, + z1: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_intersections_intersects_box( + self.0, + ids, + len, + x0, + x1, + y0, + y1, + z0, + z1, + ) + } + } + fn intersects_sphere_2( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_intersects_sphere_2( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_intersections_intersects_sphere_2( + self.0, + regionId, + x, + y, + z, + rSquared, + ) + } + } + fn intersects_sphere_2( + &mut self, + ids: core::ffi::c_int, + len: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_intersects_sphere_2( + sself: *mut core::ffi::c_void, + ids: core::ffi::c_int, + len: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_intersections_intersects_sphere_2( + self.0, + ids, + len, + x, + y, + z, + rSquared, + ) + } + } + fn intersects_cell( + &mut self, + regionId: core::ffi::c_int, + cell: *mut core::ffi::c_void, + cellRegion: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_intersects_cell( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + cell: *mut core::ffi::c_void, + cellRegion: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_intersections_intersects_cell(self.0, regionId, cell, cellRegion) + } + } + fn intersects_cell( + &mut self, + ids: core::ffi::c_int, + len: core::ffi::c_int, + cell: *mut core::ffi::c_void, + cellRegion: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_intersects_cell( + sself: *mut core::ffi::c_void, + ids: core::ffi::c_int, + len: core::ffi::c_int, + cell: *mut core::ffi::c_void, + cellRegion: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_intersections_intersects_cell(self.0, ids, len, cell, cellRegion) + } + } + fn get_compute_intersections_using_data_bounds(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_get_compute_intersections_using_data_bounds( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_intersections_get_compute_intersections_using_data_bounds(self.0) + } + } + fn set_compute_intersections_using_data_bounds( + &mut self, + c: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bsp_intersections_set_compute_intersections_using_data_bounds( + sself: *mut core::ffi::c_void, + c: core::ffi::c_int, + ); + } + unsafe { + vtk_bsp_intersections_set_compute_intersections_using_data_bounds(self.0, c) + } + } + fn compute_intersections_using_data_bounds_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_bsp_intersections_compute_intersections_using_data_bounds_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bsp_intersections_compute_intersections_using_data_bounds_on(self.0) + } + } + fn compute_intersections_using_data_bounds_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_bsp_intersections_compute_intersections_using_data_bounds_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bsp_intersections_compute_intersections_using_data_bounds_off(self.0) + } + } +} +impl VtkBezierCurve for vtkBezierCurve { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_curve_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_curve_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_curve_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_curve_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_curve_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_curve_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_curve_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_curve_get_cell_type(self.0) } + } + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_curve_evaluate_location_projected_node( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_curve_evaluate_location_projected_node( + self.0, + subId, + point_id, + x, + weights, + ) + } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_curve_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ); + } + unsafe { + vtk_bezier_curve_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_curve_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_bezier_curve_interpolate_functions(self.0, pcoords, weights) } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_curve_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_curve_get_rational_weights(self.0) } + } +} +impl VtkBezierHexahedron for vtkBezierHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_hexahedron_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_face(self.0, faceId) } + } + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_hexahedron_evaluate_location_projected_node( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_hexahedron_evaluate_location_projected_node( + self.0, + subId, + point_id, + x, + weights, + ) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_hexahedron_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_bezier_hexahedron_interpolate_functions(self.0, pcoords, weights) } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_hexahedron_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ); + } + unsafe { + vtk_bezier_hexahedron_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_rational_weights(self.0) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_edge_cell(self.0) } + } + fn get_face_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_face_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_face_cell(self.0) } + } + fn get_interpolation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_interpolation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_interpolation(self.0) } + } +} +impl VtkBezierInterpolation for vtkBezierInterpolation { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_interpolation_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_interpolation_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_interpolation_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_interpolation_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_interpolation_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_interpolation_new_instance(self.0) } + } + fn flatten_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + coord: vtkVector3i, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_interpolation_flatten_simplex( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + coord: vtkVector3i, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_interpolation_flatten_simplex(self.0, dim, deg, coord) } + } + fn flatten_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + coord: vtkVector3i, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_interpolation_flatten_simplex( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + coord: vtkVector3i, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_interpolation_flatten_simplex(self.0, dim, deg, coord) } + } + fn unflatten_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + flat: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_interpolation_unflatten_simplex( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + flat: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_interpolation_unflatten_simplex(self.0, dim, deg, flat) } + } + fn un_flatten_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + flat: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_interpolation_un_flatten_simplex( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + flat: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_interpolation_un_flatten_simplex(self.0, dim, deg, flat) } + } + fn de_casteljau_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_de_casteljau_simplex( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_de_casteljau_simplex( + self.0, + dim, + deg, + pcoords, + weights, + ) + } + } + fn de_casteljau_simplex( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_de_casteljau_simplex( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_de_casteljau_simplex( + self.0, + dim, + deg, + pcoords, + weights, + ) + } + } + fn de_casteljau_simplex_deriv( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_de_casteljau_simplex_deriv( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_de_casteljau_simplex_deriv( + self.0, + dim, + deg, + pcoords, + weights, + ) + } + } + fn de_casteljau_simplex_deriv( + &mut self, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_de_casteljau_simplex_deriv( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + deg: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_de_casteljau_simplex_deriv( + self.0, + dim, + deg, + pcoords, + weights, + ) + } + } + fn evaluate_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_evaluate_shape_functions( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_evaluate_shape_functions( + self.0, + order, + pcoord, + shape, + ) + } + } + fn evaluate_shape_and_gradient( + &mut self, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + grad: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_evaluate_shape_and_gradient( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + grad: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_evaluate_shape_and_gradient( + self.0, + order, + pcoord, + shape, + grad, + ) + } + } + fn tensor_1_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_interpolation_tensor_1_shape_functions( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bezier_interpolation_tensor_1_shape_functions( + self.0, + order, + pcoords, + shape, + ) + } + } + fn tensor_1_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_interpolation_tensor_1_shape_derivatives( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bezier_interpolation_tensor_1_shape_derivatives( + self.0, + order, + pcoords, + derivs, + ) + } + } + fn tensor_2_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_interpolation_tensor_2_shape_functions( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bezier_interpolation_tensor_2_shape_functions( + self.0, + order, + pcoords, + shape, + ) + } + } + fn tensor_2_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_interpolation_tensor_2_shape_derivatives( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bezier_interpolation_tensor_2_shape_derivatives( + self.0, + order, + pcoords, + derivs, + ) + } + } + fn tensor_3_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_interpolation_tensor_3_shape_functions( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bezier_interpolation_tensor_3_shape_functions( + self.0, + order, + pcoords, + shape, + ) + } + } + fn tensor_3_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_interpolation_tensor_3_shape_derivatives( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bezier_interpolation_tensor_3_shape_derivatives( + self.0, + order, + pcoords, + derivs, + ) + } + } + fn tensor_3_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_tensor_3_evaluate_derivative( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_tensor_3_evaluate_derivative( + self.0, + order, + pcoords, + points, + fieldVals, + fieldDim, + fieldDerivs, + ) + } + } + fn wedge_shape_functions( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_wedge_shape_functions( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_wedge_shape_functions( + self.0, + order, + numberOfPoints, + pcoords, + shape, + ) + } + } + fn wedge_shape_derivatives( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_wedge_shape_derivatives( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_wedge_shape_derivatives( + self.0, + order, + numberOfPoints, + pcoords, + derivs, + ) + } + } + fn wedge_evaluate( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldAtPCoords: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_wedge_evaluate( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldAtPCoords: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_wedge_evaluate( + self.0, + order, + numberOfPoints, + pcoords, + fieldVals, + fieldDim, + fieldAtPCoords, + ) + } + } + fn wedge_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_interpolation_wedge_evaluate_derivative( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_interpolation_wedge_evaluate_derivative( + self.0, + order, + pcoords, + points, + fieldVals, + fieldDim, + fieldDerivs, + ) + } + } +} +impl VtkBezierQuadrilateral for vtkBezierQuadrilateral { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_quadrilateral_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_get_edge(self.0, edgeId) } + } + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_evaluate_location_projected_node( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_quadrilateral_evaluate_location_projected_node( + self.0, + subId, + point_id, + x, + weights, + ) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_quadrilateral_interpolate_functions(self.0, pcoords, weights) + } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ); + } + unsafe { + vtk_bezier_quadrilateral_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_get_rational_weights(self.0) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_get_edge_cell(self.0) } + } +} +impl VtkBezierTetra for vtkBezierTetra { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_tetra_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_tetra_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_get_face(self.0, faceId) } + } + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_tetra_evaluate_location_projected_node( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_tetra_evaluate_location_projected_node( + self.0, + subId, + point_id, + x, + weights, + ) + } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_tetra_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ); + } + unsafe { + vtk_bezier_tetra_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_tetra_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_bezier_tetra_interpolate_functions(self.0, pcoords, weights) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_get_edge_cell(self.0) } + } + fn get_face_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_get_face_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_get_face_cell(self.0) } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_get_rational_weights(self.0) } + } +} +impl VtkBezierTriangle for vtkBezierTriangle { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_triangle_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_triangle_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_get_edge(self.0, edgeId) } + } + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_triangle_evaluate_location_projected_node( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_triangle_evaluate_location_projected_node( + self.0, + subId, + point_id, + x, + weights, + ) + } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_triangle_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ); + } + unsafe { + vtk_bezier_triangle_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_triangle_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_bezier_triangle_interpolate_functions(self.0, pcoords, weights) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_get_edge_cell(self.0) } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_get_rational_weights(self.0) } + } +} +impl VtkBezierWedge for vtkBezierWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_wedge_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_face(self.0, faceId) } + } + fn evaluate_location_projected_node( + &mut self, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_wedge_evaluate_location_projected_node( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + point_id: core::ffi::c_uchar, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bezier_wedge_evaluate_location_projected_node( + self.0, + subId, + point_id, + x, + weights, + ) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_wedge_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_bezier_wedge_interpolate_functions(self.0, pcoords, weights) } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_wedge_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + ); + } + unsafe { + vtk_bezier_wedge_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_boundary_quad( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_boundary_quad(self.0) } + } + fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_boundary_tri( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_boundary_tri(self.0) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_edge_cell(self.0) } + } + fn get_interpolation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_interpolation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_interpolation(self.0) } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_rational_weights(self.0) } + } +} +impl VtkBiQuadraticQuad for vtkBiQuadraticQuad { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quad_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quad_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quad_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quad_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quad_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_cell_boundary(self.0, subId, pcoords, pts) } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quad_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quad_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quad_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bi_quadratic_quad_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_bi_quadratic_quad_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quad_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_get_parametric_center(self.0, pcoords) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_bi_quadratic_quad_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_bi_quadratic_quad_interpolate_derivs(self.0, pcoords, derivs) } + } +} +impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_cell_boundary( + self.0, + subId, + pcoords, + pts, + ) + } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_evaluate_location( + self.0, + subId, + pcoords, + x, + weights, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_triangulate(self.0, index, ptIds, pts) + } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_interpolation_functions( + self.0, + pcoords, + weights, + ) + } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_interpolation_derivs( + self.0, + pcoords, + derivs, + ) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_interpolate_functions( + self.0, + pcoords, + weights, + ) + } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_interpolate_derivs( + self.0, + pcoords, + derivs, + ) + } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_face_array(self.0, faceId) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_jacobian_inverse( + self.0, + pcoords, + inverse, + derivs, + ) + } + } +} +impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_cell_boundary(self.0, subId, pcoords, pts) + } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_evaluate_location( + self.0, + subId, + pcoords, + x, + weights, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_triangulate(self.0, index, ptIds, pts) + } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_get_parametric_center(self.0, pcoords) + } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_interpolation_functions( + self.0, + pcoords, + weights, + ) + } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_interpolation_derivs( + self.0, + pcoords, + derivs, + ) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_interpolate_functions( + self.0, + pcoords, + weights, + ) + } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_interpolate_derivs(self.0, pcoords, derivs) + } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_face_array(self.0, faceId) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_jacobian_inverse( + self.0, + pcoords, + inverse, + derivs, + ) + } + } +} +impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_triangle_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_triangle_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_triangle_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_triangle_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_triangle_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bi_quadratic_triangle_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_triangle_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_triangle_evaluate_location( + self.0, + subId, + pcoords, + x, + weights, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_triangle_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_bi_quadratic_triangle_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_triangle_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_get_parametric_center(self.0, pcoords) } + } + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_parametric_distance( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_bi_quadratic_triangle_get_parametric_distance(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_triangle_interpolation_functions(self.0, pcoords, weights) + } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_triangle_interpolation_derivs(self.0, pcoords, derivs) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_bi_quadratic_triangle_interpolate_functions(self.0, pcoords, weights) + } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_bi_quadratic_triangle_interpolate_derivs(self.0, pcoords, derivs) } + } +} +impl VtkBox for vtkBox { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_new(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_box_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_box_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_box_evaluate_gradient(self.0, x, n) } + } + fn set_x_min(&mut self, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_box_set_x_min(sself: *mut core::ffi::c_void, p: core::ffi::c_double); + } + unsafe { vtk_box_set_x_min(self.0, p) } + } + fn set_x_min( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_set_x_min( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_box_set_x_min(self.0, x, y, z) } + } + fn get_x_min(&mut self, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_box_get_x_min(sself: *mut core::ffi::c_void, p: core::ffi::c_double); + } + unsafe { vtk_box_get_x_min(self.0, p) } + } + fn get_x_min( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_get_x_min( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_box_get_x_min(self.0, x, y, z) } + } + fn set_x_max(&mut self, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_box_set_x_max(sself: *mut core::ffi::c_void, p: core::ffi::c_double); + } + unsafe { vtk_box_set_x_max(self.0, p) } + } + fn set_x_max( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_set_x_max( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_box_set_x_max(self.0, x, y, z) } + } + fn get_x_max(&mut self, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_box_get_x_max(sself: *mut core::ffi::c_void, p: core::ffi::c_double); + } + unsafe { vtk_box_get_x_max(self.0, p) } + } + fn get_x_max( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_get_x_max( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_box_get_x_max(self.0, x, y, z) } + } + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_set_bounds( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ); + } + unsafe { vtk_box_set_bounds(self.0, xMin, xMax, yMin, yMax, zMin, zMax) } + } + fn set_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_box_set_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_box_set_bounds(self.0, bounds) } + } + fn get_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_get_bounds( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ); + } + unsafe { vtk_box_get_bounds(self.0, xMin, xMax, yMin, yMax, zMin, zMax) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_box_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_box_get_bounds(self.0, bounds) } + } + fn get_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_box_get_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_box_get_bounds(self.0) } + } + fn add_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_box_add_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_box_add_bounds(self.0, bounds) } + } + fn intersect_box( + &mut self, + bounds: core::ffi::c_double, + origin: core::ffi::c_double, + dir: core::ffi::c_double, + coord: core::ffi::c_double, + t: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_char { + unsafe extern "C" { + fn vtk_box_intersect_box( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + origin: core::ffi::c_double, + dir: core::ffi::c_double, + coord: core::ffi::c_double, + t: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_char; + } + unsafe { + vtk_box_intersect_box(self.0, bounds, origin, dir, coord, t, tolerance) + } + } + fn intersect_with_line( + &mut self, + bounds: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + plane1: core::ffi::c_int, + plane2: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_box_intersect_with_line( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + plane1: core::ffi::c_int, + plane2: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_box_intersect_with_line( + self.0, + bounds, + p1, + p2, + t1, + t2, + x1, + x2, + plane1, + plane2, + ) + } + } + fn intersect_with_infinite_line( + &mut self, + bounds: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + plane1: core::ffi::c_int, + plane2: core::ffi::c_int, + ) -> bool { + unsafe extern "C" { + fn vtk_box_intersect_with_infinite_line( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + plane1: core::ffi::c_int, + plane2: core::ffi::c_int, + ) -> bool; + } + unsafe { + vtk_box_intersect_with_infinite_line( + self.0, + bounds, + p1, + p2, + t1, + t2, + x1, + x2, + plane1, + plane2, + ) + } + } + fn intersect_with_plane( + &mut self, + bounds: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_box_intersect_with_plane( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_box_intersect_with_plane(self.0, bounds, origin, normal) } + } + fn intersect_with_plane( + &mut self, + bounds: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + xout: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_box_intersect_with_plane( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + xout: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_box_intersect_with_plane(self.0, bounds, origin, normal, xout) } + } + fn is_box_in_frustum( + &mut self, + planes: core::ffi::c_double, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_box_is_box_in_frustum( + sself: *mut core::ffi::c_void, + planes: core::ffi::c_double, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_box_is_box_in_frustum(self.0, planes, bounds) } + } +} +impl VtkCellArray for vtkCellArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_array_allocate(self.0, sz, ext) } + } + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_uchar, + maxCellSize: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_cell_array_allocate_estimate( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + maxCellSize: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_cell_array_allocate_estimate(self.0, numCells, maxCellSize) } + } + fn allocate_exact( + &mut self, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_cell_array_allocate_exact( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_cell_array_allocate_exact(self.0, numCells, connectivitySize) } + } + fn allocate_copy(&mut self, other: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_cell_array_allocate_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_allocate_copy(self.0, other) } + } + fn resize_exact( + &mut self, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_cell_array_resize_exact( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_cell_array_resize_exact(self.0, numCells, connectivitySize) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_initialize(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_reset(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_squeeze(self.0) } + } + fn is_valid(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_is_valid(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_cell_array_is_valid(self.0) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_get_number_of_cells(self.0) } + } + fn get_number_of_offsets(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_get_number_of_offsets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_get_number_of_offsets(self.0) } + } + fn get_number_of_connectivity_ids(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_get_number_of_connectivity_ids( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_get_number_of_connectivity_ids(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_new_iterator(self.0) } + } + fn set_data( + &mut self, + offsets: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_cell_array_set_data( + sself: *mut core::ffi::c_void, + offsets: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_set_data(self.0, offsets, connectivity) } + } + fn set_data( + &mut self, + cellSize: core::ffi::c_uchar, + connectivity: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_cell_array_set_data( + sself: *mut core::ffi::c_void, + cellSize: core::ffi::c_uchar, + connectivity: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_set_data(self.0, cellSize, connectivity) } + } + fn is_storage_64_bit(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_is_storage_64_bit(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_cell_array_is_storage_64_bit(self.0) } + } + fn is_storage_shareable(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_is_storage_shareable( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_is_storage_shareable(self.0) } + } + fn use_32_bit_storage(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_use_32_bit_storage(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_use_32_bit_storage(self.0) } + } + fn use_64_bit_storage(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_use_64_bit_storage(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_use_64_bit_storage(self.0) } + } + fn use_default_storage(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_use_default_storage(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_use_default_storage(self.0) } + } + fn can_convert_to_32_bit_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_can_convert_to_32_bit_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_can_convert_to_32_bit_storage(self.0) } + } + fn can_convert_to_64_bit_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_can_convert_to_64_bit_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_can_convert_to_64_bit_storage(self.0) } + } + fn can_convert_to_default_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_can_convert_to_default_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_can_convert_to_default_storage(self.0) } + } + fn convert_to_32_bit_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_convert_to_32_bit_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_convert_to_32_bit_storage(self.0) } + } + fn convert_to_64_bit_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_convert_to_64_bit_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_convert_to_64_bit_storage(self.0) } + } + fn convert_to_default_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_convert_to_default_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_convert_to_default_storage(self.0) } + } + fn convert_to_smallest_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_convert_to_smallest_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_convert_to_smallest_storage(self.0) } + } + fn get_offsets_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_offsets_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_offsets_array(self.0) } + } + fn get_offsets_array_32(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_offsets_array_32( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_offsets_array_32(self.0) } + } + fn get_offsets_array_64(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_offsets_array_64( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_offsets_array_64(self.0) } + } + fn get_connectivity_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_connectivity_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_connectivity_array(self.0) } + } + fn get_connectivity_array_32(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_connectivity_array_32( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_connectivity_array_32(self.0) } + } + fn get_connectivity_array_64(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_connectivity_array_64( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_connectivity_array_64(self.0) } + } + fn is_homogeneous(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_is_homogeneous( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_is_homogeneous(self.0) } + } + fn init_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_init_traversal(self.0) } + } + fn get_next_cell( + &mut self, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_array_get_next_cell( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_array_get_next_cell(self.0, npts, pts) } + } + fn get_next_cell(&mut self, pts: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_array_get_next_cell( + sself: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_array_get_next_cell(self.0, pts) } + } + fn get_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + cellSize: core::ffi::c_uchar, + cellPoints: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_get_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cellSize: core::ffi::c_uchar, + cellPoints: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_get_cell_at_id(self.0, cellId, cellSize, cellPoints) } + } + fn get_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + pts: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_get_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + pts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_get_cell_at_id(self.0, cellId, pts) } + } + fn get_cell_size(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_get_cell_size( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_get_cell_size(self.0, cellId) } + } + fn insert_next_cell(&mut self, cell: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_insert_next_cell( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_insert_next_cell(self.0, cell) } + } + fn insert_next_cell( + &mut self, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_insert_next_cell( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_insert_next_cell(self.0, npts, pts) } + } + fn insert_next_cell(&mut self, pts: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_insert_next_cell( + sself: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_insert_next_cell(self.0, pts) } + } + fn insert_next_cell( + &mut self, + cell: std::collections::LinkedList, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_insert_next_cell( + sself: *mut core::ffi::c_void, + cell: std::collections::LinkedList, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_insert_next_cell(self.0, cell) } + } + fn insert_next_cell(&mut self, npts: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_insert_next_cell( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_insert_next_cell(self.0, npts) } + } + fn insert_cell_point(&mut self, id: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_cell_array_insert_cell_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_insert_cell_point(self.0, id) } + } + fn update_cell_count(&mut self, npts: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_array_update_cell_count( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_int, + ); + } + unsafe { vtk_cell_array_update_cell_count(self.0, npts) } + } + fn get_traversal_cell_id(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_get_traversal_cell_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_get_traversal_cell_id(self.0) } + } + fn set_traversal_cell_id(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_cell_array_set_traversal_cell_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_set_traversal_cell_id(self.0, cellId) } + } + fn reverse_cell_at_id(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_cell_array_reverse_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_reverse_cell_at_id(self.0, cellId) } + } + fn replace_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + list: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_replace_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + list: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_replace_cell_at_id(self.0, cellId, list) } + } + fn replace_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + cellSize: core::ffi::c_uchar, + cellPoints: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_replace_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cellSize: core::ffi::c_uchar, + cellPoints: core::ffi::c_uchar, + ); + } + unsafe { + vtk_cell_array_replace_cell_at_id(self.0, cellId, cellSize, cellPoints) + } + } + fn replace_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + cell: std::collections::LinkedList, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_replace_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cell: std::collections::LinkedList, + ); + } + unsafe { vtk_cell_array_replace_cell_at_id(self.0, cellId, cell) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_array_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_array_get_max_cell_size(self.0) } + } + fn deep_copy(&mut self, ca: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_deep_copy( + sself: *mut core::ffi::c_void, + ca: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_deep_copy(self.0, ca) } + } + fn shallow_copy(&mut self, ca: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_shallow_copy( + sself: *mut core::ffi::c_void, + ca: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_shallow_copy(self.0, ca) } + } + fn append( + &mut self, + src: *mut core::ffi::c_void, + pointOffset: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_append( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + pointOffset: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_append(self.0, src, pointOffset) } + } + fn export_legacy_format(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_export_legacy_format( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_export_legacy_format(self.0, data) } + } + fn import_legacy_format(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_import_legacy_format( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_import_legacy_format(self.0, data) } + } + fn import_legacy_format( + &mut self, + data: core::ffi::c_uchar, + len: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_import_legacy_format( + sself: *mut core::ffi::c_void, + data: core::ffi::c_uchar, + len: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_import_legacy_format(self.0, data, len) } + } + fn append_legacy_format( + &mut self, + data: *mut core::ffi::c_void, + ptOffset: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_append_legacy_format( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ptOffset: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_append_legacy_format(self.0, data, ptOffset) } + } + fn append_legacy_format( + &mut self, + data: core::ffi::c_uchar, + len: core::ffi::c_uchar, + ptOffset: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_append_legacy_format( + sself: *mut core::ffi::c_void, + data: core::ffi::c_uchar, + len: core::ffi::c_uchar, + ptOffset: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_append_legacy_format(self.0, data, len, ptOffset) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_cell_array_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_cell_array_get_actual_memory_size(self.0) } + } + fn set_number_of_cells(&mut self, p0: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_cell_array_set_number_of_cells( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_set_number_of_cells(self.0, p0) } + } + fn estimate_size( + &mut self, + numCells: core::ffi::c_uchar, + maxPtsPerCell: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_estimate_size( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + maxPtsPerCell: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_estimate_size(self.0, numCells, maxPtsPerCell) } + } + fn get_size(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_get_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_get_size(self.0) } + } + fn get_number_of_connectivity_entries(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_get_number_of_connectivity_entries( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_get_number_of_connectivity_entries(self.0) } + } + fn get_cell( + &mut self, + loc: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_get_cell( + sself: *mut core::ffi::c_void, + loc: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_get_cell(self.0, loc, npts, pts) } + } + fn get_cell(&mut self, loc: core::ffi::c_uchar, pts: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_get_cell( + sself: *mut core::ffi::c_void, + loc: core::ffi::c_uchar, + pts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_get_cell(self.0, loc, pts) } + } + fn get_insert_location(&mut self, npts: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_get_insert_location( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_get_insert_location(self.0, npts) } + } + fn get_traversal_location(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_get_traversal_location( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_get_traversal_location(self.0) } + } + fn get_traversal_location( + &mut self, + npts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_get_traversal_location( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_get_traversal_location(self.0, npts) } + } + fn set_traversal_location(&mut self, loc: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_cell_array_set_traversal_location( + sself: *mut core::ffi::c_void, + loc: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_set_traversal_location(self.0, loc) } + } + fn reverse_cell(&mut self, loc: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_cell_array_reverse_cell( + sself: *mut core::ffi::c_void, + loc: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_reverse_cell(self.0, loc) } + } + fn replace_cell( + &mut self, + loc: core::ffi::c_uchar, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_replace_cell( + sself: *mut core::ffi::c_void, + loc: core::ffi::c_uchar, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_replace_cell(self.0, loc, npts, pts) } + } + fn set_cells( + &mut self, + ncells: core::ffi::c_uchar, + cells: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_set_cells( + sself: *mut core::ffi::c_void, + ncells: core::ffi::c_uchar, + cells: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_set_cells(self.0, ncells, cells) } + } + fn get_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_data(self.0) } + } +} +impl VtkCellArrayIterator for vtkCellArrayIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_iterator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_iterator_new(self.0) } + } + fn get_cell_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_iterator_get_cell_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_iterator_get_cell_array(self.0) } + } + fn go_to_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_go_to_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_iterator_go_to_cell(self.0, cellId) } + } + fn get_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + numCellPts: core::ffi::c_uchar, + cellPts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_get_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + numCellPts: core::ffi::c_uchar, + cellPts: core::ffi::c_uchar, + ); + } + unsafe { + vtk_cell_array_iterator_get_cell_at_id(self.0, cellId, numCellPts, cellPts) + } + } + fn get_cell_at_id( + &mut self, + cellId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_get_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_iterator_get_cell_at_id(self.0, cellId, cellIds) } + } + fn get_cell_at_id(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_iterator_get_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_iterator_get_cell_at_id(self.0, cellId) } + } + fn go_to_first_cell(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_go_to_first_cell(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_iterator_go_to_first_cell(self.0) } + } + fn go_to_next_cell(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_go_to_next_cell(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_iterator_go_to_next_cell(self.0) } + } + fn is_done_with_traversal(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_iterator_is_done_with_traversal(self.0) } + } + fn get_current_cell_id(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_array_iterator_get_current_cell_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_array_iterator_get_current_cell_id(self.0) } + } + fn get_current_cell( + &mut self, + cellSize: core::ffi::c_uchar, + cellPoints: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_get_current_cell( + sself: *mut core::ffi::c_void, + cellSize: core::ffi::c_uchar, + cellPoints: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_iterator_get_current_cell(self.0, cellSize, cellPoints) } + } + fn get_current_cell(&mut self, ids: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_get_current_cell( + sself: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_iterator_get_current_cell(self.0, ids) } + } + fn get_current_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_iterator_get_current_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_iterator_get_current_cell(self.0) } + } + fn replace_current_cell(&mut self, list: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_replace_current_cell( + sself: *mut core::ffi::c_void, + list: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_iterator_replace_current_cell(self.0, list) } + } + fn replace_current_cell( + &mut self, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_replace_current_cell( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_array_iterator_replace_current_cell(self.0, npts, pts) } + } + fn reverse_current_cell(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_reverse_current_cell( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_iterator_reverse_current_cell(self.0) } + } +} +impl VtkCellData for vtkCellData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_data_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_data_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_data_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_data_new_instance(self.0) } + } +} +impl VtkCellLinks for vtkCellLinks { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_links_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_links_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_links_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_links_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_links_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_links_new_instance(self.0) } + } + fn build_links(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_links_build_links( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_links_build_links(self.0, data) } + } + fn allocate(&mut self, numLinks: core::ffi::c_uchar, ext: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_cell_links_allocate( + sself: *mut core::ffi::c_void, + numLinks: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_links_allocate(self.0, numLinks, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_links_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_links_initialize(self.0) } + } + fn get_link(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_links_get_link( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_links_get_link(self.0, ptId) } + } + fn get_ncells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_links_get_ncells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_links_get_ncells(self.0, ptId) } + } + fn get_cells(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_links_get_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_cell_links_get_cells(self.0, ptId) } + } + fn select_cells( + &mut self, + minMaxDegree: core::ffi::c_uchar, + cellSelection: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_links_select_cells( + sself: *mut core::ffi::c_void, + minMaxDegree: core::ffi::c_uchar, + cellSelection: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_links_select_cells(self.0, minMaxDegree, cellSelection) } + } + fn insert_next_point(&mut self, numLinks: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_links_insert_next_point( + sself: *mut core::ffi::c_void, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_links_insert_next_point(self.0, numLinks) } + } + fn insert_next_cell_reference( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_links_insert_next_cell_reference( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_links_insert_next_cell_reference(self.0, ptId, cellId) } + } + fn delete_point(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_cell_links_delete_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_links_delete_point(self.0, ptId) } + } + fn remove_cell_reference( + &mut self, + cellId: core::ffi::c_uchar, + ptId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_links_remove_cell_reference( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_links_remove_cell_reference(self.0, cellId, ptId) } + } + fn add_cell_reference( + &mut self, + cellId: core::ffi::c_uchar, + ptId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_links_add_cell_reference( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_links_add_cell_reference(self.0, cellId, ptId) } + } + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_uchar, + size: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_cell_links_resize_cell_list( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + size: core::ffi::c_int, + ); + } + unsafe { vtk_cell_links_resize_cell_list(self.0, ptId, size) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_links_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_links_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_links_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_links_reset(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_cell_links_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_cell_links_get_actual_memory_size(self.0) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_links_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_links_deep_copy(self.0, src) } + } +} +impl VtkCellLocator for vtkCellLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_new(self.0) } + } + fn set_number_of_cells_per_bucket(&mut self, N: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_locator_set_number_of_cells_per_bucket( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + ); + } + unsafe { vtk_cell_locator_set_number_of_cells_per_bucket(self.0, N) } + } + fn get_number_of_cells_per_bucket(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_locator_get_number_of_cells_per_bucket( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_locator_get_number_of_cells_per_bucket(self.0) } + } + fn intersect_with_line( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_locator_intersect_with_line( + sself: *mut core::ffi::c_void, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_cell_locator_intersect_with_line( + self.0, + a0, + a1, + tol, + t, + x, + pcoords, + subId, + cellId, + cell, + ) + } + } + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cell_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + ); + } + unsafe { + vtk_cell_locator_find_closest_point( + self.0, + x, + closestPoint, + cell, + cellId, + subId, + dist2, + ) + } + } + fn find_closest_point_within_radius( + &mut self, + x: core::ffi::c_double, + radius: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + inside: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_locator_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + radius: core::ffi::c_double, + closestPoint: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + subId: core::ffi::c_int, + dist2: core::ffi::c_double, + inside: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_cell_locator_find_closest_point_within_radius( + self.0, + x, + radius, + closestPoint, + cell, + cellId, + subId, + dist2, + inside, + ) + } + } + fn get_cells(&mut self, bucket: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_get_cells( + sself: *mut core::ffi::c_void, + bucket: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_get_cells(self.0, bucket) } + } + fn get_number_of_buckets(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_locator_get_number_of_buckets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_locator_get_number_of_buckets(self.0) } + } + fn find_cells_along_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tolerance: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_locator_find_cells_along_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tolerance: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_cell_locator_find_cells_along_line(self.0, p1, p2, tolerance, cells) + } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_locator_free_search_structure(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_locator_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_locator_build_locator(self.0) } + } + fn build_locator_if_needed(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_locator_build_locator_if_needed(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_locator_build_locator_if_needed(self.0) } + } + fn force_build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_locator_force_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_locator_force_build_locator(self.0) } + } + fn build_locator_internal(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_locator_build_locator_internal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_locator_build_locator_internal(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_locator_generate_representation(self.0, level, pd) } + } +} +impl VtkCellLocatorStrategy for vtkCellLocatorStrategy { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_strategy_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_strategy_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_strategy_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_strategy_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_strategy_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_strategy_new_instance(self.0) } + } + fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_locator_strategy_initialize( + sself: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_locator_strategy_initialize(self.0, ps) } + } + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_locator_strategy_find_cell( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_cell_locator_strategy_find_cell( + self.0, + x, + cell, + gencell, + cellId, + tol2, + subId, + pcoords, + weights, + ) + } + } + fn set_cell_locator(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_locator_strategy_set_cell_locator( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_locator_strategy_set_cell_locator(self.0, p0) } + } + fn get_cell_locator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_strategy_get_cell_locator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_strategy_get_cell_locator(self.0) } + } +} +impl VtkCellTypes for vtkCellTypes { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_types_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_types_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_types_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_types_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_types_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_types_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_types_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_types_allocate(self.0, sz, ext) } + } + fn insert_cell( + &mut self, + id: core::ffi::c_uchar, + type_: core::ffi::c_uchar, + loc: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_cell_types_insert_cell( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + type_: core::ffi::c_uchar, + loc: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_types_insert_cell(self.0, id, type_, loc) } + } + fn insert_next_cell( + &mut self, + type_: core::ffi::c_uchar, + loc: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_types_insert_next_cell( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_uchar, + loc: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_types_insert_next_cell(self.0, type_, loc) } + } + fn set_cell_types( + &mut self, + ncells: core::ffi::c_uchar, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_types_set_cell_types( + sself: *mut core::ffi::c_void, + ncells: core::ffi::c_uchar, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_cell_types_set_cell_types(self.0, ncells, cellTypes, cellLocations) + } + } + fn set_cell_types( + &mut self, + ncells: core::ffi::c_uchar, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_types_set_cell_types( + sself: *mut core::ffi::c_void, + ncells: core::ffi::c_uchar, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_cell_types_set_cell_types(self.0, ncells, cellTypes, cellLocations) + } + } + fn get_cell_location(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_types_get_cell_location( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_types_get_cell_location(self.0, cellId) } + } + fn delete_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_cell_types_delete_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_cell_types_delete_cell(self.0, cellId) } + } + fn get_number_of_types(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_types_get_number_of_types( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_types_get_number_of_types(self.0) } + } + fn is_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_types_is_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_types_is_type(self.0, type_) } + } + fn insert_next_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_types_insert_next_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_types_insert_next_type(self.0, type_) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_types_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_types_get_cell_type(self.0, cellId) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_types_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_types_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_types_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_types_reset(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_cell_types_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_cell_types_get_actual_memory_size(self.0) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_types_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_types_deep_copy(self.0, src) } + } + fn get_class_name_from_type_id( + &mut self, + typeId: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_cell_types_get_class_name_from_type_id( + sself: *mut core::ffi::c_void, + typeId: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_cell_types_get_class_name_from_type_id(self.0, typeId) } + } + fn get_type_id_from_class_name( + &mut self, + classname: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_types_get_type_id_from_class_name( + sself: *mut core::ffi::c_void, + classname: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_types_get_type_id_from_class_name(self.0, classname) } + } + fn is_linear(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_types_is_linear( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_types_is_linear(self.0, type_) } + } + fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_types_get_cell_types_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_types_get_cell_types_array(self.0) } + } + fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_types_get_cell_locations_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_types_get_cell_locations_array(self.0) } + } +} +impl VtkClosestNPointsStrategy for vtkClosestNPointsStrategy { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_n_points_strategy_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_n_points_strategy_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_n_points_strategy_new_instance(self.0) } + } + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_find_cell( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_closest_n_points_strategy_find_cell( + self.0, + x, + cell, + gencell, + cellId, + tol2, + subId, + pcoords, + weights, + ) + } + } + fn set_closest_n_points(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_set_closest_n_points( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_closest_n_points_strategy_set_closest_n_points(self.0, _arg) } + } + fn get_closest_n_points_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_get_closest_n_points_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_closest_n_points_strategy_get_closest_n_points_min_value(self.0) } + } + fn get_closest_n_points_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_get_closest_n_points_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_closest_n_points_strategy_get_closest_n_points_max_value(self.0) } + } + fn get_closest_n_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_get_closest_n_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_closest_n_points_strategy_get_closest_n_points(self.0) } + } +} +impl VtkClosestPointStrategy for vtkClosestPointStrategy { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_point_strategy_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_point_strategy_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_point_strategy_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_point_strategy_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_point_strategy_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_point_strategy_new_instance(self.0) } + } + fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_closest_point_strategy_initialize( + sself: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_closest_point_strategy_initialize(self.0, ps) } + } + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_closest_point_strategy_find_cell( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_closest_point_strategy_find_cell( + self.0, + x, + cell, + gencell, + cellId, + tol2, + subId, + pcoords, + weights, + ) + } + } + fn set_point_locator(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_closest_point_strategy_set_point_locator( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_closest_point_strategy_set_point_locator(self.0, p0) } + } + fn get_point_locator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_point_strategy_get_point_locator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_point_strategy_get_point_locator(self.0) } + } + fn select_cell( + &mut self, + self_: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_point_strategy_select_cell( + sself: *mut core::ffi::c_void, + self_: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_closest_point_strategy_select_cell(self.0, self_, cellId, cell, gencell) + } + } +} +impl VtkCone for vtkCone { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_new_instance(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cone_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + g: core::ffi::c_double, + ); + } + unsafe { vtk_cone_evaluate_gradient(self.0, x, g) } + } + fn set_angle(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cone_set_angle( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cone_set_angle(self.0, _arg) } + } + fn get_angle_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_get_angle_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_get_angle_min_value(self.0) } + } + fn get_angle_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_get_angle_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_get_angle_max_value(self.0) } + } + fn get_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_get_angle(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_cone_get_angle(self.0) } + } +} +impl VtkConvexPointSet for vtkConvexPointSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_convex_point_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_convex_point_set_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_convex_point_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_convex_point_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_convex_point_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_convex_point_set_new_instance(self.0) } + } + fn has_fixed_topology(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_has_fixed_topology( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_has_fixed_topology(self.0) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_convex_point_set_get_edge_points(self.0, edgeId, pts) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_convex_point_set_get_edge_points(self.0, edgeId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_convex_point_set_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_convex_point_set_get_face_points(self.0, faceId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_convex_point_set_get_face_points(self.0, faceId, pts) } + } + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_get_edge_to_adjacent_faces( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_convex_point_set_get_edge_to_adjacent_faces(self.0, edgeId, pts) } + } + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_convex_point_set_get_face_to_adjacent_faces( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_convex_point_set_get_face_to_adjacent_faces(self.0, faceId, faceIds) + } + } + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_convex_point_set_get_point_to_incident_edges( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_convex_point_set_get_point_to_incident_edges(self.0, pointId, edgeIds) + } + } + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_convex_point_set_get_point_to_incident_faces( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_convex_point_set_get_point_to_incident_faces(self.0, pointId, faceIds) + } + } + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_convex_point_set_get_point_to_one_ring_points( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_convex_point_set_get_point_to_one_ring_points(self.0, pointId, pts) + } + } + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_convex_point_set_get_centroid( + sself: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_convex_point_set_get_centroid(self.0, centroid) } + } + fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_convex_point_set_get_parametric_coords( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_convex_point_set_get_parametric_coords(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_get_cell_type(self.0) } + } + fn requires_initialization(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_requires_initialization( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_requires_initialization(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_get_number_of_edges(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_convex_point_set_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_convex_point_set_get_edge(self.0, p0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_get_number_of_faces(self.0) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_convex_point_set_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_convex_point_set_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_convex_point_set_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_convex_point_set_clip( + self.0, + value, + cellScalars, + locator, + connectivity, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_convex_point_set_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_convex_point_set_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_convex_point_set_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_convex_point_set_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_cell_boundary(self.0, subId, pcoords, pts) } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_get_parametric_center(self.0, pcoords) } + } + fn is_primary_cell(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_is_primary_cell( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_is_primary_cell(self.0) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ); + } + unsafe { vtk_convex_point_set_interpolate_functions(self.0, pcoords, sf) } + } +} +impl VtkCubicLine for vtkCubicLine { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cubic_line_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cubic_line_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cubic_line_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cubic_line_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cubic_line_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cubic_line_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cubic_line_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cubic_line_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cubic_line_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cubic_line_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cubic_line_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_cubic_line_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_cubic_line_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cubic_line_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_cubic_line_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cubic_line_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_cubic_line_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cubic_line_get_parametric_distance( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_cubic_line_get_parametric_distance(self.0, pcoords) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_cubic_line_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_cubic_line_clip( + self.0, + value, + cellScalars, + locator, + lines, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_get_parametric_center(self.0, pcoords) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_cubic_line_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cubic_line_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_cubic_line_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cubic_line_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_cubic_line_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cubic_line_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_cubic_line_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cubic_line_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_cubic_line_interpolate_derivs(self.0, pcoords, derivs) } + } +} +impl VtkCylinder for vtkCylinder { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_new(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cylinder_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + g: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_evaluate_gradient(self.0, x, g) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cylinder_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cylinder_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_center(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cylinder_set_center( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_set_center(self.0, _arg) } + } + fn get_center(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_get_center( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_cylinder_get_center(self.0) } + } + fn get_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cylinder_get_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_get_center(self.0, _arg1, _arg2, _arg3) } + } + fn get_center(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cylinder_get_center( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_get_center(self.0, _arg) } + } + fn set_axis( + &mut self, + ax: core::ffi::c_double, + ay: core::ffi::c_double, + az: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cylinder_set_axis( + sself: *mut core::ffi::c_void, + ax: core::ffi::c_double, + ay: core::ffi::c_double, + az: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_set_axis(self.0, ax, ay, az) } + } + fn set_axis(&mut self, a: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cylinder_set_axis( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_set_axis(self.0, a) } + } + fn get_axis(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_get_axis( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_cylinder_get_axis(self.0) } + } + fn get_axis( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cylinder_get_axis( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_get_axis(self.0, _arg1, _arg2, _arg3) } + } + fn get_axis(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cylinder_get_axis( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_get_axis(self.0, _arg) } + } +} +impl VtkDataAssembly for vtkDataAssembly { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_assembly_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_assembly_initialize(self.0) } + } + fn initialize_from_xml(&mut self, xmlcontents: core::ffi::c_char) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_initialize_from_xml( + sself: *mut core::ffi::c_void, + xmlcontents: core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_data_assembly_initialize_from_xml(self.0, xmlcontents) } + } + fn serialize_to_xml(&mut self, indent: *mut core::ffi::c_void) -> &str { + unsafe extern "C" { + fn vtk_data_assembly_serialize_to_xml( + sself: *mut core::ffi::c_void, + indent: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_data_assembly_serialize_to_xml(self.0, indent) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_root_node(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_root_node( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_root_node(self.0) } + } + fn set_root_node_name(&mut self, name: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_data_assembly_set_root_node_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ); + } + unsafe { vtk_data_assembly_set_root_node_name(self.0, name) } + } + fn get_root_node_name(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_data_assembly_get_root_node_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_data_assembly_get_root_node_name(self.0) } + } + fn add_node( + &mut self, + name: core::ffi::c_char, + parent: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_add_node( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + parent: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_add_node(self.0, name, parent) } + } + fn add_nodes( + &mut self, + names: Vec, + parent: core::ffi::c_int, + ) -> Vec { + unsafe extern "C" { + fn vtk_data_assembly_add_nodes( + sself: *mut core::ffi::c_void, + names: Vec, + parent: core::ffi::c_int, + ) -> Vec; + } + unsafe { vtk_data_assembly_add_nodes(self.0, names, parent) } + } + fn add_subtree( + &mut self, + parent: core::ffi::c_int, + other: *mut core::ffi::c_void, + otherParent: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_add_subtree( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_int, + other: *mut core::ffi::c_void, + otherParent: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_add_subtree(self.0, parent, other, otherParent) } + } + fn remove_node(&mut self, id: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_remove_node( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_data_assembly_remove_node(self.0, id) } + } + fn set_node_name(&mut self, id: core::ffi::c_int, name: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_data_assembly_set_node_name( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + ); + } + unsafe { vtk_data_assembly_set_node_name(self.0, id, name) } + } + fn get_node_name(&mut self, id: core::ffi::c_int) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_data_assembly_get_node_name( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_data_assembly_get_node_name(self.0, id) } + } + fn get_node_path(&mut self, id: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_data_assembly_get_node_path( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_data_assembly_get_node_path(self.0, id) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_first_node_by_path(&mut self, path: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_first_node_by_path( + sself: *mut core::ffi::c_void, + path: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_first_node_by_path(self.0, path) } + } + fn add_data_set_index( + &mut self, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_add_data_set_index( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool; + } + unsafe { vtk_data_assembly_add_data_set_index(self.0, id, dataset_index) } + } + fn add_data_set_indices( + &mut self, + id: core::ffi::c_int, + dataset_indices: Vec, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_add_data_set_indices( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + dataset_indices: Vec, + ) -> bool; + } + unsafe { vtk_data_assembly_add_data_set_indices(self.0, id, dataset_indices) } + } + fn add_data_set_index_range( + &mut self, + id: core::ffi::c_int, + index_start: core::ffi::c_uint, + count: core::ffi::c_int, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_add_data_set_index_range( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + index_start: core::ffi::c_uint, + count: core::ffi::c_int, + ) -> bool; + } + unsafe { + vtk_data_assembly_add_data_set_index_range(self.0, id, index_start, count) + } + } + fn remove_data_set_index( + &mut self, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_remove_data_set_index( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool; + } + unsafe { vtk_data_assembly_remove_data_set_index(self.0, id, dataset_index) } + } + fn remove_all_data_set_indices( + &mut self, + id: core::ffi::c_int, + traverse_subtree: bool, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_remove_all_data_set_indices( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + traverse_subtree: bool, + ) -> bool; + } + unsafe { + vtk_data_assembly_remove_all_data_set_indices(self.0, id, traverse_subtree) + } + } + fn find_first_node_with_name( + &mut self, + name: core::ffi::c_char, + traversal_order: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_find_first_node_with_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + traversal_order: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_assembly_find_first_node_with_name(self.0, name, traversal_order) + } + } + fn find_nodes_with_name( + &mut self, + name: core::ffi::c_char, + sort_order: core::ffi::c_int, + ) -> Vec { + unsafe extern "C" { + fn vtk_data_assembly_find_nodes_with_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + sort_order: core::ffi::c_int, + ) -> Vec; + } + unsafe { vtk_data_assembly_find_nodes_with_name(self.0, name, sort_order) } + } + fn get_child_nodes( + &mut self, + parent: core::ffi::c_int, + traverse_subtree: bool, + traversal_order: core::ffi::c_int, + ) -> Vec { + unsafe extern "C" { + fn vtk_data_assembly_get_child_nodes( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_int, + traverse_subtree: bool, + traversal_order: core::ffi::c_int, + ) -> Vec; + } + unsafe { + vtk_data_assembly_get_child_nodes( + self.0, + parent, + traverse_subtree, + traversal_order, + ) + } + } + fn get_number_of_children(&mut self, parent: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_number_of_children( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_number_of_children(self.0, parent) } + } + fn get_child( + &mut self, + parent: core::ffi::c_int, + index: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_child( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_int, + index: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_child(self.0, parent, index) } + } + fn get_child_index( + &mut self, + parent: core::ffi::c_int, + child: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_child_index( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_int, + child: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_child_index(self.0, parent, child) } + } + fn get_parent(&mut self, id: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_parent( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_parent(self.0, id) } + } + fn has_attribute(&mut self, id: core::ffi::c_int, name: core::ffi::c_char) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_has_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_data_assembly_has_attribute(self.0, id, name) } + } + fn set_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_data_assembly_set_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_char, + ); + } + unsafe { vtk_data_assembly_set_attribute(self.0, id, name, value) } + } + fn set_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_assembly_set_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_int, + ); + } + unsafe { vtk_data_assembly_set_attribute(self.0, id, name, value) } + } + fn set_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_data_assembly_set_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uint, + ); + } + unsafe { vtk_data_assembly_set_attribute(self.0, id, name, value) } + } + fn set_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_assembly_set_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uchar, + ); + } + unsafe { vtk_data_assembly_set_attribute(self.0, id, name, value) } + } + fn get_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_char, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_get_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_data_assembly_get_attribute(self.0, id, name, value) } + } + fn get_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_get_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_data_assembly_get_attribute(self.0, id, name, value) } + } + fn get_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uint, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_get_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uint, + ) -> bool; + } + unsafe { vtk_data_assembly_get_attribute(self.0, id, name, value) } + } + fn get_attribute( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_get_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + value: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_data_assembly_get_attribute(self.0, id, name, value) } + } + fn get_attribute_or_default( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_char, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_data_assembly_get_attribute_or_default( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_char, + ) -> *const core::ffi::c_char; + } + unsafe { + vtk_data_assembly_get_attribute_or_default(self.0, id, name, default_value) + } + } + fn get_attribute_or_default( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_attribute_or_default( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_assembly_get_attribute_or_default(self.0, id, name, default_value) + } + } + fn get_attribute_or_default( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_uint, + ) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_data_assembly_get_attribute_or_default( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_uint, + ) -> core::ffi::c_uint; + } + unsafe { + vtk_data_assembly_get_attribute_or_default(self.0, id, name, default_value) + } + } + fn get_attribute_or_default( + &mut self, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_data_assembly_get_attribute_or_default( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: core::ffi::c_char, + default_value: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_data_assembly_get_attribute_or_default(self.0, id, name, default_value) + } + } + fn visit( + &mut self, + visitor: *mut core::ffi::c_void, + traversal_order: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_assembly_visit( + sself: *mut core::ffi::c_void, + visitor: *mut core::ffi::c_void, + traversal_order: core::ffi::c_int, + ); + } + unsafe { vtk_data_assembly_visit(self.0, visitor, traversal_order) } + } + fn visit( + &mut self, + id: core::ffi::c_int, + visitor: *mut core::ffi::c_void, + traversal_order: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_assembly_visit( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + visitor: *mut core::ffi::c_void, + traversal_order: core::ffi::c_int, + ); + } + unsafe { vtk_data_assembly_visit(self.0, id, visitor, traversal_order) } + } + fn get_data_set_indices( + &mut self, + id: core::ffi::c_int, + traverse_subtree: bool, + traversal_order: core::ffi::c_int, + ) -> Vec { + unsafe extern "C" { + fn vtk_data_assembly_get_data_set_indices( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + traverse_subtree: bool, + traversal_order: core::ffi::c_int, + ) -> Vec; + } + unsafe { + vtk_data_assembly_get_data_set_indices( + self.0, + id, + traverse_subtree, + traversal_order, + ) + } + } + fn get_data_set_indices( + &mut self, + ids: Vec, + traverse_subtree: bool, + traversal_order: core::ffi::c_int, + ) -> Vec { + unsafe extern "C" { + fn vtk_data_assembly_get_data_set_indices( + sself: *mut core::ffi::c_void, + ids: Vec, + traverse_subtree: bool, + traversal_order: core::ffi::c_int, + ) -> Vec; + } + unsafe { + vtk_data_assembly_get_data_set_indices( + self.0, + ids, + traverse_subtree, + traversal_order, + ) + } + } + fn select_nodes( + &mut self, + path_queries: Vec, + traversal_order: core::ffi::c_int, + ) -> Vec { + unsafe extern "C" { + fn vtk_data_assembly_select_nodes( + sself: *mut core::ffi::c_void, + path_queries: Vec, + traversal_order: core::ffi::c_int, + ) -> Vec; + } + unsafe { vtk_data_assembly_select_nodes(self.0, path_queries, traversal_order) } + } + fn remap_data_set_indices( + &mut self, + mapping: std::collections::HashMap, + remove_unmapped: bool, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_remap_data_set_indices( + sself: *mut core::ffi::c_void, + mapping: std::collections::HashMap, + remove_unmapped: bool, + ) -> bool; + } + unsafe { + vtk_data_assembly_remap_data_set_indices(self.0, mapping, remove_unmapped) + } + } + fn subset_copy( + &mut self, + other: *mut core::ffi::c_void, + selected_branches: Vec, + ) -> () { + unsafe extern "C" { + fn vtk_data_assembly_subset_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + selected_branches: Vec, + ); + } + unsafe { vtk_data_assembly_subset_copy(self.0, other, selected_branches) } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_assembly_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_assembly_deep_copy(self.0, other) } + } + fn is_node_name_valid(&mut self, name: core::ffi::c_char) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_is_node_name_valid( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_data_assembly_is_node_name_valid(self.0, name) } + } + fn make_valid_node_name(&mut self, name: core::ffi::c_char) -> &str { + unsafe extern "C" { + fn vtk_data_assembly_make_valid_node_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_data_assembly_make_valid_node_name(self.0, name) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn is_node_name_reserved(&mut self, name: core::ffi::c_char) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_is_node_name_reserved( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_data_assembly_is_node_name_reserved(self.0, name) } + } +} +impl VtkDataAssemblyUtilities for vtkDataAssemblyUtilities { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_utilities_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_utilities_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_utilities_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_utilities_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_utilities_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_utilities_new_instance(self.0) } + } + fn hierarchy_name(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_data_assembly_utilities_hierarchy_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_data_assembly_utilities_hierarchy_name(self.0) } + } + fn generate_hierarchy( + &mut self, + input: *mut core::ffi::c_void, + hierarchy: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_utilities_generate_hierarchy( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + hierarchy: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_data_assembly_utilities_generate_hierarchy( + self.0, + input, + hierarchy, + output, + ) + } + } + fn get_selected_composite_ids( + &mut self, + selectors: Vec, + hierarchyOrAssembly: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + leaf_nodes_only: bool, + ) -> Vec { + unsafe extern "C" { + fn vtk_data_assembly_utilities_get_selected_composite_ids( + sself: *mut core::ffi::c_void, + selectors: Vec, + hierarchyOrAssembly: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + leaf_nodes_only: bool, + ) -> Vec; + } + unsafe { + vtk_data_assembly_utilities_get_selected_composite_ids( + self.0, + selectors, + hierarchyOrAssembly, + data, + leaf_nodes_only, + ) + } + } + fn get_selector_for_composite_id( + &mut self, + id: core::ffi::c_uint, + hierarchy: *mut core::ffi::c_void, + ) -> &str { + unsafe extern "C" { + fn vtk_data_assembly_utilities_get_selector_for_composite_id( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uint, + hierarchy: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_data_assembly_utilities_get_selector_for_composite_id( + self.0, + id, + hierarchy, + ) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_selectors_for_composite_ids( + &mut self, + ids: Vec, + hierarchy: *mut core::ffi::c_void, + ) -> Vec { + unsafe extern "C" { + fn vtk_data_assembly_utilities_get_selectors_for_composite_ids( + sself: *mut core::ffi::c_void, + ids: Vec, + hierarchy: *mut core::ffi::c_void, + ) -> Vec; + } + unsafe { + vtk_data_assembly_utilities_get_selectors_for_composite_ids( + self.0, + ids, + hierarchy, + ) + } + } +} +impl VtkDataObject for vtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_new_instance(self.0) } + } + fn get_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_information(self.0) } + } + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_set_information( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_set_information(self.0, p0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_data_object_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_data_object_get_m_time(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_object_initialize(self.0) } + } + fn release_data(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_release_data(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_object_release_data(self.0) } + } + fn get_data_released(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_data_released( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_get_data_released(self.0) } + } + fn set_global_release_data_flag(&mut self, val: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_object_set_global_release_data_flag( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ); + } + unsafe { vtk_data_object_set_global_release_data_flag(self.0, val) } + } + fn global_release_data_flag_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_global_release_data_flag_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_global_release_data_flag_on(self.0) } + } + fn global_release_data_flag_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_global_release_data_flag_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_global_release_data_flag_off(self.0) } + } + fn get_global_release_data_flag(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_global_release_data_flag( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_get_global_release_data_flag(self.0) } + } + fn set_field_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_set_field_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_set_field_data(self.0, p0) } + } + fn get_field_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_field_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_field_data(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_get_data_object_type(self.0) } + } + fn get_update_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_data_object_get_update_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_data_object_get_update_time(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_data_object_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_data_object_get_actual_memory_size(self.0) } + } + fn copy_information_from_pipeline(&mut self, info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_copy_information_from_pipeline( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_copy_information_from_pipeline(self.0, info) } + } + fn copy_information_to_pipeline(&mut self, info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_copy_information_to_pipeline( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_copy_information_to_pipeline(self.0, info) } + } + fn get_active_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_active_field_information( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_data_object_get_active_field_information( + self.0, + info, + fieldAssociation, + attributeType, + ) + } + } + fn get_named_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_named_field_information( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_data_object_get_named_field_information( + self.0, + info, + fieldAssociation, + name, + ) + } + } + fn remove_named_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_data_object_remove_named_field_information( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: core::ffi::c_char, + ); + } + unsafe { + vtk_data_object_remove_named_field_information( + self.0, + info, + fieldAssociation, + name, + ) + } + } + fn set_active_attribute( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeName: core::ffi::c_char, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_set_active_attribute( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeName: core::ffi::c_char, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_data_object_set_active_attribute( + self.0, + info, + fieldAssociation, + attributeName, + attributeType, + ) + } + } + fn set_active_attribute_info( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + name: core::ffi::c_char, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + numTuples: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_object_set_active_attribute_info( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + name: core::ffi::c_char, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + numTuples: core::ffi::c_int, + ); + } + unsafe { + vtk_data_object_set_active_attribute_info( + self.0, + info, + fieldAssociation, + attributeType, + name, + arrayType, + numComponents, + numTuples, + ) + } + } + fn set_point_data_active_scalar_info( + &mut self, + info: *mut core::ffi::c_void, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_object_set_point_data_active_scalar_info( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ); + } + unsafe { + vtk_data_object_set_point_data_active_scalar_info( + self.0, + info, + arrayType, + numComponents, + ) + } + } + fn data_has_been_generated(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_data_has_been_generated(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_object_data_has_been_generated(self.0) } + } + fn prepare_for_new_data(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_prepare_for_new_data(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_object_prepare_for_new_data(self.0) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_shallow_copy(self.0, src) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_deep_copy(self.0, src) } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_get_extent_type(self.0) } + } + fn crop(&mut self, updateExtent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_object_crop( + sself: *mut core::ffi::c_void, + updateExtent: core::ffi::c_int, + ); + } + unsafe { vtk_data_object_crop(self.0, updateExtent) } + } + fn get_attributes(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_attributes( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_attributes(self.0, type_) } + } + fn get_ghost_array(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_ghost_array( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_ghost_array(self.0, type_) } + } + fn get_attributes_as_field_data( + &mut self, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_attributes_as_field_data( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_attributes_as_field_data(self.0, type_) } + } + fn get_attribute_type_for_array( + &mut self, + arr: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_attribute_type_for_array( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_get_attribute_type_for_array(self.0, arr) } + } + fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_data_object_get_number_of_elements( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_data_object_get_number_of_elements(self.0, type_) } + } + fn get_association_type_as_string( + &mut self, + associationType: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_data_object_get_association_type_as_string( + sself: *mut core::ffi::c_void, + associationType: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { + vtk_data_object_get_association_type_as_string(self.0, associationType) + } + } + fn get_association_type_from_string( + &mut self, + associationName: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_association_type_from_string( + sself: *mut core::ffi::c_void, + associationName: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_object_get_association_type_from_string(self.0, associationName) + } + } + fn data_type_name(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_type_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_type_name(self.0) } + } + fn data_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_object(self.0) } + } + fn data_extent_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_extent_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_extent_type(self.0) } + } + fn data_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_extent(self.0) } + } + fn all_pieces_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_all_pieces_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_all_pieces_extent(self.0) } + } + fn data_piece_number(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_piece_number( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_piece_number(self.0) } + } + fn data_number_of_pieces(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_number_of_pieces(self.0) } + } + fn data_number_of_ghost_levels(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_number_of_ghost_levels( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_number_of_ghost_levels(self.0) } + } + fn data_time_step(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_time_step( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_time_step(self.0) } + } + fn point_data_vector(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_point_data_vector( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_point_data_vector(self.0) } + } + fn cell_data_vector(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_cell_data_vector( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_cell_data_vector(self.0) } + } + fn vertex_data_vector(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_vertex_data_vector( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_vertex_data_vector(self.0) } + } + fn edge_data_vector(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_edge_data_vector( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_edge_data_vector(self.0) } + } + fn field_array_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_array_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_array_type(self.0) } + } + fn field_association(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_association( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_association(self.0) } + } + fn field_attribute_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_attribute_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_attribute_type(self.0) } + } + fn field_active_attribute(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_active_attribute( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_active_attribute(self.0) } + } + fn field_number_of_components(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_number_of_components( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_number_of_components(self.0) } + } + fn field_number_of_tuples(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_number_of_tuples( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_number_of_tuples(self.0) } + } + fn field_operation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_operation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_operation(self.0) } + } + fn field_range(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_range(self.0) } + } + fn piece_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_piece_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_piece_extent(self.0) } + } + fn field_name(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_name(self.0) } + } + fn origin(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_origin( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_origin(self.0) } + } + fn spacing(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_spacing( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_spacing(self.0) } + } + fn direction(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_direction( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_direction(self.0) } + } + fn bounding_box(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_bounding_box( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_bounding_box(self.0) } + } + fn sil(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_sil( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_sil(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_data(self.0, v, i) } + } +} +impl VtkDataObjectCollection for vtkDataObjectCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_new_instance(self.0) } + } + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_collection_add_item( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_collection_add_item(self.0, ds) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_get_next_item(self.0) } + } + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_get_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_get_item(self.0, i) } + } + fn get_next_data_object(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_get_next_data_object( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_get_next_data_object(self.0, cookie) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_collection_get_number_of_items(self.0) } + } +} +impl VtkDataObjectTreeIterator for vtkDataObjectTreeIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_tree_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_tree_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_tree_iterator_new_instance(self.0) } + } + fn go_to_first_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_go_to_first_item( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_go_to_first_item(self.0) } + } + fn go_to_next_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_go_to_next_item( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_go_to_next_item(self.0) } + } + fn is_done_with_traversal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_tree_iterator_is_done_with_traversal(self.0) } + } + fn get_current_data_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_get_current_data_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_tree_iterator_get_current_data_object(self.0) } + } + fn get_current_meta_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_get_current_meta_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_tree_iterator_get_current_meta_data(self.0) } + } + fn has_current_meta_data(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_has_current_meta_data( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_tree_iterator_has_current_meta_data(self.0) } + } + fn get_current_flat_index(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_get_current_flat_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_data_object_tree_iterator_get_current_flat_index(self.0) } + } + fn set_visit_only_leaves(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_set_visit_only_leaves( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_data_object_tree_iterator_set_visit_only_leaves(self.0, _arg) } + } + fn get_visit_only_leaves(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_get_visit_only_leaves( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_tree_iterator_get_visit_only_leaves(self.0) } + } + fn visit_only_leaves_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_visit_only_leaves_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_visit_only_leaves_on(self.0) } + } + fn visit_only_leaves_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_visit_only_leaves_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_visit_only_leaves_off(self.0) } + } + fn set_traverse_sub_tree(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_set_traverse_sub_tree( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_data_object_tree_iterator_set_traverse_sub_tree(self.0, _arg) } + } + fn get_traverse_sub_tree(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_get_traverse_sub_tree( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_tree_iterator_get_traverse_sub_tree(self.0) } + } + fn traverse_sub_tree_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_traverse_sub_tree_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_traverse_sub_tree_on(self.0) } + } + fn traverse_sub_tree_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_traverse_sub_tree_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_traverse_sub_tree_off(self.0) } + } +} +impl VtkDataObjectTypes for vtkDataObjectTypes { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_types_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_types_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_types_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_types_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_types_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_types_new_instance(self.0) } + } + fn get_class_name_from_type_id( + &mut self, + typeId: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_data_object_types_get_class_name_from_type_id( + sself: *mut core::ffi::c_void, + typeId: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_data_object_types_get_class_name_from_type_id(self.0, typeId) } + } + fn get_type_id_from_class_name( + &mut self, + classname: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_types_get_type_id_from_class_name( + sself: *mut core::ffi::c_void, + classname: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_types_get_type_id_from_class_name(self.0, classname) } + } + fn new_data_object( + &mut self, + classname: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_types_new_data_object( + sself: *mut core::ffi::c_void, + classname: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_types_new_data_object(self.0, classname) } + } + fn new_data_object(&mut self, typeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_types_new_data_object( + sself: *mut core::ffi::c_void, + typeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_types_new_data_object(self.0, typeId) } + } + fn type_id_is_a( + &mut self, + typeId: core::ffi::c_int, + targetTypeId: core::ffi::c_int, + ) -> bool { + unsafe extern "C" { + fn vtk_data_object_types_type_id_is_a( + sself: *mut core::ffi::c_void, + typeId: core::ffi::c_int, + targetTypeId: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_data_object_types_type_id_is_a(self.0, typeId, targetTypeId) } + } + fn get_common_base_type_id( + &mut self, + typeA: core::ffi::c_int, + typeB: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_types_get_common_base_type_id( + sself: *mut core::ffi::c_void, + typeA: core::ffi::c_int, + typeB: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_types_get_common_base_type_id(self.0, typeA, typeB) } + } +} +impl VtkDataSetAttributes for vtkDataSetAttributes { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_initialize(self.0) } + } + fn update(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_update(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_update(self.0) } + } + fn deep_copy(&mut self, pd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_deep_copy( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_deep_copy(self.0, pd) } + } + fn shallow_copy(&mut self, pd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_shallow_copy( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_shallow_copy(self.0, pd) } + } + fn ghost_array_name(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_data_set_attributes_ghost_array_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_data_set_attributes_ghost_array_name(self.0) } + } + fn set_scalars(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_scalars( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_scalars(self.0, da) } + } + fn set_active_scalars(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_scalars( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_scalars(self.0, name) } + } + fn get_scalars(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_scalars( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_scalars(self.0) } + } + fn set_vectors(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_vectors( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_vectors(self.0, da) } + } + fn set_active_vectors(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_vectors( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_vectors(self.0, name) } + } + fn get_vectors(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_vectors( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_vectors(self.0) } + } + fn set_normals(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_normals( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_normals(self.0, da) } + } + fn set_active_normals(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_normals( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_normals(self.0, name) } + } + fn get_normals(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_normals( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_normals(self.0) } + } + fn set_tangents(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_tangents( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_tangents(self.0, da) } + } + fn set_active_tangents(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_tangents( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_tangents(self.0, name) } + } + fn get_tangents(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_tangents( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_tangents(self.0) } + } + fn set_t_coords(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_t_coords( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_t_coords(self.0, da) } + } + fn set_active_t_coords(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_t_coords( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_t_coords(self.0, name) } + } + fn get_t_coords(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_t_coords( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_t_coords(self.0) } + } + fn set_tensors(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_tensors( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_tensors(self.0, da) } + } + fn set_active_tensors(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_tensors( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_tensors(self.0, name) } + } + fn get_tensors(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_tensors( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_tensors(self.0) } + } + fn set_global_ids(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_global_ids( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_global_ids(self.0, da) } + } + fn set_active_global_ids(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_global_ids( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_global_ids(self.0, name) } + } + fn get_global_ids(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_global_ids( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_global_ids(self.0) } + } + fn set_pedigree_ids(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_pedigree_ids( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_pedigree_ids(self.0, da) } + } + fn set_active_pedigree_ids(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_pedigree_ids( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_pedigree_ids(self.0, name) } + } + fn get_pedigree_ids(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_pedigree_ids( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_pedigree_ids(self.0) } + } + fn set_rational_weights(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_rational_weights( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_rational_weights(self.0, da) } + } + fn set_active_rational_weights( + &mut self, + name: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_rational_weights( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_rational_weights(self.0, name) } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_rational_weights(self.0) } + } + fn set_higher_order_degrees( + &mut self, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_higher_order_degrees( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_higher_order_degrees(self.0, da) } + } + fn set_active_higher_order_degrees( + &mut self, + name: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_higher_order_degrees( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_higher_order_degrees(self.0, name) } + } + fn get_higher_order_degrees(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_higher_order_degrees( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_higher_order_degrees(self.0) } + } + fn get_scalars(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_scalars( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_scalars(self.0, name) } + } + fn get_vectors(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_vectors( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_vectors(self.0, name) } + } + fn get_normals(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_normals( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_normals(self.0, name) } + } + fn get_tangents(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_tangents( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_tangents(self.0, name) } + } + fn get_t_coords(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_t_coords( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_t_coords(self.0, name) } + } + fn get_tensors(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_tensors( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_tensors(self.0, name) } + } + fn get_global_ids(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_global_ids( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_global_ids(self.0, name) } + } + fn get_pedigree_ids(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_pedigree_ids( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_pedigree_ids(self.0, name) } + } + fn get_rational_weights( + &mut self, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_rational_weights( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_rational_weights(self.0, name) } + } + fn get_higher_order_degrees( + &mut self, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_higher_order_degrees( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_higher_order_degrees(self.0, name) } + } + fn set_active_attribute( + &mut self, + name: core::ffi::c_char, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_set_attributes_set_active_attribute(self.0, name, attributeType) + } + } + fn set_active_attribute( + &mut self, + index: core::ffi::c_int, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_attribute( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_set_attributes_set_active_attribute(self.0, index, attributeType) + } + } + fn get_attribute_indices(&mut self, indexArray: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_get_attribute_indices( + sself: *mut core::ffi::c_void, + indexArray: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_get_attribute_indices(self.0, indexArray) } + } + fn is_array_an_attribute(&mut self, idx: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_is_array_an_attribute( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_is_array_an_attribute(self.0, idx) } + } + fn set_attribute( + &mut self, + aa: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_attribute( + sself: *mut core::ffi::c_void, + aa: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_attribute(self.0, aa, attributeType) } + } + fn get_attribute( + &mut self, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_attribute( + sself: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_attribute(self.0, attributeType) } + } + fn get_abstract_attribute( + &mut self, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_abstract_attribute( + sself: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_abstract_attribute(self.0, attributeType) } + } + fn get_attribute_type_as_string( + &mut self, + attributeType: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_data_set_attributes_get_attribute_type_as_string( + sself: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { + vtk_data_set_attributes_get_attribute_type_as_string(self.0, attributeType) + } + } + fn get_long_attribute_type_as_string( + &mut self, + attributeType: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_data_set_attributes_get_long_attribute_type_as_string( + sself: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { + vtk_data_set_attributes_get_long_attribute_type_as_string( + self.0, + attributeType, + ) + } + } + fn set_copy_attribute( + &mut self, + index: core::ffi::c_int, + value: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_attribute( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + value: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { + vtk_data_set_attributes_set_copy_attribute(self.0, index, value, ctype) + } + } + fn get_copy_attribute( + &mut self, + index: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_attribute( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_attribute(self.0, index, ctype) } + } + fn set_copy_scalars(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_scalars( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_scalars(self.0, i, ctype) } + } + fn get_copy_scalars(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_scalars( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_scalars(self.0, ctype) } + } + fn copy_scalars_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_scalars_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_scalars_on(self.0) } + } + fn copy_scalars_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_scalars_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_scalars_off(self.0) } + } + fn set_copy_vectors(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_vectors( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_vectors(self.0, i, ctype) } + } + fn get_copy_vectors(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_vectors( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_vectors(self.0, ctype) } + } + fn copy_vectors_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_vectors_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_vectors_on(self.0) } + } + fn copy_vectors_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_vectors_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_vectors_off(self.0) } + } + fn set_copy_normals(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_normals( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_normals(self.0, i, ctype) } + } + fn get_copy_normals(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_normals( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_normals(self.0, ctype) } + } + fn copy_normals_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_normals_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_normals_on(self.0) } + } + fn copy_normals_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_normals_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_normals_off(self.0) } + } + fn set_copy_tangents(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_tangents( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_tangents(self.0, i, ctype) } + } + fn get_copy_tangents(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_tangents( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_tangents(self.0, ctype) } + } + fn copy_tangents_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tangents_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_tangents_on(self.0) } + } + fn copy_tangents_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tangents_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_tangents_off(self.0) } + } + fn set_copy_t_coords(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_t_coords( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_t_coords(self.0, i, ctype) } + } + fn get_copy_t_coords(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_t_coords( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_t_coords(self.0, ctype) } + } + fn copy_t_coords_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_t_coords_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_t_coords_on(self.0) } + } + fn copy_t_coords_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_t_coords_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_t_coords_off(self.0) } + } + fn set_copy_tensors(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_tensors( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_tensors(self.0, i, ctype) } + } + fn get_copy_tensors(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_tensors( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_tensors(self.0, ctype) } + } + fn copy_tensors_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tensors_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_tensors_on(self.0) } + } + fn copy_tensors_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tensors_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_tensors_off(self.0) } + } + fn set_copy_global_ids( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_global_ids( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_global_ids(self.0, i, ctype) } + } + fn get_copy_global_ids(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_global_ids( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_global_ids(self.0, ctype) } + } + fn copy_global_ids_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_global_ids_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_global_ids_on(self.0) } + } + fn copy_global_ids_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_global_ids_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_global_ids_off(self.0) } + } + fn set_copy_pedigree_ids( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_pedigree_ids( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_pedigree_ids(self.0, i, ctype) } + } + fn get_copy_pedigree_ids(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_pedigree_ids( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_pedigree_ids(self.0, ctype) } + } + fn copy_pedigree_ids_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_pedigree_ids_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_pedigree_ids_on(self.0) } + } + fn copy_pedigree_ids_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_pedigree_ids_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_pedigree_ids_off(self.0) } + } + fn set_copy_rational_weights( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_rational_weights( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_rational_weights(self.0, i, ctype) } + } + fn get_copy_rational_weights( + &mut self, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_rational_weights( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_rational_weights(self.0, ctype) } + } + fn copy_rational_weights_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_rational_weights_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_rational_weights_on(self.0) } + } + fn copy_rational_weights_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_rational_weights_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_rational_weights_off(self.0) } + } + fn set_copy_higher_order_degrees( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_higher_order_degrees( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { + vtk_data_set_attributes_set_copy_higher_order_degrees(self.0, i, ctype) + } + } + fn get_copy_higher_order_degrees( + &mut self, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_higher_order_degrees( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_higher_order_degrees(self.0, ctype) } + } + fn copy_higher_order_degrees_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_higher_order_degrees_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_higher_order_degrees_on(self.0) } + } + fn copy_higher_order_degrees_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_higher_order_degrees_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_higher_order_degrees_off(self.0) } + } + fn copy_all_on(&mut self, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_all_on( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_copy_all_on(self.0, ctype) } + } + fn copy_all_off(&mut self, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_all_off( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_copy_all_off(self.0, ctype) } + } + fn pass_data(&mut self, fd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_pass_data( + sself: *mut core::ffi::c_void, + fd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_pass_data(self.0, fd) } + } + fn copy_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_allocate( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ); + } + unsafe { vtk_data_set_attributes_copy_allocate(self.0, pd, sze, ext) } + } + fn copy_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + shallowCopyArrays: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_allocate( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + shallowCopyArrays: core::ffi::c_int, + ); + } + unsafe { + vtk_data_set_attributes_copy_allocate( + self.0, + pd, + sze, + ext, + shallowCopyArrays, + ) + } + } + fn setup_for_copy(&mut self, pd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_setup_for_copy( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_setup_for_copy(self.0, pd) } + } + fn copy_structured_data( + &mut self, + inDsa: *mut core::ffi::c_void, + inExt: core::ffi::c_int, + outExt: core::ffi::c_int, + setSize: bool, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_structured_data( + sself: *mut core::ffi::c_void, + inDsa: *mut core::ffi::c_void, + inExt: core::ffi::c_int, + outExt: core::ffi::c_int, + setSize: bool, + ); + } + unsafe { + vtk_data_set_attributes_copy_structured_data( + self.0, + inDsa, + inExt, + outExt, + setSize, + ) + } + } + fn copy_data( + &mut self, + fromPd: *mut core::ffi::c_void, + fromId: core::ffi::c_uchar, + toId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_data( + sself: *mut core::ffi::c_void, + fromPd: *mut core::ffi::c_void, + fromId: core::ffi::c_uchar, + toId: core::ffi::c_uchar, + ); + } + unsafe { vtk_data_set_attributes_copy_data(self.0, fromPd, fromId, toId) } + } + fn copy_data( + &mut self, + fromPd: *mut core::ffi::c_void, + fromIds: *mut core::ffi::c_void, + toIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_data( + sself: *mut core::ffi::c_void, + fromPd: *mut core::ffi::c_void, + fromIds: *mut core::ffi::c_void, + toIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_data(self.0, fromPd, fromIds, toIds) } + } + fn copy_data( + &mut self, + fromPd: *mut core::ffi::c_void, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_data( + sself: *mut core::ffi::c_void, + fromPd: *mut core::ffi::c_void, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + ); + } + unsafe { + vtk_data_set_attributes_copy_data(self.0, fromPd, dstStart, n, srcStart) + } + } + fn copy_tuple( + &mut self, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromId: core::ffi::c_uchar, + toId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tuple( + sself: *mut core::ffi::c_void, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromId: core::ffi::c_uchar, + toId: core::ffi::c_uchar, + ); + } + unsafe { + vtk_data_set_attributes_copy_tuple(self.0, fromData, toData, fromId, toId) + } + } + fn copy_tuples( + &mut self, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromIds: *mut core::ffi::c_void, + toIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tuples( + sself: *mut core::ffi::c_void, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromIds: *mut core::ffi::c_void, + toIds: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_data_set_attributes_copy_tuples(self.0, fromData, toData, fromIds, toIds) + } + } + fn copy_tuples( + &mut self, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tuples( + sself: *mut core::ffi::c_void, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + ); + } + unsafe { + vtk_data_set_attributes_copy_tuples( + self.0, + fromData, + toData, + dstStart, + n, + srcStart, + ) + } + } + fn interpolate_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_interpolate_allocate( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ); + } + unsafe { vtk_data_set_attributes_interpolate_allocate(self.0, pd, sze, ext) } + } + fn interpolate_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + shallowCopyArrays: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_interpolate_allocate( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + shallowCopyArrays: core::ffi::c_int, + ); + } + unsafe { + vtk_data_set_attributes_interpolate_allocate( + self.0, + pd, + sze, + ext, + shallowCopyArrays, + ) + } + } + fn interpolate_point( + &mut self, + fromPd: *mut core::ffi::c_void, + toId: core::ffi::c_uchar, + ids: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_interpolate_point( + sself: *mut core::ffi::c_void, + fromPd: *mut core::ffi::c_void, + toId: core::ffi::c_uchar, + ids: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_data_set_attributes_interpolate_point(self.0, fromPd, toId, ids, weights) + } + } + fn interpolate_edge( + &mut self, + fromPd: *mut core::ffi::c_void, + toId: core::ffi::c_uchar, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + t: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_interpolate_edge( + sself: *mut core::ffi::c_void, + fromPd: *mut core::ffi::c_void, + toId: core::ffi::c_uchar, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + t: core::ffi::c_double, + ); + } + unsafe { + vtk_data_set_attributes_interpolate_edge(self.0, fromPd, toId, p1, p2, t) + } + } + fn interpolate_time( + &mut self, + from1: *mut core::ffi::c_void, + from2: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + t: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_interpolate_time( + sself: *mut core::ffi::c_void, + from1: *mut core::ffi::c_void, + from2: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + t: core::ffi::c_double, + ); + } + unsafe { vtk_data_set_attributes_interpolate_time(self.0, from1, from2, id, t) } + } + fn copy_allocate( + &mut self, + list: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_allocate( + sself: *mut core::ffi::c_void, + list: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ); + } + unsafe { vtk_data_set_attributes_copy_allocate(self.0, list, sze, ext) } + } + fn copy_data( + &mut self, + list: *mut core::ffi::c_void, + dsa: *mut core::ffi::c_void, + idx: core::ffi::c_int, + fromId: core::ffi::c_uchar, + toId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_data( + sself: *mut core::ffi::c_void, + list: *mut core::ffi::c_void, + dsa: *mut core::ffi::c_void, + idx: core::ffi::c_int, + fromId: core::ffi::c_uchar, + toId: core::ffi::c_uchar, + ); + } + unsafe { + vtk_data_set_attributes_copy_data(self.0, list, dsa, idx, fromId, toId) + } + } + fn copy_data( + &mut self, + list: *mut core::ffi::c_void, + dsa: *mut core::ffi::c_void, + idx: core::ffi::c_int, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_data( + sself: *mut core::ffi::c_void, + list: *mut core::ffi::c_void, + dsa: *mut core::ffi::c_void, + idx: core::ffi::c_int, + dstStart: core::ffi::c_uchar, + n: core::ffi::c_uchar, + srcStart: core::ffi::c_uchar, + ); + } + unsafe { + vtk_data_set_attributes_copy_data( + self.0, + list, + dsa, + idx, + dstStart, + n, + srcStart, + ) + } + } + fn interpolate_allocate( + &mut self, + list: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_interpolate_allocate( + sself: *mut core::ffi::c_void, + list: *mut core::ffi::c_void, + sze: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ); + } + unsafe { vtk_data_set_attributes_interpolate_allocate(self.0, list, sze, ext) } + } + fn interpolate_point( + &mut self, + list: *mut core::ffi::c_void, + fromPd: *mut core::ffi::c_void, + idx: core::ffi::c_int, + toId: core::ffi::c_uchar, + ids: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_interpolate_point( + sself: *mut core::ffi::c_void, + list: *mut core::ffi::c_void, + fromPd: *mut core::ffi::c_void, + idx: core::ffi::c_int, + toId: core::ffi::c_uchar, + ids: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_data_set_attributes_interpolate_point( + self.0, + list, + fromPd, + idx, + toId, + ids, + weights, + ) + } + } +} +impl VtkDataSetCellIterator for vtkDataSetCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_cell_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_cell_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_cell_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_cell_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_cell_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_cell_iterator_new_instance(self.0) } + } + fn is_done_with_traversal(&mut self) -> bool { + unsafe extern "C" { + fn vtk_data_set_cell_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_data_set_cell_iterator_is_done_with_traversal(self.0) } + } + fn get_cell_id(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_data_set_cell_iterator_get_cell_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_data_set_cell_iterator_get_cell_id(self.0) } + } +} +impl VtkDataSetCollection for vtkDataSetCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_new_instance(self.0) } + } + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_collection_add_item( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_collection_add_item(self.0, ds) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_get_next_item(self.0) } + } + fn get_next_data_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_get_next_data_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_get_next_data_set(self.0) } + } + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_get_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_get_item(self.0, i) } + } + fn get_data_set(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_get_data_set( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_get_data_set(self.0, i) } + } + fn get_next_data_set(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_get_next_data_set( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_get_next_data_set(self.0, cookie) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_collection_get_number_of_items(self.0) } + } +} +impl VtkDirectedAcyclicGraph for vtkDirectedAcyclicGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_acyclic_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_acyclic_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_acyclic_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_acyclic_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_acyclic_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_acyclic_graph_new_instance(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_acyclic_graph_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_acyclic_graph_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_acyclic_graph_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_acyclic_graph_get_data(self.0, v, i) } + } +} +impl VtkDirectedGraph for vtkDirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_new_instance(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_get_data(self.0, v, i) } + } + fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_directed_graph_is_structure_valid( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_directed_graph_is_structure_valid(self.0, g) } + } +} +impl VtkEdgeListIterator for vtkEdgeListIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_new_instance(self.0) } + } + fn get_graph(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_get_graph( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_get_graph(self.0) } + } + fn set_graph(&mut self, graph: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_edge_list_iterator_set_graph( + sself: *mut core::ffi::c_void, + graph: *mut core::ffi::c_void, + ); + } + unsafe { vtk_edge_list_iterator_set_graph(self.0, graph) } + } + fn next(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_next( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_next(self.0) } + } + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_next_graph_edge( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_next_graph_edge(self.0) } + } + fn has_next(&mut self) -> bool { + unsafe extern "C" { + fn vtk_edge_list_iterator_has_next(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_edge_list_iterator_has_next(self.0) } + } +} +impl VtkEdgeTable for vtkEdgeTable { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_table_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_table_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_table_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_table_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_table_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_table_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_edge_table_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_edge_table_initialize(self.0) } + } + fn init_edge_insertion( + &mut self, + numPoints: core::ffi::c_uchar, + storeAttributes: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_edge_table_init_edge_insertion( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_uchar, + storeAttributes: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_edge_table_init_edge_insertion(self.0, numPoints, storeAttributes) } + } + fn insert_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_edge_table_insert_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_edge_table_insert_edge(self.0, p1, p2) } + } + fn insert_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + attributeId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_edge_table_insert_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + attributeId: core::ffi::c_uchar, + ); + } + unsafe { vtk_edge_table_insert_edge(self.0, p1, p2, attributeId) } + } + fn insert_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ptr: (), + ) -> () { + unsafe extern "C" { + fn vtk_edge_table_insert_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ptr: (), + ); + } + unsafe { vtk_edge_table_insert_edge(self.0, p1, p2, ptr) } + } + fn is_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_edge_table_is_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_edge_table_is_edge(self.0, p1, p2) } + } + fn is_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ptr: (), + ) -> () { + unsafe extern "C" { + fn vtk_edge_table_is_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ptr: (), + ); + } + unsafe { vtk_edge_table_is_edge(self.0, p1, p2, ptr) } + } + fn init_point_insertion( + &mut self, + newPts: *mut core::ffi::c_void, + estSize: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_edge_table_init_point_insertion( + sself: *mut core::ffi::c_void, + newPts: *mut core::ffi::c_void, + estSize: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_edge_table_init_point_insertion(self.0, newPts, estSize) } + } + fn insert_unique_point( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_edge_table_insert_unique_point( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_edge_table_insert_unique_point(self.0, p1, p2, x, ptId) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_edge_table_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_edge_table_get_number_of_edges(self.0) } + } + fn init_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_edge_table_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_edge_table_init_traversal(self.0) } + } + fn get_next_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_edge_table_get_next_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_edge_table_get_next_edge(self.0, p1, p2) } + } + fn get_next_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ptr: (), + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_edge_table_get_next_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ptr: (), + ) -> core::ffi::c_int; + } + unsafe { vtk_edge_table_get_next_edge(self.0, p1, p2, ptr) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_edge_table_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_edge_table_reset(self.0) } + } +} +impl VtkEmptyCell for vtkEmptyCell { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_empty_cell_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_empty_cell_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_empty_cell_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_empty_cell_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_empty_cell_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_empty_cell_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_empty_cell_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_empty_cell_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_empty_cell_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_empty_cell_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_empty_cell_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_empty_cell_contour( + self.0, + value, + cellScalars, + locator, + verts1, + lines, + verts2, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_empty_cell_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_empty_cell_clip( + self.0, + value, + cellScalars, + locator, + pts, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_empty_cell_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_empty_cell_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_empty_cell_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_empty_cell_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_empty_cell_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_empty_cell_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } +} +impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_explicit_structured_grid_get_data_object_type(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_explicit_structured_grid_initialize(self.0) } + } + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_get_cell(self.0, cellId) } + } + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_get_cell(self.0, cellId, cell) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_explicit_structured_grid_get_cell_type(self.0, cellId) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_get_point_cells(self.0, ptId, cellIds) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_copy_structure(self.0, ds) } + } + fn get_data_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_data_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_explicit_structured_grid_get_data_dimension(self.0) } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_explicit_structured_grid_set_dimensions(self.0, i, j, k) } + } + fn set_dimensions(&mut self, dim: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_set_dimensions( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ); + } + unsafe { vtk_explicit_structured_grid_set_dimensions(self.0, dim) } + } + fn get_dimensions(&mut self, dim: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_dimensions( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ); + } + unsafe { vtk_explicit_structured_grid_get_dimensions(self.0, dim) } + } + fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell_dims( + sself: *mut core::ffi::c_void, + cellDims: core::ffi::c_int, + ); + } + unsafe { vtk_explicit_structured_grid_get_cell_dims(self.0, cellDims) } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_explicit_structured_grid_get_extent_type(self.0) } + } + fn set_extent( + &mut self, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_set_extent( + sself: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ); + } + unsafe { + vtk_explicit_structured_grid_set_extent(self.0, x0, x1, y0, y1, z0, z1) + } + } + fn set_extent(&mut self, extent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_set_extent( + sself: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_explicit_structured_grid_set_extent(self.0, extent) } + } + fn get_extent(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_explicit_structured_grid_get_extent(self.0) } + } + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_explicit_structured_grid_get_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_explicit_structured_grid_get_extent(self.0, _arg) } + } + fn set_cells(&mut self, cells: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_set_cells( + sself: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_set_cells(self.0, cells) } + } + fn get_cells(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cells( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_get_cells(self.0) } + } + fn build_links(&mut self) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_build_links(sself: *mut core::ffi::c_void); + } + unsafe { vtk_explicit_structured_grid_build_links(self.0) } + } + fn get_links(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_links( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_get_links(self.0) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_explicit_structured_grid_get_cell_points(self.0, cellId) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { + vtk_explicit_structured_grid_get_cell_points(self.0, cellId, npts, pts) + } + } + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + neighbors: core::ffi::c_uchar, + wholeExtent: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell_neighbors( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + neighbors: core::ffi::c_uchar, + wholeExtent: core::ffi::c_int, + ); + } + unsafe { + vtk_explicit_structured_grid_get_cell_neighbors( + self.0, + cellId, + neighbors, + wholeExtent, + ) + } + } + fn compute_cell_structured_coords( + &mut self, + cellId: core::ffi::c_uchar, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + adjustForExtent: bool, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_compute_cell_structured_coords( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + adjustForExtent: bool, + ); + } + unsafe { + vtk_explicit_structured_grid_compute_cell_structured_coords( + self.0, + cellId, + i, + j, + k, + adjustForExtent, + ) + } + } + fn compute_cell_id( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + adjustForExtent: bool, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_explicit_structured_grid_compute_cell_id( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + adjustForExtent: bool, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_explicit_structured_grid_compute_cell_id( + self.0, + i, + j, + k, + adjustForExtent, + ) + } + } + fn compute_faces_connectivity_flags_array(&mut self) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_compute_faces_connectivity_flags_array( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(self.0) + } + } + fn set_faces_connectivity_flags_array_name( + &mut self, + _arg: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { + vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name( + self.0, + _arg, + ) + } + } + fn get_faces_connectivity_flags_array_name(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_faces_connectivity_flags_array_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { + vtk_explicit_structured_grid_get_faces_connectivity_flags_array_name(self.0) + } + } + fn blank_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_blank_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_explicit_structured_grid_blank_cell(self.0, cellId) } + } + fn un_blank_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_un_blank_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_explicit_structured_grid_un_blank_cell(self.0, cellId) } + } + fn has_any_blank_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_explicit_structured_grid_has_any_blank_cells( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_explicit_structured_grid_has_any_blank_cells(self.0) } + } + fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_explicit_structured_grid_is_cell_visible( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_explicit_structured_grid_is_cell_visible(self.0, cellId) } + } + fn is_cell_ghost(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_explicit_structured_grid_is_cell_ghost( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_explicit_structured_grid_is_cell_ghost(self.0, cellId) } + } + fn has_any_ghost_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_explicit_structured_grid_has_any_ghost_cells( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_explicit_structured_grid_has_any_ghost_cells(self.0) } + } + fn crop(&mut self, updateExtent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_crop( + sself: *mut core::ffi::c_void, + updateExtent: core::ffi::c_int, + ); + } + unsafe { vtk_explicit_structured_grid_crop(self.0, updateExtent) } + } + fn crop( + &mut self, + input: *mut core::ffi::c_void, + updateExtent: core::ffi::c_int, + generateOriginalCellIds: bool, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_crop( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + updateExtent: core::ffi::c_int, + generateOriginalCellIds: bool, + ); + } + unsafe { + vtk_explicit_structured_grid_crop( + self.0, + input, + updateExtent, + generateOriginalCellIds, + ) + } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_get_data(self.0, v, i) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_explicit_structured_grid_get_actual_memory_size(self.0) } + } + fn check_and_reorder_faces(&mut self) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_check_and_reorder_faces( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_check_and_reorder_faces(self.0) } + } +} +impl VtkExtractStructuredGridHelper for vtkExtractStructuredGridHelper { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extract_structured_grid_helper_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extract_structured_grid_helper_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extract_structured_grid_helper_new_instance(self.0) } + } + fn get_output_whole_extent(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_output_whole_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_extract_structured_grid_helper_get_output_whole_extent(self.0) } + } + fn get_output_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_output_whole_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_extract_structured_grid_helper_get_output_whole_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn get_output_whole_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_output_whole_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_extract_structured_grid_helper_get_output_whole_extent(self.0, _arg) + } + } + fn initialize( + &mut self, + voi: core::ffi::c_int, + wholeExt: core::ffi::c_int, + sampleRate: core::ffi::c_int, + includeBoundary: bool, + ) -> () { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_initialize( + sself: *mut core::ffi::c_void, + voi: core::ffi::c_int, + wholeExt: core::ffi::c_int, + sampleRate: core::ffi::c_int, + includeBoundary: bool, + ); + } + unsafe { + vtk_extract_structured_grid_helper_initialize( + self.0, + voi, + wholeExt, + sampleRate, + includeBoundary, + ) + } + } + fn is_valid(&mut self) -> bool { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_is_valid( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_extract_structured_grid_helper_is_valid(self.0) } + } + fn get_size(&mut self, dim: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_size( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_extract_structured_grid_helper_get_size(self.0, dim) } + } + fn get_mapped_index( + &mut self, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_mapped_index( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_extract_structured_grid_helper_get_mapped_index(self.0, dim, outIdx) + } + } + fn get_mapped_index_from_extent_value( + &mut self, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value( + self.0, + dim, + outExtVal, + ) + } + } + fn get_mapped_extent_value( + &mut self, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_mapped_extent_value( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_extract_structured_grid_helper_get_mapped_extent_value( + self.0, + dim, + outExtVal, + ) + } + } + fn get_mapped_extent_value_from_index( + &mut self, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index( + self.0, + dim, + outIdx, + ) + } + } + fn compute_begin_and_end( + &mut self, + inExt: core::ffi::c_int, + voi: core::ffi::c_int, + begin: core::ffi::c_int, + end: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_compute_begin_and_end( + sself: *mut core::ffi::c_void, + inExt: core::ffi::c_int, + voi: core::ffi::c_int, + begin: core::ffi::c_int, + end: core::ffi::c_int, + ); + } + unsafe { + vtk_extract_structured_grid_helper_compute_begin_and_end( + self.0, + inExt, + voi, + begin, + end, + ) + } + } + fn copy_points_and_point_data( + &mut self, + inExt: core::ffi::c_int, + outExt: core::ffi::c_int, + pd: *mut core::ffi::c_void, + inpnts: *mut core::ffi::c_void, + outPD: *mut core::ffi::c_void, + outpnts: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_copy_points_and_point_data( + sself: *mut core::ffi::c_void, + inExt: core::ffi::c_int, + outExt: core::ffi::c_int, + pd: *mut core::ffi::c_void, + inpnts: *mut core::ffi::c_void, + outPD: *mut core::ffi::c_void, + outpnts: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_extract_structured_grid_helper_copy_points_and_point_data( + self.0, + inExt, + outExt, + pd, + inpnts, + outPD, + outpnts, + ) + } + } + fn copy_cell_data( + &mut self, + inExt: core::ffi::c_int, + outExt: core::ffi::c_int, + cd: *mut core::ffi::c_void, + outCD: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_copy_cell_data( + sself: *mut core::ffi::c_void, + inExt: core::ffi::c_int, + outExt: core::ffi::c_int, + cd: *mut core::ffi::c_void, + outCD: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_extract_structured_grid_helper_copy_cell_data( + self.0, + inExt, + outExt, + cd, + outCD, + ) + } + } + fn get_partitioned_voi( + &mut self, + globalVOI: core::ffi::c_int, + partitionedExtent: core::ffi::c_int, + sampleRate: core::ffi::c_int, + includeBoundary: bool, + partitionedVOI: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_partitioned_voi( + sself: *mut core::ffi::c_void, + globalVOI: core::ffi::c_int, + partitionedExtent: core::ffi::c_int, + sampleRate: core::ffi::c_int, + includeBoundary: bool, + partitionedVOI: core::ffi::c_int, + ); + } + unsafe { + vtk_extract_structured_grid_helper_get_partitioned_voi( + self.0, + globalVOI, + partitionedExtent, + sampleRate, + includeBoundary, + partitionedVOI, + ) + } + } + fn get_partitioned_output_extent( + &mut self, + globalVOI: core::ffi::c_int, + partitionedVOI: core::ffi::c_int, + outputWholeExtent: core::ffi::c_int, + sampleRate: core::ffi::c_int, + includeBoundary: bool, + partitionedOutputExtent: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_partitioned_output_extent( + sself: *mut core::ffi::c_void, + globalVOI: core::ffi::c_int, + partitionedVOI: core::ffi::c_int, + outputWholeExtent: core::ffi::c_int, + sampleRate: core::ffi::c_int, + includeBoundary: bool, + partitionedOutputExtent: core::ffi::c_int, + ); + } + unsafe { + vtk_extract_structured_grid_helper_get_partitioned_output_extent( + self.0, + globalVOI, + partitionedVOI, + outputWholeExtent, + sampleRate, + includeBoundary, + partitionedOutputExtent, + ) + } + } +} +impl VtkFieldData for vtkFieldData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_field_data_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_field_data_initialize(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_uchar, + ext: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_allocate(self.0, sz, ext) } + } + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_field_data_copy_structure( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_copy_structure(self.0, p0) } + } + fn allocate_arrays(&mut self, num: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_field_data_allocate_arrays( + sself: *mut core::ffi::c_void, + num: core::ffi::c_int, + ); + } + unsafe { vtk_field_data_allocate_arrays(self.0, num) } + } + fn get_number_of_arrays(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_get_number_of_arrays( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_get_number_of_arrays(self.0) } + } + fn add_array(&mut self, array: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_add_array( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_add_array(self.0, array) } + } + fn null_data(&mut self, id: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_field_data_null_data( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + ); + } + unsafe { vtk_field_data_null_data(self.0, id) } + } + fn remove_array(&mut self, name: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_field_data_remove_array( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ); + } + unsafe { vtk_field_data_remove_array(self.0, name) } + } + fn remove_array(&mut self, index: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_field_data_remove_array( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ); + } + unsafe { vtk_field_data_remove_array(self.0, index) } + } + fn get_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_get_array( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_get_array(self.0, i) } + } + fn get_array( + &mut self, + arrayName: core::ffi::c_char, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_get_array( + sself: *mut core::ffi::c_void, + arrayName: core::ffi::c_char, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_get_array(self.0, arrayName, index) } + } + fn get_array(&mut self, arrayName: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_get_array( + sself: *mut core::ffi::c_void, + arrayName: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_get_array(self.0, arrayName) } + } + fn get_abstract_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_get_abstract_array( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_get_abstract_array(self.0, i) } + } + fn get_abstract_array( + &mut self, + arrayName: core::ffi::c_char, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_get_abstract_array( + sself: *mut core::ffi::c_void, + arrayName: core::ffi::c_char, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_get_abstract_array(self.0, arrayName, index) } + } + fn get_abstract_array( + &mut self, + arrayName: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_get_abstract_array( + sself: *mut core::ffi::c_void, + arrayName: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_get_abstract_array(self.0, arrayName) } + } + fn has_array(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_has_array( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_has_array(self.0, name) } + } + fn get_array_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_field_data_get_array_name( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_field_data_get_array_name(self.0, i) } + } + fn pass_data(&mut self, fd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_field_data_pass_data( + sself: *mut core::ffi::c_void, + fd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_pass_data(self.0, fd) } + } + fn copy_field_on(&mut self, name: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_field_data_copy_field_on( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ); + } + unsafe { vtk_field_data_copy_field_on(self.0, name) } + } + fn copy_field_off(&mut self, name: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_field_data_copy_field_off( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ); + } + unsafe { vtk_field_data_copy_field_off(self.0, name) } + } + fn copy_all_on(&mut self, unused: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_field_data_copy_all_on( + sself: *mut core::ffi::c_void, + unused: core::ffi::c_int, + ); + } + unsafe { vtk_field_data_copy_all_on(self.0, unused) } + } + fn copy_all_off(&mut self, unused: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_field_data_copy_all_off( + sself: *mut core::ffi::c_void, + unused: core::ffi::c_int, + ); + } + unsafe { vtk_field_data_copy_all_off(self.0, unused) } + } + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_field_data_deep_copy( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_deep_copy(self.0, da) } + } + fn shallow_copy(&mut self, da: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_field_data_shallow_copy( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_shallow_copy(self.0, da) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_field_data_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_field_data_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_field_data_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_field_data_reset(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_field_data_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_field_data_get_actual_memory_size(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_field_data_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_field_data_get_m_time(self.0) } + } + fn get_field( + &mut self, + ptId: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_field_data_get_field( + sself: *mut core::ffi::c_void, + ptId: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_get_field(self.0, ptId, f) } + } + fn get_array_containing_component( + &mut self, + i: core::ffi::c_int, + arrayComp: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_get_array_containing_component( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + arrayComp: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_get_array_containing_component(self.0, i, arrayComp) } + } + fn get_number_of_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_get_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_get_number_of_components(self.0) } + } + fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_field_data_get_number_of_tuples( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_field_data_get_number_of_tuples(self.0) } + } + fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_field_data_set_number_of_tuples( + sself: *mut core::ffi::c_void, + number: core::ffi::c_uchar, + ); + } + unsafe { vtk_field_data_set_number_of_tuples(self.0, number) } + } + fn set_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_field_data_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_set_tuple(self.0, i, j, source) } + } + fn insert_tuple( + &mut self, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_field_data_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uchar, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_insert_tuple(self.0, i, j, source) } + } + fn insert_next_tuple( + &mut self, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_field_data_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_uchar, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_field_data_insert_next_tuple(self.0, j, source) } + } +} +impl VtkGenericAttributeCollection for vtkGenericAttributeCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_attribute_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_attribute_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_attribute_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_attribute_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_attribute_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_attribute_collection_new_instance(self.0) } + } + fn get_number_of_attributes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_number_of_attributes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_number_of_attributes(self.0) } + } + fn get_number_of_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_number_of_components(self.0) } + } + fn get_number_of_point_centered_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_number_of_point_centered_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_attribute_collection_get_number_of_point_centered_components( + self.0, + ) + } + } + fn get_max_number_of_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_max_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_max_number_of_components(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_generic_attribute_collection_get_actual_memory_size(self.0) } + } + fn is_empty(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_is_empty( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_is_empty(self.0) } + } + fn get_attribute(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_attribute( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_attribute_collection_get_attribute(self.0, i) } + } + fn find_attribute(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_find_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_find_attribute(self.0, name) } + } + fn get_attribute_index(&mut self, i: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_attribute_index( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_attribute_index(self.0, i) } + } + fn insert_next_attribute(&mut self, a: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_insert_next_attribute( + sself: *mut core::ffi::c_void, + a: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_attribute_collection_insert_next_attribute(self.0, a) } + } + fn insert_attribute( + &mut self, + i: core::ffi::c_int, + a: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_insert_attribute( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + a: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_attribute_collection_insert_attribute(self.0, i, a) } + } + fn remove_attribute(&mut self, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_remove_attribute( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ); + } + unsafe { vtk_generic_attribute_collection_remove_attribute(self.0, i) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_attribute_collection_reset(self.0) } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_attribute_collection_deep_copy(self.0, other) } + } + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_shallow_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_attribute_collection_shallow_copy(self.0, other) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_generic_attribute_collection_get_m_time(self.0) } + } + fn get_active_attribute(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_active_attribute( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_active_attribute(self.0) } + } + fn get_active_component(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_active_component( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_active_component(self.0) } + } + fn set_active_attribute( + &mut self, + attribute: core::ffi::c_int, + component: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_set_active_attribute( + sself: *mut core::ffi::c_void, + attribute: core::ffi::c_int, + component: core::ffi::c_int, + ); + } + unsafe { + vtk_generic_attribute_collection_set_active_attribute( + self.0, + attribute, + component, + ) + } + } + fn get_number_of_attributes_to_interpolate(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate( + self.0, + ) + } + } + fn get_attributes_to_interpolate(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_attributes_to_interpolate( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_attributes_to_interpolate(self.0) } + } + fn has_attribute( + &mut self, + size: core::ffi::c_int, + attributes: core::ffi::c_int, + attribute: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_has_attribute( + sself: *mut core::ffi::c_void, + size: core::ffi::c_int, + attributes: core::ffi::c_int, + attribute: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_attribute_collection_has_attribute( + self.0, + size, + attributes, + attribute, + ) + } + } + fn set_attributes_to_interpolate( + &mut self, + size: core::ffi::c_int, + attributes: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_set_attributes_to_interpolate( + sself: *mut core::ffi::c_void, + size: core::ffi::c_int, + attributes: core::ffi::c_int, + ); + } + unsafe { + vtk_generic_attribute_collection_set_attributes_to_interpolate( + self.0, + size, + attributes, + ) + } + } + fn set_attributes_to_interpolate_to_all(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(self.0) + } + } +} +impl VtkGenericCell for vtkGenericCell { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_new_instance(self.0) } + } + fn set_points(&mut self, points: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_points( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_points(self.0, points) } + } + fn set_point_ids(&mut self, pointIds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_point_ids( + sself: *mut core::ffi::c_void, + pointIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_point_ids(self.0, pointIds) } + } + fn shallow_copy(&mut self, c: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_cell_shallow_copy( + sself: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_shallow_copy(self.0, c) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_cell_boundary(self.0, subId, pcoords, pts) } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_cell_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_generic_cell_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_generic_cell_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_generic_cell_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_generic_cell_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_generic_cell_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_generic_cell_clip( + self.0, + value, + cellScalars, + locator, + connectivity, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_cell_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_generic_cell_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_generic_cell_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_generic_cell_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_generic_cell_interpolate_functions(self.0, pcoords, weights) } + } + fn set_cell_type(&mut self, cellType: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type( + sself: *mut core::ffi::c_void, + cellType: core::ffi::c_int, + ); + } + unsafe { vtk_generic_cell_set_cell_type(self.0, cellType) } + } + fn set_cell_type_to_empty_cell(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_empty_cell( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_empty_cell(self.0) } + } + fn set_cell_type_to_vertex(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_vertex(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_vertex(self.0) } + } + fn set_cell_type_to_poly_vertex(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_poly_vertex( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_poly_vertex(self.0) } + } + fn set_cell_type_to_line(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_line(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_line(self.0) } + } + fn set_cell_type_to_poly_line(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_poly_line( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_poly_line(self.0) } + } + fn set_cell_type_to_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_triangle(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_triangle(self.0) } + } + fn set_cell_type_to_triangle_strip(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_triangle_strip( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_triangle_strip(self.0) } + } + fn set_cell_type_to_polygon(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_polygon(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_polygon(self.0) } + } + fn set_cell_type_to_pixel(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_pixel(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_pixel(self.0) } + } + fn set_cell_type_to_quad(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quad(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_quad(self.0) } + } + fn set_cell_type_to_tetra(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_tetra(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_tetra(self.0) } + } + fn set_cell_type_to_voxel(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_voxel(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_voxel(self.0) } + } + fn set_cell_type_to_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_hexahedron(self.0) } + } + fn set_cell_type_to_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_wedge(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_wedge(self.0) } + } + fn set_cell_type_to_pyramid(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_pyramid(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_pyramid(self.0) } + } + fn set_cell_type_to_pentagonal_prism(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_pentagonal_prism( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_pentagonal_prism(self.0) } + } + fn set_cell_type_to_hexagonal_prism(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_hexagonal_prism( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_hexagonal_prism(self.0) } + } + fn set_cell_type_to_polyhedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_polyhedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_polyhedron(self.0) } + } + fn set_cell_type_to_convex_point_set(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_convex_point_set( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_convex_point_set(self.0) } + } + fn set_cell_type_to_quadratic_edge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_edge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_edge(self.0) } + } + fn set_cell_type_to_cubic_line(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_cubic_line( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_cubic_line(self.0) } + } + fn set_cell_type_to_quadratic_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_triangle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_triangle(self.0) } + } + fn set_cell_type_to_bi_quadratic_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle(self.0) } + } + fn set_cell_type_to_quadratic_quad(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_quad( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_quad(self.0) } + } + fn set_cell_type_to_quadratic_polygon(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_polygon( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_polygon(self.0) } + } + fn set_cell_type_to_quadratic_tetra(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_tetra( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_tetra(self.0) } + } + fn set_cell_type_to_quadratic_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_hexahedron(self.0) } + } + fn set_cell_type_to_quadratic_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_wedge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_wedge(self.0) } + } + fn set_cell_type_to_quadratic_pyramid(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_pyramid( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_pyramid(self.0) } + } + fn set_cell_type_to_quadratic_linear_quad(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_linear_quad( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_linear_quad(self.0) } + } + fn set_cell_type_to_bi_quadratic_quad(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bi_quadratic_quad( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bi_quadratic_quad(self.0) } + } + fn set_cell_type_to_quadratic_linear_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge(self.0) } + } + fn set_cell_type_to_bi_quadratic_quadratic_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge(self.0) } + } + fn set_cell_type_to_tri_quadratic_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron(self.0) } + } + fn set_cell_type_to_tri_quadratic_pyramid(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid(self.0) } + } + fn set_cell_type_to_bi_quadratic_quadratic_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron(self.0) + } + } + fn set_cell_type_to_lagrange_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_triangle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_triangle(self.0) } + } + fn set_cell_type_to_lagrange_tetra(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_tetra( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_tetra(self.0) } + } + fn set_cell_type_to_lagrange_curve(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_curve( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_curve(self.0) } + } + fn set_cell_type_to_lagrange_quadrilateral(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral(self.0) } + } + fn set_cell_type_to_lagrange_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_hexahedron(self.0) } + } + fn set_cell_type_to_lagrange_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_wedge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_wedge(self.0) } + } + fn set_cell_type_to_bezier_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_triangle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_triangle(self.0) } + } + fn set_cell_type_to_bezier_tetra(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_tetra( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_tetra(self.0) } + } + fn set_cell_type_to_bezier_curve(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_curve( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_curve(self.0) } + } + fn set_cell_type_to_bezier_quadrilateral(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_quadrilateral( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_quadrilateral(self.0) } + } + fn set_cell_type_to_bezier_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_hexahedron(self.0) } + } + fn set_cell_type_to_bezier_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_wedge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_wedge(self.0) } + } + fn instantiate_cell( + &mut self, + cellType: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_instantiate_cell( + sself: *mut core::ffi::c_void, + cellType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_instantiate_cell(self.0, cellType) } + } + fn get_representative_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_get_representative_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_get_representative_cell(self.0) } + } +} +impl VtkGenericEdgeTable for vtkGenericEdgeTable { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_edge_table_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_edge_table_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_edge_table_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_edge_table_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_edge_table_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_edge_table_new_instance(self.0) } + } + fn insert_edge( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ref_: core::ffi::c_int, + ptId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_insert_edge( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ref_: core::ffi::c_int, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_generic_edge_table_insert_edge(self.0, e1, e2, cellId, ref_, ptId) } + } + fn insert_edge( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ref_: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_insert_edge( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ref_: core::ffi::c_int, + ); + } + unsafe { vtk_generic_edge_table_insert_edge(self.0, e1, e2, cellId, ref_) } + } + fn remove_edge( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_remove_edge( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_remove_edge(self.0, e1, e2) } + } + fn check_edge( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_check_edge( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_check_edge(self.0, e1, e2, ptId) } + } + fn increment_edge_reference_count( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_increment_edge_reference_count( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_edge_table_increment_edge_reference_count(self.0, e1, e2, cellId) + } + } + fn check_edge_reference_count( + &mut self, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_check_edge_reference_count( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_uchar, + e2: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_check_edge_reference_count(self.0, e1, e2) } + } + fn initialize(&mut self, start: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_initialize( + sself: *mut core::ffi::c_void, + start: core::ffi::c_uchar, + ); + } + unsafe { vtk_generic_edge_table_initialize(self.0, start) } + } + fn get_number_of_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_get_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_get_number_of_components(self.0) } + } + fn set_number_of_components(&mut self, count: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_set_number_of_components( + sself: *mut core::ffi::c_void, + count: core::ffi::c_int, + ); + } + unsafe { vtk_generic_edge_table_set_number_of_components(self.0, count) } + } + fn check_point(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_check_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_check_point(self.0, ptId) } + } + fn check_point( + &mut self, + ptId: core::ffi::c_uchar, + point: core::ffi::c_double, + scalar: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_check_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + point: core::ffi::c_double, + scalar: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_check_point(self.0, ptId, point, scalar) } + } + fn insert_point( + &mut self, + ptId: core::ffi::c_uchar, + point: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_insert_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + point: core::ffi::c_double, + ); + } + unsafe { vtk_generic_edge_table_insert_point(self.0, ptId, point) } + } + fn insert_point_and_scalar( + &mut self, + ptId: core::ffi::c_uchar, + pt: core::ffi::c_double, + s: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_insert_point_and_scalar( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + pt: core::ffi::c_double, + s: core::ffi::c_double, + ); + } + unsafe { vtk_generic_edge_table_insert_point_and_scalar(self.0, ptId, pt, s) } + } + fn remove_point(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_remove_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_generic_edge_table_remove_point(self.0, ptId) } + } + fn increment_point_reference_count(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_increment_point_reference_count( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_generic_edge_table_increment_point_reference_count(self.0, ptId) } + } + fn dump_table(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_dump_table(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_edge_table_dump_table(self.0) } + } + fn load_factor(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_load_factor(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_edge_table_load_factor(self.0) } + } +} +impl VtkGenericInterpolatedVelocityField for vtkGenericInterpolatedVelocityField { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_interpolated_velocity_field_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_interpolated_velocity_field_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_interpolated_velocity_field_new(self.0) } + } + fn function_values( + &mut self, + x: core::ffi::c_double, + f: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_function_values( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + f: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_interpolated_velocity_field_function_values(self.0, x, f) } + } + fn add_data_set(&mut self, dataset: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_add_data_set( + sself: *mut core::ffi::c_void, + dataset: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_add_data_set(self.0, dataset) } + } + fn clear_last_cell(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_clear_last_cell( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_clear_last_cell(self.0) } + } + fn get_last_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_last_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_interpolated_velocity_field_get_last_cell(self.0) } + } + fn get_last_local_coordinates( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_last_local_coordinates( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_interpolated_velocity_field_get_last_local_coordinates( + self.0, + pcoords, + ) + } + } + fn get_caching(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_caching( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_interpolated_velocity_field_get_caching(self.0) } + } + fn set_caching(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_set_caching( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_set_caching(self.0, _arg) } + } + fn caching_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_caching_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_caching_on(self.0) } + } + fn caching_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_caching_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_caching_off(self.0) } + } + fn get_cache_hit(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_cache_hit( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_interpolated_velocity_field_get_cache_hit(self.0) } + } + fn get_cache_miss(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_cache_miss( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_interpolated_velocity_field_get_cache_miss(self.0) } + } + fn get_vectors_selection(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_vectors_selection( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_generic_interpolated_velocity_field_get_vectors_selection(self.0) } + } + fn select_vectors(&mut self, fieldName: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_select_vectors( + sself: *mut core::ffi::c_void, + fieldName: core::ffi::c_char, + ); + } + unsafe { + vtk_generic_interpolated_velocity_field_select_vectors(self.0, fieldName) + } + } + fn get_last_data_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_last_data_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_interpolated_velocity_field_get_last_data_set(self.0) } + } + fn copy_parameters(&mut self, from: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_copy_parameters( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_copy_parameters(self.0, from) } + } +} +impl VtkGeometricErrorMetric for vtkGeometricErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_geometric_error_metric_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_geometric_error_metric_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_geometric_error_metric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_geometric_error_metric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_geometric_error_metric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_geometric_error_metric_new_instance(self.0) } + } + fn get_absolute_geometric_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_geometric_error_metric_get_absolute_geometric_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_geometric_error_metric_get_absolute_geometric_tolerance(self.0) } + } + fn set_absolute_geometric_tolerance(&mut self, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_geometric_error_metric_set_absolute_geometric_tolerance( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_geometric_error_metric_set_absolute_geometric_tolerance(self.0, value) + } + } + fn set_relative_geometric_tolerance( + &mut self, + value: core::ffi::c_double, + ds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_geometric_error_metric_set_relative_geometric_tolerance( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ds: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_geometric_error_metric_set_relative_geometric_tolerance( + self.0, + value, + ds, + ) + } + } + fn requires_edge_subdivision( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_geometric_error_metric_requires_edge_subdivision( + sself: *mut core::ffi::c_void, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_geometric_error_metric_requires_edge_subdivision( + self.0, + leftPoint, + midPoint, + rightPoint, + alpha, + ) + } + } + fn get_error( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_geometric_error_metric_get_error( + sself: *mut core::ffi::c_void, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_geometric_error_metric_get_error( + self.0, + leftPoint, + midPoint, + rightPoint, + alpha, + ) + } + } + fn get_relative(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_geometric_error_metric_get_relative( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_geometric_error_metric_get_relative(self.0) } + } +} +impl VtkGraphEdge for vtkGraphEdge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_edge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_edge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_edge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_edge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_edge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_edge_new_instance(self.0) } + } + fn set_source(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_graph_edge_set_source( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_graph_edge_set_source(self.0, _arg) } + } + fn get_source(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_graph_edge_get_source( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_graph_edge_get_source(self.0) } + } + fn set_target(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_graph_edge_set_target( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_graph_edge_set_target(self.0, _arg) } + } + fn get_target(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_graph_edge_get_target( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_graph_edge_get_target(self.0) } + } + fn set_id(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_graph_edge_set_id( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_graph_edge_set_id(self.0, _arg) } + } + fn get_id(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_graph_edge_get_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_graph_edge_get_id(self.0) } + } +} +impl VtkGraphInternals for vtkGraphInternals { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_internals_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_internals_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_internals_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_internals_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_internals_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_internals_new_instance(self.0) } + } + fn remove_edge_from_out_list( + &mut self, + e: core::ffi::c_uchar, + outEdges: Vec, + ) -> () { + unsafe extern "C" { + fn vtk_graph_internals_remove_edge_from_out_list( + sself: *mut core::ffi::c_void, + e: core::ffi::c_uchar, + outEdges: Vec, + ); + } + unsafe { vtk_graph_internals_remove_edge_from_out_list(self.0, e, outEdges) } + } + fn remove_edge_from_in_list( + &mut self, + e: core::ffi::c_uchar, + inEdges: Vec, + ) -> () { + unsafe extern "C" { + fn vtk_graph_internals_remove_edge_from_in_list( + sself: *mut core::ffi::c_void, + e: core::ffi::c_uchar, + inEdges: Vec, + ); + } + unsafe { vtk_graph_internals_remove_edge_from_in_list(self.0, e, inEdges) } + } + fn replace_edge_from_out_list( + &mut self, + from: core::ffi::c_uchar, + to: core::ffi::c_uchar, + outEdges: Vec, + ) -> () { + unsafe extern "C" { + fn vtk_graph_internals_replace_edge_from_out_list( + sself: *mut core::ffi::c_void, + from: core::ffi::c_uchar, + to: core::ffi::c_uchar, + outEdges: Vec, + ); + } + unsafe { + vtk_graph_internals_replace_edge_from_out_list(self.0, from, to, outEdges) + } + } + fn replace_edge_from_in_list( + &mut self, + from: core::ffi::c_uchar, + to: core::ffi::c_uchar, + inEdges: Vec, + ) -> () { + unsafe extern "C" { + fn vtk_graph_internals_replace_edge_from_in_list( + sself: *mut core::ffi::c_void, + from: core::ffi::c_uchar, + to: core::ffi::c_uchar, + inEdges: Vec, + ); + } + unsafe { + vtk_graph_internals_replace_edge_from_in_list(self.0, from, to, inEdges) + } + } +} +impl VtkHexagonalPrism for vtkHexagonalPrism { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexagonal_prism_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexagonal_prism_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexagonal_prism_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexagonal_prism_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexagonal_prism_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexagonal_prism_new_instance(self.0) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_hexagonal_prism_get_edge_points(self.0, edgeId, pts) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_hexagonal_prism_get_edge_points(self.0, edgeId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hexagonal_prism_get_face_points(self.0, faceId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_hexagonal_prism_get_face_points(self.0, faceId, pts) } + } + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_edge_to_adjacent_faces( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_hexagonal_prism_get_edge_to_adjacent_faces(self.0, edgeId, pts) } + } + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_face_to_adjacent_faces( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_hexagonal_prism_get_face_to_adjacent_faces(self.0, faceId, faceIds) + } + } + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_point_to_incident_edges( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_hexagonal_prism_get_point_to_incident_edges(self.0, pointId, edgeIds) + } + } + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_point_to_incident_faces( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_hexagonal_prism_get_point_to_incident_faces(self.0, pointId, faceIds) + } + } + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_point_to_one_ring_points( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hexagonal_prism_get_point_to_one_ring_points(self.0, pointId, pts) } + } + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_centroid( + sself: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_hexagonal_prism_get_centroid(self.0, centroid) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexagonal_prism_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexagonal_prism_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexagonal_prism_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexagonal_prism_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexagonal_prism_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexagonal_prism_cell_boundary(self.0, subId, pcoords, pts) } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_hexagonal_prism_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_hexagonal_prism_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_hexagonal_prism_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexagonal_prism_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_hexagonal_prism_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexagonal_prism_get_parametric_center(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_hexagonal_prism_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_hexagonal_prism_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_hexagonal_prism_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_hexagonal_prism_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexagonal_prism_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexagonal_prism_get_face_array(self.0, faceId) } + } + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_edge_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexagonal_prism_get_edge_to_adjacent_faces_array(self.0, edgeId) } + } + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_face_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexagonal_prism_get_face_to_adjacent_faces_array(self.0, faceId) } + } + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_point_to_incident_edges_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexagonal_prism_get_point_to_incident_edges_array(self.0, pointId) } + } + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_point_to_incident_faces_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexagonal_prism_get_point_to_incident_faces_array(self.0, pointId) } + } + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_point_to_one_ring_points_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { + vtk_hexagonal_prism_get_point_to_one_ring_points_array(self.0, pointId) + } + } + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_hexagonal_prism_compute_centroid( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { + vtk_hexagonal_prism_compute_centroid(self.0, points, pointIds, centroid) + } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexagonal_prism_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_hexagonal_prism_jacobian_inverse(self.0, pcoords, inverse, derivs) } + } +} +impl VtkHexahedron for vtkHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexahedron_new_instance(self.0) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_hexahedron_get_edge_points(self.0, edgeId, pts) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_hexahedron_get_edge_points(self.0, edgeId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_face_points(self.0, faceId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_hexahedron_get_face_points(self.0, faceId, pts) } + } + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_get_edge_to_adjacent_faces( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_hexahedron_get_edge_to_adjacent_faces(self.0, edgeId, pts) } + } + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_face_to_adjacent_faces( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_face_to_adjacent_faces(self.0, faceId, faceIds) } + } + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_point_to_incident_edges( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_point_to_incident_edges(self.0, pointId, edgeIds) } + } + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_point_to_incident_faces( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_point_to_incident_faces(self.0, pointId, faceIds) } + } + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_point_to_one_ring_points( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_point_to_one_ring_points(self.0, pointId, pts) } + } + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_hexahedron_get_centroid( + sself: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_hexahedron_get_centroid(self.0, centroid) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexahedron_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexahedron_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexahedron_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexahedron_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexahedron_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexahedron_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexahedron_cell_boundary(self.0, subId, pcoords, pts) } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_hexahedron_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_hexahedron_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_hexahedron_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexahedron_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_hexahedron_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_get_triangle_cases( + sself: *mut core::ffi::c_void, + caseId: core::ffi::c_int, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_hexahedron_get_triangle_cases(self.0, caseId) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_hexahedron_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_hexahedron_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_hexahedron_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_hexahedron_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_face_array(self.0, faceId) } + } + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_edge_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_edge_to_adjacent_faces_array(self.0, edgeId) } + } + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_face_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_face_to_adjacent_faces_array(self.0, faceId) } + } + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_point_to_incident_edges_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_point_to_incident_edges_array(self.0, pointId) } + } + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_point_to_incident_faces_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_point_to_incident_faces_array(self.0, pointId) } + } + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hexahedron_get_point_to_one_ring_points_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_hexahedron_get_point_to_one_ring_points_array(self.0, pointId) } + } + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_hexahedron_compute_centroid( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_hexahedron_compute_centroid(self.0, points, pointIds, centroid) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hexahedron_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_hexahedron_jacobian_inverse(self.0, pcoords, inverse, derivs) } + } +} +impl VtkHierarchicalBoxDataIterator for vtkHierarchicalBoxDataIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_iterator_new_instance(self.0) } + } +} +impl VtkHierarchicalBoxDataSet for vtkHierarchicalBoxDataSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_new_instance(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_new_iterator(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_get_data(self.0, v, i) } + } +} +impl VtkHyperTreeGrid for vtkHyperTreeGrid { + fn levels(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_levels( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_levels(self.0) } + } + fn dimension(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_dimension( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_dimension(self.0) } + } + fn orientation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_orientation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_orientation(self.0) } + } + fn sizes(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_sizes( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_sizes(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_new_instance(self.0) } + } + fn set_mode_squeeze(&mut self, _arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_mode_squeeze( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { vtk_hyper_tree_grid_set_mode_squeeze(self.0, _arg) } + } + fn get_mode_squeeze(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_mode_squeeze( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_hyper_tree_grid_get_mode_squeeze(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_squeeze(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hyper_tree_grid_get_data_object_type(self.0) } + } + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_copy_structure( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_copy_structure(self.0, p0) } + } + fn copy_empty_structure(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_copy_empty_structure( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_copy_empty_structure(self.0, p0) } + } + fn set_dimensions(&mut self, dims: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_dimensions( + sself: *mut core::ffi::c_void, + dims: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_set_dimensions(self.0, dims) } + } + fn set_dimensions(&mut self, dims: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_dimensions( + sself: *mut core::ffi::c_void, + dims: core::ffi::c_int, + ); + } + unsafe { vtk_hyper_tree_grid_set_dimensions(self.0, dims) } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_uint, + j: core::ffi::c_uint, + k: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uint, + j: core::ffi::c_uint, + k: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_set_dimensions(self.0, i, j, k) } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_hyper_tree_grid_set_dimensions(self.0, i, j, k) } + } + fn get_dimensions(&mut self) -> *const core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_dimensions( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_dimensions(self.0) } + } + fn get_dimensions(&mut self, dim: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_dimensions( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ); + } + unsafe { vtk_hyper_tree_grid_get_dimensions(self.0, dim) } + } + fn get_dimensions(&mut self, dim: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_dimensions( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_get_dimensions(self.0, dim) } + } + fn set_extent(&mut self, extent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_extent( + sself: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_hyper_tree_grid_set_extent(self.0, extent) } + } + fn set_extent( + &mut self, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_extent( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ); + } + unsafe { vtk_hyper_tree_grid_set_extent(self.0, x1, x2, y1, y2, z1, z2) } + } + fn get_extent(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_hyper_tree_grid_get_extent(self.0) } + } + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_hyper_tree_grid_get_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_hyper_tree_grid_get_extent(self.0, _arg) } + } + fn get_cell_dims(&mut self) -> *const core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_cell_dims( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_cell_dims(self.0) } + } + fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_cell_dims( + sself: *mut core::ffi::c_void, + cellDims: core::ffi::c_int, + ); + } + unsafe { vtk_hyper_tree_grid_get_cell_dims(self.0, cellDims) } + } + fn get_cell_dims(&mut self, cellDims: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_cell_dims( + sself: *mut core::ffi::c_void, + cellDims: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_get_cell_dims(self.0, cellDims) } + } + fn get_dimension(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_dimension(self.0) } + } + fn get_1_d_axis(&mut self, axis: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_1_d_axis( + sself: *mut core::ffi::c_void, + axis: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_get_1_d_axis(self.0, axis) } + } + fn get_2_d_axes( + &mut self, + axis1: core::ffi::c_uint, + axis2: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_2_d_axes( + sself: *mut core::ffi::c_void, + axis1: core::ffi::c_uint, + axis2: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_get_2_d_axes(self.0, axis1, axis2) } + } + fn get_axes(&mut self) -> *const core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_axes( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_axes(self.0) } + } + fn get_number_of_children(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_children( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_number_of_children(self.0) } + } + fn set_transposed_root_indexing(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_transposed_root_indexing( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_set_transposed_root_indexing(self.0, _arg) } + } + fn get_transposed_root_indexing(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_transposed_root_indexing( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_get_transposed_root_indexing(self.0) } + } + fn set_indexing_mode_to_kji(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_indexing_mode_to_kji( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_indexing_mode_to_kji(self.0) } + } + fn set_indexing_mode_to_ijk(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_indexing_mode_to_ijk( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_indexing_mode_to_ijk(self.0) } + } + fn get_orientation(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_orientation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_orientation(self.0) } + } + fn get_freeze_state(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_freeze_state( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_get_freeze_state(self.0) } + } + fn set_branch_factor(&mut self, p0: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_branch_factor( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_set_branch_factor(self.0, p0) } + } + fn get_branch_factor(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_branch_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_branch_factor(self.0) } + } + fn get_max_number_of_trees(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_max_number_of_trees( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_get_max_number_of_trees(self.0) } + } + fn get_number_of_vertices(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_vertices( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_get_number_of_vertices(self.0) } + } + fn get_number_of_non_empty_trees(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_non_empty_trees( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_get_number_of_non_empty_trees(self.0) } + } + fn get_number_of_leaves(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_leaves( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_get_number_of_leaves(self.0) } + } + fn get_number_of_levels(&mut self, p0: core::ffi::c_uchar) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_levels( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_number_of_levels(self.0, p0) } + } + fn get_number_of_levels(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_levels( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_number_of_levels(self.0) } + } + fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_x_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_x_coordinates(self.0, p0) } + } + fn get_x_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_x_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_x_coordinates(self.0) } + } + fn set_y_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_y_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_y_coordinates(self.0, p0) } + } + fn get_y_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_y_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_y_coordinates(self.0) } + } + fn set_z_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_z_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_z_coordinates(self.0, p0) } + } + fn get_z_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_z_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_z_coordinates(self.0) } + } + fn copy_coordinates(&mut self, output: vtkHyperTreeGrid) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_copy_coordinates( + sself: *mut core::ffi::c_void, + output: vtkHyperTreeGrid, + ); + } + unsafe { vtk_hyper_tree_grid_copy_coordinates(self.0, output) } + } + fn set_fixed_coordinates( + &mut self, + axis: core::ffi::c_uint, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_fixed_coordinates( + sself: *mut core::ffi::c_void, + axis: core::ffi::c_uint, + value: core::ffi::c_double, + ); + } + unsafe { vtk_hyper_tree_grid_set_fixed_coordinates(self.0, axis, value) } + } + fn set_mask(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_mask( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_mask(self.0, p0) } + } + fn get_mask(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_mask( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_mask(self.0) } + } + fn has_mask(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_has_mask(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_hyper_tree_grid_has_mask(self.0) } + } + fn set_has_interface(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_has_interface( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_set_has_interface(self.0, _arg) } + } + fn get_has_interface(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_has_interface( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_get_has_interface(self.0) } + } + fn has_interface_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_has_interface_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_has_interface_on(self.0) } + } + fn has_interface_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_has_interface_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_has_interface_off(self.0) } + } + fn set_interface_normals_name(&mut self, _arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_interface_normals_name( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { vtk_hyper_tree_grid_set_interface_normals_name(self.0, _arg) } + } + fn get_interface_normals_name(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_interface_normals_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_hyper_tree_grid_get_interface_normals_name(self.0) } + } + fn set_interface_intercepts_name(&mut self, _arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_interface_intercepts_name( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { vtk_hyper_tree_grid_set_interface_intercepts_name(self.0, _arg) } + } + fn get_interface_intercepts_name(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_interface_intercepts_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_hyper_tree_grid_get_interface_intercepts_name(self.0) } + } + fn set_depth_limiter(&mut self, _arg: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_depth_limiter( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_set_depth_limiter(self.0, _arg) } + } + fn get_depth_limiter(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_depth_limiter( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_depth_limiter(self.0) } + } + fn initialize_oriented_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_oriented_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_oriented_cursor(self.0, cursor, index, create) + } + } + fn new_oriented_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_oriented_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_new_oriented_cursor(self.0, index, create) } + } + fn initialize_oriented_geometry_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_oriented_geometry_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_oriented_geometry_cursor( + self.0, + cursor, + index, + create, + ) + } + } + fn new_oriented_geometry_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_oriented_geometry_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_oriented_geometry_cursor(self.0, index, create) + } + } + fn initialize_non_oriented_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_cursor( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_new_non_oriented_cursor(self.0, index, create) } + } + fn initialize_non_oriented_geometry_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_geometry_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_geometry_cursor( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_geometry_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_geometry_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_non_oriented_geometry_cursor(self.0, index, create) + } + } + fn find_non_oriented_geometry_cursor( + &mut self, + x: core::ffi::c_double, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_find_non_oriented_geometry_cursor( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_find_non_oriented_geometry_cursor(self.0, x) } + } + fn find_dichotomic_x(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_find_dichotomic_x( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_find_dichotomic_x(self.0, value) } + } + fn find_dichotomic_y(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_find_dichotomic_y( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_find_dichotomic_y(self.0, value) } + } + fn find_dichotomic_z(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_find_dichotomic_z( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_find_dichotomic_z(self.0, value) } + } + fn initialize_non_oriented_von_neumann_super_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_von_neumann_super_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_von_neumann_super_cursor( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_von_neumann_super_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_von_neumann_super_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_non_oriented_von_neumann_super_cursor( + self.0, + index, + create, + ) + } + } + fn initialize_non_oriented_von_neumann_super_cursor_light( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_von_neumann_super_cursor_light( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_von_neumann_super_cursor_light( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_von_neumann_super_cursor_light( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_von_neumann_super_cursor_light( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_non_oriented_von_neumann_super_cursor_light( + self.0, + index, + create, + ) + } + } + fn initialize_non_oriented_moore_super_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_moore_super_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_moore_super_cursor( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_moore_super_cursor( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_moore_super_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_non_oriented_moore_super_cursor( + self.0, + index, + create, + ) + } + } + fn initialize_non_oriented_moore_super_cursor_light( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_moore_super_cursor_light( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_moore_super_cursor_light( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_moore_super_cursor_light( + &mut self, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_moore_super_cursor_light( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_non_oriented_moore_super_cursor_light( + self.0, + index, + create, + ) + } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_initialize(self.0) } + } + fn get_tree( + &mut self, + p0: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_tree( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_tree(self.0, p0, create) } + } + fn set_tree(&mut self, p0: core::ffi::c_uchar, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_tree( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_tree(self.0, p0, p1) } + } + fn shallow_copy(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_shallow_copy( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_shallow_copy(self.0, p0) } + } + fn deep_copy(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_deep_copy( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_deep_copy(self.0, p0) } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hyper_tree_grid_get_extent_type(self.0) } + } + fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_actual_memory_size_bytes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_hyper_tree_grid_get_actual_memory_size_bytes(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_hyper_tree_grid_get_actual_memory_size(self.0) } + } + fn recursively_initialize_pure_mask( + &mut self, + cursor: *mut core::ffi::c_void, + normale: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_recursively_initialize_pure_mask( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + normale: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_hyper_tree_grid_recursively_initialize_pure_mask(self.0, cursor, normale) + } + } + fn get_pure_mask(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_pure_mask( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_pure_mask(self.0) } + } + fn get_child_mask(&mut self, p0: core::ffi::c_uint) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_child_mask( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uint, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_child_mask(self.0, p0) } + } + fn get_index_from_level_zero_coordinates( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_index_from_level_zero_coordinates( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ); + } + unsafe { + vtk_hyper_tree_grid_get_index_from_level_zero_coordinates( + self.0, + p0, + p1, + p2, + p3, + ) + } + } + fn get_shifted_level_zero_index( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_shifted_level_zero_index( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_hyper_tree_grid_get_shifted_level_zero_index(self.0, p0, p1, p2, p3) + } + } + fn get_level_zero_coordinates_from_index( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_level_zero_coordinates_from_index( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ); + } + unsafe { + vtk_hyper_tree_grid_get_level_zero_coordinates_from_index( + self.0, + p0, + p1, + p2, + p3, + ) + } + } + fn get_level_zero_origin_and_size_from_index( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_level_zero_origin_and_size_from_index( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ); + } + unsafe { + vtk_hyper_tree_grid_get_level_zero_origin_and_size_from_index( + self.0, + p0, + p1, + p2, + ) + } + } + fn get_level_zero_origin_from_index( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_level_zero_origin_from_index( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + p1: core::ffi::c_double, + ); + } + unsafe { vtk_hyper_tree_grid_get_level_zero_origin_from_index(self.0, p0, p1) } + } + fn get_global_node_index_max(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_global_node_index_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_get_global_node_index_max(self.0) } + } + fn initialize_local_index_node(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_local_index_node( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_initialize_local_index_node(self.0) } + } + fn has_any_ghost_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_has_any_ghost_cells( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_has_any_ghost_cells(self.0) } + } + fn get_ghost_cells(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_ghost_cells( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_ghost_cells(self.0) } + } + fn get_tree_ghost_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_tree_ghost_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_tree_ghost_array(self.0) } + } + fn allocate_tree_ghost_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_allocate_tree_ghost_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_allocate_tree_ghost_array(self.0) } + } + fn initialize_tree_iterator(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_tree_iterator( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_initialize_tree_iterator(self.0, p0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_data(self.0, v, i) } + } + fn get_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_hyper_tree_grid_get_bounds(self.0) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_hyper_tree_grid_get_bounds(self.0, bounds) } + } + fn get_center(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_center( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_hyper_tree_grid_get_center(self.0) } + } + fn get_center(&mut self, center: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_center( + sself: *mut core::ffi::c_void, + center: core::ffi::c_double, + ); + } + unsafe { vtk_hyper_tree_grid_get_center(self.0, center) } + } + fn get_cell_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_cell_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_cell_data(self.0) } + } + fn get_attributes_as_field_data( + &mut self, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_attributes_as_field_data( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_attributes_as_field_data(self.0, type_) } + } + fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_elements( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_get_number_of_elements(self.0, type_) } + } +} +impl VtkHyperTreeGridNonOrientedCursor for vtkHyperTreeGridNonOrientedCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_new(self.0) } + } + fn clone(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_clone( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_clone(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_cursor_initialize( + self.0, + grid, + tree, + level, + entry, + ) + } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_cursor_initialize( + self.0, + grid, + tree, + level, + index, + ) + } + } + fn get_grid(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_grid( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_grid(self.0) } + } + fn has_tree(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_has_tree( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_has_tree(self.0) } + } + fn get_tree(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_tree( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_tree(self.0) } + } + fn get_vertex_id(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(self.0) } + } + fn get_global_node_index(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_dimension(self.0) } + } + fn get_number_of_children(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(self.0) } + } + fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(self.0, index) + } + } + fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local( + self.0, + index, + ) + } + } + fn set_mask(&mut self, state: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_set_mask( + sself: *mut core::ffi::c_void, + state: bool, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_set_mask(self.0, state) } + } + fn is_masked(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_is_masked( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_is_masked(self.0) } + } + fn is_leaf(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_is_leaf( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_is_leaf(self.0) } + } + fn subdivide_leaf(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf(self.0) } + } + fn is_root(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_is_root( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_is_root(self.0) } + } + fn get_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_level(self.0) } + } + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_to_child( + sself: *mut core::ffi::c_void, + ichild: core::ffi::c_uchar, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_to_child(self.0, ichild) } + } + fn to_root(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_to_root( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_to_root(self.0) } + } + fn to_parent(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_to_parent( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_to_parent(self.0) } + } +} +impl VtkHyperTreeGridNonOrientedGeometryCursor +for vtkHyperTreeGridNonOrientedGeometryCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_safe_down_cast(self.0, o) + } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_new(self.0) } + } + fn clone(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_clone( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_clone(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( + self.0, + grid, + tree, + level, + entry, + ) + } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + origin: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + origin: core::ffi::c_double, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( + self.0, + grid, + tree, + level, + index, + origin, + ) + } + } + fn initialize(&mut self, cursor: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize(self.0, cursor) + } + } + fn has_tree(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(self.0) } + } + fn get_tree(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_tree( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_tree(self.0) } + } + fn get_vertex_id(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(self.0) } + } + fn get_global_node_index(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index( + self.0, + ) + } + } + fn get_dimension(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension(self.0) } + } + fn get_number_of_children(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children( + self.0, + ) + } + } + fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start( + self.0, + index, + ) + } + } + fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local( + self.0, + index, + ) + } + } + fn get_origin(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_origin( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_origin(self.0) } + } + fn get_size(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_size( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_size(self.0) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_bounds(self.0, bounds) + } + } + fn get_point(&mut self, point: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_point( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_point(self.0, point) + } + } + fn set_mask(&mut self, state: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask( + sself: *mut core::ffi::c_void, + state: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask(self.0, state) + } + } + fn is_masked(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked(self.0) } + } + fn is_leaf(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf(self.0) } + } + fn subdivide_leaf(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf(self.0) + } + } + fn is_root(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root(self.0) } + } + fn get_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level(self.0) } + } + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child( + sself: *mut core::ffi::c_void, + ichild: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child(self.0, ichild) + } + } + fn to_root(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(self.0) } + } + fn to_parent(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(self.0) } + } +} +impl VtkHyperTreeGridNonOrientedMooreSuperCursor +for vtkHyperTreeGridNonOrientedMooreSuperCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_safe_down_cast(self.0, o) + } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_new_instance(self.0) + } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_moore_super_cursor_new(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn get_corner_cursors( + &mut self, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_get_corner_cursors( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_get_corner_cursors( + self.0, + p0, + p1, + p2, + ) + } + } +} +impl VtkHyperTreeGridNonOrientedMooreSuperCursorLight +for vtkHyperTreeGridNonOrientedMooreSuperCursorLight { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_safe_down_cast( + self.0, + o, + ) + } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_new_instance( + self.0, + ) + } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_new(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn get_corner_cursors( + &mut self, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_get_corner_cursors( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_get_corner_cursors( + self.0, + p0, + p1, + p2, + ) + } + } +} +impl VtkHyperTreeGridNonOrientedVonNeumannSuperCursor +for vtkHyperTreeGridNonOrientedVonNeumannSuperCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_safe_down_cast( + self.0, + o, + ) + } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_new_instance( + self.0, + ) + } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_new(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } +} +impl VtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight +for vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_safe_down_cast( + self.0, + o, + ) + } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_new_instance( + self.0, + ) + } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_new(self.0) + } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } +} +impl VtkHyperTreeGridOrientedCursor for vtkHyperTreeGridOrientedCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_new(self.0) } + } + fn clone(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_clone( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_clone(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_cursor_initialize( + self.0, + grid, + tree, + level, + index, + ) + } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_cursor_initialize( + self.0, + grid, + tree, + level, + entry, + ) + } + } + fn get_grid(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_grid( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_grid(self.0) } + } + fn has_tree(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_has_tree( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_has_tree(self.0) } + } + fn get_tree(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_tree( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_tree(self.0) } + } + fn get_vertex_id(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_vertex_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(self.0) } + } + fn get_global_node_index(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_global_node_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_dimension(self.0) } + } + fn get_number_of_children(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_number_of_children( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(self.0) } + } + fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_set_global_index_start( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(self.0, index) + } + } + fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local( + self.0, + index, + ) + } + } + fn set_mask(&mut self, state: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_set_mask( + sself: *mut core::ffi::c_void, + state: bool, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_set_mask(self.0, state) } + } + fn is_masked(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_is_masked( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_is_masked(self.0) } + } + fn is_leaf(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_is_leaf( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_is_leaf(self.0) } + } + fn subdivide_leaf(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf(self.0) } + } + fn is_root(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_is_root( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_is_root(self.0) } + } + fn get_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_level(self.0) } + } + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_to_child( + sself: *mut core::ffi::c_void, + ichild: core::ffi::c_uchar, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_to_child(self.0, ichild) } + } +} +impl VtkHyperTreeGridOrientedGeometryCursor for vtkHyperTreeGridOrientedGeometryCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_new(self.0) } + } + fn clone(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_clone( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_clone(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_uchar, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + entry: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( + self.0, + grid, + tree, + level, + entry, + ) + } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + origin: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + tree: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uchar, + origin: core::ffi::c_double, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( + self.0, + grid, + tree, + level, + index, + origin, + ) + } + } + fn initialize(&mut self, cursor: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_initialize(self.0, cursor) + } + } + fn has_tree(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(self.0) } + } + fn get_tree(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_tree( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_tree(self.0) } + } + fn get_vertex_id(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(self.0) } + } + fn get_global_node_index(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(self.0) + } + } + fn get_dimension(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension(self.0) } + } + fn get_number_of_children(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(self.0) + } + } + fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start( + self.0, + index, + ) + } + } + fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local( + self.0, + index, + ) + } + } + fn get_origin(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_origin( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_origin(self.0) } + } + fn get_size(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_size( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_size(self.0) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_get_bounds(self.0, bounds) + } + } + fn get_point(&mut self, point: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_point( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_point(self.0, point) } + } + fn set_mask(&mut self, state: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask( + sself: *mut core::ffi::c_void, + state: bool, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask(self.0, state) } + } + fn is_masked(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked(self.0) } + } + fn is_leaf(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf(self.0) } + } + fn subdivide_leaf(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf(self.0) } + } + fn is_root(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_is_root( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_is_root(self.0) } + } + fn get_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(self.0) } + } + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_to_child( + sself: *mut core::ffi::c_void, + ichild: core::ffi::c_uchar, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(self.0, ichild) } + } +} +impl VtkImageData for vtkImageData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_new_instance(self.0) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_image_data_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_copy_structure(self.0, ds) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_data_object_type(self.0) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_get_number_of_cells(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_get_number_of_points(self.0) } + } + fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_image_data_get_point(self.0, ptId) } + } + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_cell(self.0, cellId) } + } + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_get_cell(self.0, cellId, cell) } + } + fn find_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_find_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_find_point(self.0, x, y, z) } + } + fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_find_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_find_point(self.0, x) } + } + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_find_cell( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_image_data_find_cell( + self.0, + x, + cell, + cellId, + tol2, + subId, + pcoords, + weights, + ) + } + } + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_find_cell( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_image_data_find_cell( + self.0, + x, + cell, + gencell, + cellId, + tol2, + subId, + pcoords, + weights, + ) + } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_cell_type(self.0, cellId) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_get_point_cells(self.0, ptId, cellIds) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_max_cell_size(self.0) } + } + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + seedLoc: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_cell_neighbors( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + seedLoc: core::ffi::c_int, + ); + } + unsafe { + vtk_image_data_get_cell_neighbors(self.0, cellId, ptIds, cellIds, seedLoc) + } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_image_data_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_image_data_initialize(self.0) } + } + fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_is_point_visible( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_is_point_visible(self.0, ptId) } + } + fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_is_cell_visible( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_is_cell_visible(self.0, cellId) } + } + fn has_any_blank_points(&mut self) -> bool { + unsafe extern "C" { + fn vtk_image_data_has_any_blank_points( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_image_data_has_any_blank_points(self.0) } + } + fn has_any_blank_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_image_data_has_any_blank_cells(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_image_data_has_any_blank_cells(self.0) } + } + fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_image_data_get_cell_dims( + sself: *mut core::ffi::c_void, + cellDims: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_get_cell_dims(self.0, cellDims) } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_set_dimensions(self.0, i, j, k) } + } + fn set_dimensions(&mut self, dims: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_image_data_set_dimensions( + sself: *mut core::ffi::c_void, + dims: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_set_dimensions(self.0, dims) } + } + fn get_dimensions(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_dimensions( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_image_data_get_dimensions(self.0) } + } + fn get_dimensions(&mut self, dims: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_image_data_get_dimensions( + sself: *mut core::ffi::c_void, + dims: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_get_dimensions(self.0, dims) } + } + fn get_dimensions(&mut self, dims: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_image_data_get_dimensions( + sself: *mut core::ffi::c_void, + dims: core::ffi::c_uchar, + ); + } + unsafe { vtk_image_data_get_dimensions(self.0, dims) } + } + fn compute_structured_coordinates( + &mut self, + x: core::ffi::c_double, + ijk: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_compute_structured_coordinates( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ijk: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_compute_structured_coordinates(self.0, x, ijk, pcoords) } + } + fn get_voxel_gradient( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + s: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_voxel_gradient( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + s: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_get_voxel_gradient(self.0, i, j, k, s, g) } + } + fn get_point_gradient( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + s: *mut core::ffi::c_void, + g: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_point_gradient( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + s: *mut core::ffi::c_void, + g: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_get_point_gradient(self.0, i, j, k, s, g) } + } + fn get_data_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_data_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_data_dimension(self.0) } + } + fn compute_point_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_compute_point_id( + sself: *mut core::ffi::c_void, + ijk: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_compute_point_id(self.0, ijk) } + } + fn compute_cell_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_compute_cell_id( + sself: *mut core::ffi::c_void, + ijk: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_compute_cell_id(self.0, ijk) } + } + fn set_axis_update_extent( + &mut self, + axis: core::ffi::c_int, + min: core::ffi::c_int, + max: core::ffi::c_int, + updateExtent: core::ffi::c_int, + axisUpdateExtent: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_axis_update_extent( + sself: *mut core::ffi::c_void, + axis: core::ffi::c_int, + min: core::ffi::c_int, + max: core::ffi::c_int, + updateExtent: core::ffi::c_int, + axisUpdateExtent: core::ffi::c_int, + ); + } + unsafe { + vtk_image_data_set_axis_update_extent( + self.0, + axis, + min, + max, + updateExtent, + axisUpdateExtent, + ) + } + } + fn get_axis_update_extent( + &mut self, + axis: core::ffi::c_int, + min: core::ffi::c_int, + max: core::ffi::c_int, + updateExtent: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_axis_update_extent( + sself: *mut core::ffi::c_void, + axis: core::ffi::c_int, + min: core::ffi::c_int, + max: core::ffi::c_int, + updateExtent: core::ffi::c_int, + ); + } + unsafe { + vtk_image_data_get_axis_update_extent(self.0, axis, min, max, updateExtent) + } + } + fn set_extent(&mut self, extent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_image_data_set_extent( + sself: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_set_extent(self.0, extent) } + } + fn set_extent( + &mut self, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_extent( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_set_extent(self.0, x1, x2, y1, y2, z1, z2) } + } + fn get_extent(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_image_data_get_extent(self.0) } + } + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_image_data_get_extent(self.0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6) + } + } + fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_image_data_get_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_get_extent(self.0, _arg) } + } + fn get_scalar_type_min( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type_min( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_image_data_get_scalar_type_min(self.0, meta_data) } + } + fn get_scalar_type_min(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_image_data_get_scalar_type_min(self.0) } + } + fn get_scalar_type_max( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type_max( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_image_data_get_scalar_type_max(self.0, meta_data) } + } + fn get_scalar_type_max(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_image_data_get_scalar_type_max(self.0) } + } + fn get_scalar_size( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_scalar_size( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_scalar_size(self.0, meta_data) } + } + fn get_scalar_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_scalar_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_scalar_size(self.0) } + } + fn get_increments(&mut self) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_get_increments( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_image_data_get_increments(self.0) } + } + fn get_increments( + &mut self, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_increments( + sself: *mut core::ffi::c_void, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ); + } + unsafe { vtk_image_data_get_increments(self.0, incX, incY, incZ) } + } + fn get_increments(&mut self, inc: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_image_data_get_increments( + sself: *mut core::ffi::c_void, + inc: core::ffi::c_uchar, + ); + } + unsafe { vtk_image_data_get_increments(self.0, inc) } + } + fn get_increments( + &mut self, + scalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_get_increments( + sself: *mut core::ffi::c_void, + scalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_image_data_get_increments(self.0, scalars) } + } + fn get_increments( + &mut self, + scalars: *mut core::ffi::c_void, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_increments( + sself: *mut core::ffi::c_void, + scalars: *mut core::ffi::c_void, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ); + } + unsafe { vtk_image_data_get_increments(self.0, scalars, incX, incY, incZ) } + } + fn get_increments( + &mut self, + scalars: *mut core::ffi::c_void, + inc: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_increments( + sself: *mut core::ffi::c_void, + scalars: *mut core::ffi::c_void, + inc: core::ffi::c_uchar, + ); + } + unsafe { vtk_image_data_get_increments(self.0, scalars, inc) } + } + fn get_continuous_increments( + &mut self, + extent: core::ffi::c_int, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_continuous_increments( + sself: *mut core::ffi::c_void, + extent: core::ffi::c_int, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ); + } + unsafe { + vtk_image_data_get_continuous_increments(self.0, extent, incX, incY, incZ) + } + } + fn get_continuous_increments( + &mut self, + scalars: *mut core::ffi::c_void, + extent: core::ffi::c_int, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_continuous_increments( + sself: *mut core::ffi::c_void, + scalars: *mut core::ffi::c_void, + extent: core::ffi::c_int, + incX: core::ffi::c_uchar, + incY: core::ffi::c_uchar, + incZ: core::ffi::c_uchar, + ); + } + unsafe { + vtk_image_data_get_continuous_increments( + self.0, + scalars, + extent, + incX, + incY, + incZ, + ) + } + } + fn get_scalar_pointer_for_extent(&mut self, extent: core::ffi::c_int) -> *mut () { + unsafe extern "C" { + fn vtk_image_data_get_scalar_pointer_for_extent( + sself: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> *mut (); + } + unsafe { vtk_image_data_get_scalar_pointer_for_extent(self.0, extent) } + } + fn get_scalar_pointer(&mut self, coordinates: core::ffi::c_int) -> *mut () { + unsafe extern "C" { + fn vtk_image_data_get_scalar_pointer( + sself: *mut core::ffi::c_void, + coordinates: core::ffi::c_int, + ) -> *mut (); + } + unsafe { vtk_image_data_get_scalar_pointer(self.0, coordinates) } + } + fn get_scalar_pointer( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + ) -> *mut () { + unsafe extern "C" { + fn vtk_image_data_get_scalar_pointer( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + ) -> *mut (); + } + unsafe { vtk_image_data_get_scalar_pointer(self.0, x, y, z) } + } + fn get_scalar_pointer(&mut self) -> *mut () { + unsafe extern "C" { + fn vtk_image_data_get_scalar_pointer( + sself: *mut core::ffi::c_void, + ) -> *mut (); + } + unsafe { vtk_image_data_get_scalar_pointer(self.0) } + } + fn get_scalar_index_for_extent( + &mut self, + extent: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_get_scalar_index_for_extent( + sself: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_get_scalar_index_for_extent(self.0, extent) } + } + fn get_scalar_index(&mut self, coordinates: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_get_scalar_index( + sself: *mut core::ffi::c_void, + coordinates: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_get_scalar_index(self.0, coordinates) } + } + fn get_scalar_index( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_get_scalar_index( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_get_scalar_index(self.0, x, y, z) } + } + fn get_scalar_component_as_float( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_image_data_get_scalar_component_as_float( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_float; + } + unsafe { + vtk_image_data_get_scalar_component_as_float(self.0, x, y, z, component) + } + } + fn set_scalar_component_from_float( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_scalar_component_from_float( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_float, + ); + } + unsafe { + vtk_image_data_set_scalar_component_from_float(self.0, x, y, z, component, v) + } + } + fn get_scalar_component_as_double( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_scalar_component_as_double( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { + vtk_image_data_get_scalar_component_as_double(self.0, x, y, z, component) + } + } + fn set_scalar_component_from_double( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_scalar_component_from_double( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_set_scalar_component_from_double( + self.0, + x, + y, + z, + component, + v, + ) + } + } + fn allocate_scalars( + &mut self, + dataType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_allocate_scalars( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_allocate_scalars(self.0, dataType, numComponents) } + } + fn allocate_scalars(&mut self, pipeline_info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_image_data_allocate_scalars( + sself: *mut core::ffi::c_void, + pipeline_info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_allocate_scalars(self.0, pipeline_info) } + } + fn copy_and_cast_from( + &mut self, + inData: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_copy_and_cast_from( + sself: *mut core::ffi::c_void, + inData: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_copy_and_cast_from(self.0, inData, extent) } + } + fn copy_and_cast_from( + &mut self, + inData: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_copy_and_cast_from( + sself: *mut core::ffi::c_void, + inData: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ); + } + unsafe { + vtk_image_data_copy_and_cast_from(self.0, inData, x0, x1, y0, y1, z0, z1) + } + } + fn crop(&mut self, updateExtent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_image_data_crop( + sself: *mut core::ffi::c_void, + updateExtent: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_crop(self.0, updateExtent) } + } + fn get_spacing(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_spacing( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_image_data_get_spacing(self.0) } + } + fn get_spacing( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_spacing( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_get_spacing(self.0, _arg1, _arg2, _arg3) } + } + fn get_spacing(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_image_data_get_spacing( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_get_spacing(self.0, _arg) } + } + fn set_spacing( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_spacing( + sself: *mut core::ffi::c_void, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_set_spacing(self.0, i, j, k) } + } + fn set_spacing(&mut self, ijk: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_image_data_set_spacing( + sself: *mut core::ffi::c_void, + ijk: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_set_spacing(self.0, ijk) } + } + fn get_origin(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_origin( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_image_data_get_origin(self.0) } + } + fn get_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_origin( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_get_origin(self.0, _arg1, _arg2, _arg3) } + } + fn get_origin(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_image_data_get_origin( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_get_origin(self.0, _arg) } + } + fn set_origin( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_origin( + sself: *mut core::ffi::c_void, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_set_origin(self.0, i, j, k) } + } + fn set_origin(&mut self, ijk: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_image_data_set_origin( + sself: *mut core::ffi::c_void, + ijk: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_set_origin(self.0, ijk) } + } + fn get_direction_matrix(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_direction_matrix( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_direction_matrix(self.0) } + } + fn set_direction_matrix(&mut self, m: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_image_data_set_direction_matrix( + sself: *mut core::ffi::c_void, + m: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_set_direction_matrix(self.0, m) } + } + fn set_direction_matrix(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_image_data_set_direction_matrix( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_set_direction_matrix(self.0, elements) } + } + fn set_direction_matrix( + &mut self, + e00: core::ffi::c_double, + e01: core::ffi::c_double, + e02: core::ffi::c_double, + e10: core::ffi::c_double, + e11: core::ffi::c_double, + e12: core::ffi::c_double, + e20: core::ffi::c_double, + e21: core::ffi::c_double, + e22: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_direction_matrix( + sself: *mut core::ffi::c_void, + e00: core::ffi::c_double, + e01: core::ffi::c_double, + e02: core::ffi::c_double, + e10: core::ffi::c_double, + e11: core::ffi::c_double, + e12: core::ffi::c_double, + e20: core::ffi::c_double, + e21: core::ffi::c_double, + e22: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_set_direction_matrix( + self.0, + e00, + e01, + e02, + e10, + e11, + e12, + e20, + e21, + e22, + ) + } + } + fn get_index_to_physical_matrix(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_index_to_physical_matrix( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_index_to_physical_matrix(self.0) } + } + fn transform_continuous_index_to_physical_point( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + xyz: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_transform_continuous_index_to_physical_point( + sself: *mut core::ffi::c_void, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + xyz: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_transform_continuous_index_to_physical_point( + self.0, + i, + j, + k, + xyz, + ) + } + } + fn transform_continuous_index_to_physical_point( + &mut self, + ijk: core::ffi::c_double, + xyz: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_transform_continuous_index_to_physical_point( + sself: *mut core::ffi::c_void, + ijk: core::ffi::c_double, + xyz: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_transform_continuous_index_to_physical_point(self.0, ijk, xyz) + } + } + fn transform_index_to_physical_point( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + xyz: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_transform_index_to_physical_point( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + xyz: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_transform_index_to_physical_point(self.0, i, j, k, xyz) } + } + fn transform_index_to_physical_point( + &mut self, + ijk: core::ffi::c_int, + xyz: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_transform_index_to_physical_point( + sself: *mut core::ffi::c_void, + ijk: core::ffi::c_int, + xyz: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_transform_index_to_physical_point(self.0, ijk, xyz) } + } + fn transform_continuous_index_to_physical_point( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + direction: core::ffi::c_double, + xyz: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_transform_continuous_index_to_physical_point( + sself: *mut core::ffi::c_void, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + direction: core::ffi::c_double, + xyz: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_transform_continuous_index_to_physical_point( + self.0, + i, + j, + k, + origin, + spacing, + direction, + xyz, + ) + } + } + fn get_physical_to_index_matrix(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_physical_to_index_matrix( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_physical_to_index_matrix(self.0) } + } + fn transform_physical_point_to_continuous_index( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ijk: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_transform_physical_point_to_continuous_index( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ijk: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_transform_physical_point_to_continuous_index( + self.0, + x, + y, + z, + ijk, + ) + } + } + fn transform_physical_point_to_continuous_index( + &mut self, + xyz: core::ffi::c_double, + ijk: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_transform_physical_point_to_continuous_index( + sself: *mut core::ffi::c_void, + xyz: core::ffi::c_double, + ijk: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_transform_physical_point_to_continuous_index(self.0, xyz, ijk) + } + } + fn compute_index_to_physical_matrix( + &mut self, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + direction: core::ffi::c_double, + result: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_compute_index_to_physical_matrix( + sself: *mut core::ffi::c_void, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + direction: core::ffi::c_double, + result: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_compute_index_to_physical_matrix( + self.0, + origin, + spacing, + direction, + result, + ) + } + } + fn transform_physical_normal_to_continuous_index( + &mut self, + xyz: core::ffi::c_double, + ijk: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_transform_physical_normal_to_continuous_index( + sself: *mut core::ffi::c_void, + xyz: core::ffi::c_double, + ijk: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_transform_physical_normal_to_continuous_index( + self.0, + xyz, + ijk, + ) + } + } + fn transform_physical_plane_to_continuous_index( + &mut self, + pplane: core::ffi::c_double, + iplane: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_transform_physical_plane_to_continuous_index( + sself: *mut core::ffi::c_void, + pplane: core::ffi::c_double, + iplane: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_transform_physical_plane_to_continuous_index( + self.0, + pplane, + iplane, + ) + } + } + fn set_scalar_type( + &mut self, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_scalar_type( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_set_scalar_type(self.0, p0, meta_data) } + } + fn get_scalar_type( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_scalar_type(self.0, meta_data) } + } + fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_image_data_has_scalar_type( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_image_data_has_scalar_type(self.0, meta_data) } + } + fn get_scalar_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_scalar_type(self.0) } + } + fn get_scalar_type_as_string(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_image_data_get_scalar_type_as_string(self.0) } + } + fn set_number_of_scalar_components( + &mut self, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_number_of_scalar_components( + sself: *mut core::ffi::c_void, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_set_number_of_scalar_components(self.0, n, meta_data) } + } + fn get_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_number_of_scalar_components( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_number_of_scalar_components(self.0, meta_data) } + } + fn has_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_image_data_has_number_of_scalar_components( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_image_data_has_number_of_scalar_components(self.0, meta_data) } + } + fn get_number_of_scalar_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_number_of_scalar_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_number_of_scalar_components(self.0) } + } + fn copy_information_from_pipeline( + &mut self, + information: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_copy_information_from_pipeline( + sself: *mut core::ffi::c_void, + information: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_copy_information_from_pipeline(self.0, information) } + } + fn copy_information_to_pipeline( + &mut self, + information: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_copy_information_to_pipeline( + sself: *mut core::ffi::c_void, + information: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_copy_information_to_pipeline(self.0, information) } + } + fn prepare_for_new_data(&mut self) -> () { + unsafe extern "C" { + fn vtk_image_data_prepare_for_new_data(sself: *mut core::ffi::c_void); + } + unsafe { vtk_image_data_prepare_for_new_data(self.0) } + } + fn get_array_pointer_for_extent( + &mut self, + array: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> *mut () { + unsafe extern "C" { + fn vtk_image_data_get_array_pointer_for_extent( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> *mut (); + } + unsafe { vtk_image_data_get_array_pointer_for_extent(self.0, array, extent) } + } + fn get_array_pointer( + &mut self, + array: *mut core::ffi::c_void, + coordinates: core::ffi::c_int, + ) -> *mut () { + unsafe extern "C" { + fn vtk_image_data_get_array_pointer( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + coordinates: core::ffi::c_int, + ) -> *mut (); + } + unsafe { vtk_image_data_get_array_pointer(self.0, array, coordinates) } + } + fn get_tuple_index( + &mut self, + array: *mut core::ffi::c_void, + coordinates: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_get_tuple_index( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + coordinates: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_get_tuple_index(self.0, array, coordinates) } + } + fn get_array_increments( + &mut self, + array: *mut core::ffi::c_void, + increments: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_array_increments( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + increments: core::ffi::c_uchar, + ); + } + unsafe { vtk_image_data_get_array_increments(self.0, array, increments) } + } + fn compute_internal_extent( + &mut self, + intExt: core::ffi::c_int, + tgtExt: core::ffi::c_int, + bnds: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_compute_internal_extent( + sself: *mut core::ffi::c_void, + intExt: core::ffi::c_int, + tgtExt: core::ffi::c_int, + bnds: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_compute_internal_extent(self.0, intExt, tgtExt, bnds) } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_extent_type(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_data(self.0, v, i) } + } +} +impl VtkImageTransform for vtkImageTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_transform_new_instance(self.0) } + } + fn transform_point_set( + &mut self, + im: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_transform_transform_point_set( + sself: *mut core::ffi::c_void, + im: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_transform_transform_point_set(self.0, im, ps) } + } + fn transform_point_set( + &mut self, + im: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + transNormals: bool, + transVectors: bool, + ) -> () { + unsafe extern "C" { + fn vtk_image_transform_transform_point_set( + sself: *mut core::ffi::c_void, + im: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + transNormals: bool, + transVectors: bool, + ); + } + unsafe { + vtk_image_transform_transform_point_set( + self.0, + im, + ps, + transNormals, + transVectors, + ) + } + } + fn translate_points( + &mut self, + t: core::ffi::c_double, + da: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_transform_translate_points( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_transform_translate_points(self.0, t, da) } + } + fn transform_points( + &mut self, + m4: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_transform_transform_points( + sself: *mut core::ffi::c_void, + m4: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_transform_transform_points(self.0, m4, da) } + } + fn transform_normals( + &mut self, + m3: *mut core::ffi::c_void, + spacing: core::ffi::c_double, + da: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_transform_transform_normals( + sself: *mut core::ffi::c_void, + m3: *mut core::ffi::c_void, + spacing: core::ffi::c_double, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_transform_transform_normals(self.0, m3, spacing, da) } + } + fn transform_vectors( + &mut self, + m3: *mut core::ffi::c_void, + spacing: core::ffi::c_double, + da: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_transform_transform_vectors( + sself: *mut core::ffi::c_void, + m3: *mut core::ffi::c_void, + spacing: core::ffi::c_double, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_transform_transform_vectors(self.0, m3, spacing, da) } + } +} +impl VtkImplicitBoolean for vtkImplicitBoolean { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_boolean_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_boolean_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_boolean_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_boolean_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_boolean_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_boolean_new(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_boolean_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_boolean_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + g: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_boolean_evaluate_gradient(self.0, x, g) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_boolean_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_boolean_get_m_time(self.0) } + } + fn add_function(&mut self, in_: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_add_function( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_add_function(self.0, in_) } + } + fn remove_function(&mut self, in_: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_remove_function( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_remove_function(self.0, in_) } + } + fn get_function(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_boolean_get_function( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_boolean_get_function(self.0) } + } + fn set_operation_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_set_operation_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_implicit_boolean_set_operation_type(self.0, _arg) } + } + fn get_operation_type_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_implicit_boolean_get_operation_type_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_implicit_boolean_get_operation_type_min_value(self.0) } + } + fn get_operation_type_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_implicit_boolean_get_operation_type_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_implicit_boolean_get_operation_type_max_value(self.0) } + } + fn get_operation_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_implicit_boolean_get_operation_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_implicit_boolean_get_operation_type(self.0) } + } + fn set_operation_type_to_union(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_set_operation_type_to_union( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_set_operation_type_to_union(self.0) } + } + fn set_operation_type_to_intersection(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_set_operation_type_to_intersection( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_set_operation_type_to_intersection(self.0) } + } + fn set_operation_type_to_difference(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_set_operation_type_to_difference( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_set_operation_type_to_difference(self.0) } + } + fn set_operation_type_to_union_of_magnitudes(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(self.0) } + } + fn get_operation_type_as_string(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_implicit_boolean_get_operation_type_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_implicit_boolean_get_operation_type_as_string(self.0) } + } +} +impl VtkImplicitDataSet for vtkImplicitDataSet { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_data_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_data_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_data_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_data_set_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_data_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_data_set_new(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_data_set_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_data_set_get_m_time(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_data_set_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_data_set_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_data_set_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_data_set_evaluate_gradient(self.0, x, n) } + } + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_data_set_set_data_set( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_data_set_set_data_set(self.0, p0) } + } + fn get_data_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_data_set_get_data_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_data_set_get_data_set(self.0) } + } + fn set_out_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_data_set_set_out_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_data_set_set_out_value(self.0, _arg) } + } + fn get_out_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_data_set_get_out_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_data_set_get_out_value(self.0) } + } + fn set_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_data_set_set_out_gradient( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_data_set_set_out_gradient(self.0, _arg1, _arg2, _arg3) } + } + fn set_out_gradient(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_data_set_set_out_gradient( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_data_set_set_out_gradient(self.0, _arg) } + } + fn get_out_gradient(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_data_set_get_out_gradient( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_implicit_data_set_get_out_gradient(self.0) } + } + fn get_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_data_set_get_out_gradient( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_data_set_get_out_gradient(self.0, _arg1, _arg2, _arg3) } + } + fn get_out_gradient(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_data_set_get_out_gradient( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_data_set_get_out_gradient(self.0, _arg) } + } +} +impl VtkImplicitFunctionCollection for vtkImplicitFunctionCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_function_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_function_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_function_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_function_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_function_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_function_collection_new(self.0) } + } + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_function_collection_add_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_function_collection_add_item(self.0, p0) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_function_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_function_collection_get_next_item(self.0) } + } + fn get_next_implicit_function(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_function_collection_get_next_implicit_function( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_implicit_function_collection_get_next_implicit_function(self.0, cookie) + } + } +} +impl VtkImplicitHalo for vtkImplicitHalo { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_halo_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_halo_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_halo_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_halo_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_halo_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_halo_new_instance(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_halo_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_halo_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_halo_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + g: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_halo_evaluate_gradient(self.0, x, g) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_halo_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_halo_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_halo_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_halo_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_halo_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_halo_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_center(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_halo_set_center( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_halo_set_center(self.0, _arg) } + } + fn get_center(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_halo_get_center( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_implicit_halo_get_center(self.0) } + } + fn get_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_halo_get_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_halo_get_center(self.0, _arg1, _arg2, _arg3) } + } + fn get_center(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_halo_get_center( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_halo_get_center(self.0, _arg) } + } + fn set_fade_out(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_halo_set_fade_out( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_halo_set_fade_out(self.0, _arg) } + } + fn get_fade_out(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_halo_get_fade_out( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_halo_get_fade_out(self.0) } + } +} +impl VtkImplicitSelectionLoop for vtkImplicitSelectionLoop { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_selection_loop_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_selection_loop_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_selection_loop_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_selection_loop_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_selection_loop_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_selection_loop_new(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_selection_loop_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_selection_loop_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_selection_loop_evaluate_gradient(self.0, x, n) } + } + fn set_loop(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_set_loop( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_selection_loop_set_loop(self.0, p0) } + } + fn get_loop(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_selection_loop_get_loop( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_selection_loop_get_loop(self.0) } + } + fn set_automatic_normal_generation(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_set_automatic_normal_generation( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_implicit_selection_loop_set_automatic_normal_generation(self.0, _arg) + } + } + fn get_automatic_normal_generation(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_implicit_selection_loop_get_automatic_normal_generation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_implicit_selection_loop_get_automatic_normal_generation(self.0) } + } + fn automatic_normal_generation_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_automatic_normal_generation_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_selection_loop_automatic_normal_generation_on(self.0) } + } + fn automatic_normal_generation_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_automatic_normal_generation_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_selection_loop_automatic_normal_generation_off(self.0) } + } + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_set_normal( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_selection_loop_set_normal(self.0, _arg1, _arg2, _arg3) } + } + fn set_normal(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_set_normal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_selection_loop_set_normal(self.0, _arg) } + } + fn get_normal(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_selection_loop_get_normal( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_implicit_selection_loop_get_normal(self.0) } + } + fn get_normal(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_get_normal( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_selection_loop_get_normal(self.0, data) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_selection_loop_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_selection_loop_get_m_time(self.0) } + } +} +impl VtkImplicitSum for vtkImplicitSum { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_sum_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_sum_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_sum_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_sum_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_sum_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_sum_new_instance(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_sum_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_sum_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + g: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_sum_evaluate_gradient(self.0, x, g) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_sum_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_sum_get_m_time(self.0) } + } + fn add_function( + &mut self, + in_: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_add_function( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_sum_add_function(self.0, in_, weight) } + } + fn add_function(&mut self, in_: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_add_function( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_sum_add_function(self.0, in_) } + } + fn remove_all_functions(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_remove_all_functions(sself: *mut core::ffi::c_void); + } + unsafe { vtk_implicit_sum_remove_all_functions(self.0) } + } + fn set_function_weight( + &mut self, + f: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_set_function_weight( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_sum_set_function_weight(self.0, f, weight) } + } + fn set_normalize_by_weight(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_set_normalize_by_weight( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_implicit_sum_set_normalize_by_weight(self.0, _arg) } + } + fn get_normalize_by_weight(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_implicit_sum_get_normalize_by_weight( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_implicit_sum_get_normalize_by_weight(self.0) } + } + fn normalize_by_weight_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_normalize_by_weight_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_implicit_sum_normalize_by_weight_on(self.0) } + } + fn normalize_by_weight_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_normalize_by_weight_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_implicit_sum_normalize_by_weight_off(self.0) } + } +} +impl VtkImplicitVolume for vtkImplicitVolume { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_volume_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_volume_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_volume_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_volume_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_volume_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_volume_new(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_volume_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_volume_get_m_time(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_volume_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_volume_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_volume_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_volume_evaluate_gradient(self.0, x, n) } + } + fn set_volume(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_volume_set_volume( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_volume_set_volume(self.0, p0) } + } + fn get_volume(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_volume_get_volume( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_volume_get_volume(self.0) } + } + fn set_out_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_volume_set_out_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_volume_set_out_value(self.0, _arg) } + } + fn get_out_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_volume_get_out_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_volume_get_out_value(self.0) } + } + fn set_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_volume_set_out_gradient( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_volume_set_out_gradient(self.0, _arg1, _arg2, _arg3) } + } + fn set_out_gradient(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_volume_set_out_gradient( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_volume_set_out_gradient(self.0, _arg) } + } + fn get_out_gradient(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_volume_get_out_gradient( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_implicit_volume_get_out_gradient(self.0) } + } + fn get_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_volume_get_out_gradient( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_volume_get_out_gradient(self.0, _arg1, _arg2, _arg3) } + } + fn get_out_gradient(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_volume_get_out_gradient( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_volume_get_out_gradient(self.0, _arg) } + } +} +impl VtkImplicitWindowFunction for vtkImplicitWindowFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_window_function_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_window_function_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_window_function_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_window_function_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_window_function_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_window_function_new(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_window_function_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_window_function_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_window_function_evaluate_gradient(self.0, x, n) } + } + fn set_implicit_function(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_set_implicit_function( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_window_function_set_implicit_function(self.0, p0) } + } + fn get_implicit_function(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_window_function_get_implicit_function( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_window_function_get_implicit_function(self.0) } + } + fn set_window_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_set_window_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_window_function_set_window_range(self.0, _arg1, _arg2) } + } + fn set_window_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_set_window_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_window_function_set_window_range(self.0, _arg) } + } + fn get_window_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_window_function_get_window_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_implicit_window_function_get_window_range(self.0) } + } + fn get_window_range(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_get_window_range( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_window_function_get_window_range(self.0, data) } + } + fn set_window_values( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_set_window_values( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_window_function_set_window_values(self.0, _arg1, _arg2) } + } + fn set_window_values(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_set_window_values( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_window_function_set_window_values(self.0, _arg) } + } + fn get_window_values(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_window_function_get_window_values( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_implicit_window_function_get_window_values(self.0) } + } + fn get_window_values(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_get_window_values( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_window_function_get_window_values(self.0, data) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_window_function_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_window_function_get_m_time(self.0) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_window_function_register(self.0, o) } + } +} +impl VtkInEdgeIterator for vtkInEdgeIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_new_instance(self.0) } + } + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_in_edge_iterator_initialize( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + ); + } + unsafe { vtk_in_edge_iterator_initialize(self.0, g, v) } + } + fn get_graph(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_get_graph( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_get_graph(self.0) } + } + fn get_vertex(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_in_edge_iterator_get_vertex( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_in_edge_iterator_get_vertex(self.0) } + } + fn next(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_next( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_next(self.0) } + } + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_next_graph_edge( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_next_graph_edge(self.0) } + } + fn has_next(&mut self) -> bool { + unsafe extern "C" { + fn vtk_in_edge_iterator_has_next(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_in_edge_iterator_has_next(self.0) } + } +} +impl VtkIncrementalOctreeNode for vtkIncrementalOctreeNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_new(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_get_number_of_points(self.0) } + } + fn get_point_id_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_point_id_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_get_point_id_set(self.0) } + } + fn delete_child_nodes(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_delete_child_nodes( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_node_delete_child_nodes(self.0) } + } + fn set_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_set_bounds( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ); + } + unsafe { vtk_incremental_octree_node_set_bounds(self.0, x1, x2, y1, y2, z1, z2) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_incremental_octree_node_get_bounds(self.0, bounds) } + } + fn get_min_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_min_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_incremental_octree_node_get_min_bounds(self.0) } + } + fn get_min_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_min_bounds( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { + vtk_incremental_octree_node_get_min_bounds(self.0, _arg1, _arg2, _arg3) + } + } + fn get_min_bounds(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_min_bounds( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_incremental_octree_node_get_min_bounds(self.0, _arg) } + } + fn get_max_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_max_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_incremental_octree_node_get_max_bounds(self.0) } + } + fn get_max_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_max_bounds( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { + vtk_incremental_octree_node_get_max_bounds(self.0, _arg1, _arg2, _arg3) + } + } + fn get_max_bounds(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_max_bounds( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_incremental_octree_node_get_max_bounds(self.0, _arg) } + } + fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_min_data_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_incremental_octree_node_get_min_data_bounds(self.0) } + } + fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_max_data_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_incremental_octree_node_get_max_data_bounds(self.0) } + } + fn is_leaf(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_is_leaf( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_is_leaf(self.0) } + } + fn get_child_index(&mut self, point: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_child_index( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_get_child_index(self.0, point) } + } + fn get_child(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_child( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_get_child(self.0, i) } + } + fn contains_point(&mut self, pnt: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_contains_point( + sself: *mut core::ffi::c_void, + pnt: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_contains_point(self.0, pnt) } + } + fn contains_point_by_data(&mut self, pnt: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_contains_point_by_data( + sself: *mut core::ffi::c_void, + pnt: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_contains_point_by_data(self.0, pnt) } + } + fn insert_point( + &mut self, + points: *mut core::ffi::c_void, + newPnt: core::ffi::c_double, + maxPts: core::ffi::c_int, + pntId: core::ffi::c_uchar, + ptMode: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_insert_point( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + newPnt: core::ffi::c_double, + maxPts: core::ffi::c_int, + pntId: core::ffi::c_uchar, + ptMode: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_incremental_octree_node_insert_point( + self.0, + points, + newPnt, + maxPts, + pntId, + ptMode, + ) + } + } + fn insert_point( + &mut self, + points: *mut core::ffi::c_void, + newPnt: core::ffi::c_double, + maxPts: core::ffi::c_int, + pntId: core::ffi::c_uchar, + ptMode: core::ffi::c_int, + numberOfNodes: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_insert_point( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + newPnt: core::ffi::c_double, + maxPts: core::ffi::c_int, + pntId: core::ffi::c_uchar, + ptMode: core::ffi::c_int, + numberOfNodes: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_incremental_octree_node_insert_point( + self.0, + points, + newPnt, + maxPts, + pntId, + ptMode, + numberOfNodes, + ) + } + } + fn get_distance_2_to_inner_boundary( + &mut self, + point: core::ffi::c_double, + rootNode: *mut core::ffi::c_void, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_distance_2_to_inner_boundary( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + rootNode: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { + vtk_incremental_octree_node_get_distance_2_to_inner_boundary( + self.0, + point, + rootNode, + ) + } + } + fn get_distance_2_to_boundary( + &mut self, + point: core::ffi::c_double, + rootNode: *mut core::ffi::c_void, + checkData: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_distance_2_to_boundary( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + rootNode: *mut core::ffi::c_void, + checkData: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { + vtk_incremental_octree_node_get_distance_2_to_boundary( + self.0, + point, + rootNode, + checkData, + ) + } + } + fn get_distance_2_to_boundary( + &mut self, + point: core::ffi::c_double, + closest: core::ffi::c_double, + rootNode: *mut core::ffi::c_void, + checkData: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_distance_2_to_boundary( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + closest: core::ffi::c_double, + rootNode: *mut core::ffi::c_void, + checkData: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { + vtk_incremental_octree_node_get_distance_2_to_boundary( + self.0, + point, + closest, + rootNode, + checkData, + ) + } + } + fn export_all_point_ids_by_insertion( + &mut self, + idList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_export_all_point_ids_by_insertion( + sself: *mut core::ffi::c_void, + idList: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_incremental_octree_node_export_all_point_ids_by_insertion(self.0, idList) + } + } + fn export_all_point_ids_by_direct_set( + &mut self, + pntIdx: core::ffi::c_uchar, + idList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_export_all_point_ids_by_direct_set( + sself: *mut core::ffi::c_void, + pntIdx: core::ffi::c_uchar, + idList: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_incremental_octree_node_export_all_point_ids_by_direct_set( + self.0, + pntIdx, + idList, + ) + } + } + fn get_number_of_levels(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_number_of_levels( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_get_number_of_levels(self.0) } + } + fn get_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_get_id(self.0) } + } + fn get_point_ids(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_point_ids( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_get_point_ids(self.0) } + } +} +impl VtkIncrementalOctreePointLocator for vtkIncrementalOctreePointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_point_locator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_point_locator_new(self.0) } + } + fn set_max_points_per_leaf(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_set_max_points_per_leaf( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_incremental_octree_point_locator_set_max_points_per_leaf(self.0, _arg) + } + } + fn get_max_points_per_leaf_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value( + self.0, + ) + } + } + fn get_max_points_per_leaf_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value( + self.0, + ) + } + } + fn get_max_points_per_leaf(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_max_points_per_leaf( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_point_locator_get_max_points_per_leaf(self.0) } + } + fn set_build_cubic_octree(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_set_build_cubic_octree( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_incremental_octree_point_locator_set_build_cubic_octree(self.0, _arg) + } + } + fn get_build_cubic_octree(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_build_cubic_octree( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_point_locator_get_build_cubic_octree(self.0) } + } + fn build_cubic_octree_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_build_cubic_octree_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_point_locator_build_cubic_octree_on(self.0) } + } + fn build_cubic_octree_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_build_cubic_octree_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_point_locator_build_cubic_octree_off(self.0) } + } + fn get_locator_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_locator_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_point_locator_get_locator_points(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_initialize( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_point_locator_initialize(self.0) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_point_locator_free_search_structure(self.0) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_incremental_octree_point_locator_get_bounds(self.0, bounds) } + } + fn get_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_incremental_octree_point_locator_get_bounds(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_point_locator_get_number_of_points(self.0) } + } + fn get_number_of_nodes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_number_of_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_point_locator_get_number_of_nodes(self.0) } + } + fn find_closest_inserted_point( + &mut self, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_closest_inserted_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_incremental_octree_point_locator_find_closest_inserted_point(self.0, x) + } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + polysData: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + polysData: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_incremental_octree_point_locator_generate_representation( + self.0, + level, + polysData, + ) + } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + polysData: *mut core::ffi::c_void, + UserGetBounds: *mut core::ffi::c_void, + data: (), + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + polysData: *mut core::ffi::c_void, + UserGetBounds: *mut core::ffi::c_void, + data: (), + ); + } + unsafe { + vtk_incremental_octree_point_locator_generate_representation( + self.0, + level, + polysData, + UserGetBounds, + data, + ) + } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_build_locator( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_point_locator_build_locator(self.0) } + } + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_incremental_octree_point_locator_find_closest_point(self.0, x) } + } + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_incremental_octree_point_locator_find_closest_point(self.0, x, y, z) + } + } + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + miniDist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + miniDist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_incremental_octree_point_locator_find_closest_point(self.0, x, miniDist2) + } + } + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + miniDist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + miniDist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_incremental_octree_point_locator_find_closest_point( + self.0, + x, + y, + z, + miniDist2, + ) + } + } + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_incremental_octree_point_locator_find_closest_point_within_radius( + self.0, + radius, + x, + dist2, + ) + } + } + fn find_closest_point_within_squared_radius( + &mut self, + radius2: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_closest_point_within_squared_radius( + sself: *mut core::ffi::c_void, + radius2: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_incremental_octree_point_locator_find_closest_point_within_squared_radius( + self.0, + radius2, + x, + dist2, + ) + } + } + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_points_within_radius( + sself: *mut core::ffi::c_void, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_incremental_octree_point_locator_find_points_within_radius( + self.0, + R, + x, + result, + ) + } + } + fn find_points_within_squared_radius( + &mut self, + R2: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_points_within_squared_radius( + sself: *mut core::ffi::c_void, + R2: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_incremental_octree_point_locator_find_points_within_squared_radius( + self.0, + R2, + x, + result, + ) + } + } + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_closest_n_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_incremental_octree_point_locator_find_closest_n_points( + self.0, + N, + x, + result, + ) + } + } + fn init_point_insertion( + &mut self, + points: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_init_point_insertion( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_incremental_octree_point_locator_init_point_insertion( + self.0, + points, + bounds, + ) + } + } + fn init_point_insertion( + &mut self, + points: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + estSize: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_init_point_insertion( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + estSize: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { + vtk_incremental_octree_point_locator_init_point_insertion( + self.0, + points, + bounds, + estSize, + ) + } + } + fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_is_inserted_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_incremental_octree_point_locator_is_inserted_point(self.0, x) } + } + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_is_inserted_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_incremental_octree_point_locator_is_inserted_point(self.0, x, y, z) + } + } + fn insert_unique_point( + &mut self, + point: core::ffi::c_double, + pntId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_insert_unique_point( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + pntId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { + vtk_incremental_octree_point_locator_insert_unique_point( + self.0, + point, + pntId, + ) + } + } + fn insert_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_insert_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + x: core::ffi::c_double, + ); + } + unsafe { vtk_incremental_octree_point_locator_insert_point(self.0, ptId, x) } + } + fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_incremental_octree_point_locator_insert_next_point(self.0, x) } + } + fn insert_point_without_checking( + &mut self, + point: core::ffi::c_double, + pntId: core::ffi::c_uchar, + insert: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_insert_point_without_checking( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + pntId: core::ffi::c_uchar, + insert: core::ffi::c_int, + ); + } + unsafe { + vtk_incremental_octree_point_locator_insert_point_without_checking( + self.0, + point, + pntId, + insert, + ) + } + } + fn get_root(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_root( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_point_locator_get_root(self.0) } + } + fn get_number_of_levels(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_number_of_levels( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_point_locator_get_number_of_levels(self.0) } + } +} +impl VtkIterativeClosestPointTransform for vtkIterativeClosestPointTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_new_instance(self.0) } + } + fn set_source(&mut self, source: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_source( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_set_source(self.0, source) } + } + fn set_target(&mut self, target: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_target( + sself: *mut core::ffi::c_void, + target: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_set_target(self.0, target) } + } + fn get_source(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_source( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_get_source(self.0) } + } + fn get_target(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_target( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_get_target(self.0) } + } + fn set_locator(&mut self, locator: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_locator( + sself: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_set_locator(self.0, locator) } + } + fn get_locator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_locator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_get_locator(self.0) } + } + fn set_maximum_number_of_iterations(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_maximum_number_of_iterations( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_maximum_number_of_iterations( + self.0, + _arg, + ) + } + } + fn get_maximum_number_of_iterations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_maximum_number_of_iterations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_iterative_closest_point_transform_get_maximum_number_of_iterations( + self.0, + ) + } + } + fn get_number_of_iterations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_number_of_iterations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_iterative_closest_point_transform_get_number_of_iterations(self.0) } + } + fn set_check_mean_distance(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_check_mean_distance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_check_mean_distance(self.0, _arg) + } + } + fn get_check_mean_distance(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_check_mean_distance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_iterative_closest_point_transform_get_check_mean_distance(self.0) } + } + fn check_mean_distance_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_check_mean_distance_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_check_mean_distance_on(self.0) } + } + fn check_mean_distance_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_check_mean_distance_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_check_mean_distance_off(self.0) } + } + fn set_mean_distance_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_mean_distance_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_mean_distance_mode(self.0, _arg) + } + } + fn get_mean_distance_mode_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value( + self.0, + ) + } + } + fn get_mean_distance_mode_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value( + self.0, + ) + } + } + fn get_mean_distance_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_mean_distance_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_iterative_closest_point_transform_get_mean_distance_mode(self.0) } + } + fn set_mean_distance_mode_to_rms(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms(self.0) + } + } + fn set_mean_distance_mode_to_absolute_value(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value( + self.0, + ) + } + } + fn get_mean_distance_mode_as_string(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { + vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string( + self.0, + ) + } + } + fn set_maximum_mean_distance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_maximum_mean_distance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_maximum_mean_distance(self.0, _arg) + } + } + fn get_maximum_mean_distance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_maximum_mean_distance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { + vtk_iterative_closest_point_transform_get_maximum_mean_distance(self.0) + } + } + fn get_mean_distance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_mean_distance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_iterative_closest_point_transform_get_mean_distance(self.0) } + } + fn set_maximum_number_of_landmarks(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks( + self.0, + _arg, + ) + } + } + fn get_maximum_number_of_landmarks(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks(self.0) + } + } + fn set_start_by_matching_centroids(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_start_by_matching_centroids( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_start_by_matching_centroids( + self.0, + _arg, + ) + } + } + fn get_start_by_matching_centroids(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_start_by_matching_centroids( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_iterative_closest_point_transform_get_start_by_matching_centroids(self.0) + } + } + fn start_by_matching_centroids_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_start_by_matching_centroids_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_iterative_closest_point_transform_start_by_matching_centroids_on(self.0) + } + } + fn start_by_matching_centroids_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_start_by_matching_centroids_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_iterative_closest_point_transform_start_by_matching_centroids_off(self.0) + } + } + fn get_landmark_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_landmark_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_get_landmark_transform(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_inverse( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_inverse(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_make_transform(self.0) } + } +} +impl VtkKdNode for vtkKdNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_new(self.0) } + } + fn set_dim(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_dim( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_set_dim(self.0, _arg) } + } + fn get_dim(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_get_dim(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_get_dim(self.0) } + } + fn get_division_position(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_division_position( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_kd_node_get_division_position(self.0) } + } + fn set_number_of_points(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_number_of_points( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_set_number_of_points(self.0, _arg) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_get_number_of_points(self.0) } + } + fn set_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_bounds( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_set_bounds(self.0, x1, x2, y1, y2, z1, z2) } + } + fn set_bounds(&mut self, b: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_bounds( + sself: *mut core::ffi::c_void, + b: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_set_bounds(self.0, b) } + } + fn get_bounds(&mut self, b: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_node_get_bounds( + sself: *mut core::ffi::c_void, + b: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_get_bounds(self.0, b) } + } + fn set_data_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_data_bounds( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_set_data_bounds(self.0, x1, x2, y1, y2, z1, z2) } + } + fn get_data_bounds(&mut self, b: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_node_get_data_bounds( + sself: *mut core::ffi::c_void, + b: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_get_data_bounds(self.0, b) } + } + fn set_data_bounds(&mut self, v: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_data_bounds( + sself: *mut core::ffi::c_void, + v: core::ffi::c_float, + ); + } + unsafe { vtk_kd_node_set_data_bounds(self.0, v) } + } + fn get_min_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_min_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_kd_node_get_min_bounds(self.0) } + } + fn get_max_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_max_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_kd_node_get_max_bounds(self.0) } + } + fn set_min_bounds(&mut self, mb: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_min_bounds( + sself: *mut core::ffi::c_void, + mb: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_set_min_bounds(self.0, mb) } + } + fn set_max_bounds(&mut self, mb: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_max_bounds( + sself: *mut core::ffi::c_void, + mb: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_set_max_bounds(self.0, mb) } + } + fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_min_data_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_kd_node_get_min_data_bounds(self.0) } + } + fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_max_data_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_kd_node_get_max_data_bounds(self.0) } + } + fn set_min_data_bounds(&mut self, mb: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_min_data_bounds( + sself: *mut core::ffi::c_void, + mb: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_set_min_data_bounds(self.0, mb) } + } + fn set_max_data_bounds(&mut self, mb: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_max_data_bounds( + sself: *mut core::ffi::c_void, + mb: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_set_max_data_bounds(self.0, mb) } + } + fn set_id(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_id(sself: *mut core::ffi::c_void, _arg: core::ffi::c_int); + } + unsafe { vtk_kd_node_set_id(self.0, _arg) } + } + fn get_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_get_id(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_get_id(self.0) } + } + fn get_min_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_get_min_id(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_get_min_id(self.0) } + } + fn get_max_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_get_max_id(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_get_max_id(self.0) } + } + fn set_min_id(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_min_id( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_set_min_id(self.0, _arg) } + } + fn set_max_id(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_max_id( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_set_max_id(self.0, _arg) } + } + fn add_child_nodes( + &mut self, + left: *mut core::ffi::c_void, + right: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_node_add_child_nodes( + sself: *mut core::ffi::c_void, + left: *mut core::ffi::c_void, + right: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_node_add_child_nodes(self.0, left, right) } + } + fn delete_child_nodes(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_node_delete_child_nodes(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_node_delete_child_nodes(self.0) } + } + fn get_left(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_get_left( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_get_left(self.0) } + } + fn set_left(&mut self, left: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_left( + sself: *mut core::ffi::c_void, + left: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_node_set_left(self.0, left) } + } + fn get_right(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_get_right( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_get_right(self.0) } + } + fn set_right(&mut self, right: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_right( + sself: *mut core::ffi::c_void, + right: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_node_set_right(self.0, right) } + } + fn get_up(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_get_up( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_get_up(self.0) } + } + fn set_up(&mut self, up: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_up( + sself: *mut core::ffi::c_void, + up: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_node_set_up(self.0, up) } + } + fn intersects_box( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_intersects_box( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_node_intersects_box(self.0, x1, x2, y1, y2, z1, z2, useDataBounds) + } + } + fn intersects_sphere_2( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_intersects_sphere_2( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_node_intersects_sphere_2(self.0, x, y, z, rSquared, useDataBounds) + } + } + fn intersects_region( + &mut self, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_intersects_region( + sself: *mut core::ffi::c_void, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_intersects_region(self.0, pi, useDataBounds) } + } + fn intersects_cell( + &mut self, + cell: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + cellRegion: core::ffi::c_int, + cellBounds: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_intersects_cell( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + cellRegion: core::ffi::c_int, + cellBounds: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_node_intersects_cell( + self.0, + cell, + useDataBounds, + cellRegion, + cellBounds, + ) + } + } + fn contains_box( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_contains_box( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_node_contains_box(self.0, x1, x2, y1, y2, z1, z2, useDataBounds) + } + } + fn contains_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_contains_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_contains_point(self.0, x, y, z, useDataBounds) } + } + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_distance_2_to_boundary( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_kd_node_get_distance_2_to_boundary(self.0, x, y, z, useDataBounds) } + } + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + boundaryPt: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_distance_2_to_boundary( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + boundaryPt: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { + vtk_kd_node_get_distance_2_to_boundary( + self.0, + x, + y, + z, + boundaryPt, + useDataBounds, + ) + } + } + fn get_distance_2_to_inner_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_distance_2_to_inner_boundary( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_kd_node_get_distance_2_to_inner_boundary(self.0, x, y, z) } + } + fn print_node(&mut self, depth: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_print_node( + sself: *mut core::ffi::c_void, + depth: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_print_node(self.0, depth) } + } + fn print_verbose_node(&mut self, depth: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_print_verbose_node( + sself: *mut core::ffi::c_void, + depth: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_print_verbose_node(self.0, depth) } + } +} +impl VtkKdTree for vtkKdTree { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_new(self.0) } + } + fn timing_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_timing_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_timing_on(self.0) } + } + fn timing_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_timing_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_timing_off(self.0) } + } + fn set_timing(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_timing( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_set_timing(self.0, _arg) } + } + fn get_timing(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_timing(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_timing(self.0) } + } + fn set_min_cells(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_min_cells( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_set_min_cells(self.0, _arg) } + } + fn get_min_cells(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_min_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_min_cells(self.0) } + } + fn get_number_of_regions_or_less(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_number_of_regions_or_less( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_number_of_regions_or_less(self.0) } + } + fn set_number_of_regions_or_less(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_number_of_regions_or_less( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_set_number_of_regions_or_less(self.0, _arg) } + } + fn get_number_of_regions_or_more(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_number_of_regions_or_more( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_number_of_regions_or_more(self.0) } + } + fn set_number_of_regions_or_more(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_number_of_regions_or_more( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_set_number_of_regions_or_more(self.0, _arg) } + } + fn get_fudge_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_tree_get_fudge_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_kd_tree_get_fudge_factor(self.0) } + } + fn set_fudge_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_fudge_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_kd_tree_set_fudge_factor(self.0, _arg) } + } + fn get_cuts(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_cuts( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_cuts(self.0) } + } + fn set_cuts(&mut self, cuts: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_cuts( + sself: *mut core::ffi::c_void, + cuts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_set_cuts(self.0, cuts) } + } + fn omit_x_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_x_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_x_partitioning(self.0) } + } + fn omit_y_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_y_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_y_partitioning(self.0) } + } + fn omit_z_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_z_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_z_partitioning(self.0) } + } + fn omit_xy_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_xy_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_xy_partitioning(self.0) } + } + fn omit_yz_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_yz_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_yz_partitioning(self.0) } + } + fn omit_zx_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_zx_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_zx_partitioning(self.0) } + } + fn omit_no_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_no_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_no_partitioning(self.0) } + } + fn set_data_set(&mut self, set: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_data_set( + sself: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_set_data_set(self.0, set) } + } + fn add_data_set(&mut self, set: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_tree_add_data_set( + sself: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_add_data_set(self.0, set) } + } + fn remove_data_set(&mut self, index: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_remove_data_set( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_remove_data_set(self.0, index) } + } + fn remove_data_set(&mut self, set: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_tree_remove_data_set( + sself: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_remove_data_set(self.0, set) } + } + fn remove_all_data_sets(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_remove_all_data_sets(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_remove_all_data_sets(self.0) } + } + fn get_number_of_data_sets(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_number_of_data_sets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_number_of_data_sets(self.0) } + } + fn get_data_set(&mut self, n: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_data_set( + sself: *mut core::ffi::c_void, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_data_set(self.0, n) } + } + fn get_data_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_data_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_data_set(self.0) } + } + fn get_data_sets(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_data_sets( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_data_sets(self.0) } + } + fn get_data_set_index(&mut self, set: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_data_set_index( + sself: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_data_set_index(self.0, set) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_tree_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_kd_tree_get_bounds(self.0, bounds) } + } + fn set_new_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_new_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_kd_tree_set_new_bounds(self.0, bounds) } + } + fn get_number_of_regions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_number_of_regions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_number_of_regions(self.0) } + } + fn get_region_bounds( + &mut self, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_get_region_bounds( + sself: *mut core::ffi::c_void, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_kd_tree_get_region_bounds(self.0, regionID, bounds) } + } + fn get_region_data_bounds( + &mut self, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_get_region_data_bounds( + sself: *mut core::ffi::c_void, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_kd_tree_get_region_data_bounds(self.0, regionID, bounds) } + } + fn print_tree(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_print_tree(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_print_tree(self.0) } + } + fn print_verbose_tree(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_print_verbose_tree(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_print_verbose_tree(self.0) } + } + fn print_region(&mut self, id: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_print_region( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_print_region(self.0, id) } + } + fn create_cell_lists( + &mut self, + dataSetIndex: core::ffi::c_int, + regionReqList: core::ffi::c_int, + reqListSize: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_create_cell_lists( + sself: *mut core::ffi::c_void, + dataSetIndex: core::ffi::c_int, + regionReqList: core::ffi::c_int, + reqListSize: core::ffi::c_int, + ); + } + unsafe { + vtk_kd_tree_create_cell_lists( + self.0, + dataSetIndex, + regionReqList, + reqListSize, + ) + } + } + fn create_cell_lists( + &mut self, + set: *mut core::ffi::c_void, + regionReqList: core::ffi::c_int, + reqListSize: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_create_cell_lists( + sself: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + regionReqList: core::ffi::c_int, + reqListSize: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_create_cell_lists(self.0, set, regionReqList, reqListSize) } + } + fn create_cell_lists( + &mut self, + regionReqList: core::ffi::c_int, + listSize: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_create_cell_lists( + sself: *mut core::ffi::c_void, + regionReqList: core::ffi::c_int, + listSize: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_create_cell_lists(self.0, regionReqList, listSize) } + } + fn create_cell_lists(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_create_cell_lists(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_create_cell_lists(self.0) } + } + fn set_include_region_boundary_cells(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_include_region_boundary_cells( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_set_include_region_boundary_cells(self.0, _arg) } + } + fn get_include_region_boundary_cells(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_include_region_boundary_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_include_region_boundary_cells(self.0) } + } + fn include_region_boundary_cells_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_include_region_boundary_cells_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_include_region_boundary_cells_on(self.0) } + } + fn include_region_boundary_cells_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_include_region_boundary_cells_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_include_region_boundary_cells_off(self.0) } + } + fn delete_cell_lists(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_delete_cell_lists(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_delete_cell_lists(self.0) } + } + fn get_cell_list(&mut self, regionID: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_cell_list( + sself: *mut core::ffi::c_void, + regionID: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_cell_list(self.0, regionID) } + } + fn get_boundary_cell_list( + &mut self, + regionID: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_boundary_cell_list( + sself: *mut core::ffi::c_void, + regionID: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_boundary_cell_list(self.0, regionID) } + } + fn get_cell_lists( + &mut self, + regions: *mut core::ffi::c_void, + set: core::ffi::c_int, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_get_cell_lists( + sself: *mut core::ffi::c_void, + regions: *mut core::ffi::c_void, + set: core::ffi::c_int, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_kd_tree_get_cell_lists( + self.0, + regions, + set, + inRegionCells, + onBoundaryCells, + ) + } + } + fn get_cell_lists( + &mut self, + regions: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_get_cell_lists( + sself: *mut core::ffi::c_void, + regions: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_kd_tree_get_cell_lists( + self.0, + regions, + set, + inRegionCells, + onBoundaryCells, + ) + } + } + fn get_cell_lists( + &mut self, + regions: *mut core::ffi::c_void, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_get_cell_lists( + sself: *mut core::ffi::c_void, + regions: *mut core::ffi::c_void, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_kd_tree_get_cell_lists(self.0, regions, inRegionCells, onBoundaryCells) + } + } + fn get_region_containing_cell( + &mut self, + set: *mut core::ffi::c_void, + cellID: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_region_containing_cell( + sself: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + cellID: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_region_containing_cell(self.0, set, cellID) } + } + fn get_region_containing_cell( + &mut self, + set: core::ffi::c_int, + cellID: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_region_containing_cell( + sself: *mut core::ffi::c_void, + set: core::ffi::c_int, + cellID: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_region_containing_cell(self.0, set, cellID) } + } + fn get_region_containing_cell( + &mut self, + cellID: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_region_containing_cell( + sself: *mut core::ffi::c_void, + cellID: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_region_containing_cell(self.0, cellID) } + } + fn all_get_region_containing_cell(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_all_get_region_containing_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_kd_tree_all_get_region_containing_cell(self.0) } + } + fn get_region_containing_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_region_containing_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_region_containing_point(self.0, x, y, z) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_build_locator(self.0) } + } + fn minimal_number_of_convex_sub_regions( + &mut self, + regionIdList: *mut core::ffi::c_void, + convexRegionBounds: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_minimal_number_of_convex_sub_regions( + sself: *mut core::ffi::c_void, + regionIdList: *mut core::ffi::c_void, + convexRegionBounds: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_tree_minimal_number_of_convex_sub_regions( + self.0, + regionIdList, + convexRegionBounds, + ) + } + } + fn view_order_all_regions_in_direction( + &mut self, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_view_order_all_regions_in_direction( + sself: *mut core::ffi::c_void, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_tree_view_order_all_regions_in_direction( + self.0, + directionOfProjection, + orderedList, + ) + } + } + fn view_order_regions_in_direction( + &mut self, + regionIds: *mut core::ffi::c_void, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_view_order_regions_in_direction( + sself: *mut core::ffi::c_void, + regionIds: *mut core::ffi::c_void, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_tree_view_order_regions_in_direction( + self.0, + regionIds, + directionOfProjection, + orderedList, + ) + } + } + fn view_order_all_regions_from_position( + &mut self, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_view_order_all_regions_from_position( + sself: *mut core::ffi::c_void, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_tree_view_order_all_regions_from_position( + self.0, + directionOfProjection, + orderedList, + ) + } + } + fn view_order_regions_from_position( + &mut self, + regionIds: *mut core::ffi::c_void, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_view_order_regions_from_position( + sself: *mut core::ffi::c_void, + regionIds: *mut core::ffi::c_void, + directionOfProjection: core::ffi::c_double, + orderedList: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_tree_view_order_regions_from_position( + self.0, + regionIds, + directionOfProjection, + orderedList, + ) + } + } + fn build_locator_from_points(&mut self, pointset: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_tree_build_locator_from_points( + sself: *mut core::ffi::c_void, + pointset: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_build_locator_from_points(self.0, pointset) } + } + fn build_locator_from_points(&mut self, ptArray: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_tree_build_locator_from_points( + sself: *mut core::ffi::c_void, + ptArray: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_build_locator_from_points(self.0, ptArray) } + } + fn build_locator_from_points( + &mut self, + ptArray: *mut core::ffi::c_void, + numPtArrays: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_build_locator_from_points( + sself: *mut core::ffi::c_void, + ptArray: *mut core::ffi::c_void, + numPtArrays: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_build_locator_from_points(self.0, ptArray, numPtArrays) } + } + fn build_map_for_duplicate_points( + &mut self, + tolerance: core::ffi::c_float, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_build_map_for_duplicate_points( + sself: *mut core::ffi::c_void, + tolerance: core::ffi::c_float, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_build_map_for_duplicate_points(self.0, tolerance) } + } + fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_find_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_kd_tree_find_point(self.0, x) } + } + fn find_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_find_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_kd_tree_find_point(self.0, x, y, z) } + } + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_kd_tree_find_closest_point(self.0, x, dist2) } + } + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_kd_tree_find_closest_point(self.0, x, y, z, dist2) } + } + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_kd_tree_find_closest_point_within_radius(self.0, radius, x, dist2) } + } + fn find_closest_point_in_region( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_find_closest_point_in_region( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_kd_tree_find_closest_point_in_region(self.0, regionId, x, dist2) } + } + fn find_closest_point_in_region( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_find_closest_point_in_region( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_kd_tree_find_closest_point_in_region(self.0, regionId, x, y, z, dist2) + } + } + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_find_points_within_radius( + sself: *mut core::ffi::c_void, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_find_points_within_radius(self.0, R, x, result) } + } + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_find_closest_n_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_find_closest_n_points(self.0, N, x, result) } + } + fn get_points_in_region( + &mut self, + regionId: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_points_in_region( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_points_in_region(self.0, regionId) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_free_search_structure(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_free_search_structure(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_generate_representation(self.0, level, pd) } + } + fn generate_representation( + &mut self, + regionList: core::ffi::c_int, + len: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_generate_representation( + sself: *mut core::ffi::c_void, + regionList: core::ffi::c_int, + len: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_generate_representation(self.0, regionList, len, pd) } + } + fn generate_representation_using_data_bounds_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_generate_representation_using_data_bounds_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_generate_representation_using_data_bounds_on(self.0) } + } + fn generate_representation_using_data_bounds_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_generate_representation_using_data_bounds_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_generate_representation_using_data_bounds_off(self.0) } + } + fn set_generate_representation_using_data_bounds( + &mut self, + _arg: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_generate_representation_using_data_bounds( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_kd_tree_set_generate_representation_using_data_bounds(self.0, _arg) + } + } + fn get_generate_representation_using_data_bounds(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_generate_representation_using_data_bounds( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_generate_representation_using_data_bounds(self.0) } + } + fn new_geometry(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_new_geometry( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_new_geometry(self.0) } + } + fn new_geometry( + &mut self, + sets: *mut core::ffi::c_void, + numDataSets: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_new_geometry( + sself: *mut core::ffi::c_void, + sets: *mut core::ffi::c_void, + numDataSets: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_new_geometry(self.0, sets, numDataSets) } + } + fn invalidate_geometry(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_invalidate_geometry(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_invalidate_geometry(self.0) } + } + fn copy_tree(&mut self, kd: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_copy_tree( + sself: *mut core::ffi::c_void, + kd: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_copy_tree(self.0, kd) } + } + fn find_points_in_area( + &mut self, + area: core::ffi::c_double, + ids: *mut core::ffi::c_void, + clearArray: bool, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_find_points_in_area( + sself: *mut core::ffi::c_void, + area: core::ffi::c_double, + ids: *mut core::ffi::c_void, + clearArray: bool, + ); + } + unsafe { vtk_kd_tree_find_points_in_area(self.0, area, ids, clearArray) } + } +} +impl VtkKdTreePointLocator for vtkKdTreePointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_point_locator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_point_locator_new(self.0) } + } + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_kd_tree_point_locator_find_closest_point(self.0, x) } + } + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_kd_tree_point_locator_find_closest_point_within_radius( + self.0, + radius, + x, + dist2, + ) + } + } + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_find_closest_n_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_point_locator_find_closest_n_points(self.0, N, x, result) } + } + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_find_points_within_radius( + sself: *mut core::ffi::c_void, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_kd_tree_point_locator_find_points_within_radius(self.0, R, x, result) + } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_point_locator_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_point_locator_build_locator(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_point_locator_generate_representation(self.0, level, pd) } + } +} +impl VtkLagrangeCurve for vtkLagrangeCurve { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_curve_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_curve_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_curve_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_curve_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_curve_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_curve_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_curve_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_curve_get_cell_type(self.0) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_curve_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_lagrange_curve_interpolate_functions(self.0, pcoords, weights) } + } +} +impl VtkLagrangeHexahedron for vtkLagrangeHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_hexahedron_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_get_face(self.0, faceId) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_lagrange_hexahedron_interpolate_functions(self.0, pcoords, weights) + } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_get_edge_cell(self.0) } + } + fn get_face_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_face_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_get_face_cell(self.0) } + } + fn get_interpolation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_interpolation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_get_interpolation(self.0) } + } +} +impl VtkLagrangeInterpolation for vtkLagrangeInterpolation { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_interpolation_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_interpolation_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_interpolation_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_interpolation_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_interpolation_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_interpolation_new_instance(self.0) } + } + fn evaluate_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_interpolation_evaluate_shape_functions( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + ); + } + unsafe { + vtk_lagrange_interpolation_evaluate_shape_functions( + self.0, + order, + pcoord, + shape, + ) + } + } + fn evaluate_shape_and_gradient( + &mut self, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + grad: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_interpolation_evaluate_shape_and_gradient( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoord: core::ffi::c_double, + shape: core::ffi::c_double, + grad: core::ffi::c_double, + ); + } + unsafe { + vtk_lagrange_interpolation_evaluate_shape_and_gradient( + self.0, + order, + pcoord, + shape, + grad, + ) + } + } + fn tensor_1_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_interpolation_tensor_1_shape_functions( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_lagrange_interpolation_tensor_1_shape_functions( + self.0, + order, + pcoords, + shape, + ) + } + } + fn tensor_1_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_interpolation_tensor_1_shape_derivatives( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_lagrange_interpolation_tensor_1_shape_derivatives( + self.0, + order, + pcoords, + derivs, + ) + } + } + fn tensor_2_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_interpolation_tensor_2_shape_functions( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_lagrange_interpolation_tensor_2_shape_functions( + self.0, + order, + pcoords, + shape, + ) + } + } + fn tensor_2_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_interpolation_tensor_2_shape_derivatives( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_lagrange_interpolation_tensor_2_shape_derivatives( + self.0, + order, + pcoords, + derivs, + ) + } + } + fn tensor_3_shape_functions( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_interpolation_tensor_3_shape_functions( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_lagrange_interpolation_tensor_3_shape_functions( + self.0, + order, + pcoords, + shape, + ) + } + } + fn tensor_3_shape_derivatives( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_interpolation_tensor_3_shape_derivatives( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_lagrange_interpolation_tensor_3_shape_derivatives( + self.0, + order, + pcoords, + derivs, + ) + } + } + fn tensor_3_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_interpolation_tensor_3_evaluate_derivative( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ); + } + unsafe { + vtk_lagrange_interpolation_tensor_3_evaluate_derivative( + self.0, + order, + pcoords, + points, + fieldVals, + fieldDim, + fieldDerivs, + ) + } + } + fn wedge_shape_functions( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_interpolation_wedge_shape_functions( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + shape: core::ffi::c_double, + ); + } + unsafe { + vtk_lagrange_interpolation_wedge_shape_functions( + self.0, + order, + numberOfPoints, + pcoords, + shape, + ) + } + } + fn wedge_shape_derivatives( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_interpolation_wedge_shape_derivatives( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_lagrange_interpolation_wedge_shape_derivatives( + self.0, + order, + numberOfPoints, + pcoords, + derivs, + ) + } + } + fn wedge_evaluate( + &mut self, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldAtPCoords: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_interpolation_wedge_evaluate( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + numberOfPoints: core::ffi::c_uchar, + pcoords: core::ffi::c_double, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldAtPCoords: core::ffi::c_double, + ); + } + unsafe { + vtk_lagrange_interpolation_wedge_evaluate( + self.0, + order, + numberOfPoints, + pcoords, + fieldVals, + fieldDim, + fieldAtPCoords, + ) + } + } + fn wedge_evaluate_derivative( + &mut self, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_interpolation_wedge_evaluate_derivative( + sself: *mut core::ffi::c_void, + order: core::ffi::c_int, + pcoords: core::ffi::c_double, + points: *mut core::ffi::c_void, + fieldVals: core::ffi::c_double, + fieldDim: core::ffi::c_int, + fieldDerivs: core::ffi::c_double, + ); + } + unsafe { + vtk_lagrange_interpolation_wedge_evaluate_derivative( + self.0, + order, + pcoords, + points, + fieldVals, + fieldDim, + fieldDerivs, + ) + } + } +} +impl VtkLagrangeQuadrilateral for vtkLagrangeQuadrilateral { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_quadrilateral_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_quadrilateral_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_quadrilateral_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_quadrilateral_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_quadrilateral_get_edge(self.0, edgeId) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_lagrange_quadrilateral_interpolate_functions(self.0, pcoords, weights) + } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_quadrilateral_get_edge_cell(self.0) } + } +} +impl VtkLagrangeTetra for vtkLagrangeTetra { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_tetra_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_tetra_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_get_face(self.0, faceId) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_tetra_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_lagrange_tetra_interpolate_functions(self.0, pcoords, weights) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_get_edge_cell(self.0) } + } + fn get_face_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_get_face_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_get_face_cell(self.0) } + } +} +impl VtkLagrangeTriangle for vtkLagrangeTriangle { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_triangle_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_triangle_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_triangle_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_triangle_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_triangle_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_triangle_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_triangle_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_triangle_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_triangle_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_triangle_get_edge(self.0, edgeId) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_triangle_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_lagrange_triangle_interpolate_functions(self.0, pcoords, weights) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_triangle_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_triangle_get_edge_cell(self.0) } + } +} +impl VtkLagrangeWedge for vtkLagrangeWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_wedge_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_face(self.0, faceId) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lagrange_wedge_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_lagrange_wedge_interpolate_functions(self.0, pcoords, weights) } + } + fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_boundary_quad( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_boundary_quad(self.0) } + } + fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_boundary_tri( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_boundary_tri(self.0) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_edge_cell(self.0) } + } + fn get_interpolation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_interpolation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_interpolation(self.0) } + } +} +impl VtkLine for vtkLine { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_get_cell_type(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_line_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_line_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_line_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_line_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_line_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_line_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_inflate( + sself: *mut core::ffi::c_void, + dist: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_inflate(self.0, dist) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_line_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_line_clip( + self.0, + value, + cellScalars, + locator, + lines, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_get_parametric_center(self.0, pcoords) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_line_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn intersection( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + u: core::ffi::c_double, + v: core::ffi::c_double, + tolerance: core::ffi::c_double, + toleranceType: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_intersection( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + u: core::ffi::c_double, + v: core::ffi::c_double, + tolerance: core::ffi::c_double, + toleranceType: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_line_intersection(self.0, p1, p2, x1, x2, u, v, tolerance, toleranceType) + } + } + fn intersection_3_d( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + u: core::ffi::c_double, + v: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_intersection_3_d( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + u: core::ffi::c_double, + v: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_intersection_3_d(self.0, p1, p2, x1, x2, u, v, tolerance) } + } + fn distance_to_line( + &mut self, + x: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t: core::ffi::c_double, + closestPoint: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_line_distance_to_line( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t: core::ffi::c_double, + closestPoint: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_line_distance_to_line(self.0, x, p1, p2, t, closestPoint) } + } + fn distance_to_line( + &mut self, + x: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_line_distance_to_line( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_line_distance_to_line(self.0, x, p1, p2) } + } + fn distance_between_lines( + &mut self, + l0: core::ffi::c_double, + l1: core::ffi::c_double, + m0: core::ffi::c_double, + m1: core::ffi::c_double, + closestPt1: core::ffi::c_double, + closestPt2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_line_distance_between_lines( + sself: *mut core::ffi::c_void, + l0: core::ffi::c_double, + l1: core::ffi::c_double, + m0: core::ffi::c_double, + m1: core::ffi::c_double, + closestPt1: core::ffi::c_double, + closestPt2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_line_distance_between_lines( + self.0, + l0, + l1, + m0, + m1, + closestPt1, + closestPt2, + t1, + t2, + ) + } + } + fn distance_between_line_segments( + &mut self, + l0: core::ffi::c_double, + l1: core::ffi::c_double, + m0: core::ffi::c_double, + m1: core::ffi::c_double, + closestPt1: core::ffi::c_double, + closestPt2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_line_distance_between_line_segments( + sself: *mut core::ffi::c_void, + l0: core::ffi::c_double, + l1: core::ffi::c_double, + m0: core::ffi::c_double, + m1: core::ffi::c_double, + closestPt1: core::ffi::c_double, + closestPt2: core::ffi::c_double, + t1: core::ffi::c_double, + t2: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_line_distance_between_line_segments( + self.0, + l0, + l1, + m0, + m1, + closestPt1, + closestPt2, + t1, + t2, + ) + } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_line_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_line_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_line_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_line_interpolate_derivs(self.0, pcoords, derivs) } + } +} +impl VtkMeanValueCoordinatesInterpolator for vtkMeanValueCoordinatesInterpolator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mean_value_coordinates_interpolator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mean_value_coordinates_interpolator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mean_value_coordinates_interpolator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mean_value_coordinates_interpolator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mean_value_coordinates_interpolator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mean_value_coordinates_interpolator_new_instance(self.0) } + } + fn compute_interpolation_weights( + &mut self, + x: core::ffi::c_double, + pts: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_mean_value_coordinates_interpolator_compute_interpolation_weights( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + pts: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_mean_value_coordinates_interpolator_compute_interpolation_weights( + self.0, + x, + pts, + tris, + weights, + ) + } + } + fn compute_interpolation_weights( + &mut self, + x: core::ffi::c_double, + pts: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_mean_value_coordinates_interpolator_compute_interpolation_weights( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + pts: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_mean_value_coordinates_interpolator_compute_interpolation_weights( + self.0, + x, + pts, + tris, + weights, + ) + } + } +} +impl VtkMergePoints for vtkMergePoints { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_merge_points_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_merge_points_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_merge_points_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_merge_points_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_merge_points_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_merge_points_new_instance(self.0) } + } + fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_merge_points_is_inserted_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_merge_points_is_inserted_point(self.0, x) } + } + fn insert_unique_point( + &mut self, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_merge_points_insert_unique_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_merge_points_insert_unique_point(self.0, x, ptId) } + } +} +impl VtkMolecule for vtkMolecule { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_new_instance(self.0) } + } + fn append_atom(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_append_atom( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_append_atom(self.0) } + } + fn append_atom( + &mut self, + atomicNumber: core::ffi::c_ushort, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_append_atom( + sself: *mut core::ffi::c_void, + atomicNumber: core::ffi::c_ushort, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_append_atom(self.0, atomicNumber, x, y, z) } + } + fn append_atom( + &mut self, + atomicNumber: core::ffi::c_ushort, + pos: vtkVector3f, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_append_atom( + sself: *mut core::ffi::c_void, + atomicNumber: core::ffi::c_ushort, + pos: vtkVector3f, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_append_atom(self.0, atomicNumber, pos) } + } + fn append_atom( + &mut self, + atomicNumber: core::ffi::c_ushort, + pos: core::ffi::c_double, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_append_atom( + sself: *mut core::ffi::c_void, + atomicNumber: core::ffi::c_ushort, + pos: core::ffi::c_double, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_append_atom(self.0, atomicNumber, pos) } + } + fn get_atom(&mut self, atomId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_atom( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_atom(self.0, atomId) } + } + fn get_number_of_atoms(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_molecule_get_number_of_atoms( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_molecule_get_number_of_atoms(self.0) } + } + fn append_bond( + &mut self, + atom1: core::ffi::c_uchar, + atom2: core::ffi::c_uchar, + order: core::ffi::c_ushort, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_append_bond( + sself: *mut core::ffi::c_void, + atom1: core::ffi::c_uchar, + atom2: core::ffi::c_uchar, + order: core::ffi::c_ushort, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_append_bond(self.0, atom1, atom2, order) } + } + fn append_bond( + &mut self, + atom1: vtkAtom, + atom2: vtkAtom, + order: core::ffi::c_ushort, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_append_bond( + sself: *mut core::ffi::c_void, + atom1: vtkAtom, + atom2: vtkAtom, + order: core::ffi::c_ushort, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_append_bond(self.0, atom1, atom2, order) } + } + fn get_bond(&mut self, bondId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_bond( + sself: *mut core::ffi::c_void, + bondId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_bond(self.0, bondId) } + } + fn get_number_of_bonds(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_molecule_get_number_of_bonds( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_molecule_get_number_of_bonds(self.0) } + } + fn get_atom_atomic_number( + &mut self, + atomId: core::ffi::c_uchar, + ) -> core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_molecule_get_atom_atomic_number( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_uchar, + ) -> core::ffi::c_ushort; + } + unsafe { vtk_molecule_get_atom_atomic_number(self.0, atomId) } + } + fn set_atom_atomic_number( + &mut self, + atomId: core::ffi::c_uchar, + atomicNum: core::ffi::c_ushort, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_set_atom_atomic_number( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_uchar, + atomicNum: core::ffi::c_ushort, + ); + } + unsafe { vtk_molecule_set_atom_atomic_number(self.0, atomId, atomicNum) } + } + fn set_atom_position(&mut self, atomId: core::ffi::c_uchar, pos: vtkVector3f) -> () { + unsafe extern "C" { + fn vtk_molecule_set_atom_position( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_uchar, + pos: vtkVector3f, + ); + } + unsafe { vtk_molecule_set_atom_position(self.0, atomId, pos) } + } + fn set_atom_position( + &mut self, + atomId: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_set_atom_position( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_uchar, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_molecule_set_atom_position(self.0, atomId, x, y, z) } + } + fn set_atom_position( + &mut self, + atomId: core::ffi::c_uchar, + pos: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_set_atom_position( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_uchar, + pos: core::ffi::c_double, + ); + } + unsafe { vtk_molecule_set_atom_position(self.0, atomId, pos) } + } + fn get_atom_position( + &mut self, + atomId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_atom_position( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_atom_position(self.0, atomId) } + } + fn get_atom_position( + &mut self, + atomId: core::ffi::c_uchar, + pos: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_get_atom_position( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_uchar, + pos: core::ffi::c_float, + ); + } + unsafe { vtk_molecule_get_atom_position(self.0, atomId, pos) } + } + fn get_atom_position( + &mut self, + atomId: core::ffi::c_uchar, + pos: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_get_atom_position( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_uchar, + pos: core::ffi::c_double, + ); + } + unsafe { vtk_molecule_get_atom_position(self.0, atomId, pos) } + } + fn set_bond_order( + &mut self, + bondId: core::ffi::c_uchar, + order: core::ffi::c_ushort, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_set_bond_order( + sself: *mut core::ffi::c_void, + bondId: core::ffi::c_uchar, + order: core::ffi::c_ushort, + ); + } + unsafe { vtk_molecule_set_bond_order(self.0, bondId, order) } + } + fn get_bond_order(&mut self, bondId: core::ffi::c_uchar) -> core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_molecule_get_bond_order( + sself: *mut core::ffi::c_void, + bondId: core::ffi::c_uchar, + ) -> core::ffi::c_ushort; + } + unsafe { vtk_molecule_get_bond_order(self.0, bondId) } + } + fn get_bond_length(&mut self, bondId: core::ffi::c_uchar) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_molecule_get_bond_length( + sself: *mut core::ffi::c_void, + bondId: core::ffi::c_uchar, + ) -> core::ffi::c_double; + } + unsafe { vtk_molecule_get_bond_length(self.0, bondId) } + } + fn get_atomic_position_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_atomic_position_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_atomic_position_array(self.0) } + } + fn get_atomic_number_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_atomic_number_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_atomic_number_array(self.0) } + } + fn get_bond_orders_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_bond_orders_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_bond_orders_array(self.0) } + } + fn get_electronic_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_electronic_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_electronic_data(self.0) } + } + fn set_electronic_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_set_electronic_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_set_electronic_data(self.0, p0) } + } + fn shallow_copy(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_shallow_copy( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_shallow_copy(self.0, obj) } + } + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_deep_copy( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_deep_copy(self.0, obj) } + } + fn shallow_copy_structure(&mut self, m: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_shallow_copy_structure( + sself: *mut core::ffi::c_void, + m: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_shallow_copy_structure(self.0, m) } + } + fn deep_copy_structure(&mut self, m: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_deep_copy_structure( + sself: *mut core::ffi::c_void, + m: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_deep_copy_structure(self.0, m) } + } + fn shallow_copy_attributes(&mut self, m: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_shallow_copy_attributes( + sself: *mut core::ffi::c_void, + m: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_shallow_copy_attributes(self.0, m) } + } + fn deep_copy_attributes(&mut self, m: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_deep_copy_attributes( + sself: *mut core::ffi::c_void, + m: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_deep_copy_attributes(self.0, m) } + } + fn get_plane_from_bond( + &mut self, + bond: vtkBond, + normal: vtkVector3f, + plane: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_molecule_get_plane_from_bond( + sself: *mut core::ffi::c_void, + bond: vtkBond, + normal: vtkVector3f, + plane: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_molecule_get_plane_from_bond(self.0, bond, normal, plane) } + } + fn get_plane_from_bond( + &mut self, + atom1: vtkAtom, + atom2: vtkAtom, + normal: vtkVector3f, + plane: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_molecule_get_plane_from_bond( + sself: *mut core::ffi::c_void, + atom1: vtkAtom, + atom2: vtkAtom, + normal: vtkVector3f, + plane: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_molecule_get_plane_from_bond(self.0, atom1, atom2, normal, plane) } + } + fn has_lattice(&mut self) -> bool { + unsafe extern "C" { + fn vtk_molecule_has_lattice(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_molecule_has_lattice(self.0) } + } + fn clear_lattice(&mut self) -> () { + unsafe extern "C" { + fn vtk_molecule_clear_lattice(sself: *mut core::ffi::c_void); + } + unsafe { vtk_molecule_clear_lattice(self.0) } + } + fn set_lattice(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_set_lattice( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_set_lattice(self.0, matrix) } + } + fn set_lattice(&mut self, a: vtkVector3d, b: vtkVector3d, c: vtkVector3d) -> () { + unsafe extern "C" { + fn vtk_molecule_set_lattice( + sself: *mut core::ffi::c_void, + a: vtkVector3d, + b: vtkVector3d, + c: vtkVector3d, + ); + } + unsafe { vtk_molecule_set_lattice(self.0, a, b, c) } + } + fn get_lattice(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_lattice( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_lattice(self.0) } + } + fn get_lattice( + &mut self, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_get_lattice( + sself: *mut core::ffi::c_void, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_get_lattice(self.0, a, b, c) } + } + fn get_lattice( + &mut self, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + origin: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_get_lattice( + sself: *mut core::ffi::c_void, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + origin: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_get_lattice(self.0, a, b, c, origin) } + } + fn get_lattice_origin(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_lattice_origin( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_lattice_origin(self.0) } + } + fn set_lattice_origin(&mut self, _arg: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_set_lattice_origin( + sself: *mut core::ffi::c_void, + _arg: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_set_lattice_origin(self.0, _arg) } + } + fn get_atom_ghost_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_atom_ghost_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_atom_ghost_array(self.0) } + } + fn allocate_atom_ghost_array(&mut self) -> () { + unsafe extern "C" { + fn vtk_molecule_allocate_atom_ghost_array(sself: *mut core::ffi::c_void); + } + unsafe { vtk_molecule_allocate_atom_ghost_array(self.0) } + } + fn get_bond_ghost_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_bond_ghost_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_bond_ghost_array(self.0) } + } + fn allocate_bond_ghost_array(&mut self) -> () { + unsafe extern "C" { + fn vtk_molecule_allocate_bond_ghost_array(sself: *mut core::ffi::c_void); + } + unsafe { vtk_molecule_allocate_bond_ghost_array(self.0) } + } + fn initialize( + &mut self, + atomPositions: *mut core::ffi::c_void, + atomicNumberArray: *mut core::ffi::c_void, + atomData: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_molecule_initialize( + sself: *mut core::ffi::c_void, + atomPositions: *mut core::ffi::c_void, + atomicNumberArray: *mut core::ffi::c_void, + atomData: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_molecule_initialize(self.0, atomPositions, atomicNumberArray, atomData) + } + } + fn initialize( + &mut self, + atomPositions: *mut core::ffi::c_void, + atomData: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_molecule_initialize( + sself: *mut core::ffi::c_void, + atomPositions: *mut core::ffi::c_void, + atomData: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_molecule_initialize(self.0, atomPositions, atomData) } + } + fn initialize(&mut self, molecule: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_molecule_initialize( + sself: *mut core::ffi::c_void, + molecule: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_molecule_initialize(self.0, molecule) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_data(self.0, v, i) } + } + fn get_atom_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_atom_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_atom_data(self.0) } + } + fn get_bond_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_bond_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_bond_data(self.0) } + } + fn get_bond_id( + &mut self, + a: core::ffi::c_uchar, + b: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_molecule_get_bond_id( + sself: *mut core::ffi::c_void, + a: core::ffi::c_uchar, + b: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_molecule_get_bond_id(self.0, a, b) } + } + fn set_atomic_number_array_name(&mut self, _arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_molecule_set_atomic_number_array_name( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { vtk_molecule_set_atomic_number_array_name(self.0, _arg) } + } + fn get_atomic_number_array_name(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_molecule_get_atomic_number_array_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_molecule_get_atomic_number_array_name(self.0) } + } + fn set_bond_orders_array_name(&mut self, _arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_molecule_set_bond_orders_array_name( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { vtk_molecule_set_bond_orders_array_name(self.0, _arg) } + } + fn get_bond_orders_array_name(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_molecule_get_bond_orders_array_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_molecule_get_bond_orders_array_name(self.0) } + } +} +impl VtkMultiBlockDataSet for vtkMultiBlockDataSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_new_instance(self.0) } + } + fn set_number_of_blocks(&mut self, numBlocks: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_multi_block_data_set_set_number_of_blocks( + sself: *mut core::ffi::c_void, + numBlocks: core::ffi::c_uint, + ); + } + unsafe { vtk_multi_block_data_set_set_number_of_blocks(self.0, numBlocks) } + } + fn get_number_of_blocks(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_multi_block_data_set_get_number_of_blocks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_multi_block_data_set_get_number_of_blocks(self.0) } + } + fn get_block(&mut self, blockno: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_get_block( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_get_block(self.0, blockno) } + } + fn set_block( + &mut self, + blockno: core::ffi::c_uint, + block: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_multi_block_data_set_set_block( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_uint, + block: *mut core::ffi::c_void, + ); + } + unsafe { vtk_multi_block_data_set_set_block(self.0, blockno, block) } + } + fn remove_block(&mut self, blockno: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_multi_block_data_set_remove_block( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_uint, + ); + } + unsafe { vtk_multi_block_data_set_remove_block(self.0, blockno) } + } + fn has_meta_data(&mut self, blockno: core::ffi::c_uint) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_block_data_set_has_meta_data( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_block_data_set_has_meta_data(self.0, blockno) } + } + fn get_meta_data(&mut self, blockno: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_get_meta_data( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_get_meta_data(self.0, blockno) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_get_data(self.0, v, i) } + } + fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_get_meta_data( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_get_meta_data(self.0, iter) } + } + fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_block_data_set_has_meta_data( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_block_data_set_has_meta_data(self.0, iter) } + } +} +impl VtkMultiPieceDataSet for vtkMultiPieceDataSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_new_instance(self.0) } + } + fn set_number_of_pieces(&mut self, numpieces: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_multi_piece_data_set_set_number_of_pieces( + sself: *mut core::ffi::c_void, + numpieces: core::ffi::c_uint, + ); + } + unsafe { vtk_multi_piece_data_set_set_number_of_pieces(self.0, numpieces) } + } + fn get_number_of_pieces(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_multi_piece_data_set_get_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_multi_piece_data_set_get_number_of_pieces(self.0) } + } + fn get_piece(&mut self, pieceno: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_get_piece( + sself: *mut core::ffi::c_void, + pieceno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_get_piece(self.0, pieceno) } + } + fn get_piece_as_data_object( + &mut self, + pieceno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_get_piece_as_data_object( + sself: *mut core::ffi::c_void, + pieceno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_get_piece_as_data_object(self.0, pieceno) } + } + fn set_piece( + &mut self, + pieceno: core::ffi::c_uint, + piece: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_multi_piece_data_set_set_piece( + sself: *mut core::ffi::c_void, + pieceno: core::ffi::c_uint, + piece: *mut core::ffi::c_void, + ); + } + unsafe { vtk_multi_piece_data_set_set_piece(self.0, pieceno, piece) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_get_data(self.0, v, i) } + } +} +impl VtkMutableDirectedGraph for vtkMutableDirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_new_instance(self.0) } + } + fn set_number_of_vertices( + &mut self, + numVerts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_mutable_directed_graph_set_number_of_vertices( + sself: *mut core::ffi::c_void, + numVerts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_mutable_directed_graph_set_number_of_vertices(self.0, numVerts) } + } + fn add_vertex(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_vertex( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_mutable_directed_graph_add_vertex(self.0) } + } + fn add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_vertex( + sself: *mut core::ffi::c_void, + propertyArr: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_mutable_directed_graph_add_vertex(self.0, propertyArr) } + } + fn add_vertex(&mut self, pedigreeId: vtkVariant) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_vertex( + sself: *mut core::ffi::c_void, + pedigreeId: vtkVariant, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_mutable_directed_graph_add_vertex(self.0, pedigreeId) } + } + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_add_edge(self.0, u, v) } + } + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_add_edge(self.0, u, v, propertyArr) } + } + fn add_edge( + &mut self, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_edge( + sself: *mut core::ffi::c_void, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_add_edge(self.0, u, v, propertyArr) } + } + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_add_edge(self.0, u, v, propertyArr) } + } + fn add_edge( + &mut self, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_edge( + sself: *mut core::ffi::c_void, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_add_edge(self.0, u, v, propertyArr) } + } + fn lazy_add_vertex(&mut self) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_lazy_add_vertex(sself: *mut core::ffi::c_void); + } + unsafe { vtk_mutable_directed_graph_lazy_add_vertex(self.0) } + } + fn lazy_add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_lazy_add_vertex( + sself: *mut core::ffi::c_void, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_directed_graph_lazy_add_vertex(self.0, propertyArr) } + } + fn lazy_add_vertex(&mut self, pedigreeId: vtkVariant) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_lazy_add_vertex( + sself: *mut core::ffi::c_void, + pedigreeId: vtkVariant, + ); + } + unsafe { vtk_mutable_directed_graph_lazy_add_vertex(self.0, pedigreeId) } + } + fn lazy_add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_directed_graph_lazy_add_edge(self.0, u, v, propertyArr) } + } + fn lazy_add_edge( + &mut self, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_directed_graph_lazy_add_edge(self.0, u, v, propertyArr) } + } + fn lazy_add_edge( + &mut self, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_directed_graph_lazy_add_edge(self.0, u, v, propertyArr) } + } + fn lazy_add_edge( + &mut self, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_directed_graph_lazy_add_edge(self.0, u, v, propertyArr) } + } + fn add_graph_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_graph_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_add_graph_edge(self.0, u, v) } + } + fn add_child( + &mut self, + parent: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_child( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_mutable_directed_graph_add_child(self.0, parent, propertyArr) } + } + fn add_child(&mut self, parent: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_child( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_mutable_directed_graph_add_child(self.0, parent) } + } + fn remove_vertex(&mut self, v: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_remove_vertex( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + ); + } + unsafe { vtk_mutable_directed_graph_remove_vertex(self.0, v) } + } + fn remove_edge(&mut self, e: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_remove_edge( + sself: *mut core::ffi::c_void, + e: core::ffi::c_uchar, + ); + } + unsafe { vtk_mutable_directed_graph_remove_edge(self.0, e) } + } + fn remove_vertices(&mut self, arr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_remove_vertices( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_directed_graph_remove_vertices(self.0, arr) } + } + fn remove_edges(&mut self, arr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_remove_edges( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_directed_graph_remove_edges(self.0, arr) } + } +} +impl VtkMutableUndirectedGraph for vtkMutableUndirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_new_instance(self.0) } + } + fn set_number_of_vertices( + &mut self, + numVerts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_set_number_of_vertices( + sself: *mut core::ffi::c_void, + numVerts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_mutable_undirected_graph_set_number_of_vertices(self.0, numVerts) } + } + fn add_vertex(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_vertex( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_mutable_undirected_graph_add_vertex(self.0) } + } + fn add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_vertex( + sself: *mut core::ffi::c_void, + propertyArr: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_mutable_undirected_graph_add_vertex(self.0, propertyArr) } + } + fn add_vertex(&mut self, pedigreeId: vtkVariant) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_vertex( + sself: *mut core::ffi::c_void, + pedigreeId: vtkVariant, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_mutable_undirected_graph_add_vertex(self.0, pedigreeId) } + } + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_add_edge(self.0, u, v) } + } + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_add_edge(self.0, u, v, propertyArr) } + } + fn add_edge( + &mut self, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_edge( + sself: *mut core::ffi::c_void, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_add_edge(self.0, u, v, propertyArr) } + } + fn add_edge( + &mut self, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_add_edge(self.0, u, v, propertyArr) } + } + fn add_edge( + &mut self, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_edge( + sself: *mut core::ffi::c_void, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_add_edge(self.0, u, v, propertyArr) } + } + fn lazy_add_vertex(&mut self) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_lazy_add_vertex( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_lazy_add_vertex(self.0) } + } + fn lazy_add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_lazy_add_vertex( + sself: *mut core::ffi::c_void, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_lazy_add_vertex(self.0, propertyArr) } + } + fn lazy_add_vertex(&mut self, pedigreeId: vtkVariant) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_lazy_add_vertex( + sself: *mut core::ffi::c_void, + pedigreeId: vtkVariant, + ); + } + unsafe { vtk_mutable_undirected_graph_lazy_add_vertex(self.0, pedigreeId) } + } + fn lazy_add_edge(&mut self, u: core::ffi::c_uchar, v: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ); + } + unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v) } + } + fn lazy_add_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v, propertyArr) } + } + fn lazy_add_edge( + &mut self, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: vtkVariant, + v: core::ffi::c_uchar, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v, propertyArr) } + } + fn lazy_add_edge( + &mut self, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v, propertyArr) } + } + fn lazy_add_edge( + &mut self, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: vtkVariant, + v: vtkVariant, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v, propertyArr) } + } + fn add_graph_edge( + &mut self, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_graph_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_uchar, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_add_graph_edge(self.0, u, v) } + } + fn remove_vertex(&mut self, v: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_remove_vertex( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + ); + } + unsafe { vtk_mutable_undirected_graph_remove_vertex(self.0, v) } + } + fn remove_edge(&mut self, e: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_remove_edge( + sself: *mut core::ffi::c_void, + e: core::ffi::c_uchar, + ); + } + unsafe { vtk_mutable_undirected_graph_remove_edge(self.0, e) } + } + fn remove_vertices(&mut self, arr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_remove_vertices( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_remove_vertices(self.0, arr) } + } + fn remove_edges(&mut self, arr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_remove_edges( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_remove_edges(self.0, arr) } + } +} +impl VtkNonMergingPointLocator for vtkNonMergingPointLocator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_merging_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_merging_point_locator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_merging_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_merging_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_merging_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_merging_point_locator_new_instance(self.0) } + } + fn is_inserted_point(&mut self, p0: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_non_merging_point_locator_is_inserted_point( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_non_merging_point_locator_is_inserted_point(self.0, p0) } + } + fn is_inserted_point( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_non_merging_point_locator_is_inserted_point( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_non_merging_point_locator_is_inserted_point(self.0, p0, p1, p2) } + } + fn insert_unique_point( + &mut self, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_non_merging_point_locator_insert_unique_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_non_merging_point_locator_insert_unique_point(self.0, x, ptId) } + } +} +impl VtkNonOverlappingAMR for vtkNonOverlappingAMR { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_non_overlapping_amr_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_non_overlapping_amr_get_data_object_type(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_get_data(self.0, v, i) } + } +} +impl VtkOctreePointLocator for vtkOctreePointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_new(self.0) } + } + fn set_maximum_points_per_region(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_set_maximum_points_per_region( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_octree_point_locator_set_maximum_points_per_region(self.0, _arg) } + } + fn get_maximum_points_per_region(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_get_maximum_points_per_region( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_get_maximum_points_per_region(self.0) } + } + fn set_create_cubic_octants(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_set_create_cubic_octants( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_octree_point_locator_set_create_cubic_octants(self.0, _arg) } + } + fn get_create_cubic_octants(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_get_create_cubic_octants( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_get_create_cubic_octants(self.0) } + } + fn get_fudge_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_get_fudge_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_octree_point_locator_get_fudge_factor(self.0) } + } + fn set_fudge_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_set_fudge_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_octree_point_locator_set_fudge_factor(self.0, _arg) } + } + fn get_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_get_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_octree_point_locator_get_bounds(self.0) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_octree_point_locator_get_bounds(self.0, bounds) } + } + fn get_number_of_leaf_nodes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_get_number_of_leaf_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_get_number_of_leaf_nodes(self.0) } + } + fn get_region_bounds( + &mut self, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_get_region_bounds( + sself: *mut core::ffi::c_void, + regionID: core::ffi::c_int, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_octree_point_locator_get_region_bounds(self.0, regionID, bounds) } + } + fn get_region_data_bounds( + &mut self, + leafNodeID: core::ffi::c_int, + bounds: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_get_region_data_bounds( + sself: *mut core::ffi::c_void, + leafNodeID: core::ffi::c_int, + bounds: core::ffi::c_double, + ); + } + unsafe { + vtk_octree_point_locator_get_region_data_bounds(self.0, leafNodeID, bounds) + } + } + fn get_region_containing_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_get_region_containing_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_get_region_containing_point(self.0, x, y, z) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_octree_point_locator_build_locator(self.0) } + } + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_octree_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_octree_point_locator_find_closest_point(self.0, x) } + } + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_octree_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_octree_point_locator_find_closest_point(self.0, x, y, z, dist2) } + } + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_octree_point_locator_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_octree_point_locator_find_closest_point_within_radius( + self.0, + radius, + x, + dist2, + ) + } + } + fn find_closest_point_in_region( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_octree_point_locator_find_closest_point_in_region( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_octree_point_locator_find_closest_point_in_region( + self.0, + regionId, + x, + dist2, + ) + } + } + fn find_closest_point_in_region( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_octree_point_locator_find_closest_point_in_region( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_octree_point_locator_find_closest_point_in_region( + self.0, + regionId, + x, + y, + z, + dist2, + ) + } + } + fn find_points_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_find_points_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_octree_point_locator_find_points_within_radius(self.0, radius, x, result) + } + } + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_find_closest_n_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { vtk_octree_point_locator_find_closest_n_points(self.0, N, x, result) } + } + fn get_points_in_region( + &mut self, + leafNodeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_get_points_in_region( + sself: *mut core::ffi::c_void, + leafNodeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_get_points_in_region(self.0, leafNodeId) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_octree_point_locator_free_search_structure(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_octree_point_locator_generate_representation(self.0, level, pd) } + } + fn find_points_in_area( + &mut self, + area: core::ffi::c_double, + ids: *mut core::ffi::c_void, + clearArray: bool, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_find_points_in_area( + sself: *mut core::ffi::c_void, + area: core::ffi::c_double, + ids: *mut core::ffi::c_void, + clearArray: bool, + ); + } + unsafe { + vtk_octree_point_locator_find_points_in_area(self.0, area, ids, clearArray) + } + } +} +impl VtkOctreePointLocatorNode for vtkOctreePointLocatorNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_node_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_node_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_node_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_node_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_node_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_node_new(self.0) } + } + fn set_number_of_points(&mut self, numberOfPoints: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_number_of_points( + sself: *mut core::ffi::c_void, + numberOfPoints: core::ffi::c_int, + ); + } + unsafe { + vtk_octree_point_locator_node_set_number_of_points(self.0, numberOfPoints) + } + } + fn get_number_of_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_node_get_number_of_points(self.0) } + } + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_bounds( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ); + } + unsafe { + vtk_octree_point_locator_node_set_bounds( + self.0, + xMin, + xMax, + yMin, + yMax, + zMin, + zMax, + ) + } + } + fn set_bounds(&mut self, b: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_bounds( + sself: *mut core::ffi::c_void, + b: core::ffi::c_double, + ); + } + unsafe { vtk_octree_point_locator_node_set_bounds(self.0, b) } + } + fn get_bounds(&mut self, b: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_bounds( + sself: *mut core::ffi::c_void, + b: core::ffi::c_double, + ); + } + unsafe { vtk_octree_point_locator_node_get_bounds(self.0, b) } + } + fn set_data_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_data_bounds( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ); + } + unsafe { + vtk_octree_point_locator_node_set_data_bounds( + self.0, + xMin, + xMax, + yMin, + yMax, + zMin, + zMax, + ) + } + } + fn get_data_bounds(&mut self, b: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_data_bounds( + sself: *mut core::ffi::c_void, + b: core::ffi::c_double, + ); + } + unsafe { vtk_octree_point_locator_node_get_data_bounds(self.0, b) } + } + fn get_min_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_min_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_octree_point_locator_node_get_min_bounds(self.0) } + } + fn get_max_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_max_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_octree_point_locator_node_get_max_bounds(self.0) } + } + fn set_min_bounds(&mut self, minBounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_min_bounds( + sself: *mut core::ffi::c_void, + minBounds: core::ffi::c_double, + ); + } + unsafe { vtk_octree_point_locator_node_set_min_bounds(self.0, minBounds) } + } + fn set_max_bounds(&mut self, maxBounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_max_bounds( + sself: *mut core::ffi::c_void, + maxBounds: core::ffi::c_double, + ); + } + unsafe { vtk_octree_point_locator_node_set_max_bounds(self.0, maxBounds) } + } + fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_min_data_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_octree_point_locator_node_get_min_data_bounds(self.0) } + } + fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_max_data_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_octree_point_locator_node_get_max_data_bounds(self.0) } + } + fn set_min_data_bounds(&mut self, minDataBounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_min_data_bounds( + sself: *mut core::ffi::c_void, + minDataBounds: core::ffi::c_double, + ); + } + unsafe { + vtk_octree_point_locator_node_set_min_data_bounds(self.0, minDataBounds) + } + } + fn set_max_data_bounds(&mut self, maxDataBounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_max_data_bounds( + sself: *mut core::ffi::c_void, + maxDataBounds: core::ffi::c_double, + ); + } + unsafe { + vtk_octree_point_locator_node_set_max_data_bounds(self.0, maxDataBounds) + } + } + fn get_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_node_get_id(self.0) } + } + fn get_min_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_min_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_node_get_min_id(self.0) } + } + fn create_child_nodes(&mut self) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_create_child_nodes( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_octree_point_locator_node_create_child_nodes(self.0) } + } + fn delete_child_nodes(&mut self) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_delete_child_nodes( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_octree_point_locator_node_delete_child_nodes(self.0) } + } + fn get_child(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_child( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_node_get_child(self.0, i) } + } + fn intersects_region( + &mut self, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_intersects_region( + sself: *mut core::ffi::c_void, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_octree_point_locator_node_intersects_region(self.0, pi, useDataBounds) + } + } + fn contains_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_contains_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_octree_point_locator_node_contains_point(self.0, x, y, z, useDataBounds) + } + } + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_distance_2_to_boundary( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { + vtk_octree_point_locator_node_get_distance_2_to_boundary( + self.0, + x, + y, + z, + top, + useDataBounds, + ) + } + } + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + boundaryPt: core::ffi::c_double, + top: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_distance_2_to_boundary( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + boundaryPt: core::ffi::c_double, + top: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { + vtk_octree_point_locator_node_get_distance_2_to_boundary( + self.0, + x, + y, + z, + boundaryPt, + top, + useDataBounds, + ) + } + } + fn get_distance_2_to_inner_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_distance_2_to_inner_boundary( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { + vtk_octree_point_locator_node_get_distance_2_to_inner_boundary( + self.0, + x, + y, + z, + top, + ) + } + } + fn get_sub_octant_index( + &mut self, + point: core::ffi::c_double, + CheckContainment: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_sub_octant_index( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + CheckContainment: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_octree_point_locator_node_get_sub_octant_index( + self.0, + point, + CheckContainment, + ) + } + } + fn compute_octree_node_information( + &mut self, + Parent: *mut core::ffi::c_void, + NextLeafId: core::ffi::c_int, + NextMinId: core::ffi::c_int, + coordinates: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_compute_octree_node_information( + sself: *mut core::ffi::c_void, + Parent: *mut core::ffi::c_void, + NextLeafId: core::ffi::c_int, + NextMinId: core::ffi::c_int, + coordinates: core::ffi::c_float, + ); + } + unsafe { + vtk_octree_point_locator_node_compute_octree_node_information( + self.0, + Parent, + NextLeafId, + NextMinId, + coordinates, + ) + } + } +} +impl VtkOrderedTriangulator for vtkOrderedTriangulator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ordered_triangulator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ordered_triangulator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ordered_triangulator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ordered_triangulator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ordered_triangulator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ordered_triangulator_new(self.0) } + } + fn init_triangulation( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + numPts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_init_triangulation( + sself: *mut core::ffi::c_void, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + numPts: core::ffi::c_int, + ); + } + unsafe { + vtk_ordered_triangulator_init_triangulation( + self.0, + xmin, + xmax, + ymin, + ymax, + zmin, + zmax, + numPts, + ) + } + } + fn init_triangulation( + &mut self, + bounds: core::ffi::c_double, + numPts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_init_triangulation( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + numPts: core::ffi::c_int, + ); + } + unsafe { vtk_ordered_triangulator_init_triangulation(self.0, bounds, numPts) } + } + fn insert_point( + &mut self, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + p: core::ffi::c_double, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + x: core::ffi::c_double, + p: core::ffi::c_double, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_ordered_triangulator_insert_point(self.0, id, x, p, type_) } + } + fn insert_point( + &mut self, + id: core::ffi::c_uchar, + sortid: core::ffi::c_uchar, + x: core::ffi::c_double, + p: core::ffi::c_double, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + sortid: core::ffi::c_uchar, + x: core::ffi::c_double, + p: core::ffi::c_double, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_ordered_triangulator_insert_point(self.0, id, sortid, x, p, type_) } + } + fn insert_point( + &mut self, + id: core::ffi::c_uchar, + sortid: core::ffi::c_uchar, + sortid2: core::ffi::c_uchar, + x: core::ffi::c_double, + p: core::ffi::c_double, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + sortid: core::ffi::c_uchar, + sortid2: core::ffi::c_uchar, + x: core::ffi::c_double, + p: core::ffi::c_double, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_ordered_triangulator_insert_point( + self.0, + id, + sortid, + sortid2, + x, + p, + type_, + ) + } + } + fn triangulate(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_triangulate(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ordered_triangulator_triangulate(self.0) } + } + fn template_triangulate( + &mut self, + cellType: core::ffi::c_int, + numPts: core::ffi::c_int, + numEdges: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_template_triangulate( + sself: *mut core::ffi::c_void, + cellType: core::ffi::c_int, + numPts: core::ffi::c_int, + numEdges: core::ffi::c_int, + ); + } + unsafe { + vtk_ordered_triangulator_template_triangulate( + self.0, + cellType, + numPts, + numEdges, + ) + } + } + fn update_point_type( + &mut self, + internalId: core::ffi::c_uchar, + type_: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_update_point_type( + sself: *mut core::ffi::c_void, + internalId: core::ffi::c_uchar, + type_: core::ffi::c_int, + ); + } + unsafe { vtk_ordered_triangulator_update_point_type(self.0, internalId, type_) } + } + fn get_point_position( + &mut self, + internalId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_point_position( + sself: *mut core::ffi::c_void, + internalId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_ordered_triangulator_get_point_position(self.0, internalId) } + } + fn get_point_location( + &mut self, + internalId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_point_location( + sself: *mut core::ffi::c_void, + internalId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_ordered_triangulator_get_point_location(self.0, internalId) } + } + fn get_point_id(&mut self, internalId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_point_id( + sself: *mut core::ffi::c_void, + internalId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_ordered_triangulator_get_point_id(self.0, internalId) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ordered_triangulator_get_number_of_points(self.0) } + } + fn set_use_templates(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_set_use_templates( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_ordered_triangulator_set_use_templates(self.0, _arg) } + } + fn get_use_templates(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_use_templates( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ordered_triangulator_get_use_templates(self.0) } + } + fn use_templates_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_use_templates_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ordered_triangulator_use_templates_on(self.0) } + } + fn use_templates_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_use_templates_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ordered_triangulator_use_templates_off(self.0) } + } + fn set_pre_sorted(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_set_pre_sorted( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_ordered_triangulator_set_pre_sorted(self.0, _arg) } + } + fn get_pre_sorted(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_pre_sorted( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ordered_triangulator_get_pre_sorted(self.0) } + } + fn pre_sorted_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_pre_sorted_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ordered_triangulator_pre_sorted_on(self.0) } + } + fn pre_sorted_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_pre_sorted_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ordered_triangulator_pre_sorted_off(self.0) } + } + fn set_use_two_sort_ids(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_set_use_two_sort_ids( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_ordered_triangulator_set_use_two_sort_ids(self.0, _arg) } + } + fn get_use_two_sort_ids(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_use_two_sort_ids( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ordered_triangulator_get_use_two_sort_ids(self.0) } + } + fn use_two_sort_ids_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_use_two_sort_ids_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_ordered_triangulator_use_two_sort_ids_on(self.0) } + } + fn use_two_sort_ids_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_use_two_sort_ids_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_ordered_triangulator_use_two_sort_ids_off(self.0) } + } + fn get_tetras( + &mut self, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_tetras( + sself: *mut core::ffi::c_void, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_ordered_triangulator_get_tetras(self.0, classification, ugrid) } + } + fn add_tetras( + &mut self, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_add_tetras( + sself: *mut core::ffi::c_void, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_ordered_triangulator_add_tetras(self.0, classification, ugrid) } + } + fn add_tetras( + &mut self, + classification: core::ffi::c_int, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_add_tetras( + sself: *mut core::ffi::c_void, + classification: core::ffi::c_int, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_ordered_triangulator_add_tetras(self.0, classification, connectivity) + } + } + fn add_tetras( + &mut self, + classification: core::ffi::c_int, + locator: *mut core::ffi::c_void, + outConnectivity: *mut core::ffi::c_void, + inPD: *mut core::ffi::c_void, + outPD: *mut core::ffi::c_void, + inCD: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCD: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_add_tetras( + sself: *mut core::ffi::c_void, + classification: core::ffi::c_int, + locator: *mut core::ffi::c_void, + outConnectivity: *mut core::ffi::c_void, + inPD: *mut core::ffi::c_void, + outPD: *mut core::ffi::c_void, + inCD: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCD: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_ordered_triangulator_add_tetras( + self.0, + classification, + locator, + outConnectivity, + inPD, + outPD, + inCD, + cellId, + outCD, + ) + } + } + fn add_tetras( + &mut self, + classification: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_add_tetras( + sself: *mut core::ffi::c_void, + classification: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_ordered_triangulator_add_tetras(self.0, classification, ptIds, pts) + } + } + fn add_triangles( + &mut self, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_add_triangles( + sself: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_ordered_triangulator_add_triangles(self.0, connectivity) } + } + fn add_triangles( + &mut self, + id: core::ffi::c_uchar, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_ordered_triangulator_add_triangles( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uchar, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_ordered_triangulator_add_triangles(self.0, id, connectivity) } + } + fn init_tetra_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_init_tetra_traversal( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_ordered_triangulator_init_tetra_traversal(self.0) } + } + fn get_next_tetra( + &mut self, + classification: core::ffi::c_int, + tet: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + tetScalars: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_next_tetra( + sself: *mut core::ffi::c_void, + classification: core::ffi::c_int, + tet: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + tetScalars: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_ordered_triangulator_get_next_tetra( + self.0, + classification, + tet, + cellScalars, + tetScalars, + ) + } + } +} +impl VtkOutEdgeIterator for vtkOutEdgeIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_new_instance(self.0) } + } + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_out_edge_iterator_initialize( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + ); + } + unsafe { vtk_out_edge_iterator_initialize(self.0, g, v) } + } + fn get_graph(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_get_graph( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_get_graph(self.0) } + } + fn get_vertex(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_out_edge_iterator_get_vertex( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_out_edge_iterator_get_vertex(self.0) } + } + fn next(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_next( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_next(self.0) } + } + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_next_graph_edge( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_next_graph_edge(self.0) } + } + fn has_next(&mut self) -> bool { + unsafe extern "C" { + fn vtk_out_edge_iterator_has_next(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_out_edge_iterator_has_next(self.0) } + } +} +impl VtkOverlappingAMR for vtkOverlappingAMR { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_new_instance(self.0) } + } + fn set_origin(&mut self, origin: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_set_origin( + sself: *mut core::ffi::c_void, + origin: core::ffi::c_double, + ); + } + unsafe { vtk_overlapping_amr_set_origin(self.0, origin) } + } + fn get_origin(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_overlapping_amr_get_origin( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_overlapping_amr_get_origin(self.0) } + } + fn set_spacing( + &mut self, + level: core::ffi::c_uint, + spacing: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_set_spacing( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + spacing: core::ffi::c_double, + ); + } + unsafe { vtk_overlapping_amr_set_spacing(self.0, level, spacing) } + } + fn get_spacing( + &mut self, + level: core::ffi::c_uint, + spacing: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_get_spacing( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + spacing: core::ffi::c_double, + ); + } + unsafe { vtk_overlapping_amr_get_spacing(self.0, level, spacing) } + } + fn set_amr_box( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + box_: vtkAMRBox, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_set_amr_box( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + box_: vtkAMRBox, + ); + } + unsafe { vtk_overlapping_amr_set_amr_box(self.0, level, id, box_) } + } + fn get_amr_box( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> vtkAMRBox { + unsafe extern "C" { + fn vtk_overlapping_amr_get_amr_box( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> vtkAMRBox; + } + unsafe { vtk_overlapping_amr_get_amr_box(self.0, level, id) } + } + fn get_bounds( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + bb: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_get_bounds( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + bb: core::ffi::c_double, + ); + } + unsafe { vtk_overlapping_amr_get_bounds(self.0, level, id, bb) } + } + fn get_origin( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + origin: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_get_origin( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + origin: core::ffi::c_double, + ); + } + unsafe { vtk_overlapping_amr_get_origin(self.0, level, id, origin) } + } + fn number_of_blanked_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_number_of_blanked_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_number_of_blanked_points(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_get_data(self.0, v, i) } + } + fn set_refinement_ratio( + &mut self, + level: core::ffi::c_uint, + refRatio: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_set_refinement_ratio( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + refRatio: core::ffi::c_int, + ); + } + unsafe { vtk_overlapping_amr_set_refinement_ratio(self.0, level, refRatio) } + } + fn get_refinement_ratio(&mut self, level: core::ffi::c_uint) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_overlapping_amr_get_refinement_ratio( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_overlapping_amr_get_refinement_ratio(self.0, level) } + } + fn set_amr_block_source_index( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + sourceId: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_set_amr_block_source_index( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + sourceId: core::ffi::c_int, + ); + } + unsafe { + vtk_overlapping_amr_set_amr_block_source_index(self.0, level, id, sourceId) + } + } + fn get_amr_block_source_index( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_overlapping_amr_get_amr_block_source_index( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_overlapping_amr_get_amr_block_source_index(self.0, level, id) } + } + fn get_refinement_ratio( + &mut self, + iter: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_overlapping_amr_get_refinement_ratio( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_overlapping_amr_get_refinement_ratio(self.0, iter) } + } + fn has_children_information(&mut self) -> bool { + unsafe extern "C" { + fn vtk_overlapping_amr_has_children_information( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_overlapping_amr_has_children_information(self.0) } + } + fn generate_parent_child_information(&mut self) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_generate_parent_child_information( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_overlapping_amr_generate_parent_child_information(self.0) } + } + fn get_parents( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + numParents: core::ffi::c_uint, + ) -> *mut core::ffi::c_uint { + unsafe extern "C" { + fn vtk_overlapping_amr_get_parents( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + numParents: core::ffi::c_uint, + ) -> *mut core::ffi::c_uint; + } + unsafe { vtk_overlapping_amr_get_parents(self.0, level, index, numParents) } + } + fn get_children( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + numChildren: core::ffi::c_uint, + ) -> *mut core::ffi::c_uint { + unsafe extern "C" { + fn vtk_overlapping_amr_get_children( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + numChildren: core::ffi::c_uint, + ) -> *mut core::ffi::c_uint; + } + unsafe { vtk_overlapping_amr_get_children(self.0, level, index, numChildren) } + } + fn print_parent_child_info( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_print_parent_child_info( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ); + } + unsafe { vtk_overlapping_amr_print_parent_child_info(self.0, level, index) } + } + fn get_bounds(&mut self, b: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_get_bounds( + sself: *mut core::ffi::c_void, + b: core::ffi::c_double, + ); + } + unsafe { vtk_overlapping_amr_get_bounds(self.0, b) } + } + fn find_grid( + &mut self, + q: core::ffi::c_double, + level: core::ffi::c_uint, + gridId: core::ffi::c_uint, + ) -> bool { + unsafe extern "C" { + fn vtk_overlapping_amr_find_grid( + sself: *mut core::ffi::c_void, + q: core::ffi::c_double, + level: core::ffi::c_uint, + gridId: core::ffi::c_uint, + ) -> bool; + } + unsafe { vtk_overlapping_amr_find_grid(self.0, q, level, gridId) } + } + fn get_amr_info(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_get_amr_info( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_get_amr_info(self.0) } + } + fn set_amr_info(&mut self, info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_set_amr_info( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_overlapping_amr_set_amr_info(self.0, info) } + } + fn audit(&mut self) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_audit(sself: *mut core::ffi::c_void); + } + unsafe { vtk_overlapping_amr_audit(self.0) } + } +} +impl VtkPartitionedDataSet for vtkPartitionedDataSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_new_instance(self.0) } + } + fn set_number_of_partitions(&mut self, numPartitions: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_set_number_of_partitions( + sself: *mut core::ffi::c_void, + numPartitions: core::ffi::c_uint, + ); + } + unsafe { + vtk_partitioned_data_set_set_number_of_partitions(self.0, numPartitions) + } + } + fn get_number_of_partitions(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_number_of_partitions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_partitioned_data_set_get_number_of_partitions(self.0) } + } + fn get_partition(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_partition( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_get_partition(self.0, idx) } + } + fn get_partition_as_data_object( + &mut self, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_partition_as_data_object( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_get_partition_as_data_object(self.0, idx) } + } + fn set_partition( + &mut self, + idx: core::ffi::c_uint, + partition: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_set_partition( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + partition: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_set_partition(self.0, idx, partition) } + } + fn has_meta_data(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_has_meta_data( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_partitioned_data_set_has_meta_data(self.0, idx) } + } + fn get_meta_data(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_meta_data( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_get_meta_data(self.0, idx) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_get_data(self.0, v, i) } + } + fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_meta_data( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_get_meta_data(self.0, iter) } + } + fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_has_meta_data( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_partitioned_data_set_has_meta_data(self.0, iter) } + } + fn remove_null_partitions(&mut self) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_remove_null_partitions( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_remove_null_partitions(self.0) } + } +} +impl VtkPartitionedDataSetCollection for vtkPartitionedDataSetCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_new_instance(self.0) } + } + fn set_number_of_partitioned_data_sets( + &mut self, + numDataSets: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets( + sself: *mut core::ffi::c_void, + numDataSets: core::ffi::c_uint, + ); + } + unsafe { + vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets( + self.0, + numDataSets, + ) + } + } + fn get_number_of_partitioned_data_sets(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { + vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets( + self.0, + ) + } + } + fn get_partitioned_data_set( + &mut self, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_partitioned_data_set( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_partitioned_data_set_collection_get_partitioned_data_set(self.0, idx) + } + } + fn set_partitioned_data_set( + &mut self, + idx: core::ffi::c_uint, + dataset: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_set_partitioned_data_set( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + dataset: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_partitioned_data_set_collection_set_partitioned_data_set( + self.0, + idx, + dataset, + ) + } + } + fn remove_partitioned_data_set(&mut self, idx: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_remove_partitioned_data_set( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ); + } + unsafe { + vtk_partitioned_data_set_collection_remove_partitioned_data_set(self.0, idx) + } + } + fn set_partition( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + object: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_set_partition( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + object: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_partitioned_data_set_collection_set_partition( + self.0, + idx, + partition, + object, + ) + } + } + fn get_partition( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_partition( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_partitioned_data_set_collection_get_partition(self.0, idx, partition) + } + } + fn get_partition_as_data_object( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_partition_as_data_object( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_partitioned_data_set_collection_get_partition_as_data_object( + self.0, + idx, + partition, + ) + } + } + fn get_number_of_partitions(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_number_of_partitions( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> core::ffi::c_uint; + } + unsafe { + vtk_partitioned_data_set_collection_get_number_of_partitions(self.0, idx) + } + } + fn set_number_of_partitions( + &mut self, + idx: core::ffi::c_uint, + numPartitions: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_set_number_of_partitions( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + numPartitions: core::ffi::c_uint, + ); + } + unsafe { + vtk_partitioned_data_set_collection_set_number_of_partitions( + self.0, + idx, + numPartitions, + ) + } + } + fn has_meta_data(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_has_meta_data( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_partitioned_data_set_collection_has_meta_data(self.0, idx) } + } + fn get_meta_data(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_meta_data( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_get_meta_data(self.0, idx) } + } + fn get_data_assembly(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_data_assembly( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_get_data_assembly(self.0) } + } + fn set_data_assembly(&mut self, assembly: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_set_data_assembly( + sself: *mut core::ffi::c_void, + assembly: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_partitioned_data_set_collection_set_data_assembly(self.0, assembly) + } + } + fn get_composite_index(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_composite_index( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> core::ffi::c_uint; + } + unsafe { vtk_partitioned_data_set_collection_get_composite_index(self.0, idx) } + } + fn get_composite_index( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_composite_index( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> core::ffi::c_uint; + } + unsafe { + vtk_partitioned_data_set_collection_get_composite_index( + self.0, + idx, + partition, + ) + } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_get_data(self.0, v, i) } + } + fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_meta_data( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_get_meta_data(self.0, iter) } + } + fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_has_meta_data( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_partitioned_data_set_collection_has_meta_data(self.0, iter) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_partitioned_data_set_collection_get_m_time(self.0) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_collection_shallow_copy(self.0, src) } + } +} +impl VtkPath for vtkPath { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_path_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_path_get_data_object_type(self.0) } + } + fn insert_next_point( + &mut self, + pts: core::ffi::c_float, + code: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_path_insert_next_point( + sself: *mut core::ffi::c_void, + pts: core::ffi::c_float, + code: core::ffi::c_int, + ); + } + unsafe { vtk_path_insert_next_point(self.0, pts, code) } + } + fn insert_next_point( + &mut self, + pts: core::ffi::c_double, + code: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_path_insert_next_point( + sself: *mut core::ffi::c_void, + pts: core::ffi::c_double, + code: core::ffi::c_int, + ); + } + unsafe { vtk_path_insert_next_point(self.0, pts, code) } + } + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + code: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_path_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + code: core::ffi::c_int, + ); + } + unsafe { vtk_path_insert_next_point(self.0, x, y, z, code) } + } + fn set_codes(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_path_set_codes( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_path_set_codes(self.0, p0) } + } + fn get_codes(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_get_codes( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_get_codes(self.0) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_path_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_path_get_number_of_cells(self.0) } + } + fn get_cell(&mut self, p0: core::ffi::c_uchar, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_path_get_cell( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_path_get_cell(self.0, p0, p1) } + } + fn get_cell_points( + &mut self, + p0: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_path_get_cell_points( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_path_get_cell_points(self.0, p0, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_path_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_path_get_point_cells(self.0, ptId, cellIds) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_path_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_path_get_max_cell_size(self.0) } + } + fn allocate(&mut self, size: core::ffi::c_uchar, extSize: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_path_allocate( + sself: *mut core::ffi::c_void, + size: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ); + } + unsafe { vtk_path_allocate(self.0, size, extSize) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_path_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_path_reset(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_get_data(self.0, v, i) } + } +} +impl VtkPentagonalPrism for vtkPentagonalPrism { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pentagonal_prism_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pentagonal_prism_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pentagonal_prism_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pentagonal_prism_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pentagonal_prism_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pentagonal_prism_new_instance(self.0) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_pentagonal_prism_get_edge_points(self.0, edgeId, pts) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_pentagonal_prism_get_edge_points(self.0, edgeId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_pentagonal_prism_get_face_points(self.0, faceId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_pentagonal_prism_get_face_points(self.0, faceId, pts) } + } + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_edge_to_adjacent_faces( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_pentagonal_prism_get_edge_to_adjacent_faces(self.0, edgeId, pts) } + } + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_face_to_adjacent_faces( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_pentagonal_prism_get_face_to_adjacent_faces(self.0, faceId, faceIds) + } + } + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_point_to_incident_edges( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_pentagonal_prism_get_point_to_incident_edges(self.0, pointId, edgeIds) + } + } + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_point_to_incident_faces( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_pentagonal_prism_get_point_to_incident_faces(self.0, pointId, faceIds) + } + } + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_point_to_one_ring_points( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_pentagonal_prism_get_point_to_one_ring_points(self.0, pointId, pts) + } + } + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_centroid( + sself: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_pentagonal_prism_get_centroid(self.0, centroid) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pentagonal_prism_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pentagonal_prism_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pentagonal_prism_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pentagonal_prism_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pentagonal_prism_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pentagonal_prism_cell_boundary(self.0, subId, pcoords, pts) } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_pentagonal_prism_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_pentagonal_prism_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_pentagonal_prism_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pentagonal_prism_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_pentagonal_prism_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_pentagonal_prism_get_parametric_center(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_pentagonal_prism_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_pentagonal_prism_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_pentagonal_prism_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_pentagonal_prism_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pentagonal_prism_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pentagonal_prism_get_face_array(self.0, faceId) } + } + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_edge_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pentagonal_prism_get_edge_to_adjacent_faces_array(self.0, edgeId) } + } + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_face_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pentagonal_prism_get_face_to_adjacent_faces_array(self.0, faceId) } + } + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_point_to_incident_edges_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { + vtk_pentagonal_prism_get_point_to_incident_edges_array(self.0, pointId) + } + } + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_point_to_incident_faces_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { + vtk_pentagonal_prism_get_point_to_incident_faces_array(self.0, pointId) + } + } + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_point_to_one_ring_points_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { + vtk_pentagonal_prism_get_point_to_one_ring_points_array(self.0, pointId) + } + } + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_pentagonal_prism_compute_centroid( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { + vtk_pentagonal_prism_compute_centroid(self.0, points, pointIds, centroid) + } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pentagonal_prism_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_pentagonal_prism_jacobian_inverse(self.0, pcoords, inverse, derivs) + } + } +} +impl VtkPerlinNoise for vtkPerlinNoise { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perlin_noise_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perlin_noise_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perlin_noise_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perlin_noise_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perlin_noise_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perlin_noise_new(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_perlin_noise_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_perlin_noise_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_evaluate_gradient(self.0, x, n) } + } + fn set_frequency( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_set_frequency( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_set_frequency(self.0, _arg1, _arg2, _arg3) } + } + fn set_frequency(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_set_frequency( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_set_frequency(self.0, _arg) } + } + fn get_frequency(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_perlin_noise_get_frequency( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_perlin_noise_get_frequency(self.0) } + } + fn get_frequency(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_get_frequency( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_get_frequency(self.0, data) } + } + fn set_phase( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_set_phase( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_set_phase(self.0, _arg1, _arg2, _arg3) } + } + fn set_phase(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_set_phase( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_set_phase(self.0, _arg) } + } + fn get_phase(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_perlin_noise_get_phase( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_perlin_noise_get_phase(self.0) } + } + fn get_phase(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_get_phase( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_get_phase(self.0, data) } + } + fn set_amplitude(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_set_amplitude( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_set_amplitude(self.0, _arg) } + } + fn get_amplitude(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_perlin_noise_get_amplitude( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_perlin_noise_get_amplitude(self.0) } + } +} +impl VtkPiecewiseFunction for vtkPiecewiseFunction { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_new_instance(self.0) } + } + fn deep_copy(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_deep_copy( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_deep_copy(self.0, f) } + } + fn shallow_copy(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_shallow_copy( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_shallow_copy(self.0, f) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_get_data_object_type(self.0) } + } + fn get_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_get_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_get_size(self.0) } + } + fn add_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_add_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_add_point(self.0, x, y) } + } + fn add_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + midpoint: core::ffi::c_double, + sharpness: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_add_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + midpoint: core::ffi::c_double, + sharpness: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_add_point(self.0, x, y, midpoint, sharpness) } + } + fn remove_point_by_index(&mut self, id: usize) -> bool { + unsafe extern "C" { + fn vtk_piecewise_function_remove_point_by_index( + sself: *mut core::ffi::c_void, + id: usize, + ) -> bool; + } + unsafe { vtk_piecewise_function_remove_point_by_index(self.0, id) } + } + fn remove_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_remove_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_remove_point(self.0, x) } + } + fn remove_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_remove_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_remove_point(self.0, x, y) } + } + fn remove_all_points(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_remove_all_points(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_remove_all_points(self.0) } + } + fn add_segment( + &mut self, + x1: core::ffi::c_double, + y1: core::ffi::c_double, + x2: core::ffi::c_double, + y2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_add_segment( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + y1: core::ffi::c_double, + x2: core::ffi::c_double, + y2: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_add_segment(self.0, x1, y1, x2, y2) } + } + fn get_value(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_get_value( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_get_value(self.0, x) } + } + fn get_node_value( + &mut self, + index: core::ffi::c_int, + val: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_get_node_value( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + val: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_get_node_value(self.0, index, val) } + } + fn set_node_value( + &mut self, + index: core::ffi::c_int, + val: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_set_node_value( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + val: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_set_node_value(self.0, index, val) } + } + fn get_data_pointer(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_get_data_pointer( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_piecewise_function_get_data_pointer(self.0) } + } + fn fill_from_data_pointer( + &mut self, + p0: core::ffi::c_int, + p1: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_fill_from_data_pointer( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_fill_from_data_pointer(self.0, p0, p1) } + } + fn get_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_get_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_piecewise_function_get_range(self.0) } + } + fn get_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_get_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_get_range(self.0, _arg1, _arg2) } + } + fn get_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_get_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_get_range(self.0, _arg) } + } + fn adjust_range(&mut self, range: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_adjust_range( + sself: *mut core::ffi::c_void, + range: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_adjust_range(self.0, range) } + } + fn get_table( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + size: core::ffi::c_int, + table: core::ffi::c_float, + stride: core::ffi::c_int, + logIncrements: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_get_table( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + size: core::ffi::c_int, + table: core::ffi::c_float, + stride: core::ffi::c_int, + logIncrements: core::ffi::c_int, + ); + } + unsafe { + vtk_piecewise_function_get_table( + self.0, + x1, + x2, + size, + table, + stride, + logIncrements, + ) + } + } + fn get_table( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + size: core::ffi::c_int, + table: core::ffi::c_double, + stride: core::ffi::c_int, + logIncrements: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_get_table( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + size: core::ffi::c_int, + table: core::ffi::c_double, + stride: core::ffi::c_int, + logIncrements: core::ffi::c_int, + ); + } + unsafe { + vtk_piecewise_function_get_table( + self.0, + x1, + x2, + size, + table, + stride, + logIncrements, + ) + } + } + fn build_function_from_table( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + size: core::ffi::c_int, + table: core::ffi::c_double, + stride: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_build_function_from_table( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + size: core::ffi::c_int, + table: core::ffi::c_double, + stride: core::ffi::c_int, + ); + } + unsafe { + vtk_piecewise_function_build_function_from_table( + self.0, + x1, + x2, + size, + table, + stride, + ) + } + } + fn set_clamping(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_set_clamping( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_piecewise_function_set_clamping(self.0, _arg) } + } + fn get_clamping(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_get_clamping( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_get_clamping(self.0) } + } + fn clamping_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_clamping_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_clamping_on(self.0) } + } + fn clamping_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_clamping_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_clamping_off(self.0) } + } + fn set_use_log_scale(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_set_use_log_scale( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_piecewise_function_set_use_log_scale(self.0, _arg) } + } + fn get_use_log_scale(&mut self) -> bool { + unsafe extern "C" { + fn vtk_piecewise_function_get_use_log_scale( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_piecewise_function_get_use_log_scale(self.0) } + } + fn use_log_scale_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_use_log_scale_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_use_log_scale_on(self.0) } + } + fn use_log_scale_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_use_log_scale_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_use_log_scale_off(self.0) } + } + fn get_type(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_piecewise_function_get_type( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_piecewise_function_get_type(self.0) } + } + fn get_first_non_zero_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_get_first_non_zero_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_get_first_non_zero_value(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_initialize(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_get_data(self.0, v, i) } + } + fn set_allow_duplicate_scalars(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_set_allow_duplicate_scalars( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_piecewise_function_set_allow_duplicate_scalars(self.0, _arg) } + } + fn get_allow_duplicate_scalars(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_get_allow_duplicate_scalars( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_get_allow_duplicate_scalars(self.0) } + } + fn allow_duplicate_scalars_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_allow_duplicate_scalars_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_allow_duplicate_scalars_on(self.0) } + } + fn allow_duplicate_scalars_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_allow_duplicate_scalars_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_allow_duplicate_scalars_off(self.0) } + } + fn estimate_min_number_of_samples( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_estimate_min_number_of_samples( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_estimate_min_number_of_samples(self.0, x1, x2) } + } +} +impl VtkPixel for vtkPixel { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pixel_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_pixel_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pixel_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pixel_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pixel_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pixel_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pixel_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pixel_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pixel_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pixel_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_pixel_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_pixel_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_pixel_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_pixel_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_pixel_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pixel_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_pixel_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_inflate( + sself: *mut core::ffi::c_void, + dist: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_inflate(self.0, dist) } + } + fn compute_bounding_sphere( + &mut self, + center: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_pixel_compute_bounding_sphere( + sself: *mut core::ffi::c_void, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_pixel_compute_bounding_sphere(self.0, center) } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_get_parametric_center(self.0, pcoords) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_pixel_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pixel_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_pixel_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pixel_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_pixel_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pixel_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_pixel_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pixel_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_pixel_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pixel_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_pixel_interpolate_derivs(self.0, pcoords, derivs) } + } + fn compute_normal(&mut self, n: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_compute_normal( + sself: *mut core::ffi::c_void, + n: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_compute_normal(self.0, n) } + } +} +impl VtkPlane for vtkPlane { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_new_instance(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_plane_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_plane_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + g: core::ffi::c_double, + ); + } + unsafe { vtk_plane_evaluate_gradient(self.0, x, g) } + } + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_set_normal( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_plane_set_normal(self.0, _arg1, _arg2, _arg3) } + } + fn set_normal(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_plane_set_normal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_plane_set_normal(self.0, _arg) } + } + fn get_normal(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_plane_get_normal( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_plane_get_normal(self.0) } + } + fn get_normal(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_plane_get_normal( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_plane_get_normal(self.0, data) } + } + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_set_origin( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_plane_set_origin(self.0, _arg1, _arg2, _arg3) } + } + fn set_origin(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_plane_set_origin( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_plane_set_origin(self.0, _arg) } + } + fn get_origin(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_plane_get_origin( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_plane_get_origin(self.0) } + } + fn get_origin(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_plane_get_origin( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_plane_get_origin(self.0, data) } + } + fn push(&mut self, distance: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_plane_push( + sself: *mut core::ffi::c_void, + distance: core::ffi::c_double, + ); + } + unsafe { vtk_plane_push(self.0, distance) } + } + fn project_point( + &mut self, + x: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + xproj: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_project_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + xproj: core::ffi::c_double, + ); + } + unsafe { vtk_plane_project_point(self.0, x, origin, normal, xproj) } + } + fn project_point( + &mut self, + x: core::ffi::c_double, + xproj: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_project_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + xproj: core::ffi::c_double, + ); + } + unsafe { vtk_plane_project_point(self.0, x, xproj) } + } + fn project_vector( + &mut self, + v: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + vproj: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_project_vector( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + vproj: core::ffi::c_double, + ); + } + unsafe { vtk_plane_project_vector(self.0, v, origin, normal, vproj) } + } + fn project_vector( + &mut self, + v: core::ffi::c_double, + vproj: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_project_vector( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + vproj: core::ffi::c_double, + ); + } + unsafe { vtk_plane_project_vector(self.0, v, vproj) } + } + fn generalized_project_point( + &mut self, + x: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + xproj: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_generalized_project_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + xproj: core::ffi::c_double, + ); + } + unsafe { vtk_plane_generalized_project_point(self.0, x, origin, normal, xproj) } + } + fn generalized_project_point( + &mut self, + x: core::ffi::c_double, + xproj: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_generalized_project_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + xproj: core::ffi::c_double, + ); + } + unsafe { vtk_plane_generalized_project_point(self.0, x, xproj) } + } + fn evaluate( + &mut self, + normal: core::ffi::c_double, + origin: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_plane_evaluate( + sself: *mut core::ffi::c_void, + normal: core::ffi::c_double, + origin: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_plane_evaluate(self.0, normal, origin, x) } + } + fn distance_to_plane( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + p0: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_plane_distance_to_plane( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_double, + p0: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_plane_distance_to_plane(self.0, x, n, p0) } + } + fn distance_to_plane(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_plane_distance_to_plane( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_plane_distance_to_plane(self.0, x) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + n: core::ffi::c_double, + p0: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + n: core::ffi::c_double, + p0: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_intersect_with_line(self.0, p1, p2, n, p0, t, x) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_intersect_with_line(self.0, p1, p2, t, x) } + } + fn intersect_with_finite_plane( + &mut self, + n: core::ffi::c_double, + o: core::ffi::c_double, + pOrigin: core::ffi::c_double, + px: core::ffi::c_double, + py: core::ffi::c_double, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_intersect_with_finite_plane( + sself: *mut core::ffi::c_void, + n: core::ffi::c_double, + o: core::ffi::c_double, + pOrigin: core::ffi::c_double, + px: core::ffi::c_double, + py: core::ffi::c_double, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_plane_intersect_with_finite_plane(self.0, n, o, pOrigin, px, py, x0, x1) + } + } + fn intersect_with_finite_plane( + &mut self, + pOrigin: core::ffi::c_double, + px: core::ffi::c_double, + py: core::ffi::c_double, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_intersect_with_finite_plane( + sself: *mut core::ffi::c_void, + pOrigin: core::ffi::c_double, + px: core::ffi::c_double, + py: core::ffi::c_double, + x0: core::ffi::c_double, + x1: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_intersect_with_finite_plane(self.0, pOrigin, px, py, x0, x1) } + } + fn compute_best_fitting_plane( + &mut self, + pts: *mut core::ffi::c_void, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_plane_compute_best_fitting_plane( + sself: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_plane_compute_best_fitting_plane(self.0, pts, origin, normal) } + } +} +impl VtkPlaneCollection for vtkPlaneCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_new(self.0) } + } + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_plane_collection_add_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_plane_collection_add_item(self.0, p0) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_get_next_item(self.0) } + } + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_get_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_get_item(self.0, i) } + } + fn get_next_plane(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_get_next_plane( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_get_next_plane(self.0, cookie) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_collection_get_number_of_items(self.0) } + } +} +impl VtkPlanes for vtkPlanes { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_new_instance(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_planes_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_planes_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_planes_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_planes_evaluate_gradient(self.0, x, n) } + } + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_planes_set_points( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_planes_set_points(self.0, p0) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_get_points(self.0) } + } + fn set_normals(&mut self, normals: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_planes_set_normals( + sself: *mut core::ffi::c_void, + normals: *mut core::ffi::c_void, + ); + } + unsafe { vtk_planes_set_normals(self.0, normals) } + } + fn get_normals(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_get_normals( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_get_normals(self.0) } + } + fn set_frustum_planes(&mut self, planes: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_planes_set_frustum_planes( + sself: *mut core::ffi::c_void, + planes: core::ffi::c_double, + ); + } + unsafe { vtk_planes_set_frustum_planes(self.0, planes) } + } + fn set_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_planes_set_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_planes_set_bounds(self.0, bounds) } + } + fn set_bounds( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_planes_set_bounds( + sself: *mut core::ffi::c_void, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + ); + } + unsafe { vtk_planes_set_bounds(self.0, xmin, xmax, ymin, ymax, zmin, zmax) } + } + fn get_number_of_planes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_planes_get_number_of_planes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_planes_get_number_of_planes(self.0) } + } + fn get_plane(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_get_plane( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_get_plane(self.0, i) } + } + fn get_plane(&mut self, i: core::ffi::c_int, plane: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_planes_get_plane( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + plane: *mut core::ffi::c_void, + ); + } + unsafe { vtk_planes_get_plane(self.0, i, plane) } + } +} +impl VtkPlanesIntersection for vtkPlanesIntersection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_intersection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_intersection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_intersection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_intersection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_intersection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_intersection_new(self.0) } + } + fn set_region_vertices(&mut self, pts: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_planes_intersection_set_region_vertices( + sself: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_planes_intersection_set_region_vertices(self.0, pts) } + } + fn set_region_vertices( + &mut self, + v: core::ffi::c_double, + nvertices: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_planes_intersection_set_region_vertices( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + nvertices: core::ffi::c_int, + ); + } + unsafe { vtk_planes_intersection_set_region_vertices(self.0, v, nvertices) } + } + fn get_number_of_region_vertices(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_planes_intersection_get_number_of_region_vertices( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_planes_intersection_get_number_of_region_vertices(self.0) } + } + fn get_num_region_vertices(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_planes_intersection_get_num_region_vertices( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_planes_intersection_get_num_region_vertices(self.0) } + } + fn get_region_vertices( + &mut self, + v: core::ffi::c_double, + nvertices: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_planes_intersection_get_region_vertices( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + nvertices: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_planes_intersection_get_region_vertices(self.0, v, nvertices) } + } + fn intersects_region(&mut self, R: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_planes_intersection_intersects_region( + sself: *mut core::ffi::c_void, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_planes_intersection_intersects_region(self.0, R) } + } + fn polygon_intersects_b_box( + &mut self, + bounds: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_planes_intersection_polygon_intersects_b_box( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_planes_intersection_polygon_intersects_b_box(self.0, bounds, pts) } + } + fn convert_3_d_cell( + &mut self, + cell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_intersection_convert_3_d_cell( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_intersection_convert_3_d_cell(self.0, cell) } + } +} +impl VtkPointData for vtkPointData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_data_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_data_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_data_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_data_new_instance(self.0) } + } + fn null_point(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_point_data_null_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_point_data_null_point(self.0, ptId) } + } +} +impl VtkPointLocator for vtkPointLocator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_locator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_locator_new_instance(self.0) } + } + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_point_locator_set_divisions( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ); + } + unsafe { vtk_point_locator_set_divisions(self.0, _arg1, _arg2, _arg3) } + } + fn set_divisions(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_point_locator_set_divisions( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_point_locator_set_divisions(self.0, _arg) } + } + fn get_divisions(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_locator_get_divisions( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_point_locator_get_divisions(self.0) } + } + fn get_divisions(&mut self, data: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_point_locator_get_divisions( + sself: *mut core::ffi::c_void, + data: core::ffi::c_int, + ); + } + unsafe { vtk_point_locator_get_divisions(self.0, data) } + } + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_point_locator_set_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_point_locator_set_number_of_points_per_bucket(self.0, _arg) } + } + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_locator_get_number_of_points_per_bucket_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_locator_get_number_of_points_per_bucket_min_value(self.0) } + } + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_locator_get_number_of_points_per_bucket_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_locator_get_number_of_points_per_bucket_max_value(self.0) } + } + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_locator_get_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_locator_get_number_of_points_per_bucket(self.0) } + } + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_point_locator_find_closest_point(self.0, x) } + } + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_locator_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_point_locator_find_closest_point_within_radius(self.0, radius, x, dist2) + } + } + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + inputDataLength: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_locator_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + inputDataLength: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_point_locator_find_closest_point_within_radius( + self.0, + radius, + x, + inputDataLength, + dist2, + ) + } + } + fn init_point_insertion( + &mut self, + newPts: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_locator_init_point_insertion( + sself: *mut core::ffi::c_void, + newPts: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_locator_init_point_insertion(self.0, newPts, bounds) } + } + fn init_point_insertion( + &mut self, + newPts: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + estNumPts: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_locator_init_point_insertion( + sself: *mut core::ffi::c_void, + newPts: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + estNumPts: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { + vtk_point_locator_init_point_insertion(self.0, newPts, bounds, estNumPts) + } + } + fn insert_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_point_locator_insert_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + x: core::ffi::c_double, + ); + } + unsafe { vtk_point_locator_insert_point(self.0, ptId, x) } + } + fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_locator_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_point_locator_insert_next_point(self.0, x) } + } + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_locator_is_inserted_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_point_locator_is_inserted_point(self.0, x, y, z) } + } + fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_locator_is_inserted_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_point_locator_is_inserted_point(self.0, x) } + } + fn insert_unique_point( + &mut self, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_locator_insert_unique_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_locator_insert_unique_point(self.0, x, ptId) } + } + fn find_closest_inserted_point( + &mut self, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_locator_find_closest_inserted_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_point_locator_find_closest_inserted_point(self.0, x) } + } + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_locator_find_closest_n_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_locator_find_closest_n_points(self.0, N, x, result) } + } + fn find_distributed_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_point_locator_find_distributed_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ); + } + unsafe { vtk_point_locator_find_distributed_points(self.0, N, x, result, M) } + } + fn find_distributed_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_point_locator_find_distributed_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ); + } + unsafe { + vtk_point_locator_find_distributed_points(self.0, N, x, y, z, result, M) + } + } + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_locator_find_points_within_radius( + sself: *mut core::ffi::c_void, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_locator_find_points_within_radius(self.0, R, x, result) } + } + fn get_points_in_bucket( + &mut self, + x: core::ffi::c_double, + ijk: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_locator_get_points_in_bucket( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ijk: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_locator_get_points_in_bucket(self.0, x, ijk) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_locator_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_locator_get_points(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_locator_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_locator_initialize(self.0) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_locator_free_search_structure(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_locator_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_locator_build_locator(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_locator_generate_representation(self.0, level, pd) } + } +} +impl VtkPointSet for vtkPointSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_new_instance(self.0) } + } + fn set_editable(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_point_set_set_editable(sself: *mut core::ffi::c_void, _arg: bool); + } + unsafe { vtk_point_set_set_editable(self.0, _arg) } + } + fn get_editable(&mut self) -> bool { + unsafe extern "C" { + fn vtk_point_set_get_editable(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_point_set_get_editable(self.0) } + } + fn editable_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_editable_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_editable_on(self.0) } + } + fn editable_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_editable_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_editable_off(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_initialize(self.0) } + } + fn copy_structure(&mut self, pd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_copy_structure( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_copy_structure(self.0, pd) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_set_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_point_set_get_number_of_points(self.0) } + } + fn get_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_point_set_get_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + x: core::ffi::c_double, + ); + } + unsafe { vtk_point_set_get_point(self.0, ptId, x) } + } + fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_set_find_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_point_set_find_point(self.0, x) } + } + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_set_find_cell( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_point_set_find_cell( + self.0, + x, + cell, + cellId, + tol2, + subId, + pcoords, + weights, + ) + } + } + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_set_find_cell( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_point_set_find_cell( + self.0, + x, + cell, + gencell, + cellId, + tol2, + subId, + pcoords, + weights, + ) + } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_set_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_point_set_get_number_of_cells(self.0) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_set_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_set_get_max_cell_size(self.0) } + } + fn get_cell(&mut self, p0: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_cell( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_cell(self.0, p0) } + } + fn get_cell_points( + &mut self, + p0: core::ffi::c_uchar, + idList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_set_get_cell_points( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + idList: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_get_cell_points(self.0, p0, idList) } + } + fn get_point_cells( + &mut self, + p0: core::ffi::c_uchar, + idList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_set_get_point_cells( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + idList: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_get_point_cells(self.0, p0, idList) } + } + fn get_cell(&mut self, p0: core::ffi::c_uchar, cell: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_get_cell( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_get_cell(self.0, p0, cell) } + } + fn get_cell_type(&mut self, p0: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_set_get_cell_type( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_set_get_cell_type(self.0, p0) } + } + fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_point_set_get_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_point_set_get_point(self.0, ptId) } + } + fn build_point_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_build_point_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_build_point_locator(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_build_locator(self.0) } + } + fn build_cell_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_build_cell_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_build_cell_locator(self.0) } + } + fn set_point_locator(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_set_point_locator( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_set_point_locator(self.0, p0) } + } + fn get_point_locator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_point_locator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_point_locator(self.0) } + } + fn set_cell_locator(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_set_cell_locator( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_set_cell_locator(self.0, p0) } + } + fn get_cell_locator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_cell_locator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_cell_locator(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_point_set_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_point_set_get_m_time(self.0) } + } + fn compute_bounds(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_compute_bounds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_compute_bounds(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_squeeze(self.0) } + } + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_set_points( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_set_points(self.0, p0) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_points(self.0) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_register(self.0, o) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_data(self.0, v, i) } + } +} +impl VtkPointSetCellIterator for vtkPointSetCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_cell_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_cell_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_cell_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_cell_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_cell_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_cell_iterator_new_instance(self.0) } + } + fn is_done_with_traversal(&mut self) -> bool { + unsafe extern "C" { + fn vtk_point_set_cell_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_point_set_cell_iterator_is_done_with_traversal(self.0) } + } + fn get_cell_id(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_point_set_cell_iterator_get_cell_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_point_set_cell_iterator_get_cell_id(self.0) } + } +} +impl VtkPointsProjectedHull for vtkPointsProjectedHull { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_projected_hull_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_projected_hull_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_projected_hull_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_projected_hull_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_projected_hull_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_projected_hull_new(self.0) } + } + fn rectangle_intersection_x( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_x( + sself: *mut core::ffi::c_void, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_rectangle_intersection_x(self.0, R) } + } + fn rectangle_intersection_x( + &mut self, + ymin: core::ffi::c_float, + ymax: core::ffi::c_float, + zmin: core::ffi::c_float, + zmax: core::ffi::c_float, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_x( + sself: *mut core::ffi::c_void, + ymin: core::ffi::c_float, + ymax: core::ffi::c_float, + zmin: core::ffi::c_float, + zmax: core::ffi::c_float, + ) -> core::ffi::c_int; + } + unsafe { + vtk_points_projected_hull_rectangle_intersection_x( + self.0, + ymin, + ymax, + zmin, + zmax, + ) + } + } + fn rectangle_intersection_x( + &mut self, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_x( + sself: *mut core::ffi::c_void, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_points_projected_hull_rectangle_intersection_x( + self.0, + ymin, + ymax, + zmin, + zmax, + ) + } + } + fn rectangle_intersection_y( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_y( + sself: *mut core::ffi::c_void, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_rectangle_intersection_y(self.0, R) } + } + fn rectangle_intersection_y( + &mut self, + zmin: core::ffi::c_float, + zmax: core::ffi::c_float, + xmin: core::ffi::c_float, + xmax: core::ffi::c_float, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_y( + sself: *mut core::ffi::c_void, + zmin: core::ffi::c_float, + zmax: core::ffi::c_float, + xmin: core::ffi::c_float, + xmax: core::ffi::c_float, + ) -> core::ffi::c_int; + } + unsafe { + vtk_points_projected_hull_rectangle_intersection_y( + self.0, + zmin, + zmax, + xmin, + xmax, + ) + } + } + fn rectangle_intersection_y( + &mut self, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_y( + sself: *mut core::ffi::c_void, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_points_projected_hull_rectangle_intersection_y( + self.0, + zmin, + zmax, + xmin, + xmax, + ) + } + } + fn rectangle_intersection_z( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_z( + sself: *mut core::ffi::c_void, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_rectangle_intersection_z(self.0, R) } + } + fn rectangle_intersection_z( + &mut self, + xmin: core::ffi::c_float, + xmax: core::ffi::c_float, + ymin: core::ffi::c_float, + ymax: core::ffi::c_float, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_z( + sself: *mut core::ffi::c_void, + xmin: core::ffi::c_float, + xmax: core::ffi::c_float, + ymin: core::ffi::c_float, + ymax: core::ffi::c_float, + ) -> core::ffi::c_int; + } + unsafe { + vtk_points_projected_hull_rectangle_intersection_z( + self.0, + xmin, + xmax, + ymin, + ymax, + ) + } + } + fn rectangle_intersection_z( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_z( + sself: *mut core::ffi::c_void, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_points_projected_hull_rectangle_intersection_z( + self.0, + xmin, + xmax, + ymin, + ymax, + ) + } + } + fn get_ccw_hull_x( + &mut self, + pts: core::ffi::c_float, + len: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_ccw_hull_x( + sself: *mut core::ffi::c_void, + pts: core::ffi::c_float, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_ccw_hull_x(self.0, pts, len) } + } + fn get_ccw_hull_x( + &mut self, + pts: core::ffi::c_double, + len: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_ccw_hull_x( + sself: *mut core::ffi::c_void, + pts: core::ffi::c_double, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_ccw_hull_x(self.0, pts, len) } + } + fn get_ccw_hull_y( + &mut self, + pts: core::ffi::c_float, + len: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_ccw_hull_y( + sself: *mut core::ffi::c_void, + pts: core::ffi::c_float, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_ccw_hull_y(self.0, pts, len) } + } + fn get_ccw_hull_y( + &mut self, + pts: core::ffi::c_double, + len: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_ccw_hull_y( + sself: *mut core::ffi::c_void, + pts: core::ffi::c_double, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_ccw_hull_y(self.0, pts, len) } + } + fn get_ccw_hull_z( + &mut self, + pts: core::ffi::c_float, + len: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_ccw_hull_z( + sself: *mut core::ffi::c_void, + pts: core::ffi::c_float, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_ccw_hull_z(self.0, pts, len) } + } + fn get_ccw_hull_z( + &mut self, + pts: core::ffi::c_double, + len: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_ccw_hull_z( + sself: *mut core::ffi::c_void, + pts: core::ffi::c_double, + len: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_ccw_hull_z(self.0, pts, len) } + } + fn get_size_ccw_hull_x(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_size_ccw_hull_x( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_size_ccw_hull_x(self.0) } + } + fn get_size_ccw_hull_y(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_size_ccw_hull_y( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_size_ccw_hull_y(self.0) } + } + fn get_size_ccw_hull_z(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_size_ccw_hull_z( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_size_ccw_hull_z(self.0) } + } + fn update(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_projected_hull_update(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_projected_hull_update(self.0) } + } +} +impl VtkPolyData for vtkPolyData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_data_object_type(self.0) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_copy_structure(self.0, ds) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_get_number_of_cells(self.0) } + } + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_cell(self.0, cellId) } + } + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_get_cell(self.0, cellId, cell) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_cell_type(self.0, cellId) } + } + fn copy_cells( + &mut self, + pd: *mut core::ffi::c_void, + idList: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_copy_cells( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + idList: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_copy_cells(self.0, pd, idList, locator) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_get_point_cells(self.0, ptId, cellIds) } + } + fn compute_cells_bounds(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_compute_cells_bounds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_compute_cells_bounds(self.0) } + } + fn get_cells_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_poly_data_get_cells_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_poly_data_get_cells_bounds(self.0, bounds) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_squeeze(self.0) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_max_cell_size(self.0) } + } + fn get_cell_id_relative_to_cell_array( + &mut self, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_get_cell_id_relative_to_cell_array( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_get_cell_id_relative_to_cell_array(self.0, cellId) } + } + fn set_verts(&mut self, v: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_set_verts( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_set_verts(self.0, v) } + } + fn get_verts(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_verts( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_verts(self.0) } + } + fn set_lines(&mut self, l: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_set_lines( + sself: *mut core::ffi::c_void, + l: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_set_lines(self.0, l) } + } + fn get_lines(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_lines( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_lines(self.0) } + } + fn set_polys(&mut self, p: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_set_polys( + sself: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_set_polys(self.0, p) } + } + fn get_polys(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_polys( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_polys(self.0) } + } + fn set_strips(&mut self, s: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_set_strips( + sself: *mut core::ffi::c_void, + s: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_set_strips(self.0, s) } + } + fn get_strips(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_strips( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_strips(self.0) } + } + fn get_number_of_verts(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_verts( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_get_number_of_verts(self.0) } + } + fn get_number_of_lines(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_lines( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_get_number_of_lines(self.0) } + } + fn get_number_of_polys(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_polys( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_get_number_of_polys(self.0) } + } + fn get_number_of_strips(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_strips( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_get_number_of_strips(self.0) } + } + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_uchar, + maxCellSize: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_poly_data_allocate_estimate( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + maxCellSize: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_poly_data_allocate_estimate(self.0, numCells, maxCellSize) } + } + fn allocate_estimate( + &mut self, + numVerts: core::ffi::c_uchar, + maxVertSize: core::ffi::c_uchar, + numLines: core::ffi::c_uchar, + maxLineSize: core::ffi::c_uchar, + numPolys: core::ffi::c_uchar, + maxPolySize: core::ffi::c_uchar, + numStrips: core::ffi::c_uchar, + maxStripSize: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_poly_data_allocate_estimate( + sself: *mut core::ffi::c_void, + numVerts: core::ffi::c_uchar, + maxVertSize: core::ffi::c_uchar, + numLines: core::ffi::c_uchar, + maxLineSize: core::ffi::c_uchar, + numPolys: core::ffi::c_uchar, + maxPolySize: core::ffi::c_uchar, + numStrips: core::ffi::c_uchar, + maxStripSize: core::ffi::c_uchar, + ) -> bool; + } + unsafe { + vtk_poly_data_allocate_estimate( + self.0, + numVerts, + maxVertSize, + numLines, + maxLineSize, + numPolys, + maxPolySize, + numStrips, + maxStripSize, + ) + } + } + fn allocate_exact( + &mut self, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_poly_data_allocate_exact( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_poly_data_allocate_exact(self.0, numCells, connectivitySize) } + } + fn allocate_exact( + &mut self, + numVerts: core::ffi::c_uchar, + vertConnSize: core::ffi::c_uchar, + numLines: core::ffi::c_uchar, + lineConnSize: core::ffi::c_uchar, + numPolys: core::ffi::c_uchar, + polyConnSize: core::ffi::c_uchar, + numStrips: core::ffi::c_uchar, + stripConnSize: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_poly_data_allocate_exact( + sself: *mut core::ffi::c_void, + numVerts: core::ffi::c_uchar, + vertConnSize: core::ffi::c_uchar, + numLines: core::ffi::c_uchar, + lineConnSize: core::ffi::c_uchar, + numPolys: core::ffi::c_uchar, + polyConnSize: core::ffi::c_uchar, + numStrips: core::ffi::c_uchar, + stripConnSize: core::ffi::c_uchar, + ) -> bool; + } + unsafe { + vtk_poly_data_allocate_exact( + self.0, + numVerts, + vertConnSize, + numLines, + lineConnSize, + numPolys, + polyConnSize, + numStrips, + stripConnSize, + ) + } + } + fn allocate_copy(&mut self, pd: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_poly_data_allocate_copy( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_poly_data_allocate_copy(self.0, pd) } + } + fn allocate_proportional( + &mut self, + pd: *mut core::ffi::c_void, + ratio: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_poly_data_allocate_proportional( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ratio: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_poly_data_allocate_proportional(self.0, pd, ratio) } + } + fn allocate( + &mut self, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_allocate( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ); + } + unsafe { vtk_poly_data_allocate(self.0, numCells, extSize) } + } + fn allocate( + &mut self, + inPolyData: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_allocate( + sself: *mut core::ffi::c_void, + inPolyData: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ); + } + unsafe { vtk_poly_data_allocate(self.0, inPolyData, numCells, extSize) } + } + fn insert_next_cell( + &mut self, + type_: core::ffi::c_int, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_insert_next_cell( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_insert_next_cell(self.0, type_, npts, pts) } + } + fn insert_next_cell( + &mut self, + type_: core::ffi::c_int, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_insert_next_cell( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_insert_next_cell(self.0, type_, pts) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_reset(self.0) } + } + fn build_cells(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_build_cells(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_build_cells(self.0) } + } + fn need_to_build_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_poly_data_need_to_build_cells(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_poly_data_need_to_build_cells(self.0) } + } + fn build_links(&mut self, initialSize: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_poly_data_build_links( + sself: *mut core::ffi::c_void, + initialSize: core::ffi::c_int, + ); + } + unsafe { vtk_poly_data_build_links(self.0, initialSize) } + } + fn delete_cells(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_delete_cells(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_delete_cells(self.0) } + } + fn delete_links(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_delete_links(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_delete_links(self.0) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_uchar, + cells: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_uchar, + cells: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_get_point_cells(self.0, ptId, ncells, cells) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_ushort, + cells: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_ushort, + cells: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_get_point_cells(self.0, ptId, ncells, cells) } + } + fn get_cell_edge_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_get_cell_edge_neighbors( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_get_cell_edge_neighbors(self.0, cellId, p1, p2, cellIds) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_get_cell_points(self.0, cellId, npts, pts) } + } + fn is_triangle( + &mut self, + v1: core::ffi::c_int, + v2: core::ffi::c_int, + v3: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_is_triangle( + sself: *mut core::ffi::c_void, + v1: core::ffi::c_int, + v2: core::ffi::c_int, + v3: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_is_triangle(self.0, v1, v2, v3) } + } + fn is_edge( + &mut self, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_is_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_uchar, + p2: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_is_edge(self.0, p1, p2) } + } + fn is_point_used_by_cell( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_is_point_used_by_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_is_point_used_by_cell(self.0, ptId, cellId) } + } + fn replace_cell( + &mut self, + cellId: core::ffi::c_uchar, + ids: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_replace_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_replace_cell(self.0, cellId, ids) } + } + fn replace_cell( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_replace_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_replace_cell(self.0, cellId, npts, pts) } + } + fn replace_cell_point( + &mut self, + cellId: core::ffi::c_uchar, + oldPtId: core::ffi::c_uchar, + newPtId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_replace_cell_point( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + oldPtId: core::ffi::c_uchar, + newPtId: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_replace_cell_point(self.0, cellId, oldPtId, newPtId) } + } + fn reverse_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_poly_data_reverse_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_reverse_cell(self.0, cellId) } + } + fn delete_point(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_poly_data_delete_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_delete_point(self.0, ptId) } + } + fn delete_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_poly_data_delete_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_delete_cell(self.0, cellId) } + } + fn remove_deleted_cells(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_remove_deleted_cells(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_remove_deleted_cells(self.0) } + } + fn insert_next_linked_point( + &mut self, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_insert_next_linked_point( + sself: *mut core::ffi::c_void, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_insert_next_linked_point(self.0, numLinks) } + } + fn insert_next_linked_point( + &mut self, + x: core::ffi::c_double, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_insert_next_linked_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_insert_next_linked_point(self.0, x, numLinks) } + } + fn insert_next_linked_cell( + &mut self, + type_: core::ffi::c_int, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_insert_next_linked_cell( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_insert_next_linked_cell(self.0, type_, npts, pts) } + } + fn replace_linked_cell( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_replace_linked_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_replace_linked_cell(self.0, cellId, npts, pts) } + } + fn remove_cell_reference(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_poly_data_remove_cell_reference( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_remove_cell_reference(self.0, cellId) } + } + fn add_cell_reference(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_poly_data_add_cell_reference( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_add_cell_reference(self.0, cellId) } + } + fn remove_reference_to_cell( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_remove_reference_to_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_remove_reference_to_cell(self.0, ptId, cellId) } + } + fn add_reference_to_cell( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_add_reference_to_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_poly_data_add_reference_to_cell(self.0, ptId, cellId) } + } + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_uchar, + size: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_resize_cell_list( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + size: core::ffi::c_int, + ); + } + unsafe { vtk_poly_data_resize_cell_list(self.0, ptId, size) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_initialize(self.0) } + } + fn get_piece(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_piece( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_piece(self.0) } + } + fn get_number_of_pieces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_number_of_pieces(self.0) } + } + fn get_ghost_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_ghost_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_ghost_level(self.0) } + } + fn remove_ghost_cells(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_remove_ghost_cells(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_remove_ghost_cells(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_data(self.0, v, i) } + } + fn get_scalar_field_critical_index( + &mut self, + pointId: core::ffi::c_uchar, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_scalar_field_critical_index( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_poly_data_get_scalar_field_critical_index(self.0, pointId, scalarField) + } + } + fn get_scalar_field_critical_index( + &mut self, + pointId: core::ffi::c_uchar, + fieldId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_scalar_field_critical_index( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + fieldId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_poly_data_get_scalar_field_critical_index(self.0, pointId, fieldId) + } + } + fn get_scalar_field_critical_index( + &mut self, + pointId: core::ffi::c_uchar, + fieldName: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_scalar_field_critical_index( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + fieldName: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_poly_data_get_scalar_field_critical_index(self.0, pointId, fieldName) + } + } + fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_poly_data_get_mesh_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_poly_data_get_mesh_m_time(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_poly_data_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_poly_data_get_m_time(self.0) } + } + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_poly_data_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_poly_data_get_cell(self.0, cellId, pts) } + } +} +impl VtkPolyDataCollection for vtkPolyDataCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_collection_new_instance(self.0) } + } + fn add_item(&mut self, pd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_collection_add_item( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_collection_add_item(self.0, pd) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_collection_get_next_item(self.0) } + } + fn get_next_poly_data(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_collection_get_next_poly_data( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_collection_get_next_poly_data(self.0, cookie) } + } +} +impl VtkPolyLine for vtkPolyLine { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_new_instance(self.0) } + } + fn generate_sliding_normals( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_generate_sliding_normals( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_generate_sliding_normals(self.0, p0, p1, p2) } + } + fn generate_sliding_normals( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + firstNormal: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_generate_sliding_normals( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + firstNormal: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_poly_line_generate_sliding_normals(self.0, p0, p1, p2, firstNormal) + } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_line_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_poly_line_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_poly_line_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_poly_line_clip( + self.0, + value, + cellScalars, + locator, + lines, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_poly_line_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_poly_line_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_poly_line_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_poly_line_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_poly_line_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_poly_line_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_get_parametric_center(self.0, pcoords) } + } +} +impl VtkPolyPlane for vtkPolyPlane { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_plane_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_plane_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_plane_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_plane_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_plane_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_plane_new_instance(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_poly_plane_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_poly_plane_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_poly_plane_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + g: core::ffi::c_double, + ); + } + unsafe { vtk_poly_plane_evaluate_gradient(self.0, x, g) } + } + fn set_poly_line(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_plane_set_poly_line( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_plane_set_poly_line(self.0, p0) } + } + fn get_poly_line(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_plane_get_poly_line( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_plane_get_poly_line(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_poly_plane_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_poly_plane_get_m_time(self.0) } + } +} +impl VtkPolyVertex for vtkPolyVertex { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_vertex_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_vertex_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_vertex_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_vertex_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_vertex_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_vertex_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_vertex_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_vertex_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_vertex_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_vertex_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_vertex_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_poly_vertex_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_poly_vertex_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_poly_vertex_clip( + self.0, + value, + cellScalars, + locator, + verts, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_poly_vertex_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_poly_vertex_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_poly_vertex_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_poly_vertex_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_poly_vertex_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_poly_vertex_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_get_parametric_center(self.0, pcoords) } + } +} +impl VtkPolygon for vtkPolygon { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polygon_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_polygon_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polygon_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polygon_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polygon_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polygon_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polygon_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polygon_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polygon_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polygon_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_polygon_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_polygon_clip( + self.0, + value, + cellScalars, + locator, + tris, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polygon_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_polygon_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polygon_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_polygon_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn compute_area(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polygon_compute_area( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_polygon_compute_area(self.0) } + } + fn interpolate_functions( + &mut self, + x: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_interpolate_functions( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + sf: core::ffi::c_double, + ); + } + unsafe { vtk_polygon_interpolate_functions(self.0, x, sf) } + } + fn compute_normal( + &mut self, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_compute_normal( + sself: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + n: core::ffi::c_double, + ); + } + unsafe { vtk_polygon_compute_normal(self.0, p, numPts, pts, n) } + } + fn compute_normal( + &mut self, + p: *mut core::ffi::c_void, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_compute_normal( + sself: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + n: core::ffi::c_double, + ); + } + unsafe { vtk_polygon_compute_normal(self.0, p, n) } + } + fn compute_normal( + &mut self, + ids: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_compute_normal( + sself: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + n: core::ffi::c_double, + ); + } + unsafe { vtk_polygon_compute_normal(self.0, ids, pts, n) } + } + fn compute_normal( + &mut self, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_compute_normal( + sself: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_polygon_compute_normal(self.0, numPts, pts, n) } + } + fn is_convex(&mut self) -> bool { + unsafe extern "C" { + fn vtk_polygon_is_convex(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_polygon_is_convex(self.0) } + } + fn is_convex( + &mut self, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_polygon_is_convex( + sself: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_polygon_is_convex(self.0, p, numPts, pts) } + } + fn is_convex( + &mut self, + ids: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_polygon_is_convex( + sself: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_polygon_is_convex(self.0, ids, p) } + } + fn is_convex(&mut self, p: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_polygon_is_convex( + sself: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_polygon_is_convex(self.0, p) } + } + fn compute_centroid( + &mut self, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_polygon_compute_centroid( + sself: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_polygon_compute_centroid(self.0, p, numPts, pts, centroid) } + } + fn compute_centroid( + &mut self, + ids: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_polygon_compute_centroid( + sself: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_polygon_compute_centroid(self.0, ids, pts, centroid) } + } + fn compute_area( + &mut self, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + normal: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polygon_compute_area( + sself: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + normal: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_polygon_compute_area(self.0, p, numPts, pts, normal) } + } + fn parameterize_polygon( + &mut self, + p0: core::ffi::c_double, + p10: core::ffi::c_double, + l10: core::ffi::c_double, + p20: core::ffi::c_double, + l20: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_parameterize_polygon( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + p10: core::ffi::c_double, + l10: core::ffi::c_double, + p20: core::ffi::c_double, + l20: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_parameterize_polygon(self.0, p0, p10, l10, p20, l20, n) } + } + fn point_in_polygon( + &mut self, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_point_in_polygon( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_point_in_polygon(self.0, x, numPts, pts, bounds, n) } + } + fn triangulate(&mut self, outTris: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_triangulate( + sself: *mut core::ffi::c_void, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_triangulate(self.0, outTris) } + } + fn non_degenerate_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_non_degenerate_triangulate( + sself: *mut core::ffi::c_void, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_non_degenerate_triangulate(self.0, outTris) } + } + fn bounded_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + tol: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_bounded_triangulate( + sself: *mut core::ffi::c_void, + outTris: *mut core::ffi::c_void, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_bounded_triangulate(self.0, outTris, tol) } + } + fn distance_to_polygon( + &mut self, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + closest: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polygon_distance_to_polygon( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + closest: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_polygon_distance_to_polygon(self.0, x, numPts, pts, bounds, closest) + } + } + fn intersect_polygon_with_polygon( + &mut self, + npts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + npts2: core::ffi::c_int, + pts2: core::ffi::c_double, + bounds2: core::ffi::c_double, + tol: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_intersect_polygon_with_polygon( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + npts2: core::ffi::c_int, + pts2: core::ffi::c_double, + bounds2: core::ffi::c_double, + tol: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polygon_intersect_polygon_with_polygon( + self.0, + npts, + pts, + bounds, + npts2, + pts2, + bounds2, + tol, + x, + ) + } + } + fn intersect_convex_2_d_cells( + &mut self, + cell1: *mut core::ffi::c_void, + cell2: *mut core::ffi::c_void, + tol: core::ffi::c_double, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_intersect_convex_2_d_cells( + sself: *mut core::ffi::c_void, + cell1: *mut core::ffi::c_void, + cell2: *mut core::ffi::c_void, + tol: core::ffi::c_double, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polygon_intersect_convex_2_d_cells(self.0, cell1, cell2, tol, p0, p1) + } + } + fn get_use_mvc_interpolation(&mut self) -> bool { + unsafe extern "C" { + fn vtk_polygon_get_use_mvc_interpolation( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_polygon_get_use_mvc_interpolation(self.0) } + } + fn set_use_mvc_interpolation(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_polygon_set_use_mvc_interpolation( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_polygon_set_use_mvc_interpolation(self.0, _arg) } + } + fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_polygon_set_tolerance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_polygon_set_tolerance(self.0, _arg) } + } + fn get_tolerance_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polygon_get_tolerance_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_polygon_get_tolerance_min_value(self.0) } + } + fn get_tolerance_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polygon_get_tolerance_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_polygon_get_tolerance_max_value(self.0) } + } + fn get_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polygon_get_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_polygon_get_tolerance(self.0) } + } + fn ear_cut_triangulation(&mut self, measure: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_ear_cut_triangulation( + sself: *mut core::ffi::c_void, + measure: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_ear_cut_triangulation(self.0, measure) } + } + fn ear_cut_triangulation( + &mut self, + outTris: *mut core::ffi::c_void, + measure: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_ear_cut_triangulation( + sself: *mut core::ffi::c_void, + outTris: *mut core::ffi::c_void, + measure: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_ear_cut_triangulation(self.0, outTris, measure) } + } + fn unbiased_ear_cut_triangulation( + &mut self, + seed: core::ffi::c_int, + measure: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_unbiased_ear_cut_triangulation( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_int, + measure: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_unbiased_ear_cut_triangulation(self.0, seed, measure) } + } + fn unbiased_ear_cut_triangulation( + &mut self, + seed: core::ffi::c_int, + outTris: *mut core::ffi::c_void, + measure: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_unbiased_ear_cut_triangulation( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_int, + outTris: *mut core::ffi::c_void, + measure: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polygon_unbiased_ear_cut_triangulation(self.0, seed, outTris, measure) + } + } +} +impl VtkPolyhedron for vtkPolyhedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_new_instance(self.0) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_polyhedron_get_edge_points(self.0, edgeId, pts) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_polyhedron_get_edge_points(self.0, edgeId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_polyhedron_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_polyhedron_get_face_points(self.0, faceId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_polyhedron_get_face_points(self.0, faceId, pts) } + } + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_get_edge_to_adjacent_faces( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_polyhedron_get_edge_to_adjacent_faces(self.0, edgeId, pts) } + } + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_polyhedron_get_face_to_adjacent_faces( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_polyhedron_get_face_to_adjacent_faces(self.0, faceId, faceIds) } + } + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_polyhedron_get_point_to_incident_edges( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_polyhedron_get_point_to_incident_edges(self.0, pointId, edgeIds) } + } + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_polyhedron_get_point_to_incident_faces( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_polyhedron_get_point_to_incident_faces(self.0, pointId, faceIds) } + } + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_polyhedron_get_point_to_one_ring_points( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_polyhedron_get_point_to_one_ring_points(self.0, pointId, pts) } + } + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_polyhedron_get_centroid( + sself: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_polyhedron_get_centroid(self.0, centroid) } + } + fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_polyhedron_get_parametric_coords( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_polyhedron_get_parametric_coords(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_get_cell_type(self.0) } + } + fn requires_initialization(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_requires_initialization( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_requires_initialization(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_get_number_of_edges(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_get_edge(self.0, p0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_get_number_of_faces(self.0) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_polyhedron_contour( + self.0, + value, + scalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_polyhedron_clip( + self.0, + value, + scalars, + locator, + connectivity, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polyhedron_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_polyhedron_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polyhedron_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_polyhedron_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_cell_boundary(self.0, subId, pcoords, pts) } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_get_parametric_center(self.0, pcoords) } + } + fn is_primary_cell(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_is_primary_cell( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_is_primary_cell(self.0) } + } + fn interpolate_functions( + &mut self, + x: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_interpolate_functions( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + sf: core::ffi::c_double, + ); + } + unsafe { vtk_polyhedron_interpolate_functions(self.0, x, sf) } + } + fn interpolate_derivs( + &mut self, + x: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_interpolate_derivs( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_polyhedron_interpolate_derivs(self.0, x, derivs) } + } + fn requires_explicit_face_representation(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_requires_explicit_face_representation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_requires_explicit_face_representation(self.0) } + } + fn is_inside( + &mut self, + x: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_is_inside( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_is_inside(self.0, x, tolerance) } + } + fn is_convex(&mut self) -> bool { + unsafe extern "C" { + fn vtk_polyhedron_is_convex(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_polyhedron_is_convex(self.0) } + } + fn get_poly_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_get_poly_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_get_poly_data(self.0) } + } +} +impl VtkPyramid for vtkPyramid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pyramid_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_pyramid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pyramid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pyramid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pyramid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pyramid_new_instance(self.0) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_pyramid_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_pyramid_get_edge_points(self.0, edgeId, pts) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_pyramid_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_pyramid_get_edge_points(self.0, edgeId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_face_points(self.0, faceId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_pyramid_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_pyramid_get_face_points(self.0, faceId, pts) } + } + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_pyramid_get_edge_to_adjacent_faces( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_pyramid_get_edge_to_adjacent_faces(self.0, edgeId, pts) } + } + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_face_to_adjacent_faces( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_face_to_adjacent_faces(self.0, faceId, faceIds) } + } + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_point_to_incident_edges( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_point_to_incident_edges(self.0, pointId, edgeIds) } + } + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_point_to_incident_faces( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_point_to_incident_faces(self.0, pointId, faceIds) } + } + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_point_to_one_ring_points( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_point_to_one_ring_points(self.0, pointId, pts) } + } + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_pyramid_get_centroid( + sself: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_pyramid_get_centroid(self.0, centroid) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pyramid_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pyramid_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pyramid_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pyramid_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_cell_boundary(self.0, subId, pcoords, pts) } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_pyramid_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pyramid_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_pyramid_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_pyramid_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pyramid_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_pyramid_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_get_triangle_cases( + sself: *mut core::ffi::c_void, + caseId: core::ffi::c_int, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_pyramid_get_triangle_cases(self.0, caseId) } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_get_parametric_center(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pyramid_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_pyramid_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pyramid_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_pyramid_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pyramid_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_pyramid_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_pyramid_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_pyramid_interpolate_derivs(self.0, pcoords, derivs) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_jacobian_inverse(self.0, pcoords, inverse, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_face_array(self.0, faceId) } + } + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_edge_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_edge_to_adjacent_faces_array(self.0, edgeId) } + } + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_face_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_face_to_adjacent_faces_array(self.0, faceId) } + } + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_point_to_incident_edges_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_point_to_incident_edges_array(self.0, pointId) } + } + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_point_to_incident_faces_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_point_to_incident_faces_array(self.0, pointId) } + } + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_pyramid_get_point_to_one_ring_points_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_pyramid_get_point_to_one_ring_points_array(self.0, pointId) } + } + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_pyramid_compute_centroid( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_pyramid_compute_centroid(self.0, points, pointIds, centroid) } + } +} +impl VtkQuad for vtkQuad { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quad_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_quad_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quad_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quad_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quad_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quad_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_get_cell_type(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_quad_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quad_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quad_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quad_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quad_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quad_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quad_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quad_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quad_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quad_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quad_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quad_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quad_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quad_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quad_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quad_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quad_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quad_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_quad_get_parametric_center(self.0, pcoords) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quad_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quad_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quad_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ); + } + unsafe { vtk_quad_interpolation_functions(self.0, pcoords, sf) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quad_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quad_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quad_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ); + } + unsafe { vtk_quad_interpolate_functions(self.0, pcoords, sf) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quad_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quad_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quad_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quad_get_edge_array(self.0, edgeId) } + } +} +impl VtkQuadraticEdge for vtkQuadraticEdge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_edge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_edge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_edge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_edge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_edge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_edge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_edge_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_edge_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_edge_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_edge_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_edge_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_edge_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_edge_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_edge_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_edge_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_edge_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_edge_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_edge_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_edge_clip( + self.0, + value, + cellScalars, + locator, + lines, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_edge_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_get_parametric_center(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_edge_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_edge_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_edge_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_edge_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_edge_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_edge_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_edge_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_edge_interpolate_derivs(self.0, pcoords, derivs) } + } +} +impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_hexahedron_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_hexahedron_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_hexahedron_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_hexahedron_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_hexahedron_evaluate_location( + self.0, + subId, + pcoords, + x, + weights, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_hexahedron_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_hexahedron_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_hexahedron_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_hexahedron_interpolation_functions(self.0, pcoords, weights) + } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_hexahedron_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_hexahedron_interpolate_functions(self.0, pcoords, weights) + } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_hexahedron_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quadratic_hexahedron_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quadratic_hexahedron_get_face_array(self.0, faceId) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_hexahedron_jacobian_inverse(self.0, pcoords, inverse, derivs) + } + } +} +impl VtkQuadraticLinearQuad for vtkQuadraticLinearQuad { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_quad_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_quad_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_quad_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_quad_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_quad_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_linear_quad_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_linear_quad_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_quad_evaluate_location( + self.0, + subId, + pcoords, + x, + weights, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_quad_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_linear_quad_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_linear_quad_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_get_parametric_center(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_quad_interpolation_functions(self.0, pcoords, weights) + } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_quad_interpolation_derivs(self.0, pcoords, derivs) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_quad_interpolate_functions(self.0, pcoords, weights) + } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_linear_quad_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array(&mut self, edgeId: core::ffi::c_uchar) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_get_edge_array(self.0, edgeId) } + } +} +impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_wedge_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_linear_wedge_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_linear_wedge_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_wedge_evaluate_location( + self.0, + subId, + pcoords, + x, + weights, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_wedge_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_linear_wedge_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_linear_wedge_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_get_parametric_center(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_wedge_interpolation_functions(self.0, pcoords, weights) + } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_wedge_interpolation_derivs(self.0, pcoords, derivs) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_wedge_interpolate_functions(self.0, pcoords, weights) + } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_linear_wedge_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quadratic_linear_wedge_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quadratic_linear_wedge_get_face_array(self.0, faceId) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_linear_wedge_jacobian_inverse(self.0, pcoords, inverse, derivs) + } + } +} +impl VtkQuadraticPolygon for vtkQuadraticPolygon { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_polygon_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_polygon_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_polygon_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_polygon_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_polygon_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_polygon_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_polygon_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_polygon_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_polygon_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_polygon_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_polygon_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_polygon_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_polygon_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_polygon_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_polygon_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_polygon_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn interpolate_functions( + &mut self, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_polygon_interpolate_functions( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_polygon_interpolate_functions(self.0, x, weights) } + } + fn compute_centroid( + &mut self, + ids: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_polygon_compute_centroid( + sself: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_polygon_compute_centroid(self.0, ids, pts, centroid) } + } + fn parameterize_polygon( + &mut self, + p0: core::ffi::c_double, + p10: core::ffi::c_double, + l10: core::ffi::c_double, + p20: core::ffi::c_double, + l20: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_parameterize_polygon( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + p10: core::ffi::c_double, + l10: core::ffi::c_double, + p20: core::ffi::c_double, + l20: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_polygon_parameterize_polygon(self.0, p0, p10, l10, p20, l20, n) + } + } + fn point_in_polygon( + &mut self, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_point_in_polygon( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + n: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_polygon_point_in_polygon(self.0, x, numPts, pts, bounds, n) + } + } + fn triangulate(&mut self, outTris: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_triangulate( + sself: *mut core::ffi::c_void, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_triangulate(self.0, outTris) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_triangulate(self.0, index, ptIds, pts) } + } + fn non_degenerate_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_non_degenerate_triangulate( + sself: *mut core::ffi::c_void, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_non_degenerate_triangulate(self.0, outTris) } + } + fn distance_to_polygon( + &mut self, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + closest: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_quadratic_polygon_distance_to_polygon( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + numPts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + closest: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_quadratic_polygon_distance_to_polygon( + self.0, + x, + numPts, + pts, + bounds, + closest, + ) + } + } + fn intersect_polygon_with_polygon( + &mut self, + npts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + npts2: core::ffi::c_int, + pts2: core::ffi::c_double, + bounds2: core::ffi::c_double, + tol: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_intersect_polygon_with_polygon( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_int, + pts: core::ffi::c_double, + bounds: core::ffi::c_double, + npts2: core::ffi::c_int, + pts2: core::ffi::c_double, + bounds2: core::ffi::c_double, + tol: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_polygon_intersect_polygon_with_polygon( + self.0, + npts, + pts, + bounds, + npts2, + pts2, + bounds2, + tol, + x, + ) + } + } + fn intersect_convex_2_d_cells( + &mut self, + cell1: *mut core::ffi::c_void, + cell2: *mut core::ffi::c_void, + tol: core::ffi::c_double, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_intersect_convex_2_d_cells( + sself: *mut core::ffi::c_void, + cell1: *mut core::ffi::c_void, + cell2: *mut core::ffi::c_void, + tol: core::ffi::c_double, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_polygon_intersect_convex_2_d_cells( + self.0, + cell1, + cell2, + tol, + p0, + p1, + ) + } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_polygon_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_polygon_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn get_use_mvc_interpolation(&mut self) -> bool { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_use_mvc_interpolation( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_quadratic_polygon_get_use_mvc_interpolation(self.0) } + } + fn set_use_mvc_interpolation(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_quadratic_polygon_set_use_mvc_interpolation( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_quadratic_polygon_set_use_mvc_interpolation(self.0, _arg) } + } +} +impl VtkQuadraticPyramid for vtkQuadraticPyramid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_pyramid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_pyramid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_pyramid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_pyramid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_pyramid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_pyramid_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_pyramid_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_pyramid_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_pyramid_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_pyramid_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_pyramid_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_pyramid_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_pyramid_clip( + self.0, + value, + cellScalars, + locator, + tets, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_pyramid_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_get_parametric_center(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_pyramid_interpolation_functions(self.0, pcoords, weights) + } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_pyramid_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_pyramid_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_pyramid_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quadratic_pyramid_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quadratic_pyramid_get_face_array(self.0, faceId) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_pyramid_jacobian_inverse(self.0, pcoords, inverse, derivs) + } + } +} +impl VtkQuadraticQuad for vtkQuadraticQuad { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_quad_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_quad_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_quad_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_quad_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_quad_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_quad_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_quad_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_quad_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_quad_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_quad_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_quad_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_quad_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_quad_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_quad_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_quad_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_quad_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_quad_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_quad_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_quad_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_quad_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_get_parametric_center(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_quad_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_quad_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_quad_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_quad_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_quad_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_quad_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_quad_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_quad_interpolate_derivs(self.0, pcoords, derivs) } + } +} +impl VtkQuadraticTetra for vtkQuadraticTetra { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_tetra_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_tetra_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_tetra_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_tetra_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_tetra_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_tetra_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_tetra_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_tetra_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_tetra_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_tetra_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_tetra_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_tetra_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_tetra_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_tetra_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_get_parametric_center(self.0, pcoords) } + } + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_parametric_distance( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_quadratic_tetra_get_parametric_distance(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_tetra_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_tetra_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_tetra_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_tetra_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quadratic_tetra_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quadratic_tetra_get_face_array(self.0, faceId) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_tetra_jacobian_inverse(self.0, pcoords, inverse, derivs) } + } +} +impl VtkQuadraticTriangle for vtkQuadraticTriangle { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_triangle_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_triangle_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_triangle_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_triangle_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_triangle_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_triangle_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_triangle_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_triangle_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_triangle_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_triangle_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_triangle_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_triangle_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_triangle_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_triangle_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_triangle_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_triangle_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_triangle_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_triangle_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_get_parametric_center(self.0, pcoords) } + } + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_parametric_distance( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_quadratic_triangle_get_parametric_distance(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_triangle_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_triangle_interpolation_functions(self.0, pcoords, weights) + } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_triangle_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_triangle_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_triangle_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_triangle_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_triangle_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_triangle_interpolate_derivs(self.0, pcoords, derivs) } + } +} +impl VtkQuadraticWedge for vtkQuadraticWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_wedge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_wedge_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_wedge_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_wedge_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_wedge_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_quadratic_wedge_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_wedge_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadratic_wedge_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_get_parametric_center(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_wedge_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_wedge_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_wedge_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_wedge_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quadratic_wedge_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_quadratic_wedge_get_face_array(self.0, faceId) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_quadratic_wedge_jacobian_inverse(self.0, pcoords, inverse, derivs) } + } +} +impl VtkQuadratureSchemeDefinition for vtkQuadratureSchemeDefinition { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadrature_scheme_definition_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadrature_scheme_definition_new_instance(self.0) } + } + fn dictionary(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_dictionary( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadrature_scheme_definition_dictionary(self.0) } + } + fn quadrature_offset_array_name(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_quadrature_offset_array_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadrature_scheme_definition_quadrature_offset_array_name(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadrature_scheme_definition_new(self.0) } + } + fn deep_copy(&mut self, other: vtkQuadratureSchemeDefinition) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_deep_copy( + sself: *mut core::ffi::c_void, + other: vtkQuadratureSchemeDefinition, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_deep_copy(self.0, other) } + } + fn save_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_save_state( + sself: *mut core::ffi::c_void, + root: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_save_state(self.0, root) } + } + fn restore_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_restore_state( + sself: *mut core::ffi::c_void, + root: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_restore_state(self.0, root) } + } + fn clear(&mut self) -> () { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_clear(sself: *mut core::ffi::c_void); + } + unsafe { vtk_quadrature_scheme_definition_clear(self.0) } + } + fn initialize( + &mut self, + cellType: core::ffi::c_int, + numberOfNodes: core::ffi::c_int, + numberOfQuadraturePoints: core::ffi::c_int, + shapeFunctionWeights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_initialize( + sself: *mut core::ffi::c_void, + cellType: core::ffi::c_int, + numberOfNodes: core::ffi::c_int, + numberOfQuadraturePoints: core::ffi::c_int, + shapeFunctionWeights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadrature_scheme_definition_initialize( + self.0, + cellType, + numberOfNodes, + numberOfQuadraturePoints, + shapeFunctionWeights, + ) + } + } + fn initialize( + &mut self, + cellType: core::ffi::c_int, + numberOfNodes: core::ffi::c_int, + numberOfQuadraturePoints: core::ffi::c_int, + shapeFunctionWeights: core::ffi::c_double, + quadratureWeights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_initialize( + sself: *mut core::ffi::c_void, + cellType: core::ffi::c_int, + numberOfNodes: core::ffi::c_int, + numberOfQuadraturePoints: core::ffi::c_int, + shapeFunctionWeights: core::ffi::c_double, + quadratureWeights: core::ffi::c_double, + ); + } + unsafe { + vtk_quadrature_scheme_definition_initialize( + self.0, + cellType, + numberOfNodes, + numberOfQuadraturePoints, + shapeFunctionWeights, + quadratureWeights, + ) + } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_get_cell_type(self.0) } + } + fn get_quadrature_key(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_quadrature_key( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_get_quadrature_key(self.0) } + } + fn get_number_of_nodes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_number_of_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_get_number_of_nodes(self.0) } + } + fn get_number_of_quadrature_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_number_of_quadrature_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadrature_scheme_definition_get_number_of_quadrature_points(self.0) + } + } + fn get_shape_function_weights(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_shape_function_weights( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_quadrature_scheme_definition_get_shape_function_weights(self.0) } + } + fn get_shape_function_weights( + &mut self, + quadraturePointId: core::ffi::c_int, + ) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_shape_function_weights( + sself: *mut core::ffi::c_void, + quadraturePointId: core::ffi::c_int, + ) -> *const core::ffi::c_double; + } + unsafe { + vtk_quadrature_scheme_definition_get_shape_function_weights( + self.0, + quadraturePointId, + ) + } + } + fn get_quadrature_weights(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_quadrature_weights( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_quadrature_scheme_definition_get_quadrature_weights(self.0) } + } +} +impl VtkQuadric for vtkQuadric { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadric_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadric_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadric_new(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_quadric_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_quadric_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadric_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + g: core::ffi::c_double, + ); + } + unsafe { vtk_quadric_evaluate_gradient(self.0, x, g) } + } + fn set_coefficients(&mut self, a: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_quadric_set_coefficients( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + ); + } + unsafe { vtk_quadric_set_coefficients(self.0, a) } + } + fn set_coefficients( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + a4: core::ffi::c_double, + a5: core::ffi::c_double, + a6: core::ffi::c_double, + a7: core::ffi::c_double, + a8: core::ffi::c_double, + a9: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadric_set_coefficients( + sself: *mut core::ffi::c_void, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + a4: core::ffi::c_double, + a5: core::ffi::c_double, + a6: core::ffi::c_double, + a7: core::ffi::c_double, + a8: core::ffi::c_double, + a9: core::ffi::c_double, + ); + } + unsafe { + vtk_quadric_set_coefficients(self.0, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) + } + } + fn get_coefficients(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_quadric_get_coefficients( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_quadric_get_coefficients(self.0) } + } + fn get_coefficients(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_quadric_get_coefficients( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_quadric_get_coefficients(self.0, data) } + } +} +impl VtkRectilinearGrid for vtkRectilinearGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_data_object_type(self.0) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_copy_structure(self.0, ds) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_rectilinear_grid_initialize(self.0) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_rectilinear_grid_get_number_of_cells(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_rectilinear_grid_get_number_of_points(self.0) } + } + fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_rectilinear_grid_get_point(self.0, ptId) } + } + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_cell(self.0, cellId) } + } + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_get_cell(self.0, cellId, cell) } + } + fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_find_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_rectilinear_grid_find_point(self.0, x) } + } + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_find_cell( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_rectilinear_grid_find_cell( + self.0, + x, + cell, + cellId, + tol2, + subId, + pcoords, + weights, + ) + } + } + fn find_cell( + &mut self, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_find_cell( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + tol2: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_rectilinear_grid_find_cell( + self.0, + x, + cell, + gencell, + cellId, + tol2, + subId, + pcoords, + weights, + ) + } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_cell_type(self.0, cellId) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_get_point_cells(self.0, ptId, cellIds) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_max_cell_size(self.0) } + } + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + seedLoc: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_cell_neighbors( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + seedLoc: core::ffi::c_int, + ); + } + unsafe { + vtk_rectilinear_grid_get_cell_neighbors( + self.0, + cellId, + ptIds, + cellIds, + seedLoc, + ) + } + } + fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_is_point_visible( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_rectilinear_grid_is_point_visible(self.0, ptId) } + } + fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_is_cell_visible( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_rectilinear_grid_is_cell_visible(self.0, cellId) } + } + fn has_any_blank_points(&mut self) -> bool { + unsafe extern "C" { + fn vtk_rectilinear_grid_has_any_blank_points( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_rectilinear_grid_has_any_blank_points(self.0) } + } + fn has_any_blank_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_rectilinear_grid_has_any_blank_cells( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_rectilinear_grid_has_any_blank_cells(self.0) } + } + fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_cell_dims( + sself: *mut core::ffi::c_void, + cellDims: core::ffi::c_int, + ); + } + unsafe { vtk_rectilinear_grid_get_cell_dims(self.0, cellDims) } + } + fn get_points(&mut self, pnts: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_points( + sself: *mut core::ffi::c_void, + pnts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_get_points(self.0, pnts) } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_rectilinear_grid_set_dimensions(self.0, i, j, k) } + } + fn set_dimensions(&mut self, dim: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_dimensions( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ); + } + unsafe { vtk_rectilinear_grid_set_dimensions(self.0, dim) } + } + fn get_dimensions(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_dimensions( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_dimensions(self.0) } + } + fn get_dimensions(&mut self, data: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_dimensions( + sself: *mut core::ffi::c_void, + data: core::ffi::c_int, + ); + } + unsafe { vtk_rectilinear_grid_get_dimensions(self.0, data) } + } + fn get_data_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_data_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_data_dimension(self.0) } + } + fn compute_structured_coordinates( + &mut self, + x: core::ffi::c_double, + ijk: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_compute_structured_coordinates( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ijk: core::ffi::c_int, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_rectilinear_grid_compute_structured_coordinates(self.0, x, ijk, pcoords) + } + } + fn compute_point_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_compute_point_id( + sself: *mut core::ffi::c_void, + ijk: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_rectilinear_grid_compute_point_id(self.0, ijk) } + } + fn compute_cell_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_compute_cell_id( + sself: *mut core::ffi::c_void, + ijk: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_rectilinear_grid_compute_cell_id(self.0, ijk) } + } + fn get_point( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + p: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_point( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + p: core::ffi::c_double, + ); + } + unsafe { vtk_rectilinear_grid_get_point(self.0, i, j, k, p) } + } + fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_x_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_set_x_coordinates(self.0, p0) } + } + fn get_x_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_x_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_x_coordinates(self.0) } + } + fn set_y_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_y_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_set_y_coordinates(self.0, p0) } + } + fn get_y_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_y_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_y_coordinates(self.0) } + } + fn set_z_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_z_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_set_z_coordinates(self.0, p0) } + } + fn get_z_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_z_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_z_coordinates(self.0) } + } + fn set_extent(&mut self, extent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_extent( + sself: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_rectilinear_grid_set_extent(self.0, extent) } + } + fn set_extent( + &mut self, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_extent( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ); + } + unsafe { + vtk_rectilinear_grid_set_extent(self.0, xMin, xMax, yMin, yMax, zMin, zMax) + } + } + fn get_extent(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_extent(self.0) } + } + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_rectilinear_grid_get_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_rectilinear_grid_get_extent(self.0, _arg) } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_extent_type(self.0) } + } + fn crop(&mut self, updateExtent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_crop( + sself: *mut core::ffi::c_void, + updateExtent: core::ffi::c_int, + ); + } + unsafe { vtk_rectilinear_grid_crop(self.0, updateExtent) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_data(self.0, v, i) } + } + fn set_scalar_type( + &mut self, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_scalar_type( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_set_scalar_type(self.0, p0, meta_data) } + } + fn get_scalar_type( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_scalar_type( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_scalar_type(self.0, meta_data) } + } + fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_rectilinear_grid_has_scalar_type( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_rectilinear_grid_has_scalar_type(self.0, meta_data) } + } + fn get_scalar_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_scalar_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_scalar_type(self.0) } + } + fn get_scalar_type_as_string(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_scalar_type_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_rectilinear_grid_get_scalar_type_as_string(self.0) } + } + fn set_number_of_scalar_components( + &mut self, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_number_of_scalar_components( + sself: *mut core::ffi::c_void, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_rectilinear_grid_set_number_of_scalar_components(self.0, n, meta_data) + } + } + fn get_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_number_of_scalar_components( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_rectilinear_grid_get_number_of_scalar_components(self.0, meta_data) + } + } + fn has_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_rectilinear_grid_has_number_of_scalar_components( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_rectilinear_grid_has_number_of_scalar_components(self.0, meta_data) + } + } + fn get_number_of_scalar_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_number_of_scalar_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_number_of_scalar_components(self.0) } + } +} +impl VtkReebGraph for vtkReebGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_new_instance(self.0) } + } + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_build( + sself: *mut core::ffi::c_void, + mesh: *mut core::ffi::c_void, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_reeb_graph_build(self.0, mesh, scalarField) } + } + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_build( + sself: *mut core::ffi::c_void, + mesh: *mut core::ffi::c_void, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_reeb_graph_build(self.0, mesh, scalarField) } + } + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarFieldId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_build( + sself: *mut core::ffi::c_void, + mesh: *mut core::ffi::c_void, + scalarFieldId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_reeb_graph_build(self.0, mesh, scalarFieldId) } + } + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarFieldId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_build( + sself: *mut core::ffi::c_void, + mesh: *mut core::ffi::c_void, + scalarFieldId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_reeb_graph_build(self.0, mesh, scalarFieldId) } + } + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarFieldName: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_build( + sself: *mut core::ffi::c_void, + mesh: *mut core::ffi::c_void, + scalarFieldName: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_reeb_graph_build(self.0, mesh, scalarFieldName) } + } + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarFieldName: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_build( + sself: *mut core::ffi::c_void, + mesh: *mut core::ffi::c_void, + scalarFieldName: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_reeb_graph_build(self.0, mesh, scalarFieldName) } + } + fn stream_triangle( + &mut self, + vertex0Id: core::ffi::c_uchar, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_uchar, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_uchar, + scalar2: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_stream_triangle( + sself: *mut core::ffi::c_void, + vertex0Id: core::ffi::c_uchar, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_uchar, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_uchar, + scalar2: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_reeb_graph_stream_triangle( + self.0, + vertex0Id, + scalar0, + vertex1Id, + scalar1, + vertex2Id, + scalar2, + ) + } + } + fn stream_tetrahedron( + &mut self, + vertex0Id: core::ffi::c_uchar, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_uchar, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_uchar, + scalar2: core::ffi::c_double, + vertex3Id: core::ffi::c_uchar, + scalar3: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_stream_tetrahedron( + sself: *mut core::ffi::c_void, + vertex0Id: core::ffi::c_uchar, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_uchar, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_uchar, + scalar2: core::ffi::c_double, + vertex3Id: core::ffi::c_uchar, + scalar3: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_reeb_graph_stream_tetrahedron( + self.0, + vertex0Id, + scalar0, + vertex1Id, + scalar1, + vertex2Id, + scalar2, + vertex3Id, + scalar3, + ) + } + } + fn close_stream(&mut self) -> () { + unsafe extern "C" { + fn vtk_reeb_graph_close_stream(sself: *mut core::ffi::c_void); + } + unsafe { vtk_reeb_graph_close_stream(self.0) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_reeb_graph_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_reeb_graph_deep_copy(self.0, src) } + } + fn simplify( + &mut self, + simplificationThreshold: core::ffi::c_double, + simplificationMetric: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_simplify( + sself: *mut core::ffi::c_void, + simplificationThreshold: core::ffi::c_double, + simplificationMetric: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_reeb_graph_simplify( + self.0, + simplificationThreshold, + simplificationMetric, + ) + } + } + fn set(&mut self, g: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_reeb_graph_set( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ); + } + unsafe { vtk_reeb_graph_set(self.0, g) } + } +} +impl VtkReebGraphSimplificationMetric for vtkReebGraphSimplificationMetric { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_simplification_metric_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_simplification_metric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_simplification_metric_new_instance(self.0) } + } + fn set_lower_bound(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_set_lower_bound( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_reeb_graph_simplification_metric_set_lower_bound(self.0, _arg) } + } + fn get_lower_bound(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_get_lower_bound( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_reeb_graph_simplification_metric_get_lower_bound(self.0) } + } + fn set_upper_bound(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_set_upper_bound( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_reeb_graph_simplification_metric_set_upper_bound(self.0, _arg) } + } + fn get_upper_bound(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_get_upper_bound( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_reeb_graph_simplification_metric_get_upper_bound(self.0) } + } + fn compute_metric( + &mut self, + mesh: *mut core::ffi::c_void, + field: *mut core::ffi::c_void, + startCriticalPoint: core::ffi::c_uchar, + vertexList: *mut core::ffi::c_void, + endCriticalPoint: core::ffi::c_uchar, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_compute_metric( + sself: *mut core::ffi::c_void, + mesh: *mut core::ffi::c_void, + field: *mut core::ffi::c_void, + startCriticalPoint: core::ffi::c_uchar, + vertexList: *mut core::ffi::c_void, + endCriticalPoint: core::ffi::c_uchar, + ) -> core::ffi::c_double; + } + unsafe { + vtk_reeb_graph_simplification_metric_compute_metric( + self.0, + mesh, + field, + startCriticalPoint, + vertexList, + endCriticalPoint, + ) + } + } +} +impl VtkSelection for vtkSelection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_new(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_get_data_object_type(self.0) } + } + fn get_number_of_nodes(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_selection_get_number_of_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_selection_get_number_of_nodes(self.0) } + } + fn get_node(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_get_node( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_get_node(self.0, idx) } + } + fn get_node(&mut self, name: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_get_node( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_get_node(self.0, c_name.as_ptr()) } + } + fn add_node(&mut self, p0: *mut core::ffi::c_void) -> &str { + unsafe extern "C" { + fn vtk_selection_add_node( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_selection_add_node(self.0, p0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn set_node(&mut self, name: &str, p1: *mut core::ffi::c_void) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_set_node( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_set_node(self.0, c_name.as_ptr(), p1) } + } + fn get_node_name_at_index(&mut self, idx: core::ffi::c_uint) -> &str { + unsafe extern "C" { + fn vtk_selection_get_node_name_at_index( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_selection_get_node_name_at_index(self.0, idx) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn remove_node(&mut self, idx: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_selection_remove_node( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ); + } + unsafe { vtk_selection_remove_node(self.0, idx) } + } + fn remove_node(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_remove_node( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_remove_node(self.0, c_name.as_ptr()) } + } + fn remove_node(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_remove_node( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_remove_node(self.0, p0) } + } + fn remove_all_nodes(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_remove_all_nodes(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_remove_all_nodes(self.0) } + } + fn set_expression(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_set_expression( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_set_expression(self.0, c__arg.as_ptr()) } + } + fn get_expression(&mut self) -> &str { + unsafe extern "C" { + fn vtk_selection_get_expression( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_selection_get_expression(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_deep_copy(self.0, src) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_shallow_copy(self.0, src) } + } + fn union(&mut self, selection: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_union( + sself: *mut core::ffi::c_void, + selection: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_union(self.0, selection) } + } + fn union(&mut self, node: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_union( + sself: *mut core::ffi::c_void, + node: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_union(self.0, node) } + } + fn subtract(&mut self, selection: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_subtract( + sself: *mut core::ffi::c_void, + selection: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_subtract(self.0, selection) } + } + fn subtract(&mut self, node: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_subtract( + sself: *mut core::ffi::c_void, + node: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_subtract(self.0, node) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_selection_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_selection_get_m_time(self.0) } + } + fn dump(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_dump(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_dump(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_get_data(self.0, v, i) } + } +} +impl VtkSelectionNode for vtkSelectionNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_new(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_node_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_node_initialize(self.0) } + } + fn set_selection_list(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_set_selection_list( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_set_selection_list(self.0, p0) } + } + fn get_selection_list(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_get_selection_list( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_get_selection_list(self.0) } + } + fn set_selection_data(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_set_selection_data( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_set_selection_data(self.0, data) } + } + fn get_selection_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_get_selection_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_get_selection_data(self.0) } + } + fn get_properties(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_get_properties( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_get_properties(self.0) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_deep_copy(self.0, src) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_shallow_copy(self.0, src) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_selection_node_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_selection_node_get_m_time(self.0) } + } + fn content_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_content_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_content_type(self.0) } + } + fn set_content_type(&mut self, type_: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_node_set_content_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ); + } + unsafe { vtk_selection_node_set_content_type(self.0, type_) } + } + fn get_content_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_node_get_content_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_node_get_content_type(self.0) } + } + fn get_content_type_as_string( + &mut self, + type_: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_selection_node_get_content_type_as_string( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_selection_node_get_content_type_as_string(self.0, type_) } + } + fn field_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_field_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_field_type(self.0) } + } + fn set_field_type(&mut self, type_: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_node_set_field_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ); + } + unsafe { vtk_selection_node_set_field_type(self.0, type_) } + } + fn get_field_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_node_get_field_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_node_get_field_type(self.0) } + } + fn get_field_type_as_string( + &mut self, + type_: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_selection_node_get_field_type_as_string( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_selection_node_get_field_type_as_string(self.0, type_) } + } + fn get_field_type_from_string( + &mut self, + type_: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_node_get_field_type_from_string( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_node_get_field_type_from_string(self.0, type_) } + } + fn convert_selection_field_to_attribute_type( + &mut self, + val: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_node_convert_selection_field_to_attribute_type( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_selection_node_convert_selection_field_to_attribute_type(self.0, val) + } + } + fn convert_attribute_type_to_selection_field( + &mut self, + val: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_node_convert_attribute_type_to_selection_field( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_selection_node_convert_attribute_type_to_selection_field(self.0, val) + } + } + fn set_query_string(&mut self, _arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_selection_node_set_query_string( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { vtk_selection_node_set_query_string(self.0, _arg) } + } + fn get_query_string(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_selection_node_get_query_string( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_selection_node_get_query_string(self.0) } + } + fn epsilon(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_epsilon( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_epsilon(self.0) } + } + fn zbuffer_value(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_zbuffer_value( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_zbuffer_value(self.0) } + } + fn containing_cells(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_containing_cells( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_containing_cells(self.0) } + } + fn connected_layers(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_connected_layers( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_connected_layers(self.0) } + } + fn component_number(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_component_number( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_component_number(self.0) } + } + fn inverse(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_inverse( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_inverse(self.0) } + } + fn pixel_count(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_pixel_count( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_pixel_count(self.0) } + } + fn source(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_source( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_source(self.0) } + } + fn source_id(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_source_id( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_source_id(self.0) } + } + fn prop(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_prop( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_prop(self.0) } + } + fn prop_id(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_prop_id( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_prop_id(self.0) } + } + fn process_id(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_process_id( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_process_id(self.0) } + } + fn assembly_name(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_assembly_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_assembly_name(self.0) } + } + fn selectors(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_selectors( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_selectors(self.0) } + } + fn composite_index(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_composite_index( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_composite_index(self.0) } + } + fn hierarchical_level(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_hierarchical_level( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_hierarchical_level(self.0) } + } + fn hierarchical_index(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_hierarchical_index( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_hierarchical_index(self.0) } + } + fn indexed_vertices(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_indexed_vertices( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_indexed_vertices(self.0) } + } + fn union_selection_list(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_union_selection_list( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_union_selection_list(self.0, other) } + } + fn subtract_selection_list(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_subtract_selection_list( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_subtract_selection_list(self.0, other) } + } + fn equal_properties( + &mut self, + other: *mut core::ffi::c_void, + fullcompare: bool, + ) -> bool { + unsafe extern "C" { + fn vtk_selection_node_equal_properties( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + fullcompare: bool, + ) -> bool; + } + unsafe { vtk_selection_node_equal_properties(self.0, other, fullcompare) } + } +} +impl VtkSimpleCellTessellator for vtkSimpleCellTessellator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_cell_tessellator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_cell_tessellator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_cell_tessellator_new_instance(self.0) } + } + fn get_generic_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_get_generic_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_cell_tessellator_get_generic_cell(self.0) } + } + fn tessellate_face( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_tessellate_face( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_simple_cell_tessellator_tessellate_face( + self.0, + cell, + att, + index, + points, + cellArray, + internalPd, + ) + } + } + fn tessellate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_tessellate( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_simple_cell_tessellator_tessellate( + self.0, + cell, + att, + points, + cellArray, + internalPd, + ) + } + } + fn triangulate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_triangulate( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_simple_cell_tessellator_triangulate( + self.0, + cell, + att, + points, + cellArray, + internalPd, + ) + } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_simple_cell_tessellator_reset(self.0) } + } + fn initialize(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_initialize( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_simple_cell_tessellator_initialize(self.0, ds) } + } + fn get_fixed_subdivisions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_get_fixed_subdivisions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_cell_tessellator_get_fixed_subdivisions(self.0) } + } + fn get_max_subdivision_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_get_max_subdivision_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_cell_tessellator_get_max_subdivision_level(self.0) } + } + fn get_max_adaptive_subdivisions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_get_max_adaptive_subdivisions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_cell_tessellator_get_max_adaptive_subdivisions(self.0) } + } + fn set_fixed_subdivisions(&mut self, level: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_set_fixed_subdivisions( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + ); + } + unsafe { vtk_simple_cell_tessellator_set_fixed_subdivisions(self.0, level) } + } + fn set_max_subdivision_level(&mut self, level: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_set_max_subdivision_level( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + ); + } + unsafe { vtk_simple_cell_tessellator_set_max_subdivision_level(self.0, level) } + } + fn set_subdivision_levels( + &mut self, + fixed: core::ffi::c_int, + maxLevel: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_set_subdivision_levels( + sself: *mut core::ffi::c_void, + fixed: core::ffi::c_int, + maxLevel: core::ffi::c_int, + ); + } + unsafe { + vtk_simple_cell_tessellator_set_subdivision_levels(self.0, fixed, maxLevel) + } + } +} +impl VtkSmoothErrorMetric for vtkSmoothErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smooth_error_metric_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smooth_error_metric_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smooth_error_metric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smooth_error_metric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smooth_error_metric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smooth_error_metric_new_instance(self.0) } + } + fn get_angle_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_smooth_error_metric_get_angle_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_smooth_error_metric_get_angle_tolerance(self.0) } + } + fn set_angle_tolerance(&mut self, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_smooth_error_metric_set_angle_tolerance( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { vtk_smooth_error_metric_set_angle_tolerance(self.0, value) } + } + fn requires_edge_subdivision( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_smooth_error_metric_requires_edge_subdivision( + sself: *mut core::ffi::c_void, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_smooth_error_metric_requires_edge_subdivision( + self.0, + leftPoint, + midPoint, + rightPoint, + alpha, + ) + } + } + fn get_error( + &mut self, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_smooth_error_metric_get_error( + sself: *mut core::ffi::c_void, + leftPoint: core::ffi::c_double, + midPoint: core::ffi::c_double, + rightPoint: core::ffi::c_double, + alpha: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_smooth_error_metric_get_error( + self.0, + leftPoint, + midPoint, + rightPoint, + alpha, + ) + } + } +} +impl VtkSortFieldData for vtkSortFieldData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_field_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_field_data_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_field_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_field_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_field_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_field_data_new_instance(self.0) } + } + fn sort( + &mut self, + fd: *mut core::ffi::c_void, + arrayName: core::ffi::c_char, + k: core::ffi::c_int, + returnIndices: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_sort_field_data_sort( + sself: *mut core::ffi::c_void, + fd: *mut core::ffi::c_void, + arrayName: core::ffi::c_char, + k: core::ffi::c_int, + returnIndices: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_sort_field_data_sort(self.0, fd, arrayName, k, returnIndices) } + } + fn sort( + &mut self, + fd: *mut core::ffi::c_void, + arrayName: core::ffi::c_char, + k: core::ffi::c_int, + returnIndices: core::ffi::c_int, + dir: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_sort_field_data_sort( + sself: *mut core::ffi::c_void, + fd: *mut core::ffi::c_void, + arrayName: core::ffi::c_char, + k: core::ffi::c_int, + returnIndices: core::ffi::c_int, + dir: core::ffi::c_int, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_sort_field_data_sort(self.0, fd, arrayName, k, returnIndices, dir) } + } +} +impl VtkSphere for vtkSphere { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_new(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_evaluate_gradient(self.0, x, n) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_center(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_set_center( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_set_center(self.0, _arg) } + } + fn get_center(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_get_center( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_sphere_get_center(self.0) } + } + fn get_center(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_get_center( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_get_center(self.0, data) } + } + fn evaluate( + &mut self, + center: core::ffi::c_double, + R: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_evaluate( + sself: *mut core::ffi::c_void, + center: core::ffi::c_double, + R: core::ffi::c_double, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_evaluate(self.0, center, R, x) } + } + fn compute_bounding_sphere( + &mut self, + pts: core::ffi::c_float, + numPts: core::ffi::c_uchar, + sphere: core::ffi::c_float, + hints: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_compute_bounding_sphere( + sself: *mut core::ffi::c_void, + pts: core::ffi::c_float, + numPts: core::ffi::c_uchar, + sphere: core::ffi::c_float, + hints: core::ffi::c_uchar, + ); + } + unsafe { vtk_sphere_compute_bounding_sphere(self.0, pts, numPts, sphere, hints) } + } + fn compute_bounding_sphere( + &mut self, + pts: core::ffi::c_double, + numPts: core::ffi::c_uchar, + sphere: core::ffi::c_double, + hints: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_compute_bounding_sphere( + sself: *mut core::ffi::c_void, + pts: core::ffi::c_double, + numPts: core::ffi::c_uchar, + sphere: core::ffi::c_double, + hints: core::ffi::c_uchar, + ); + } + unsafe { vtk_sphere_compute_bounding_sphere(self.0, pts, numPts, sphere, hints) } + } + fn compute_bounding_sphere( + &mut self, + spheres: core::ffi::c_float, + numSpheres: core::ffi::c_uchar, + sphere: core::ffi::c_float, + hints: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_compute_bounding_sphere( + sself: *mut core::ffi::c_void, + spheres: core::ffi::c_float, + numSpheres: core::ffi::c_uchar, + sphere: core::ffi::c_float, + hints: core::ffi::c_uchar, + ); + } + unsafe { + vtk_sphere_compute_bounding_sphere( + self.0, + spheres, + numSpheres, + sphere, + hints, + ) + } + } + fn compute_bounding_sphere( + &mut self, + spheres: core::ffi::c_double, + numSpheres: core::ffi::c_uchar, + sphere: core::ffi::c_double, + hints: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_compute_bounding_sphere( + sself: *mut core::ffi::c_void, + spheres: core::ffi::c_double, + numSpheres: core::ffi::c_uchar, + sphere: core::ffi::c_double, + hints: core::ffi::c_uchar, + ); + } + unsafe { + vtk_sphere_compute_bounding_sphere( + self.0, + spheres, + numSpheres, + sphere, + hints, + ) + } + } +} +impl VtkSpheres for vtkSpheres { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_new_instance(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_spheres_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_spheres_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_spheres_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_spheres_evaluate_gradient(self.0, x, n) } + } + fn set_centers(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_spheres_set_centers( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_spheres_set_centers(self.0, p0) } + } + fn get_centers(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_get_centers( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_get_centers(self.0) } + } + fn set_radii(&mut self, radii: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_spheres_set_radii( + sself: *mut core::ffi::c_void, + radii: *mut core::ffi::c_void, + ); + } + unsafe { vtk_spheres_set_radii(self.0, radii) } + } + fn get_radii(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_get_radii( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_get_radii(self.0) } + } + fn get_number_of_spheres(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_spheres_get_number_of_spheres( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_spheres_get_number_of_spheres(self.0) } + } + fn get_sphere(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_get_sphere( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_get_sphere(self.0, i) } + } + fn get_sphere(&mut self, i: core::ffi::c_int, sphere: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_spheres_get_sphere( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + sphere: *mut core::ffi::c_void, + ); + } + unsafe { vtk_spheres_get_sphere(self.0, i, sphere) } + } +} +impl VtkStaticCellLinks for vtkStaticCellLinks { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_links_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_links_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_links_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_links_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_links_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_links_new_instance(self.0) } + } + fn build_links(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_build_links( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_links_build_links(self.0, ds) } + } + fn get_number_of_cells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_cell_links_get_number_of_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_cell_links_get_number_of_cells(self.0, ptId) } + } + fn get_ncells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_cell_links_get_ncells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_cell_links_get_ncells(self.0, ptId) } + } + fn get_cells(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_cell_links_get_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_static_cell_links_get_cells(self.0, ptId) } + } + fn select_cells( + &mut self, + minMaxDegree: core::ffi::c_uchar, + cellSelection: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_select_cells( + sself: *mut core::ffi::c_void, + minMaxDegree: core::ffi::c_uchar, + cellSelection: core::ffi::c_uchar, + ); + } + unsafe { + vtk_static_cell_links_select_cells(self.0, minMaxDegree, cellSelection) + } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_cell_links_initialize(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_cell_links_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_cell_links_reset(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_static_cell_links_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_static_cell_links_get_actual_memory_size(self.0) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_links_deep_copy(self.0, src) } + } +} +impl VtkStaticCellLocator for vtkStaticCellLocator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_locator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_locator_new_instance(self.0) } + } + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_set_divisions( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ); + } + unsafe { vtk_static_cell_locator_set_divisions(self.0, _arg1, _arg2, _arg3) } + } + fn set_divisions(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_set_divisions( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_static_cell_locator_set_divisions(self.0, _arg) } + } + fn get_divisions(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_cell_locator_get_divisions( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_static_cell_locator_get_divisions(self.0) } + } + fn get_divisions(&mut self, data: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_get_divisions( + sself: *mut core::ffi::c_void, + data: core::ffi::c_int, + ); + } + unsafe { vtk_static_cell_locator_get_divisions(self.0, data) } + } + fn find_cell( + &mut self, + pos: core::ffi::c_double, + tol2: core::ffi::c_double, + cell: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_cell_locator_find_cell( + sself: *mut core::ffi::c_void, + pos: core::ffi::c_double, + tol2: core::ffi::c_double, + cell: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_static_cell_locator_find_cell(self.0, pos, tol2, cell, pcoords, weights) + } + } + fn find_cell(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_cell_locator_find_cell( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_cell_locator_find_cell(self.0, x) } + } + fn find_cells_along_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tolerance: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_find_cells_along_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tolerance: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_static_cell_locator_find_cells_along_line( + self.0, + p1, + p2, + tolerance, + cells, + ) + } + } + fn find_cells_along_plane( + &mut self, + o: core::ffi::c_double, + n: core::ffi::c_double, + tolerance: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_find_cells_along_plane( + sself: *mut core::ffi::c_void, + o: core::ffi::c_double, + n: core::ffi::c_double, + tolerance: core::ffi::c_double, + cells: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_static_cell_locator_find_cells_along_plane( + self.0, + o, + n, + tolerance, + cells, + ) + } + } + fn intersect_with_line( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_cell_locator_intersect_with_line( + sself: *mut core::ffi::c_void, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_cell_locator_intersect_with_line( + self.0, + a0, + a1, + tol, + t, + x, + pcoords, + subId, + cellId, + cell, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_cell_locator_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_cell_locator_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_cell_locator_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_cell_locator_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + cellId, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + points: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_cell_locator_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + points: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_cell_locator_intersect_with_line(self.0, p1, p2, points, cellIds) + } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_locator_generate_representation(self.0, level, pd) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_locator_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_cell_locator_build_locator(self.0) } + } + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_set_max_number_of_buckets( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_static_cell_locator_set_max_number_of_buckets(self.0, _arg) } + } + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_cell_locator_get_max_number_of_buckets_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_cell_locator_get_max_number_of_buckets_min_value(self.0) } + } + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_cell_locator_get_max_number_of_buckets_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_cell_locator_get_max_number_of_buckets_max_value(self.0) } + } + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_cell_locator_get_max_number_of_buckets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_cell_locator_get_max_number_of_buckets(self.0) } + } + fn get_large_ids(&mut self) -> bool { + unsafe extern "C" { + fn vtk_static_cell_locator_get_large_ids( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_static_cell_locator_get_large_ids(self.0) } + } + fn set_use_diagonal_length_tolerance(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_set_use_diagonal_length_tolerance( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { + vtk_static_cell_locator_set_use_diagonal_length_tolerance(self.0, _arg) + } + } + fn get_use_diagonal_length_tolerance(&mut self) -> bool { + unsafe extern "C" { + fn vtk_static_cell_locator_get_use_diagonal_length_tolerance( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_static_cell_locator_get_use_diagonal_length_tolerance(self.0) } + } + fn use_diagonal_length_tolerance_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_use_diagonal_length_tolerance_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_locator_use_diagonal_length_tolerance_on(self.0) } + } + fn use_diagonal_length_tolerance_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_use_diagonal_length_tolerance_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_locator_use_diagonal_length_tolerance_off(self.0) } + } +} +impl VtkStaticPointLocator for vtkStaticPointLocator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_new_instance(self.0) } + } + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_set_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_set_number_of_points_per_bucket(self.0, _arg) } + } + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_get_number_of_points_per_bucket_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_point_locator_get_number_of_points_per_bucket_min_value(self.0) + } + } + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_get_number_of_points_per_bucket_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_point_locator_get_number_of_points_per_bucket_max_value(self.0) + } + } + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_get_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_static_point_locator_get_number_of_points_per_bucket(self.0) } + } + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_set_divisions( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_set_divisions(self.0, _arg1, _arg2, _arg3) } + } + fn set_divisions(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_set_divisions( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_set_divisions(self.0, _arg) } + } + fn get_divisions(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_get_divisions( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_static_point_locator_get_divisions(self.0) } + } + fn get_divisions(&mut self, data: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_get_divisions( + sself: *mut core::ffi::c_void, + data: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_get_divisions(self.0, data) } + } + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_point_locator_find_closest_point(self.0, x) } + } + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_static_point_locator_find_closest_point_within_radius( + self.0, + radius, + x, + dist2, + ) + } + } + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + inputDataLength: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + inputDataLength: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_static_point_locator_find_closest_point_within_radius( + self.0, + radius, + x, + inputDataLength, + dist2, + ) + } + } + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_find_closest_n_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_find_closest_n_points(self.0, N, x, result) } + } + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_find_points_within_radius( + sself: *mut core::ffi::c_void, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_static_point_locator_find_points_within_radius(self.0, R, x, result) + } + } + fn intersect_with_line( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + lineX: core::ffi::c_double, + ptX: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_intersect_with_line( + sself: *mut core::ffi::c_void, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + lineX: core::ffi::c_double, + ptX: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_point_locator_intersect_with_line( + self.0, + a0, + a1, + tol, + t, + lineX, + ptX, + ptId, + ) + } + } + fn merge_points( + &mut self, + tol: core::ffi::c_double, + mergeMap: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_merge_points( + sself: *mut core::ffi::c_void, + tol: core::ffi::c_double, + mergeMap: core::ffi::c_uchar, + ); + } + unsafe { vtk_static_point_locator_merge_points(self.0, tol, mergeMap) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_point_locator_initialize(self.0) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_point_locator_build_locator(self.0) } + } + fn build_locator(&mut self, inBounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_build_locator( + sself: *mut core::ffi::c_void, + inBounds: core::ffi::c_double, + ); + } + unsafe { vtk_static_point_locator_build_locator(self.0, inBounds) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_generate_representation(self.0, level, pd) } + } + fn get_number_of_points_in_bucket( + &mut self, + bNum: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_get_number_of_points_in_bucket( + sself: *mut core::ffi::c_void, + bNum: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_point_locator_get_number_of_points_in_bucket(self.0, bNum) } + } + fn get_bucket_ids( + &mut self, + bNum: core::ffi::c_uchar, + bList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_get_bucket_ids( + sself: *mut core::ffi::c_void, + bNum: core::ffi::c_uchar, + bList: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_get_bucket_ids(self.0, bNum, bList) } + } + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_set_max_number_of_buckets( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_static_point_locator_set_max_number_of_buckets(self.0, _arg) } + } + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_get_max_number_of_buckets_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_point_locator_get_max_number_of_buckets_min_value(self.0) } + } + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_get_max_number_of_buckets_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_point_locator_get_max_number_of_buckets_max_value(self.0) } + } + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_get_max_number_of_buckets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_point_locator_get_max_number_of_buckets(self.0) } + } + fn get_large_ids(&mut self) -> bool { + unsafe extern "C" { + fn vtk_static_point_locator_get_large_ids( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_static_point_locator_get_large_ids(self.0) } + } + fn get_spacing(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_static_point_locator_get_spacing( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_static_point_locator_get_spacing(self.0) } + } + fn get_spacing(&mut self, spacing: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_get_spacing( + sself: *mut core::ffi::c_void, + spacing: core::ffi::c_double, + ); + } + unsafe { vtk_static_point_locator_get_spacing(self.0, spacing) } + } +} +impl VtkStaticPointLocator2D for vtkStaticPointLocator2D { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_2_d_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_2_d_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_2_d_new_instance(self.0) } + } + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_set_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_static_point_locator_2_d_set_number_of_points_per_bucket(self.0, _arg) + } + } + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value( + self.0, + ) + } + } + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value( + self.0, + ) + } + } + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_static_point_locator_2_d_get_number_of_points_per_bucket(self.0) } + } + fn set_divisions(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_set_divisions( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_2_d_set_divisions(self.0, _arg1, _arg2) } + } + fn set_divisions(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_set_divisions( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_2_d_set_divisions(self.0, _arg) } + } + fn get_divisions(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_divisions( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_static_point_locator_2_d_get_divisions(self.0) } + } + fn get_divisions(&mut self, data: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_divisions( + sself: *mut core::ffi::c_void, + data: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_2_d_get_divisions(self.0, data) } + } + fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_point_locator_2_d_find_closest_point(self.0, x) } + } + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_static_point_locator_2_d_find_closest_point_within_radius( + self.0, + radius, + x, + dist2, + ) + } + } + fn find_closest_point_within_radius( + &mut self, + radius: core::ffi::c_double, + x: core::ffi::c_double, + inputDataLength: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_find_closest_point_within_radius( + sself: *mut core::ffi::c_void, + radius: core::ffi::c_double, + x: core::ffi::c_double, + inputDataLength: core::ffi::c_double, + dist2: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_static_point_locator_2_d_find_closest_point_within_radius( + self.0, + radius, + x, + inputDataLength, + dist2, + ) + } + } + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_find_closest_n_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_static_point_locator_2_d_find_closest_n_points(self.0, N, x, result) + } + } + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_find_points_within_radius( + sself: *mut core::ffi::c_void, + R: core::ffi::c_double, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_static_point_locator_2_d_find_points_within_radius(self.0, R, x, result) + } + } + fn intersect_with_line( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + lineX: core::ffi::c_double, + ptX: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_intersect_with_line( + sself: *mut core::ffi::c_void, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + lineX: core::ffi::c_double, + ptX: core::ffi::c_double, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_point_locator_2_d_intersect_with_line( + self.0, + a0, + a1, + tol, + t, + lineX, + ptX, + ptId, + ) + } + } + fn find_close_n_bounded_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_find_close_n_bounded_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { + vtk_static_point_locator_2_d_find_close_n_bounded_points( + self.0, + N, + x, + result, + ) + } + } + fn merge_points( + &mut self, + tol: core::ffi::c_double, + mergeMap: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_merge_points( + sself: *mut core::ffi::c_void, + tol: core::ffi::c_double, + mergeMap: core::ffi::c_uchar, + ); + } + unsafe { vtk_static_point_locator_2_d_merge_points(self.0, tol, mergeMap) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_point_locator_2_d_initialize(self.0) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_2_d_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_point_locator_2_d_build_locator(self.0) } + } + fn get_number_of_points_in_bucket( + &mut self, + bNum: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_number_of_points_in_bucket( + sself: *mut core::ffi::c_void, + bNum: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_static_point_locator_2_d_get_number_of_points_in_bucket(self.0, bNum) + } + } + fn get_bucket_ids( + &mut self, + bNum: core::ffi::c_uchar, + bList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_bucket_ids( + sself: *mut core::ffi::c_void, + bNum: core::ffi::c_uchar, + bList: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_2_d_get_bucket_ids(self.0, bNum, bList) } + } + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_set_max_number_of_buckets( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_static_point_locator_2_d_set_max_number_of_buckets(self.0, _arg) } + } + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(self.0) + } + } + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(self.0) + } + } + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_max_number_of_buckets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_point_locator_2_d_get_max_number_of_buckets(self.0) } + } + fn get_large_ids(&mut self) -> bool { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_large_ids( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_static_point_locator_2_d_get_large_ids(self.0) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_static_point_locator_2_d_get_bounds(self.0, bounds) } + } + fn get_spacing(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_spacing( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_static_point_locator_2_d_get_spacing(self.0) } + } + fn get_spacing(&mut self, spacing: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_spacing( + sself: *mut core::ffi::c_void, + spacing: core::ffi::c_double, + ); + } + unsafe { vtk_static_point_locator_2_d_get_spacing(self.0, spacing) } + } + fn get_bucket_indices( + &mut self, + x: core::ffi::c_double, + ij: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_bucket_indices( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ij: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_2_d_get_bucket_indices(self.0, x, ij) } + } + fn get_bucket_index(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_bucket_index( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_static_point_locator_2_d_get_bucket_index(self.0, x) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_static_point_locator_2_d_generate_representation(self.0, level, pd) + } + } +} +impl VtkStructuredExtent for vtkStructuredExtent { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_extent_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_extent_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_extent_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_extent_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_extent_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_extent_new_instance(self.0) } + } + fn clamp(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_structured_extent_clamp( + sself: *mut core::ffi::c_void, + ext: core::ffi::c_int, + wholeExt: core::ffi::c_int, + ); + } + unsafe { vtk_structured_extent_clamp(self.0, ext, wholeExt) } + } + fn strictly_smaller( + &mut self, + ext: core::ffi::c_int, + wholeExt: core::ffi::c_int, + ) -> bool { + unsafe extern "C" { + fn vtk_structured_extent_strictly_smaller( + sself: *mut core::ffi::c_void, + ext: core::ffi::c_int, + wholeExt: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_structured_extent_strictly_smaller(self.0, ext, wholeExt) } + } + fn smaller(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_structured_extent_smaller( + sself: *mut core::ffi::c_void, + ext: core::ffi::c_int, + wholeExt: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_structured_extent_smaller(self.0, ext, wholeExt) } + } + fn grow(&mut self, ext: core::ffi::c_int, count: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_structured_extent_grow( + sself: *mut core::ffi::c_void, + ext: core::ffi::c_int, + count: core::ffi::c_int, + ); + } + unsafe { vtk_structured_extent_grow(self.0, ext, count) } + } + fn grow( + &mut self, + ext: core::ffi::c_int, + count: core::ffi::c_int, + wholeExt: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_structured_extent_grow( + sself: *mut core::ffi::c_void, + ext: core::ffi::c_int, + count: core::ffi::c_int, + wholeExt: core::ffi::c_int, + ); + } + unsafe { vtk_structured_extent_grow(self.0, ext, count, wholeExt) } + } + fn transform(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_structured_extent_transform( + sself: *mut core::ffi::c_void, + ext: core::ffi::c_int, + wholeExt: core::ffi::c_int, + ); + } + unsafe { vtk_structured_extent_transform(self.0, ext, wholeExt) } + } + fn get_dimensions(&mut self, ext: core::ffi::c_int, dims: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_structured_extent_get_dimensions( + sself: *mut core::ffi::c_void, + ext: core::ffi::c_int, + dims: core::ffi::c_int, + ); + } + unsafe { vtk_structured_extent_get_dimensions(self.0, ext, dims) } + } +} +impl VtkStructuredGrid for vtkStructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_grid_get_data_object_type(self.0) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_structured_grid_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_copy_structure(self.0, ds) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_structured_grid_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_structured_grid_get_number_of_points(self.0) } + } + fn get_point(&mut self, ptId: core::ffi::c_uchar, p: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + p: core::ffi::c_double, + ); + } + unsafe { vtk_structured_grid_get_point(self.0, ptId, p) } + } + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_get_cell(self.0, cellId) } + } + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_get_cell(self.0, cellId, cell) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_grid_get_cell_type(self.0, cellId) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_get_point_cells(self.0, ptId, cellIds) } + } + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + seedLoc: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_cell_neighbors( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + seedLoc: core::ffi::c_int, + ); + } + unsafe { + vtk_structured_grid_get_cell_neighbors( + self.0, + cellId, + ptIds, + cellIds, + seedLoc, + ) + } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_structured_grid_set_dimensions(self.0, i, j, k) } + } + fn set_dimensions(&mut self, dim: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_structured_grid_set_dimensions( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ); + } + unsafe { vtk_structured_grid_set_dimensions(self.0, dim) } + } + fn get_dimensions(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_get_dimensions( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_structured_grid_get_dimensions(self.0) } + } + fn get_dimensions(&mut self, dim: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_dimensions( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ); + } + unsafe { vtk_structured_grid_get_dimensions(self.0, dim) } + } + fn get_data_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_get_data_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_grid_get_data_dimension(self.0) } + } + fn set_extent(&mut self, extent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_structured_grid_set_extent( + sself: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_structured_grid_set_extent(self.0, extent) } + } + fn set_extent( + &mut self, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_set_extent( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ); + } + unsafe { + vtk_structured_grid_set_extent(self.0, xMin, xMax, yMin, yMax, zMin, zMax) + } + } + fn get_extent(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_get_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_structured_grid_get_extent(self.0) } + } + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_structured_grid_get_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_structured_grid_get_extent(self.0, _arg) } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_grid_get_extent_type(self.0) } + } + fn blank_point(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_structured_grid_blank_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_structured_grid_blank_point(self.0, ptId) } + } + fn un_blank_point(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_structured_grid_un_blank_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_structured_grid_un_blank_point(self.0, ptId) } + } + fn blank_cell(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_structured_grid_blank_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_structured_grid_blank_cell(self.0, ptId) } + } + fn un_blank_cell(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_structured_grid_un_blank_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_structured_grid_un_blank_cell(self.0, ptId) } + } + fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_structured_grid_is_point_visible( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_structured_grid_is_point_visible(self.0, ptId) } + } + fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_structured_grid_is_cell_visible( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_structured_grid_is_cell_visible(self.0, cellId) } + } + fn has_any_blank_points(&mut self) -> bool { + unsafe extern "C" { + fn vtk_structured_grid_has_any_blank_points( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_structured_grid_has_any_blank_points(self.0) } + } + fn has_any_blank_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_structured_grid_has_any_blank_cells( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_structured_grid_has_any_blank_cells(self.0) } + } + fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_cell_dims( + sself: *mut core::ffi::c_void, + cellDims: core::ffi::c_int, + ); + } + unsafe { vtk_structured_grid_get_cell_dims(self.0, cellDims) } + } + fn crop(&mut self, updateExtent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_structured_grid_crop( + sself: *mut core::ffi::c_void, + updateExtent: core::ffi::c_int, + ); + } + unsafe { vtk_structured_grid_crop(self.0, updateExtent) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_get_data(self.0, v, i) } + } + fn get_point( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + p: core::ffi::c_double, + adjustForExtent: bool, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_point( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + p: core::ffi::c_double, + adjustForExtent: bool, + ); + } + unsafe { vtk_structured_grid_get_point(self.0, i, j, k, p, adjustForExtent) } + } +} +impl VtkStructuredPoints for vtkStructuredPoints { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_points_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_points_get_data_object_type(self.0) } + } +} +impl VtkStructuredPointsCollection for vtkStructuredPointsCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_collection_new_instance(self.0) } + } + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_structured_points_collection_add_item( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_points_collection_add_item(self.0, ds) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_collection_get_next_item(self.0) } + } + fn get_next_structured_points(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_collection_get_next_structured_points( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_structured_points_collection_get_next_structured_points(self.0, cookie) + } + } +} +impl VtkSuperquadric for vtkSuperquadric { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_new_instance(self.0) } + } + fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_evaluate_function( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_evaluate_function(self.0, x) } + } + fn evaluate_gradient( + &mut self, + x: core::ffi::c_double, + g: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_superquadric_evaluate_gradient( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + g: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_evaluate_gradient(self.0, x, g) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_center(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_center( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_center(self.0, _arg) } + } + fn get_center(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_center( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_superquadric_get_center(self.0) } + } + fn get_center(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_get_center( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_get_center(self.0, data) } + } + fn set_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_scale( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_scale(self.0, _arg1, _arg2, _arg3) } + } + fn set_scale(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_scale( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_scale(self.0, _arg) } + } + fn get_scale(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_scale( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_superquadric_get_scale(self.0) } + } + fn get_scale(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_get_scale( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_get_scale(self.0, data) } + } + fn get_thickness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_thickness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_thickness(self.0) } + } + fn set_thickness(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_thickness( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_thickness(self.0, _arg) } + } + fn get_thickness_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_thickness_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_thickness_min_value(self.0) } + } + fn get_thickness_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_thickness_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_thickness_max_value(self.0) } + } + fn get_phi_roundness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_phi_roundness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_phi_roundness(self.0) } + } + fn set_phi_roundness(&mut self, e: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_phi_roundness( + sself: *mut core::ffi::c_void, + e: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_phi_roundness(self.0, e) } + } + fn get_theta_roundness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_theta_roundness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_theta_roundness(self.0) } + } + fn set_theta_roundness(&mut self, e: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_theta_roundness( + sself: *mut core::ffi::c_void, + e: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_theta_roundness(self.0, e) } + } + fn set_size(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_size(self.0, _arg) } + } + fn get_size(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_size(self.0) } + } + fn toroidal_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_toroidal_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_superquadric_toroidal_on(self.0) } + } + fn toroidal_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_toroidal_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_superquadric_toroidal_off(self.0) } + } + fn get_toroidal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_get_toroidal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_get_toroidal(self.0) } + } + fn set_toroidal(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_toroidal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_set_toroidal(self.0, _arg) } + } +} +impl VtkTable for vtkTable { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_new_instance(self.0) } + } + fn dump(&mut self, colWidth: core::ffi::c_uint, rowLimit: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_table_dump( + sself: *mut core::ffi::c_void, + colWidth: core::ffi::c_uint, + rowLimit: core::ffi::c_int, + ); + } + unsafe { vtk_table_dump(self.0, colWidth, rowLimit) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_table_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_table_get_data_object_type(self.0) } + } + fn get_row_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_row_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_row_data(self.0) } + } + fn set_row_data(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_table_set_row_data( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_set_row_data(self.0, data) } + } + fn get_number_of_rows(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_table_get_number_of_rows( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_table_get_number_of_rows(self.0) } + } + fn set_number_of_rows(&mut self, p0: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_table_set_number_of_rows( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + ); + } + unsafe { vtk_table_set_number_of_rows(self.0, p0) } + } + fn get_row(&mut self, row: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_row( + sself: *mut core::ffi::c_void, + row: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_row(self.0, row) } + } + fn get_row( + &mut self, + row: core::ffi::c_uchar, + values: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_table_get_row( + sself: *mut core::ffi::c_void, + row: core::ffi::c_uchar, + values: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_get_row(self.0, row, values) } + } + fn set_row( + &mut self, + row: core::ffi::c_uchar, + values: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_table_set_row( + sself: *mut core::ffi::c_void, + row: core::ffi::c_uchar, + values: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_set_row(self.0, row, values) } + } + fn insert_next_blank_row( + &mut self, + default_num_val: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_table_insert_next_blank_row( + sself: *mut core::ffi::c_void, + default_num_val: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_table_insert_next_blank_row(self.0, default_num_val) } + } + fn insert_next_row(&mut self, values: *mut core::ffi::c_void) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_table_insert_next_row( + sself: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_table_insert_next_row(self.0, values) } + } + fn remove_row(&mut self, row: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_table_remove_row( + sself: *mut core::ffi::c_void, + row: core::ffi::c_uchar, + ); + } + unsafe { vtk_table_remove_row(self.0, row) } + } + fn get_number_of_columns(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_table_get_number_of_columns( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_table_get_number_of_columns(self.0) } + } + fn get_column_name(&mut self, col: core::ffi::c_uchar) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_table_get_column_name( + sself: *mut core::ffi::c_void, + col: core::ffi::c_uchar, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_table_get_column_name(self.0, col) } + } + fn get_column_by_name(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_column_by_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_column_by_name(self.0, name) } + } + fn get_column(&mut self, col: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_column( + sself: *mut core::ffi::c_void, + col: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_column(self.0, col) } + } + fn add_column(&mut self, arr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_table_add_column( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_add_column(self.0, arr) } + } + fn remove_column_by_name(&mut self, name: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_table_remove_column_by_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ); + } + unsafe { vtk_table_remove_column_by_name(self.0, name) } + } + fn remove_column(&mut self, col: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_table_remove_column( + sself: *mut core::ffi::c_void, + col: core::ffi::c_uchar, + ); + } + unsafe { vtk_table_remove_column(self.0, col) } + } + fn get_value( + &mut self, + row: core::ffi::c_uchar, + col: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_value( + sself: *mut core::ffi::c_void, + row: core::ffi::c_uchar, + col: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_value(self.0, row, col) } + } + fn get_value_by_name( + &mut self, + row: core::ffi::c_uchar, + col: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_value_by_name( + sself: *mut core::ffi::c_void, + row: core::ffi::c_uchar, + col: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_value_by_name(self.0, row, col) } + } + fn set_value( + &mut self, + row: core::ffi::c_uchar, + col: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_table_set_value( + sself: *mut core::ffi::c_void, + row: core::ffi::c_uchar, + col: core::ffi::c_uchar, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_set_value(self.0, row, col, value) } + } + fn set_value_by_name( + &mut self, + row: core::ffi::c_uchar, + col: core::ffi::c_char, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_table_set_value_by_name( + sself: *mut core::ffi::c_void, + row: core::ffi::c_uchar, + col: core::ffi::c_char, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_set_value_by_name(self.0, row, col, value) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_table_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_table_initialize(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_data(self.0, v, i) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_table_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_shallow_copy(self.0, src) } + } + fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_table_get_number_of_elements( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_table_get_number_of_elements(self.0, type_) } + } +} +impl VtkTetra for vtkTetra { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tetra_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_tetra_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tetra_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tetra_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tetra_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tetra_new_instance(self.0) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_tetra_get_edge_points(self.0, edgeId, pts) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_tetra_get_edge_points(self.0, edgeId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_face_points(self.0, faceId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_tetra_get_face_points(self.0, faceId, pts) } + } + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_get_edge_to_adjacent_faces( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_tetra_get_edge_to_adjacent_faces(self.0, edgeId, pts) } + } + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_face_to_adjacent_faces( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_face_to_adjacent_faces(self.0, faceId, faceIds) } + } + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_point_to_incident_edges( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_point_to_incident_edges(self.0, pointId, edgeIds) } + } + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_point_to_incident_faces( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_point_to_incident_faces(self.0, pointId, faceIds) } + } + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_point_to_one_ring_points( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_point_to_one_ring_points(self.0, pointId, pts) } + } + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_tetra_get_centroid( + sself: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_tetra_get_centroid(self.0, centroid) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tetra_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tetra_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tetra_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tetra_get_face(self.0, faceId) } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_tetra_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_tetra_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_tetra_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_tetra_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_get_triangle_cases( + sself: *mut core::ffi::c_void, + caseId: core::ffi::c_int, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_tetra_get_triangle_cases(self.0, caseId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_cell_boundary(self.0, subId, pcoords, pts) } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_get_parametric_center(self.0, pcoords) } + } + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_tetra_get_parametric_distance( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_tetra_get_parametric_distance(self.0, pcoords) } + } + fn tetra_center( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + p4: core::ffi::c_double, + center: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_tetra_center( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + p4: core::ffi::c_double, + center: core::ffi::c_double, + ); + } + unsafe { vtk_tetra_tetra_center(self.0, p1, p2, p3, p4, center) } + } + fn circumsphere( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + x4: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_tetra_circumsphere( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + x4: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_tetra_circumsphere(self.0, x1, x2, x3, x4, center) } + } + fn insphere( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + p4: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_tetra_insphere( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + p4: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_tetra_insphere(self.0, p1, p2, p3, p4, center) } + } + fn barycentric_coords( + &mut self, + x: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + x4: core::ffi::c_double, + bcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_barycentric_coords( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + x4: core::ffi::c_double, + bcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_barycentric_coords(self.0, x, x1, x2, x3, x4, bcoords) } + } + fn compute_volume( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + p4: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_tetra_compute_volume( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + p4: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_tetra_compute_volume(self.0, p1, p2, p3, p4) } + } + fn jacobian_inverse( + &mut self, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_jacobian_inverse( + sself: *mut core::ffi::c_void, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_jacobian_inverse(self.0, inverse, derivs) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_tetra_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_tetra_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_tetra_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tetra_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_tetra_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_face_array(self.0, faceId) } + } + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_edge_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_edge_to_adjacent_faces_array(self.0, edgeId) } + } + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_face_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_face_to_adjacent_faces_array(self.0, faceId) } + } + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_point_to_incident_edges_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_point_to_incident_edges_array(self.0, pointId) } + } + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_point_to_incident_faces_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_point_to_incident_faces_array(self.0, pointId) } + } + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tetra_get_point_to_one_ring_points_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tetra_get_point_to_one_ring_points_array(self.0, pointId) } + } + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_tetra_compute_centroid( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_tetra_compute_centroid(self.0, points, pointIds, centroid) } + } +} +impl VtkTree for vtkTree { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_new_instance(self.0) } + } + fn get_root(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tree_get_root(sself: *mut core::ffi::c_void) -> core::ffi::c_uchar; + } + unsafe { vtk_tree_get_root(self.0) } + } + fn get_number_of_children(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tree_get_number_of_children( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_tree_get_number_of_children(self.0, v) } + } + fn get_child( + &mut self, + v: core::ffi::c_uchar, + i: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tree_get_child( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + i: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_tree_get_child(self.0, v, i) } + } + fn get_children(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_tree_get_children( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + it: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tree_get_children(self.0, v, it) } + } + fn get_parent(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tree_get_parent( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_tree_get_parent(self.0, v) } + } + fn get_parent_edge(&mut self, v: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_get_parent_edge( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_get_parent_edge(self.0, v) } + } + fn get_level(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tree_get_level( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_tree_get_level(self.0, v) } + } + fn is_leaf(&mut self, vertex: core::ffi::c_uchar) -> bool { + unsafe extern "C" { + fn vtk_tree_is_leaf( + sself: *mut core::ffi::c_void, + vertex: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_tree_is_leaf(self.0, vertex) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_get_data(self.0, v, i) } + } + fn reorder_children( + &mut self, + parent: core::ffi::c_uchar, + children: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_tree_reorder_children( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_uchar, + children: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tree_reorder_children(self.0, parent, children) } + } +} +impl VtkTreeBFSIterator for vtkTreeBFSIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_bfs_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_bfs_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_bfs_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_bfs_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_bfs_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_bfs_iterator_new_instance(self.0) } + } +} +impl VtkTreeDFSIterator for vtkTreeDFSIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_dfs_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_dfs_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_dfs_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_dfs_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_dfs_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_dfs_iterator_new_instance(self.0) } + } + fn set_mode(&mut self, mode: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_tree_dfs_iterator_set_mode( + sself: *mut core::ffi::c_void, + mode: core::ffi::c_int, + ); + } + unsafe { vtk_tree_dfs_iterator_set_mode(self.0, mode) } + } + fn get_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tree_dfs_iterator_get_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tree_dfs_iterator_get_mode(self.0) } + } +} +impl VtkTriQuadraticHexahedron for vtkTriQuadraticHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_hexahedron_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_hexahedron_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_hexahedron_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_hexahedron_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_hexahedron_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_hexahedron_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_tri_quadratic_hexahedron_cell_boundary(self.0, subId, pcoords, pts) + } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_tri_quadratic_hexahedron_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_evaluate_location( + self.0, + subId, + pcoords, + x, + weights, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_hexahedron_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_tri_quadratic_hexahedron_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_interpolation_functions( + self.0, + pcoords, + weights, + ) + } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_interpolation_derivs(self.0, pcoords, derivs) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_interpolate_functions(self.0, pcoords, weights) + } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_interpolate_derivs(self.0, pcoords, derivs) + } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tri_quadratic_hexahedron_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tri_quadratic_hexahedron_get_face_array(self.0, faceId) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_jacobian_inverse( + self.0, + pcoords, + inverse, + derivs, + ) + } + } +} +impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_pyramid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_pyramid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_pyramid_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_pyramid_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_pyramid_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_tri_quadratic_pyramid_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_tri_quadratic_pyramid_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_pyramid_evaluate_location( + self.0, + subId, + pcoords, + x, + weights, + ) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_tri_quadratic_pyramid_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_pyramid_derivatives( + self.0, + subId, + pcoords, + values, + dim, + derivs, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_tri_quadratic_pyramid_clip( + self.0, + value, + cellScalars, + locator, + tets, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_get_parametric_center(self.0, pcoords) } + } + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_parametric_distance( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_tri_quadratic_pyramid_get_parametric_distance(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_pyramid_interpolation_functions(self.0, pcoords, weights) + } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_pyramid_interpolation_derivs(self.0, pcoords, derivs) + } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_pyramid_interpolate_functions(self.0, pcoords, weights) + } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_tri_quadratic_pyramid_interpolate_derivs(self.0, pcoords, derivs) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_tri_quadratic_pyramid_jacobian_inverse(self.0, pcoords, inverse, derivs) + } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tri_quadratic_pyramid_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_tri_quadratic_pyramid_get_face_array(self.0, faceId) } + } +} +impl VtkTriangle for vtkTriangle { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_new_instance(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_get_edge(self.0, edgeId) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_get_number_of_faces(self.0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_get_face(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_triangle_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_triangle_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn compute_area(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_triangle_compute_area( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_triangle_compute_area(self.0) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_triangle_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_interpolation_functions(self.0, pcoords, sf) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + sf: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_interpolate_functions(self.0, pcoords, sf) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_interpolate_derivs(self.0, pcoords, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_triangle_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_triangle_get_edge_array(self.0, edgeId) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_triangle_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_get_parametric_center(self.0, pcoords) } + } + fn get_parametric_distance( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_triangle_get_parametric_distance( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_triangle_get_parametric_distance(self.0, pcoords) } + } + fn triangle_center( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + center: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_triangle_center( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + center: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_triangle_center(self.0, p1, p2, p3, center) } + } + fn triangle_area( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_triangle_triangle_area( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_triangle_triangle_area(self.0, p1, p2, p3) } + } + fn circumcircle( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_triangle_circumcircle( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + p3: core::ffi::c_double, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_triangle_circumcircle(self.0, p1, p2, p3, center) } + } + fn barycentric_coords( + &mut self, + x: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + bcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_barycentric_coords( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + bcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_barycentric_coords(self.0, x, x1, x2, x3, bcoords) } + } + fn project_to_2_d( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_project_to_2_d( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_project_to_2_d(self.0, x1, x2, x3, v1, v2, v3) } + } + fn compute_normal( + &mut self, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_compute_normal( + sself: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + numPts: core::ffi::c_int, + pts: core::ffi::c_uchar, + n: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_compute_normal(self.0, p, numPts, pts, n) } + } + fn compute_normal( + &mut self, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_compute_normal( + sself: *mut core::ffi::c_void, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_compute_normal(self.0, v1, v2, v3, n) } + } + fn compute_normal_direction( + &mut self, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + n: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_compute_normal_direction( + sself: *mut core::ffi::c_void, + v1: core::ffi::c_double, + v2: core::ffi::c_double, + v3: core::ffi::c_double, + n: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_compute_normal_direction(self.0, v1, v2, v3, n) } + } + fn triangles_intersect( + &mut self, + p1: core::ffi::c_double, + q1: core::ffi::c_double, + r1: core::ffi::c_double, + p2: core::ffi::c_double, + q2: core::ffi::c_double, + r2: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_triangles_intersect( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + q1: core::ffi::c_double, + r1: core::ffi::c_double, + p2: core::ffi::c_double, + q2: core::ffi::c_double, + r2: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_triangles_intersect(self.0, p1, q1, r1, p2, q2, r2) } + } + fn point_in_triangle( + &mut self, + x: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + tol2: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_point_in_triangle( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + tol2: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_point_in_triangle(self.0, x, x1, x2, x3, tol2) } + } + fn compute_quadric( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + quadric: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_compute_quadric( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + quadric: core::ffi::c_double, + ); + } + unsafe { vtk_triangle_compute_quadric(self.0, x1, x2, x3, quadric) } + } + fn compute_quadric( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + quadric: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_compute_quadric( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + x3: core::ffi::c_double, + quadric: *mut core::ffi::c_void, + ); + } + unsafe { vtk_triangle_compute_quadric(self.0, x1, x2, x3, quadric) } + } + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_triangle_compute_centroid( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_triangle_compute_centroid(self.0, points, pointIds, centroid) } + } +} +impl VtkTriangleStrip for vtkTriangleStrip { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_strip_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_strip_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_strip_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_strip_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_strip_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_strip_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_strip_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_strip_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_strip_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_strip_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_strip_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_triangle_strip_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_strip_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_triangle_strip_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_triangle_strip_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_strip_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { + vtk_triangle_strip_evaluate_location(self.0, subId, pcoords, x, weights) + } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_triangle_strip_intersect_with_line( + self.0, + p1, + p2, + tol, + t, + x, + pcoords, + subId, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_strip_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { + vtk_triangle_strip_derivatives(self.0, subId, pcoords, values, dim, derivs) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_get_parametric_center(self.0, pcoords) } + } + fn decompose_strip( + &mut self, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + tris: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_strip_decompose_strip( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + tris: *mut core::ffi::c_void, + ); + } + unsafe { vtk_triangle_strip_decompose_strip(self.0, npts, pts, tris) } + } +} +impl VtkUndirectedGraph for vtkUndirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_new_instance(self.0) } + } + fn get_in_degree(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_undirected_graph_get_in_degree( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_undirected_graph_get_in_degree(self.0, v) } + } + fn get_in_edge( + &mut self, + v: core::ffi::c_uchar, + i: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_get_in_edge( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + i: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_get_in_edge(self.0, v, i) } + } + fn get_in_edge( + &mut self, + v: core::ffi::c_uchar, + i: core::ffi::c_uchar, + e: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_undirected_graph_get_in_edge( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + i: core::ffi::c_uchar, + e: *mut core::ffi::c_void, + ); + } + unsafe { vtk_undirected_graph_get_in_edge(self.0, v, i, e) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_get_data(self.0, v, i) } + } + fn get_in_edges(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_undirected_graph_get_in_edges( + sself: *mut core::ffi::c_void, + v: core::ffi::c_uchar, + it: *mut core::ffi::c_void, + ); + } + unsafe { vtk_undirected_graph_get_in_edges(self.0, v, it) } + } + fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_undirected_graph_is_structure_valid( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_undirected_graph_is_structure_valid(self.0, g) } + } +} +impl VtkUniformGrid for vtkUniformGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_new_instance(self.0) } + } + fn get_cell( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_get_cell( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_get_cell(self.0, i, j, k) } + } + fn get_grid_description(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_get_grid_description( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_get_grid_description(self.0) } + } + fn initialize( + &mut self, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_initialize( + sself: *mut core::ffi::c_void, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_initialize(self.0, def, origin, spacing) } + } + fn initialize( + &mut self, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + nGhosts: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_initialize( + sself: *mut core::ffi::c_void, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + nGhosts: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_initialize(self.0, def, origin, spacing, nGhosts) } + } + fn initialize( + &mut self, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + nGhosts: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_initialize( + sself: *mut core::ffi::c_void, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + nGhosts: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_initialize(self.0, def, origin, spacing, nGhosts) } + } + fn initialize( + &mut self, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + nGhostsI: core::ffi::c_int, + nGhostsJ: core::ffi::c_int, + nGhostsK: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_initialize( + sself: *mut core::ffi::c_void, + def: vtkAMRBox, + origin: core::ffi::c_double, + spacing: core::ffi::c_double, + nGhostsI: core::ffi::c_int, + nGhostsJ: core::ffi::c_int, + nGhostsK: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_uniform_grid_initialize( + self.0, + def, + origin, + spacing, + nGhostsI, + nGhostsJ, + nGhostsK, + ) + } + } + fn blank_point(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_blank_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_uniform_grid_blank_point(self.0, ptId) } + } + fn un_blank_point(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_un_blank_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_uniform_grid_un_blank_point(self.0, ptId) } + } + fn blank_point( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_blank_point( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_blank_point(self.0, i, j, k) } + } + fn un_blank_point( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_un_blank_point( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_un_blank_point(self.0, i, j, k) } + } + fn blank_cell(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_blank_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_uniform_grid_blank_cell(self.0, ptId) } + } + fn un_blank_cell(&mut self, ptId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_un_blank_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ); + } + unsafe { vtk_uniform_grid_un_blank_cell(self.0, ptId) } + } + fn blank_cell( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_blank_cell( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_blank_cell(self.0, i, j, k) } + } + fn un_blank_cell( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_un_blank_cell( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_un_blank_cell(self.0, i, j, k) } + } + fn is_point_visible(&mut self, pointId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_uniform_grid_is_point_visible( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_uniform_grid_is_point_visible(self.0, pointId) } + } + fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_uniform_grid_is_cell_visible( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_uniform_grid_is_cell_visible(self.0, cellId) } + } + fn new_image_data_copy(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_new_image_data_copy( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_new_image_data_copy(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_get_data(self.0, v, i) } + } +} +impl VtkUniformGridAMR for vtkUniformGridAMR { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_new_instance(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_new_iterator(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_amr_get_data_object_type(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_uniform_grid_amr_initialize(self.0) } + } + fn initialize( + &mut self, + numLevels: core::ffi::c_int, + blocksPerLevel: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_initialize( + sself: *mut core::ffi::c_void, + numLevels: core::ffi::c_int, + blocksPerLevel: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_amr_initialize(self.0, numLevels, blocksPerLevel) } + } + fn set_grid_description(&mut self, gridDescription: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_set_grid_description( + sself: *mut core::ffi::c_void, + gridDescription: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_amr_set_grid_description(self.0, gridDescription) } + } + fn get_grid_description(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_grid_description( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_amr_get_grid_description(self.0) } + } + fn get_number_of_levels(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_number_of_levels( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_get_number_of_levels(self.0) } + } + fn get_total_number_of_blocks(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_total_number_of_blocks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_get_total_number_of_blocks(self.0) } + } + fn get_number_of_data_sets( + &mut self, + level: core::ffi::c_uint, + ) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_number_of_data_sets( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_get_number_of_data_sets(self.0, level) } + } + fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_bounds( + sself: *mut core::ffi::c_void, + bounds: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_grid_amr_get_bounds(self.0, bounds) } + } + fn get_bounds(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_bounds( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_uniform_grid_amr_get_bounds(self.0) } + } + fn get_min(&mut self, min: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_min( + sself: *mut core::ffi::c_void, + min: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_grid_amr_get_min(self.0, min) } + } + fn get_max(&mut self, max: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_max( + sself: *mut core::ffi::c_void, + max: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_grid_amr_get_max(self.0, max) } + } + fn set_data_set( + &mut self, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_set_data_set( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_set_data_set(self.0, iter, dataObj) } + } + fn set_data_set( + &mut self, + level: core::ffi::c_uint, + idx: core::ffi::c_uint, + grid: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_set_data_set( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + idx: core::ffi::c_uint, + grid: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_set_data_set(self.0, level, idx, grid) } + } + fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_data_set( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_get_data_set(self.0, iter) } + } + fn get_data_set( + &mut self, + level: core::ffi::c_uint, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_data_set( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_get_data_set(self.0, level, idx) } + } + fn get_composite_index( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_composite_index( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_amr_get_composite_index(self.0, level, index) } + } + fn get_level_and_index( + &mut self, + compositeIdx: core::ffi::c_uint, + level: core::ffi::c_uint, + idx: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_level_and_index( + sself: *mut core::ffi::c_void, + compositeIdx: core::ffi::c_uint, + level: core::ffi::c_uint, + idx: core::ffi::c_uint, + ); + } + unsafe { + vtk_uniform_grid_amr_get_level_and_index(self.0, compositeIdx, level, idx) + } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_shallow_copy(self.0, src) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_deep_copy(self.0, src) } + } + fn copy_structure(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_copy_structure( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_copy_structure(self.0, src) } + } + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_recursive_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_recursive_shallow_copy(self.0, src) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_get_data(self.0, v, i) } + } +} +impl VtkUniformGridAMRDataIterator for vtkUniformGridAMRDataIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_data_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_data_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_data_iterator_new_instance(self.0) } + } + fn get_current_meta_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_get_current_meta_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_data_iterator_get_current_meta_data(self.0) } + } + fn has_current_meta_data(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_has_current_meta_data( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_amr_data_iterator_has_current_meta_data(self.0) } + } + fn get_current_data_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_get_current_data_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_data_iterator_get_current_data_object(self.0) } + } + fn get_current_flat_index(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_get_current_flat_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_data_iterator_get_current_flat_index(self.0) } + } + fn get_current_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_get_current_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_data_iterator_get_current_level(self.0) } + } + fn get_current_index(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_get_current_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_data_iterator_get_current_index(self.0) } + } + fn go_to_first_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_go_to_first_item( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_data_iterator_go_to_first_item(self.0) } + } + fn go_to_next_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_go_to_next_item( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_data_iterator_go_to_next_item(self.0) } + } + fn is_done_with_traversal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(self.0) } + } +} +impl VtkUniformHyperTreeGrid for vtkUniformHyperTreeGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_new_instance(self.0) } + } + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_copy_structure( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_copy_structure(self.0, p0) } + } + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_origin( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_origin(self.0, _arg1, _arg2, _arg3) } + } + fn set_origin(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_origin( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_origin(self.0, _arg) } + } + fn get_origin(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_get_origin( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_uniform_hyper_tree_grid_get_origin(self.0) } + } + fn get_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_get_origin( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_get_origin(self.0, _arg1, _arg2, _arg3) } + } + fn get_origin(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_get_origin( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_get_origin(self.0, _arg) } + } + fn set_grid_scale( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_grid_scale( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_grid_scale(self.0, p0, p1, p2) } + } + fn set_grid_scale(&mut self, p0: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_grid_scale( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_grid_scale(self.0, p0) } + } + fn get_grid_scale(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_get_grid_scale( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_uniform_hyper_tree_grid_get_grid_scale(self.0) } + } + fn get_grid_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_get_grid_scale( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { + vtk_uniform_hyper_tree_grid_get_grid_scale(self.0, _arg1, _arg2, _arg3) + } + } + fn get_grid_scale(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_get_grid_scale( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_get_grid_scale(self.0, _arg) } + } + fn set_grid_scale(&mut self, p0: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_grid_scale( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_grid_scale(self.0, p0) } + } + fn set_x_coordinates(&mut self, XCoordinates: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_x_coordinates( + sself: *mut core::ffi::c_void, + XCoordinates: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_x_coordinates(self.0, XCoordinates) } + } + fn set_y_coordinates(&mut self, YCoordinates: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_y_coordinates( + sself: *mut core::ffi::c_void, + YCoordinates: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_y_coordinates(self.0, YCoordinates) } + } + fn set_z_coordinates(&mut self, ZCoordinates: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_z_coordinates( + sself: *mut core::ffi::c_void, + ZCoordinates: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_z_coordinates(self.0, ZCoordinates) } + } + fn get_level_zero_origin_from_index( + &mut self, + p0: core::ffi::c_uchar, + p1: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_get_level_zero_origin_from_index( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uchar, + p1: core::ffi::c_double, + ); + } + unsafe { + vtk_uniform_hyper_tree_grid_get_level_zero_origin_from_index(self.0, p0, p1) + } + } + fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(self.0) } + } +} +impl VtkUnstructuredGrid for vtkUnstructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_data_object_type(self.0) } + } + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_uchar, + maxCellSize: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_unstructured_grid_allocate_estimate( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + maxCellSize: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_unstructured_grid_allocate_estimate(self.0, numCells, maxCellSize) } + } + fn allocate_exact( + &mut self, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_unstructured_grid_allocate_exact( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + connectivitySize: core::ffi::c_uchar, + ) -> bool; + } + unsafe { + vtk_unstructured_grid_allocate_exact(self.0, numCells, connectivitySize) + } + } + fn allocate( + &mut self, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_allocate( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_uchar, + extSize: core::ffi::c_int, + ); + } + unsafe { vtk_unstructured_grid_allocate(self.0, numCells, extSize) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unstructured_grid_reset(self.0) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_copy_structure(self.0, ds) } + } + fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_cell(self.0, cellId) } + } + fn get_cell( + &mut self, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + cell: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_cell(self.0, cellId, cell) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_point_cells(self.0, ptId, cellIds) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_cell_type(self.0, cellId) } + } + fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_types( + sself: *mut core::ffi::c_void, + types: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_cell_types(self.0, types) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_unstructured_grid_get_cell_points(self.0, cellId, npts, pts) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_uchar, + cells: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_uchar, + cells: core::ffi::c_uchar, + ); + } + unsafe { vtk_unstructured_grid_get_point_cells(self.0, ptId, ncells, cells) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_ushort, + cells: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + ncells: core::ffi::c_ushort, + cells: core::ffi::c_uchar, + ); + } + unsafe { vtk_unstructured_grid_get_point_cells(self.0, ptId, ncells, cells) } + } + fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_types_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_cell_types_array(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unstructured_grid_squeeze(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unstructured_grid_initialize(self.0) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_max_cell_size(self.0) } + } + fn build_links(&mut self) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_build_links(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unstructured_grid_build_links(self.0) } + } + fn get_cell_links(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_links( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_cell_links(self.0) } + } + fn get_face_stream( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_face_stream( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_face_stream(self.0, cellId, ptIds) } + } + fn get_face_stream( + &mut self, + cellId: core::ffi::c_uchar, + nfaces: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_face_stream( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + nfaces: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + ); + } + unsafe { vtk_unstructured_grid_get_face_stream(self.0, cellId, nfaces, ptIds) } + } + fn set_cells( + &mut self, + type_: core::ffi::c_int, + cells: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_set_cells( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + cells: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_set_cells(self.0, type_, cells) } + } + fn set_cells( + &mut self, + types: core::ffi::c_int, + cells: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_set_cells( + sself: *mut core::ffi::c_void, + types: core::ffi::c_int, + cells: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_set_cells(self.0, types, cells) } + } + fn set_cells( + &mut self, + cellTypes: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_set_cells( + sself: *mut core::ffi::c_void, + cellTypes: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_set_cells(self.0, cellTypes, cells) } + } + fn set_cells( + &mut self, + cellTypes: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + faceLocations: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_set_cells( + sself: *mut core::ffi::c_void, + cellTypes: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + faceLocations: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unstructured_grid_set_cells( + self.0, + cellTypes, + cells, + faceLocations, + faces, + ) + } + } + fn get_cells(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cells( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_cells(self.0) } + } + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_neighbors( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unstructured_grid_get_cell_neighbors(self.0, cellId, ptIds, cellIds) + } + } + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_neighbors( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unstructured_grid_get_cell_neighbors( + self.0, + cellId, + npts, + ptIds, + cellIds, + ) + } + } + fn is_cell_boundary( + &mut self, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + ) -> bool { + unsafe extern "C" { + fn vtk_unstructured_grid_is_cell_boundary( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + npts: core::ffi::c_uchar, + ptIds: core::ffi::c_uchar, + ) -> bool; + } + unsafe { vtk_unstructured_grid_is_cell_boundary(self.0, cellId, npts, ptIds) } + } + fn insert_next_linked_cell( + &mut self, + type_: core::ffi::c_int, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unstructured_grid_insert_next_linked_cell( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + npts: core::ffi::c_int, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_unstructured_grid_insert_next_linked_cell(self.0, type_, npts, pts) + } + } + fn remove_reference_to_cell( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_remove_reference_to_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_unstructured_grid_remove_reference_to_cell(self.0, ptId, cellId) } + } + fn add_reference_to_cell( + &mut self, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_add_reference_to_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_unstructured_grid_add_reference_to_cell(self.0, ptId, cellId) } + } + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_uchar, + size: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_resize_cell_list( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_uchar, + size: core::ffi::c_int, + ); + } + unsafe { vtk_unstructured_grid_resize_cell_list(self.0, ptId, size) } + } + fn get_piece(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_piece( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_piece(self.0) } + } + fn get_number_of_pieces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_number_of_pieces(self.0) } + } + fn get_ghost_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_ghost_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_ghost_level(self.0) } + } + fn get_ids_of_cells_of_type( + &mut self, + type_: core::ffi::c_int, + array: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_ids_of_cells_of_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + array: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_ids_of_cells_of_type(self.0, type_, array) } + } + fn is_homogeneous(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_is_homogeneous( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_is_homogeneous(self.0) } + } + fn remove_ghost_cells(&mut self) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_remove_ghost_cells(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unstructured_grid_remove_ghost_cells(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_data(self.0, info) } + } + fn get_data( + &mut self, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_data( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_data(self.0, v, i) } + } + fn get_faces(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unstructured_grid_get_faces( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ) -> *mut core::ffi::c_uchar; + } + unsafe { vtk_unstructured_grid_get_faces(self.0, cellId) } + } + fn get_faces(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_faces( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_faces(self.0) } + } + fn get_face_locations(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_face_locations( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_face_locations(self.0) } + } + fn initialize_faces_representation( + &mut self, + numPrevCells: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_initialize_faces_representation( + sself: *mut core::ffi::c_void, + numPrevCells: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { + vtk_unstructured_grid_initialize_faces_representation(self.0, numPrevCells) + } + } + fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unstructured_grid_get_mesh_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_unstructured_grid_get_mesh_m_time(self.0) } + } + fn decompose_a_polyhedron_cell( + &mut self, + polyhedronCellArray: *mut core::ffi::c_void, + nCellpts: core::ffi::c_uchar, + nCellfaces: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_decompose_a_polyhedron_cell( + sself: *mut core::ffi::c_void, + polyhedronCellArray: *mut core::ffi::c_void, + nCellpts: core::ffi::c_uchar, + nCellfaces: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unstructured_grid_decompose_a_polyhedron_cell( + self.0, + polyhedronCellArray, + nCellpts, + nCellfaces, + cellArray, + faces, + ) + } + } + fn decompose_a_polyhedron_cell( + &mut self, + polyhedronCellStream: core::ffi::c_uchar, + nCellpts: core::ffi::c_uchar, + nCellfaces: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_decompose_a_polyhedron_cell( + sself: *mut core::ffi::c_void, + polyhedronCellStream: core::ffi::c_uchar, + nCellpts: core::ffi::c_uchar, + nCellfaces: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unstructured_grid_decompose_a_polyhedron_cell( + self.0, + polyhedronCellStream, + nCellpts, + nCellfaces, + cellArray, + faces, + ) + } + } + fn decompose_a_polyhedron_cell( + &mut self, + nCellFaces: core::ffi::c_uchar, + inFaceStream: core::ffi::c_uchar, + nCellpts: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_decompose_a_polyhedron_cell( + sself: *mut core::ffi::c_void, + nCellFaces: core::ffi::c_uchar, + inFaceStream: core::ffi::c_uchar, + nCellpts: core::ffi::c_uchar, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unstructured_grid_decompose_a_polyhedron_cell( + self.0, + nCellFaces, + inFaceStream, + nCellpts, + cellArray, + faces, + ) + } + } + fn convert_face_stream_point_ids( + &mut self, + faceStream: *mut core::ffi::c_void, + idMap: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_convert_face_stream_point_ids( + sself: *mut core::ffi::c_void, + faceStream: *mut core::ffi::c_void, + idMap: core::ffi::c_uchar, + ); + } + unsafe { + vtk_unstructured_grid_convert_face_stream_point_ids( + self.0, + faceStream, + idMap, + ) + } + } + fn convert_face_stream_point_ids( + &mut self, + nfaces: core::ffi::c_uchar, + faceStream: core::ffi::c_uchar, + idMap: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_convert_face_stream_point_ids( + sself: *mut core::ffi::c_void, + nfaces: core::ffi::c_uchar, + faceStream: core::ffi::c_uchar, + idMap: core::ffi::c_uchar, + ); + } + unsafe { + vtk_unstructured_grid_convert_face_stream_point_ids( + self.0, + nfaces, + faceStream, + idMap, + ) + } + } + fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_locations_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_cell_locations_array(self.0) } + } + fn set_cells( + &mut self, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_set_cells( + sself: *mut core::ffi::c_void, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unstructured_grid_set_cells(self.0, cellTypes, cellLocations, cells) + } + } + fn set_cells( + &mut self, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + faceLocations: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_set_cells( + sself: *mut core::ffi::c_void, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + faceLocations: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unstructured_grid_set_cells( + self.0, + cellTypes, + cellLocations, + cells, + faceLocations, + faces, + ) + } + } +} +impl VtkUnstructuredGridCellIterator for vtkUnstructuredGridCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_cell_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_cell_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_cell_iterator_new_instance(self.0) } + } + fn is_done_with_traversal(&mut self) -> bool { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_unstructured_grid_cell_iterator_is_done_with_traversal(self.0) } + } + fn get_cell_id(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_get_cell_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unstructured_grid_cell_iterator_get_cell_id(self.0) } + } + fn go_to_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_go_to_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ); + } + unsafe { vtk_unstructured_grid_cell_iterator_go_to_cell(self.0, cellId) } + } +} +impl VtkVertex for vtkVertex { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_get_face(self.0, p0) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_vertex_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_vertex_clip( + self.0, + value, + cellScalars, + locator, + pts, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_vertex_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_vertex_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_vertex_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn inflate(&mut self, p0: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_inflate( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_inflate(self.0, p0) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_cell_boundary(self.0, subId, pcoords, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_vertex_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_vertex_contour( + self.0, + value, + cellScalars, + locator, + verts1, + lines, + verts2, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_get_parametric_center(self.0, pcoords) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_vertex_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_vertex_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_vertex_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_vertex_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_vertex_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_vertex_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_vertex_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_vertex_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_vertex_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_vertex_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_vertex_interpolate_derivs(self.0, pcoords, derivs) } + } +} +impl VtkVertexListIterator for vtkVertexListIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_list_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_list_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_list_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_list_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_list_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_list_iterator_new_instance(self.0) } + } + fn set_graph(&mut self, graph: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_vertex_list_iterator_set_graph( + sself: *mut core::ffi::c_void, + graph: *mut core::ffi::c_void, + ); + } + unsafe { vtk_vertex_list_iterator_set_graph(self.0, graph) } + } + fn get_graph(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_list_iterator_get_graph( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_list_iterator_get_graph(self.0) } + } + fn next(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_vertex_list_iterator_next( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_vertex_list_iterator_next(self.0) } + } + fn has_next(&mut self) -> bool { + unsafe extern "C" { + fn vtk_vertex_list_iterator_has_next(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_vertex_list_iterator_has_next(self.0) } + } +} +impl VtkVoxel for vtkVoxel { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_voxel_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_voxel_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_voxel_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_voxel_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_voxel_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_voxel_new_instance(self.0) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_voxel_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_voxel_get_edge_points(self.0, edgeId, pts) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_voxel_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_voxel_get_edge_points(self.0, edgeId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_face_points(self.0, faceId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_voxel_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_voxel_get_face_points(self.0, faceId, pts) } + } + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_voxel_get_edge_to_adjacent_faces( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_voxel_get_edge_to_adjacent_faces(self.0, edgeId, pts) } + } + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faces: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_face_to_adjacent_faces( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + faces: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_face_to_adjacent_faces(self.0, faceId, faces) } + } + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edges: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_point_to_incident_edges( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + edges: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_point_to_incident_edges(self.0, pointId, edges) } + } + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faces: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_point_to_incident_faces( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + faces: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_point_to_incident_faces(self.0, pointId, faces) } + } + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_point_to_one_ring_points( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_point_to_one_ring_points(self.0, pointId, pts) } + } + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_voxel_get_centroid( + sself: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_voxel_get_centroid(self.0, centroid) } + } + fn compute_bounding_sphere( + &mut self, + center: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_voxel_compute_bounding_sphere( + sself: *mut core::ffi::c_void, + center: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_voxel_compute_bounding_sphere(self.0, center) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_voxel_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_voxel_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_voxel_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_voxel_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_cell_boundary(self.0, subId, pcoords, pts) } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_voxel_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_voxel_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_voxel_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_voxel_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_voxel_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_voxel_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_inflate( + sself: *mut core::ffi::c_void, + dist: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_inflate(self.0, dist) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_voxel_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_voxel_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_voxel_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_voxel_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_voxel_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_voxel_interpolate_derivs(self.0, pcoords, derivs) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_voxel_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_voxel_interpolation_functions(self.0, pcoords, weights) } + } + fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_get_triangle_cases( + sself: *mut core::ffi::c_void, + caseId: core::ffi::c_int, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_voxel_get_triangle_cases(self.0, caseId) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_face_array(self.0, faceId) } + } + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_edge_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_edge_to_adjacent_faces_array(self.0, edgeId) } + } + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_face_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_face_to_adjacent_faces_array(self.0, faceId) } + } + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_point_to_incident_edges_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_point_to_incident_edges_array(self.0, pointId) } + } + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_point_to_incident_faces_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_point_to_incident_faces_array(self.0, pointId) } + } + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_voxel_get_point_to_one_ring_points_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_voxel_get_point_to_one_ring_points_array(self.0, pointId) } + } + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_voxel_compute_centroid( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_voxel_compute_centroid(self.0, points, pointIds, centroid) } + } +} +impl VtkWedge for vtkWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_wedge_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_wedge_new_instance(self.0) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_wedge_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_wedge_get_edge_points(self.0, edgeId, pts) } + } + fn get_edge_points( + &mut self, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_wedge_get_edge_points( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_wedge_get_edge_points(self.0, edgeId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_face_points(self.0, faceId, pts) } + } + fn get_face_points( + &mut self, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_wedge_get_face_points( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + pts: core::ffi::c_int, + ); + } + unsafe { vtk_wedge_get_face_points(self.0, faceId, pts) } + } + fn get_edge_to_adjacent_faces( + &mut self, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_wedge_get_edge_to_adjacent_faces( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ); + } + unsafe { vtk_wedge_get_edge_to_adjacent_faces(self.0, edgeId, pts) } + } + fn get_face_to_adjacent_faces( + &mut self, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_face_to_adjacent_faces( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_face_to_adjacent_faces(self.0, faceId, faceIds) } + } + fn get_point_to_incident_edges( + &mut self, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_point_to_incident_edges( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + edgeIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_point_to_incident_edges(self.0, pointId, edgeIds) } + } + fn get_point_to_incident_faces( + &mut self, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_point_to_incident_faces( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + faceIds: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_point_to_incident_faces(self.0, pointId, faceIds) } + } + fn get_point_to_one_ring_points( + &mut self, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_point_to_one_ring_points( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + pts: core::ffi::c_uchar, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_point_to_one_ring_points(self.0, pointId, pts) } + } + fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_wedge_get_centroid( + sself: *mut core::ffi::c_void, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_wedge_get_centroid(self.0, centroid) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_wedge_get_face(self.0, faceId) } + } + fn cell_boundary( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_cell_boundary( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_cell_boundary(self.0, subId, pcoords, pts) } + } + fn evaluate_position( + &mut self, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_evaluate_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + closestPoint: core::ffi::c_double, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + dist2: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_wedge_evaluate_position( + self.0, + x, + closestPoint, + subId, + pcoords, + dist2, + weights, + ) + } + } + fn evaluate_location( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_wedge_evaluate_location( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + x: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_wedge_evaluate_location(self.0, subId, pcoords, x, weights) } + } + fn intersect_with_line( + &mut self, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_intersect_with_line( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + tol: core::ffi::c_double, + t: core::ffi::c_double, + x: core::ffi::c_double, + pcoords: core::ffi::c_double, + subId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_wedge_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_triangulate(self.0, index, ptIds, pts) } + } + fn derivatives( + &mut self, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_wedge_derivatives( + sself: *mut core::ffi::c_void, + subId: core::ffi::c_int, + pcoords: core::ffi::c_double, + values: core::ffi::c_double, + dim: core::ffi::c_int, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_wedge_derivatives(self.0, subId, pcoords, values, dim, derivs) } + } + fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_get_triangle_cases( + sself: *mut core::ffi::c_void, + caseId: core::ffi::c_int, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_wedge_get_triangle_cases(self.0, caseId) } + } + fn get_parametric_center( + &mut self, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_get_parametric_center( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_get_parametric_center(self.0, pcoords) } + } + fn interpolation_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_wedge_interpolation_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_wedge_interpolation_functions(self.0, pcoords, weights) } + } + fn interpolation_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_wedge_interpolation_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_wedge_interpolation_derivs(self.0, pcoords, derivs) } + } + fn interpolate_functions( + &mut self, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_wedge_interpolate_functions( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + weights: core::ffi::c_double, + ); + } + unsafe { vtk_wedge_interpolate_functions(self.0, pcoords, weights) } + } + fn interpolate_derivs( + &mut self, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_wedge_interpolate_derivs( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + derivs: core::ffi::c_double, + ); + } + unsafe { vtk_wedge_interpolate_derivs(self.0, pcoords, derivs) } + } + fn jacobian_inverse( + &mut self, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_jacobian_inverse( + sself: *mut core::ffi::c_void, + pcoords: core::ffi::c_double, + inverse: core::ffi::c_double, + derivs: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_jacobian_inverse(self.0, pcoords, inverse, derivs) } + } + fn get_edge_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_edge_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_edge_array(self.0, edgeId) } + } + fn get_face_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_face_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_face_array(self.0, faceId) } + } + fn get_edge_to_adjacent_faces_array( + &mut self, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_edge_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_edge_to_adjacent_faces_array(self.0, edgeId) } + } + fn get_face_to_adjacent_faces_array( + &mut self, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_face_to_adjacent_faces_array( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_face_to_adjacent_faces_array(self.0, faceId) } + } + fn get_point_to_incident_edges_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_point_to_incident_edges_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_point_to_incident_edges_array(self.0, pointId) } + } + fn get_point_to_incident_faces_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_point_to_incident_faces_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_point_to_incident_faces_array(self.0, pointId) } + } + fn get_point_to_one_ring_points_array( + &mut self, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_wedge_get_point_to_one_ring_points_array( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_wedge_get_point_to_one_ring_points_array(self.0, pointId) } + } + fn compute_centroid( + &mut self, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_wedge_compute_centroid( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + pointIds: core::ffi::c_uchar, + centroid: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_wedge_compute_centroid(self.0, points, pointIds, centroid) } + } +} +impl VtkXMLDataElement for vtkXMLDataElement { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_new(self.0) } + } + fn get_name(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_xml_data_element_get_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_xml_data_element_get_name(self.0) } + } + fn set_name(&mut self, _arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_name( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { vtk_xml_data_element_set_name(self.0, _arg) } + } + fn get_id(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_xml_data_element_get_id( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_xml_data_element_get_id(self.0) } + } + fn set_id(&mut self, _arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_id( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_char, + ); + } + unsafe { vtk_xml_data_element_set_id(self.0, _arg) } + } + fn get_attribute(&mut self, name: core::ffi::c_char) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_xml_data_element_get_attribute(self.0, name) } + } + fn set_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_char, + ); + } + unsafe { vtk_xml_data_element_set_attribute(self.0, name, value) } + } + fn set_character_data( + &mut self, + data: core::ffi::c_char, + length: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_character_data( + sself: *mut core::ffi::c_void, + data: core::ffi::c_char, + length: core::ffi::c_int, + ); + } + unsafe { vtk_xml_data_element_set_character_data(self.0, data, length) } + } + fn add_character_data(&mut self, c: core::ffi::c_char, length: usize) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_add_character_data( + sself: *mut core::ffi::c_void, + c: core::ffi::c_char, + length: usize, + ); + } + unsafe { vtk_xml_data_element_add_character_data(self.0, c, length) } + } + fn get_character_data(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_xml_data_element_get_character_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_xml_data_element_get_character_data(self.0) } + } + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_scalar_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } + } + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_float, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_scalar_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_float, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } + } + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_scalar_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } + } + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_long, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_scalar_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_long, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } + } + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_ulong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_scalar_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_ulong, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } + } + fn set_int_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_int_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_int, + ); + } + unsafe { vtk_xml_data_element_set_int_attribute(self.0, name, value) } + } + fn set_float_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_float_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_float, + ); + } + unsafe { vtk_xml_data_element_set_float_attribute(self.0, name, value) } + } + fn set_double_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_double_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { vtk_xml_data_element_set_double_attribute(self.0, name, value) } + } + fn set_unsigned_long_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_ulong, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_unsigned_long_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_ulong, + ); + } + unsafe { vtk_xml_data_element_set_unsigned_long_attribute(self.0, name, value) } + } + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } + } + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_float, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_float, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } + } + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } + } + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_long, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_long, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } + } + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulong, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } + } + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_int, + ); + } + unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } + } + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_float, + ); + } + unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } + } + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } + } + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulong, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulong, + ); + } + unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } + } + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_scalar_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } + } + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_uchar, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } + } + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_uchar, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_uchar, + ); + } + unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } + } + fn get_scalar_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_ulonglong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_scalar_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } + } + fn get_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulonglong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } + } + fn set_vector_attribute( + &mut self, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulonglong, + ) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_vector_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + length: core::ffi::c_int, + value: core::ffi::c_ulonglong, + ); + } + unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } + } + fn get_word_type_attribute( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_word_type_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_word_type_attribute(self.0, name, value) } + } + fn get_number_of_attributes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_number_of_attributes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_number_of_attributes(self.0) } + } + fn get_attribute_name(&mut self, idx: core::ffi::c_int) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute_name( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_xml_data_element_get_attribute_name(self.0, idx) } + } + fn get_attribute_value( + &mut self, + idx: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_xml_data_element_get_attribute_value(self.0, idx) } + } + fn remove_attribute(&mut self, name: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_remove_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ); + } + unsafe { vtk_xml_data_element_remove_attribute(self.0, name) } + } + fn remove_all_attributes(&mut self) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_remove_all_attributes(sself: *mut core::ffi::c_void); + } + unsafe { vtk_xml_data_element_remove_all_attributes(self.0) } + } + fn get_parent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_get_parent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_get_parent(self.0) } + } + fn set_parent(&mut self, parent: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_parent( + sself: *mut core::ffi::c_void, + parent: *mut core::ffi::c_void, + ); + } + unsafe { vtk_xml_data_element_set_parent(self.0, parent) } + } + fn get_root(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_get_root( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_get_root(self.0) } + } + fn get_number_of_nested_elements(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_number_of_nested_elements( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_number_of_nested_elements(self.0) } + } + fn get_nested_element(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_get_nested_element( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_get_nested_element(self.0, index) } + } + fn add_nested_element(&mut self, element: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_add_nested_element( + sself: *mut core::ffi::c_void, + element: *mut core::ffi::c_void, + ); + } + unsafe { vtk_xml_data_element_add_nested_element(self.0, element) } + } + fn remove_nested_element(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_remove_nested_element( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_xml_data_element_remove_nested_element(self.0, p0) } + } + fn remove_all_nested_elements(&mut self) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_remove_all_nested_elements( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_xml_data_element_remove_all_nested_elements(self.0) } + } + fn find_nested_element(&mut self, id: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_find_nested_element( + sself: *mut core::ffi::c_void, + id: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_find_nested_element(self.0, id) } + } + fn find_nested_element_with_name( + &mut self, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_find_nested_element_with_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_find_nested_element_with_name(self.0, name) } + } + fn find_nested_element_with_name_and_id( + &mut self, + name: core::ffi::c_char, + id: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_find_nested_element_with_name_and_id( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + id: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_xml_data_element_find_nested_element_with_name_and_id(self.0, name, id) + } + } + fn find_nested_element_with_name_and_attribute( + &mut self, + name: core::ffi::c_char, + att_name: core::ffi::c_char, + att_value: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_find_nested_element_with_name_and_attribute( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + att_name: core::ffi::c_char, + att_value: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_xml_data_element_find_nested_element_with_name_and_attribute( + self.0, + name, + att_name, + att_value, + ) + } + } + fn lookup_element_with_name( + &mut self, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_lookup_element_with_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_lookup_element_with_name(self.0, name) } + } + fn lookup_element(&mut self, id: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_lookup_element( + sself: *mut core::ffi::c_void, + id: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_lookup_element(self.0, id) } + } + fn get_xml_byte_index(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_xml_data_element_get_xml_byte_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_xml_data_element_get_xml_byte_index(self.0) } + } + fn set_xml_byte_index(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_xml_byte_index( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_xml_data_element_set_xml_byte_index(self.0, _arg) } + } + fn is_equal_to(&mut self, elem: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_is_equal_to( + sself: *mut core::ffi::c_void, + elem: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_is_equal_to(self.0, elem) } + } + fn deep_copy(&mut self, elem: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_deep_copy( + sself: *mut core::ffi::c_void, + elem: *mut core::ffi::c_void, + ); + } + unsafe { vtk_xml_data_element_deep_copy(self.0, elem) } + } + fn set_attribute_encoding(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_attribute_encoding( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_xml_data_element_set_attribute_encoding(self.0, _arg) } + } + fn get_attribute_encoding_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute_encoding_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_attribute_encoding_min_value(self.0) } + } + fn get_attribute_encoding_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute_encoding_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_attribute_encoding_max_value(self.0) } + } + fn get_attribute_encoding(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute_encoding( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_attribute_encoding(self.0) } + } + fn print_xml(&mut self, fname: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_print_xml( + sself: *mut core::ffi::c_void, + fname: core::ffi::c_char, + ); + } + unsafe { vtk_xml_data_element_print_xml(self.0, fname) } + } + fn get_character_data_width(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_character_data_width( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_character_data_width(self.0) } + } + fn set_character_data_width(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_character_data_width( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_xml_data_element_set_character_data_width(self.0, _arg) } + } +} /// container of vtkUniformGrid for an AMR data set /// /// @@ -1254,7 +72101,7 @@ fn test_vtkBox_create_drop() { /// /// While this class provides traversal methods (the legacy InitTraversal(), /// GetNextCell() methods, and the newer method GetCellAtId()) these are in -/// general not thread-safe. Whenever possible it is preferable to use a +/// general not thread-safe. Whenever possible it is preferrable to use a /// local thread-safe, vtkCellArrayIterator object, which can be obtained via: /// /// ```cpp,ignore @@ -1481,9 +72328,6 @@ fn test_vtkCellArrayIterator_create_drop() { /// coordinates, etc.) Special methods are provided to work with filter /// objects, such as passing data through filter, copying data from one /// cell to another, and interpolating data given cell interpolation weights. -/// -/// By default, `GhostTypesToSkip` is set to `DUPLICATECELL | HIDDENCELL | REFINEDCELL`. -/// See `vtkDataSetAttributes` for the definition of those constants. #[allow(non_camel_case_types)] pub struct vtkCellData(*mut core::ffi::c_void); impl vtkCellData { @@ -1605,20 +72449,17 @@ fn test_vtkCellLinks_create_drop() { /// candidate cells. /// /// @warning -/// vtkCellLocator utilizes the following parent class parameters: -/// - Automatic (default true) -/// - Level (default 8) -/// - MaxLevel (default 8) -/// - NumberOfCellsPerNode (default 25) -/// - CacheCellBounds (default true) -/// - UseExistingSearchStructure (default false) -/// -/// vtkCellLocator does NOT utilize the following parameters: -/// - Tolerance -/// - RetainCellLists +/// Many other types of spatial locators have been developed, such as +/// variable depth octrees and kd-trees. These are often more efficient +/// for the operations described here. vtkCellLocator has been designed +/// for subclassing; so these locators can be derived if necessary. +/// +/// @warning +/// Most of the methods of this class are not thread-safe. For a thread-safe, +/// more efficient generic implementation, please use vtkStaticCellLocator /// /// @sa -/// vtkAbstractCellLocator vtkStaticCellLocator vtkCellTreeLocator vtkModifiedBSPTree vtkOBBTree +/// vtkLocator vtkPointLocator vtkOBBTree vtkStaticCellLocator #[allow(non_camel_case_types)] pub struct vtkCellLocator(*mut core::ffi::c_void); impl vtkCellLocator { @@ -1719,84 +72560,6 @@ fn test_vtkCellLocatorStrategy_create_drop() { let new_obj = vtkCellLocatorStrategy(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } -/// This class implements the data structures, construction -/// -/// algorithms for fast cell location. -/// -/// Cell Tree is a bounding interval hierarchy based data structure, where child boxes -/// do not form an exact split of the parent boxes along a dimension. Therefore two axis- -/// aligned bounding planes (left max and right min) are stored for each node along a -/// dimension. This class implements the data structure (Cell Tree Node) and its build -/// and traversal algorithms described in the paper. -/// Some methods in building and traversing the cell tree in this class were derived -/// from avtCellLocatorBIH class in the VisIT Visualization Tool. -/// -/// vtkCellTreeLocator utilizes the following parent class parameters: -/// - NumberOfCellsPerNode (default 8) -/// - CacheCellBounds (default true) -/// - UseExistingSearchStructure (default false) -/// -/// vtkCellTreeLocator does NOT utilize the following parameters: -/// - Automatic -/// - Level -/// - MaxLevel -/// - Tolerance -/// - RetainCellLists -/// -/// @warning -/// This class is templated. It may run slower than serial execution if the code -/// is not optimized during compilation. Build in Release or ReleaseWithDebugInfo. -/// -/// From the article: "Fast, Memory-Efficient Cell location in Unstructured Grids for Visualization" -/// by Christoph Garth and Kenneth I. Joy in VisWeek, 2011. -/// -/// @sa -/// vtkAbstractCellLocator vtkCellLocator vtkStaticCellLocator vtkModifiedBSPTree vtkOBBTree -#[allow(non_camel_case_types)] -pub struct vtkCellTreeLocator(*mut core::ffi::c_void); -impl vtkCellTreeLocator { - /// Creates a new [vtkCellTreeLocator] wrapped inside `vtkNew` - #[doc(alias = "vtkCellTreeLocator")] - pub fn new() -> Self { - unsafe extern "C" { - fn vtkCellTreeLocator_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkCellTreeLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellTreeLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellTreeLocator_get_ptr(self.0) } - } -} -impl std::default::Default for vtkCellTreeLocator { - fn default() -> Self { - Self::new() - } -} -impl Drop for vtkCellTreeLocator { - fn drop(&mut self) { - unsafe extern "C" { - fn vtkCellTreeLocator_destructor(sself: *mut core::ffi::c_void); - } - unsafe { vtkCellTreeLocator_destructor(self.0) } - self.0 = core::ptr::null_mut(); - } -} -#[test] -fn test_vtkCellTreeLocator_create_drop() { - let obj = vtkCellTreeLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); - drop(obj); - let new_obj = vtkCellTreeLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); -} /// object provides direct access to cells in vtkCellArray and type information /// /// @@ -2088,69 +72851,6 @@ fn test_vtkConvexPointSet_create_drop() { let new_obj = vtkConvexPointSet(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } -/// implicit function for a right-handed coordinate system -/// -/// -/// vtkCoordinateFrame computes an implicit function and function gradient -/// for a set of 3 orthogonal planes. -/// -/// The function evaluates to a combination of quartic spherical harmonic -/// basis functions: -/// \f$\sqrt(\frac{7}{12})*Y_{4,0} + \sqrt(\frac{5}{12})*Y_{4,4}\f$ -/// that – when evaluated on a unit sphere centered at the coordinate frame's -/// origin – form a 6-lobed function with a maximum along each of the -/// 6 axes (3 positive, 3 negative). -/// This function is frequently used in frame-field design. -/// -/// See the paper "On Smooth Frame Field Design" by Nicolas Ray and -/// Dmitry Sokolov (2016, hal-01245657, -/// https://hal.inria.fr/hal-01245657/file/framefield.pdf ) for more -/// information. -#[allow(non_camel_case_types)] -pub struct vtkCoordinateFrame(*mut core::ffi::c_void); -impl vtkCoordinateFrame { - /// Creates a new [vtkCoordinateFrame] wrapped inside `vtkNew` - #[doc(alias = "vtkCoordinateFrame")] - pub fn new() -> Self { - unsafe extern "C" { - fn vtkCoordinateFrame_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkCoordinateFrame_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCoordinateFrame_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCoordinateFrame_get_ptr(self.0) } - } -} -impl std::default::Default for vtkCoordinateFrame { - fn default() -> Self { - Self::new() - } -} -impl Drop for vtkCoordinateFrame { - fn drop(&mut self) { - unsafe extern "C" { - fn vtkCoordinateFrame_destructor(sself: *mut core::ffi::c_void); - } - unsafe { vtkCoordinateFrame_destructor(self.0) } - self.0 = core::ptr::null_mut(); - } -} -#[test] -fn test_vtkCoordinateFrame_create_drop() { - let obj = vtkCoordinateFrame::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); - drop(obj); - let new_obj = vtkCoordinateFrame(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); -} /// cell represents a cubic , isoparametric 1D line /// /// @@ -2228,9 +72928,6 @@ fn test_vtkCubicLine_create_drop() { /// The cylinder is infinite in extent. To truncate the cylinder in /// modeling operations use the vtkImplicitBoolean in combination with /// clipping planes. -/// -/// @sa -/// vtkCylinderSource #[allow(non_camel_case_types)] pub struct vtkCylinder(*mut core::ffi::c_void); impl vtkCylinder { @@ -2354,11 +73051,11 @@ fn test_vtkCylinder_create_drop() { /// nodes rather than the nodes themselves. /// /// * '/nodename1/nodename2' selects all nodes named 'nodename2' which are -/// children of nodes with name 'nodename1' that are themselves children of -/// the root node. +/// childen of nodes with name 'nodename1' that are themselves children of the +/// root node. /// /// * '//nodename1/nodename2' finds all nodes in the tree named 'nodename1' and -/// then selects all children of these found nodes that are named 'nodename2'. +/// then selects all chidren of these found nodes that are named 'nodename2'. /// /// @section Applications Applications /// @@ -3873,9 +74570,6 @@ fn test_vtkHexahedron_create_drop() { } /// Empty class for backwards compatibility. /// -/// -/// @deprecated vtkHierarchicalBoxDataIterator is deprecated in VTK 9.2 and will be removed. -/// Use `vtkUniformGridAMRDataIterator` instead of `vtkHierarchicalBoxDataIterator`. #[allow(non_camel_case_types)] pub struct vtkHierarchicalBoxDataIterator(*mut core::ffi::c_void); impl vtkHierarchicalBoxDataIterator { @@ -4663,7 +75357,7 @@ fn test_vtkImageData_create_drop() { /// /// vtkImageTransform is a helper class to transform the output of /// image filters (i.e., filter that input vtkImageData) by applying the -/// Index to Physical transformation from the input image, which can +/// Index to Physical transformation frmo the input image, which can /// include origin, spacing, direction. The transformation process is /// threaded with vtkSMPTools for performance. /// @@ -7671,10 +78365,7 @@ fn test_vtkPlanesIntersection_create_drop() { /// vtkPointData is a class that is used to represent and manipulate /// point attribute data (e.g., scalars, vectors, normals, texture /// coordinates, etc.) Most of the functionality is handled by -/// vtkDataSetAttributes. -/// -/// By default, `GhostTypesToSkip` is set to `DUPLICATEPOINT | HIDDENPOINT`. -/// See `vtkDataSetAttributes` for the definition of those constants. +/// vtkDataSetAttributes #[allow(non_camel_case_types)] pub struct vtkPointData(*mut core::ffi::c_void); impl vtkPointData { @@ -7739,13 +78430,6 @@ fn test_vtkPointData_create_drop() { /// octrees and kd-trees. These are often more efficient for the /// operations described here. /// -/// @warning -/// Frequently vtkStaticPointLocator is used in lieu of vtkPointLocator. -/// They are very similar in terms of algorithmic approach, however -/// vtkStaticCellLocator is threaded and is typically much faster for -/// a large number of points (on the order of 3-5x faster). For small numbers -/// of points, vtkPointLocator is just as fast as vtkStaticPointLocator. -/// /// @sa /// vtkCellPicker vtkPointPicker vtkStaticPointLocator #[allow(non_camel_case_types)] @@ -8340,7 +79024,7 @@ fn test_vtkPolygon_create_drop() { /// definitely cause problems, especially in severely warped situations. /// /// @sa -/// vtkCell3D vtkConvexPointSet vtkMeanValueCoordinatesInterpolator +/// vtkCell3D vtkConvecPointSet vtkMeanValueCoordinatesInterpolator #[allow(non_camel_case_types)] pub struct vtkPolyhedron(*mut core::ffi::c_void); impl vtkPolyhedron { @@ -9128,7 +79812,7 @@ fn test_vtkQuadraticWedge_create_drop() { /// /// 2) /// The number of quadrature points and cell nodes. These parameters -/// size the matrix, and allow for convenient evaluation by users +/// size the matrix, and allow for convinent evaluation by users /// of the definition. /// #[allow(non_camel_case_types)] @@ -9589,7 +80273,7 @@ fn test_vtkSelection_create_drop() { /// qualifiers, and information. The core properties must be specified other wise the /// vtkSelectionNode is not considered valid. These are `FIELD_TYPE` and /// `CONTENT_TYPE`. `FIELD_TYPE` defines what kinds of entities are being selected. -/// Since selections are used to select items in a data-object, these correspond to +/// Since selections are used select items in a data-object, these correspond to /// things like cells, points, nodes, edges, rows, etc. Supported FIELD_TYPE /// values are defined in `vtkSelectionNode::SelectionField`. `CONTENT_TYPE` /// defines the how the selection is described. Supported values are @@ -9622,7 +80306,7 @@ fn test_vtkSelection_create_drop() { /// using vtkDataSetAttributes API. Since global ids are expected to be unique /// for that element type over the entire dataset, it's a convenient way of /// defining selections. For this content-type, the selection list must be -/// a single-component, `vtkIdTypeArray` that lists all the globals ids for +/// to a single-component, `vtkIdTypeArray` that lists all the globals ids for /// the selected elements. /// /// * `vtkSelectionNode::PEDIGREEIDS`: similar to `GLOBALIDS` except uses @@ -9647,14 +80331,14 @@ fn test_vtkSelection_create_drop() { /// `BLOCK_SELECTORS`, `PROCESS_ID` etc. are needed to correctly identify the /// chosen element(s) in case of composite or distributed datasets. /// -/// * `vtkSelectionNode::FRUSTUM`: this type is used to define a frustum in world +/// * `vtkSelectionNode::FRUSTUM: this type is used to define a frustum in world /// coordinates that identifies the selected elements. In this case, the /// selection list is a vtkDoubleArray with 32 values specifying the 8 frustum /// corners in homogeneous world coordinates. /// /// * `vtkSelectionNode::LOCATIONS`: this is used to select points (or cells) /// near (or containing) specified locations. The selection list is a -/// 3-component vtkDoubleArray with coordinates for locations of interest. +/// 3-compnent vtkDoubleArray with coordinates for locations of interest. /// /// * `vtkSelectionNode::THRESHOLDS`: this type is used to define a selection based /// on array value ranges. This is akin to thresholding. All elements with values in @@ -10124,106 +80808,6 @@ fn test_vtkSpheres_create_drop() { let new_obj = vtkSpheres(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } -/// Traverse a collection of points in spherical ordering. -/// -/// -/// -/// vtkSphericalPointIterator is a state-based iterator for traversing a set -/// of points (i.e., a neighborhood of points) in a dataset, providing a point -/// traversal order across user-defined "axes" which span a 2D or 3D space -/// (typically a circle or sphere). The points along each axes may be sorted -/// in increasing radial order. To define the points, specify a dataset (i.e., -/// its associated points, whether the points are represented implicitly or -/// explicitly) and an associated neighborhood over which to iterate. Methods -/// for iterating over the points are provided. -/// -/// For example, consider the axes of iteration to be the four rays emanating -/// from the center of a square and passing through the center of each of the -/// four edges of the square. Points to be iterated over are associated (using -/// a dot product) with each of the four axes, and then can be sorted along -/// each axis. Then the order of iteration is then: (axis0,pt0), (axis1,pt0), -/// (axis2,pt0), (axis3,pt0), (axis0,pt1), (axis1,pt1), (axis2,pt1), -/// (axis3,pt1), (axis0,pt2), (axis1,pt2), (axis2,pt2), (axis3,pt2), and so on -/// in a "spiraling" fashion until all points are visited. Thus the order of -/// visitation is: iteration i visits all N axes in order, returning the jth -/// point sorted along each of the N axes (i.e., i increases the fastest). -/// Alternatively, methods exist to randomly access points, or points -/// associated with an axes, so that custom iteration methods can be defined. -/// -/// The iterator can be defined with any number of axes (defined by 3D -/// vectors). The axes must not be coincident, and typically are equally -/// spaced from one another. The order which the axes are defined determines -/// the order in which the axes (and hence the points) are traversed. So for -/// example, in a 2D sphere, four axes in the (-x,+x,-y,+y) directions would -/// provide a "ping pong" iteration, while four axes ordered in the -/// (+x,+y,-x,-y) directions would provide a counterclockwise rotation -/// iteration. -/// -/// The iterator provides thread-safe iteration of dataset points. It supports -/// both random and forward iteration. -/// -/// @warning -/// The behavior of the iterator depends on the ordering of the iteration -/// axes. It is possible to obtain a wide variety of iteration patterns -/// depending on these axes. For example, if only one axis is defined, then a -/// "linear" pattern is possible (i.e., visiting points in the half space -/// defined by the vector); if two axes, then a "diagonal" iteration pattern; -/// and so on. Note that points are sorted along the iteration axes depending -/// on the their projection onto them (e.g., using the dot product). Because -/// only points with positive projection are associated with an axis, it is -/// possible that some points in the neighborhood will not be processed (i.e., -/// if a point in the neighborhood does not positively project onto any of the -/// axes, then it will not be iterated over). Thus if all points are to be -/// iterated over, then the axes must form a basis which covers all points -/// using positive projections. -/// -/// @sa -/// vtkVoronoi2D vtkVoronoi3D vtkStaticPointLocator vtkPointLocator -#[allow(non_camel_case_types)] -pub struct vtkSphericalPointIterator(*mut core::ffi::c_void); -impl vtkSphericalPointIterator { - /// Creates a new [vtkSphericalPointIterator] wrapped inside `vtkNew` - #[doc(alias = "vtkSphericalPointIterator")] - pub fn new() -> Self { - unsafe extern "C" { - fn vtkSphericalPointIterator_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkSphericalPointIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSphericalPointIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSphericalPointIterator_get_ptr(self.0) } - } -} -impl std::default::Default for vtkSphericalPointIterator { - fn default() -> Self { - Self::new() - } -} -impl Drop for vtkSphericalPointIterator { - fn drop(&mut self) { - unsafe extern "C" { - fn vtkSphericalPointIterator_destructor(sself: *mut core::ffi::c_void); - } - unsafe { vtkSphericalPointIterator_destructor(self.0) } - self.0 = core::ptr::null_mut(); - } -} -#[test] -fn test_vtkSphericalPointIterator_create_drop() { - let obj = vtkSphericalPointIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); - drop(obj); - let new_obj = vtkSphericalPointIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); -} /// object represents upward pointers from points /// /// to list of cells using each point @@ -10307,24 +80891,15 @@ fn test_vtkStaticCellLinks_create_drop() { /// (i.e., incremental cell insertion is not supported). /// /// @warning -/// vtkStaticCellLocator utilizes the following parent class parameters: -/// - Automatic (default true) -/// - NumberOfCellsPerNode (default 10) -/// - UseExistingSearchStructure (default false) -/// -/// vtkStaticCellLocator does NOT utilize the following parameters: -/// - CacheCellBounds (always cached) -/// - Tolerance -/// - Level -/// - MaxLevel -/// - RetainCellLists -/// -/// @warning /// This class is templated. It may run slower than serial execution if the code /// is not optimized during compilation. Build in Release or ReleaseWithDebugInfo. /// +/// @warning +/// This class *always* caches cell bounds. +/// /// @sa -/// vtkAbstractCellLocator vtkCellLocator vtkCellTreeLocator vtkModifiedBSPTree vtkOBBTree +/// vtkLocator vakAbstractCellLocator vtkCellLocator vtkCellTreeLocator +/// vtkModifiedBSPTree #[allow(non_camel_case_types)] pub struct vtkStaticCellLocator(*mut core::ffi::c_void); impl vtkStaticCellLocator { @@ -10400,13 +80975,6 @@ fn test_vtkStaticCellLocator_create_drop() { /// kd-trees. These are often more efficient for the operations described /// here. /// -/// @warning -/// Frequently vtkStaticPointLocator is used in lieu of vtkPointLocator. -/// They are very similar in terms of algorithmic approach, however -/// vtkStaticCellLocator is threaded and is typically much faster for -/// a large number of points (on the order of 3-5x faster). For small numbers -/// of points, vtkPointLocator is just as fast as vtkStaticPointLocator. -/// /// @sa /// vtkPointLocator vtkCellLocator vtkLocator vtkAbstractPointLocator #[allow(non_camel_case_types)] @@ -10663,7 +81231,7 @@ fn test_vtkStructuredGrid_create_drop() { /// /// /// StructuredPoints is a subclass of ImageData that requires the data extent -/// to exactly match the update extent. Normal image data allows that the +/// to exactly match the update extent. Normall image data allows that the /// data extent may be larger than the update extent. /// StructuredPoints also defines the origin differently that vtkImageData. /// For structured points the origin is the location of first point. @@ -10844,11 +81412,6 @@ fn test_vtkSuperquadric_create_drop() { /// has the same number of entries, and provides row access (using vtkVariantArray) /// and single entry access (using vtkVariant). /// -/// Inserting or removing rows via the class API preserves existing table data where possible. -/// -/// The "RemoveRow*" and SetNumberOfRows() operations will not release memory. Call on SqueezeRows() -/// to achieve this after performing the operations. -/// /// The field data inherited from vtkDataObject may be used to store metadata /// related to the table. /// @@ -11246,7 +81809,7 @@ fn test_vtkTriQuadraticHexahedron_create_drop() { let new_obj = vtkTriQuadraticHexahedron(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } -/// cell represents a parabolic, 19-node isoparametric pyramid +/// cell represents a parabolic, 13-node isoparametric pyramid /// /// /// vtkTriQuadraticPyramid is a concrete implementation of vtkNonLinearCell to @@ -11581,13 +82144,7 @@ fn test_vtkUniformGrid_create_drop() { let new_obj = vtkUniformGrid(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } -/// a concrete implementation of vtkCompositeDataSet -/// /// -/// vtkUniformGridAMR is an AMR (hierarchical) composite dataset that holds vtkUniformGrids. -/// -/// @sa -/// vtkUniformGridAMRDataIterator #[allow(non_camel_case_types)] pub struct vtkUniformGridAMR(*mut core::ffi::c_void); impl vtkUniformGridAMR { diff --git a/vtk-rs-9.1/src/vtkCommonExecutionModel.rs b/vtk-rs-9.1/src/vtkCommonExecutionModel.rs index 6846309..3fd1d99 100644 --- a/vtk-rs-9.1/src/vtkCommonExecutionModel.rs +++ b/vtk-rs-9.1/src/vtkCommonExecutionModel.rs @@ -1,3 +1,8960 @@ +pub trait VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn has_executive(&mut self) -> core::ffi::c_int; + fn get_executive(&mut self) -> *mut core::ffi::c_void; + fn set_executive(&mut self, executive: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn compute_pipeline_m_time( + &mut self, + request: *mut core::ffi::c_void, + inInfoVec: *mut core::ffi::c_void, + outInfoVec: *mut core::ffi::c_void, + requestFromOutputPort: core::ffi::c_int, + mtime: core::ffi::c_ulong, + ) -> core::ffi::c_int; + fn modify_request( + &mut self, + request: *mut core::ffi::c_void, + when: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_input_port_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_output_port_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_information(&mut self) -> *mut core::ffi::c_void; + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_number_of_input_ports(&mut self) -> core::ffi::c_int; + fn get_number_of_output_ports(&mut self) -> core::ffi::c_int; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn set_abort_execute(&mut self, _arg: core::ffi::c_int) -> (); + fn get_abort_execute(&mut self) -> core::ffi::c_int; + fn abort_execute_on(&mut self) -> (); + fn abort_execute_off(&mut self) -> (); + fn get_progress(&mut self) -> core::ffi::c_double; + fn set_progress(&mut self, p0: core::ffi::c_double) -> (); + fn update_progress(&mut self, amount: core::ffi::c_double) -> (); + fn set_progress_shift_scale( + &mut self, + shift: core::ffi::c_double, + scale: core::ffi::c_double, + ) -> (); + fn get_progress_shift(&mut self) -> core::ffi::c_double; + fn get_progress_scale(&mut self) -> core::ffi::c_double; + fn set_progress_text(&mut self, ptext: core::ffi::c_char) -> (); + fn get_progress_text(&mut self) -> *mut core::ffi::c_char; + fn get_error_code(&mut self) -> core::ffi::c_ulong; + fn input_is_optional(&mut self) -> *mut core::ffi::c_void; + fn input_is_repeatable(&mut self) -> *mut core::ffi::c_void; + fn input_required_fields(&mut self) -> *mut core::ffi::c_void; + fn input_required_data_type(&mut self) -> *mut core::ffi::c_void; + fn input_arrays_to_process(&mut self) -> *mut core::ffi::c_void; + fn input_port(&mut self) -> *mut core::ffi::c_void; + fn input_connection(&mut self) -> *mut core::ffi::c_void; + fn can_produce_sub_extent(&mut self) -> *mut core::ffi::c_void; + fn can_handle_piece_request(&mut self) -> *mut core::ffi::c_void; + fn set_input_array_to_process( + &mut self, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_int, + name: core::ffi::c_char, + ) -> (); + fn set_input_array_to_process( + &mut self, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_int, + fieldAttributeType: core::ffi::c_int, + ) -> (); + fn set_input_array_to_process( + &mut self, + idx: core::ffi::c_int, + info: *mut core::ffi::c_void, + ) -> (); + fn set_input_array_to_process( + &mut self, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_char, + attributeTypeorName: core::ffi::c_char, + ) -> (); + fn get_input_array_information( + &mut self, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn remove_all_inputs(&mut self) -> (); + fn get_output_data_object( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_data_object( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> (); + fn set_input_connection(&mut self, input: *mut core::ffi::c_void) -> (); + fn add_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> (); + fn add_input_connection(&mut self, input: *mut core::ffi::c_void) -> (); + fn remove_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> (); + fn remove_input_connection( + &mut self, + port: core::ffi::c_int, + idx: core::ffi::c_int, + ) -> (); + fn remove_all_input_connections(&mut self, port: core::ffi::c_int) -> (); + fn set_input_data_object( + &mut self, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ) -> (); + fn set_input_data_object(&mut self, data: *mut core::ffi::c_void) -> (); + fn add_input_data_object( + &mut self, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ) -> (); + fn add_input_data_object(&mut self, data: *mut core::ffi::c_void) -> (); + fn get_output_port(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_output_port(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_input_connections( + &mut self, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_total_number_of_input_connections(&mut self) -> core::ffi::c_int; + fn get_input_connection( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_algorithm( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + algPort: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_algorithm( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_algorithm(&mut self) -> *mut core::ffi::c_void; + fn get_input_executive( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_executive(&mut self) -> *mut core::ffi::c_void; + fn get_input_information( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_information(&mut self) -> *mut core::ffi::c_void; + fn get_output_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn update(&mut self, port: core::ffi::c_int) -> (); + fn update(&mut self) -> (); + fn update( + &mut self, + port: core::ffi::c_int, + requests: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn update(&mut self, requests: *mut core::ffi::c_void) -> core::ffi::c_int; + fn update_piece( + &mut self, + piece: core::ffi::c_int, + numPieces: core::ffi::c_int, + ghostLevels: core::ffi::c_int, + extents: core::ffi::c_int, + ) -> core::ffi::c_int; + fn update_extent(&mut self, extents: core::ffi::c_int) -> core::ffi::c_int; + fn update_time_step( + &mut self, + time: core::ffi::c_double, + piece: core::ffi::c_int, + numPieces: core::ffi::c_int, + ghostLevels: core::ffi::c_int, + extents: core::ffi::c_int, + ) -> core::ffi::c_int; + fn update_information(&mut self) -> (); + fn update_data_object(&mut self) -> (); + fn propagate_update_extent(&mut self) -> (); + fn update_whole_extent(&mut self) -> (); + fn convert_total_input_to_port_connection( + &mut self, + ind: core::ffi::c_int, + port: core::ffi::c_int, + conn: core::ffi::c_int, + ) -> (); + fn set_release_data_flag(&mut self, p0: core::ffi::c_int) -> (); + fn get_release_data_flag(&mut self) -> core::ffi::c_int; + fn release_data_flag_on(&mut self) -> (); + fn release_data_flag_off(&mut self) -> (); + fn update_extent_is_empty( + &mut self, + pinfo: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn update_extent_is_empty( + &mut self, + pinfo: *mut core::ffi::c_void, + extentType: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_default_executive_prototype(&mut self, proto: *mut core::ffi::c_void) -> (); + fn get_update_extent(&mut self) -> *mut core::ffi::c_int; + fn get_update_extent(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_int; + fn get_update_extent( + &mut self, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> (); + fn get_update_extent( + &mut self, + port: core::ffi::c_int, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> (); + fn get_update_extent(&mut self, extent: core::ffi::c_int) -> (); + fn get_update_extent( + &mut self, + port: core::ffi::c_int, + extent: core::ffi::c_int, + ) -> (); + fn get_update_piece(&mut self) -> core::ffi::c_int; + fn get_update_piece(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; + fn get_update_number_of_pieces(&mut self) -> core::ffi::c_int; + fn get_update_number_of_pieces( + &mut self, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_update_ghost_level(&mut self) -> core::ffi::c_int; + fn get_update_ghost_level(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; + fn set_progress_observer(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_progress_observer(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkAlgorithmOutput { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_index(&mut self, index: core::ffi::c_int) -> (); + fn get_index(&mut self) -> core::ffi::c_int; + fn get_producer(&mut self) -> *mut core::ffi::c_void; + fn set_producer(&mut self, producer: *mut core::ffi::c_void) -> (); +} +pub trait VtkAnnotationLayersAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkArrayDataAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkCachedStreamingDemandDrivenPipeline: VtkStreamingDemandDrivenPipeline + VtkDemandDrivenPipeline + VtkExecutive { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_cache_size(&mut self, size: core::ffi::c_int) -> (); + fn get_cache_size(&mut self) -> core::ffi::c_int; +} +pub trait VtkCastToConcrete: VtkDataSetAlgorithm + VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCompositeDataPipeline: VtkStreamingDemandDrivenPipeline + VtkDemandDrivenPipeline + VtkExecutive { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_composite_output_data( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_composite_input_data( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + inInfoVec: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn load_requested_blocks(&mut self) -> *mut core::ffi::c_void; + fn composite_data_meta_data(&mut self) -> *mut core::ffi::c_void; + fn update_composite_indices(&mut self) -> *mut core::ffi::c_void; + fn block_amount_of_detail(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCompositeDataSetAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkDataObjectAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkDataSetAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void; + fn get_image_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkDemandDrivenPipeline: VtkExecutive { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn compute_pipeline_m_time( + &mut self, + request: *mut core::ffi::c_void, + inInfoVec: *mut core::ffi::c_void, + outInfoVec: *mut core::ffi::c_void, + requestFromOutputPort: core::ffi::c_int, + mtime: core::ffi::c_ulong, + ) -> core::ffi::c_int; + fn get_pipeline_m_time(&mut self) -> core::ffi::c_ulong; + fn set_release_data_flag( + &mut self, + port: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_release_data_flag(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; + fn update_pipeline_m_time(&mut self) -> core::ffi::c_int; + fn update_data_object(&mut self) -> core::ffi::c_int; + fn update_data(&mut self, outputPort: core::ffi::c_int) -> core::ffi::c_int; + fn request_data_object(&mut self) -> *mut core::ffi::c_void; + fn request_information(&mut self) -> *mut core::ffi::c_void; + fn request_data(&mut self) -> *mut core::ffi::c_void; + fn request_data_not_generated(&mut self) -> *mut core::ffi::c_void; + fn release_data(&mut self) -> *mut core::ffi::c_void; + fn data_not_generated(&mut self) -> *mut core::ffi::c_void; + fn new_data_object(&mut self, type_: core::ffi::c_char) -> *mut core::ffi::c_void; +} +pub trait VtkDirectedGraphAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkEnsembleSource: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_member(&mut self, p0: *mut core::ffi::c_void) -> (); + fn remove_all_members(&mut self) -> (); + fn get_number_of_members(&mut self) -> core::ffi::c_uint; + fn set_current_member(&mut self, _arg: core::ffi::c_uint) -> (); + fn get_current_member(&mut self) -> core::ffi::c_uint; + fn set_meta_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn meta_data(&mut self) -> *mut core::ffi::c_void; + fn update_member(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkExecutive { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_algorithm(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn compute_pipeline_m_time( + &mut self, + request: *mut core::ffi::c_void, + inInfoVec: *mut core::ffi::c_void, + outInfoVec: *mut core::ffi::c_void, + requestFromOutputPort: core::ffi::c_int, + mtime: core::ffi::c_ulong, + ) -> core::ffi::c_int; + fn update_information(&mut self) -> core::ffi::c_int; + fn update(&mut self) -> core::ffi::c_int; + fn update(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; + fn get_number_of_input_ports(&mut self) -> core::ffi::c_int; + fn get_number_of_output_ports(&mut self) -> core::ffi::c_int; + fn get_number_of_input_connections( + &mut self, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_output_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_output_information(&mut self) -> *mut core::ffi::c_void; + fn get_input_information( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_information(&mut self) -> *mut &mut vtkInformationVector; + fn get_input_executive( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_output_data(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output_data( + &mut self, + port: core::ffi::c_int, + p1: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> (); + fn set_output_data( + &mut self, + port: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> (); + fn get_input_data( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_data( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + inInfoVec: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn set_shared_input_information(&mut self, inInfoVec: *mut core::ffi::c_void) -> (); + fn set_shared_output_information( + &mut self, + outInfoVec: *mut core::ffi::c_void, + ) -> (); + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn producer(&mut self) -> *mut core::ffi::c_void; + fn consumers(&mut self) -> *mut core::ffi::c_void; + fn from_output_port(&mut self) -> *mut core::ffi::c_void; + fn algorithm_before_forward(&mut self) -> *mut core::ffi::c_void; + fn algorithm_after_forward(&mut self) -> *mut core::ffi::c_void; + fn algorithm_direction(&mut self) -> *mut core::ffi::c_void; + fn forward_direction(&mut self) -> *mut core::ffi::c_void; + fn keys_to_copy(&mut self) -> *mut core::ffi::c_void; + fn call_algorithm( + &mut self, + request: *mut core::ffi::c_void, + direction: core::ffi::c_int, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkExplicitStructuredGridAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_explicit_structured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkExtentRCBPartitioner { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_partitions(&mut self, N: core::ffi::c_int) -> (); + fn set_global_extent( + &mut self, + imin: core::ffi::c_int, + imax: core::ffi::c_int, + jmin: core::ffi::c_int, + jmax: core::ffi::c_int, + kmin: core::ffi::c_int, + kmax: core::ffi::c_int, + ) -> (); + fn set_global_extent(&mut self, ext: core::ffi::c_int) -> (); + fn set_duplicate_nodes(&mut self, _arg: core::ffi::c_int) -> (); + fn get_duplicate_nodes(&mut self) -> core::ffi::c_int; + fn duplicate_nodes_on(&mut self) -> (); + fn duplicate_nodes_off(&mut self) -> (); + fn set_number_of_ghost_layers(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_ghost_layers(&mut self) -> core::ffi::c_int; + fn get_num_extents(&mut self) -> core::ffi::c_int; + fn partition(&mut self) -> (); + fn get_partition_extent( + &mut self, + idx: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> (); +} +pub trait VtkExtentSplitter { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_extent_source( + &mut self, + id: core::ffi::c_int, + priority: core::ffi::c_int, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> (); + fn add_extent_source( + &mut self, + id: core::ffi::c_int, + priority: core::ffi::c_int, + extent: core::ffi::c_int, + ) -> (); + fn remove_extent_source(&mut self, id: core::ffi::c_int) -> (); + fn remove_all_extent_sources(&mut self) -> (); + fn add_extent( + &mut self, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> (); + fn add_extent(&mut self, extent: core::ffi::c_int) -> (); + fn compute_sub_extents(&mut self) -> core::ffi::c_int; + fn get_number_of_sub_extents(&mut self) -> core::ffi::c_int; + fn get_sub_extent(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_int; + fn get_sub_extent( + &mut self, + index: core::ffi::c_int, + extent: core::ffi::c_int, + ) -> (); + fn get_sub_extent_source(&mut self, index: core::ffi::c_int) -> core::ffi::c_int; + fn get_point_mode(&mut self) -> core::ffi::c_int; + fn set_point_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn point_mode_on(&mut self) -> (); + fn point_mode_off(&mut self) -> (); +} +pub trait VtkExtentTranslator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn set_whole_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn get_whole_extent(&mut self) -> *mut core::ffi::c_int; + fn get_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn get_whole_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn set_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn set_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn get_extent(&mut self) -> *mut core::ffi::c_int; + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn set_piece(&mut self, _arg: core::ffi::c_int) -> (); + fn get_piece(&mut self) -> core::ffi::c_int; + fn set_number_of_pieces(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_pieces(&mut self) -> core::ffi::c_int; + fn set_ghost_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_ghost_level(&mut self) -> core::ffi::c_int; + fn piece_to_extent(&mut self) -> core::ffi::c_int; + fn piece_to_extent_by_points(&mut self) -> core::ffi::c_int; + fn piece_to_extent_thread_safe( + &mut self, + piece: core::ffi::c_int, + numPieces: core::ffi::c_int, + ghostLevel: core::ffi::c_int, + wholeExtent: core::ffi::c_int, + resultExtent: core::ffi::c_int, + splitMode: core::ffi::c_int, + byPoints: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_split_mode_to_block(&mut self) -> (); + fn set_split_mode_to_x_slab(&mut self) -> (); + fn set_split_mode_to_y_slab(&mut self) -> (); + fn set_split_mode_to_z_slab(&mut self) -> (); + fn get_split_mode(&mut self) -> core::ffi::c_int; + fn set_split_path( + &mut self, + len: core::ffi::c_int, + splitpath: core::ffi::c_int, + ) -> (); + fn update_split_mode(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkFilteringInformationKeyManager { + fn register(&mut self, key: *mut core::ffi::c_void) -> (); +} +pub trait VtkGraphAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkHierarchicalBoxDataSetAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkHyperTreeGridAlgorithm: VtkAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_hyper_tree_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_hyper_tree_grid_output( + &mut self, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_poly_data_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output( + &mut self, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkImageAlgorithm: VtkAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_image_data_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkImageInPlaceFilter: VtkImageAlgorithm + VtkAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkImageProgressIterator { + fn next_span(&mut self) -> (); + fn is_at_end(&mut self) -> core::ffi::c_int; +} +pub trait VtkImageToStructuredGrid: VtkStructuredGridAlgorithm + VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkImageToStructuredPoints: VtkImageAlgorithm + VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_vector_input_data(&mut self, input: *mut core::ffi::c_void) -> (); + fn get_vector_input(&mut self) -> *mut core::ffi::c_void; + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkInformationDataObjectMetaDataKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn copy_default_information( + &mut self, + request: *mut core::ffi::c_void, + fromInfo: *mut core::ffi::c_void, + toInfo: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationExecutivePortKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn set( + &mut self, + info: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: core::ffi::c_int, + ) -> (); + fn get_executive(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_port(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get( + &mut self, + info: *mut core::ffi::c_void, + executive: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> (); + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationExecutivePortVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn append( + &mut self, + info: *mut core::ffi::c_void, + executive: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> (); + fn remove( + &mut self, + info: *mut core::ffi::c_void, + executive: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + executives: *mut core::ffi::c_void, + ports: core::ffi::c_int, + length: core::ffi::c_int, + ) -> (); + fn get_executives(&mut self, info: *mut core::ffi::c_void) -> *mut &mut vtkExecutive; + fn get_ports(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_int; + fn get( + &mut self, + info: *mut core::ffi::c_void, + executives: *mut core::ffi::c_void, + ports: core::ffi::c_int, + ) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIntegerRequestKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: core::ffi::c_char, + location: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + fn need_to_execute( + &mut self, + pipelineInfo: *mut core::ffi::c_void, + dobjInfo: *mut core::ffi::c_void, + ) -> bool; + fn store_meta_data( + &mut self, + request: *mut core::ffi::c_void, + pipelineInfo: *mut core::ffi::c_void, + dobjInfo: *mut core::ffi::c_void, + ) -> (); + fn copy_default_information( + &mut self, + request: *mut core::ffi::c_void, + fromInfo: *mut core::ffi::c_void, + toInfo: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkMoleculeAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_molecule_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkMultiBlockDataSetAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkMultiTimeStepAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkNonOverlappingAMRAlgorithm: VtkUniformGridAMRAlgorithm + VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; +} +pub trait VtkOverlappingAMRAlgorithm: VtkUniformGridAMRAlgorithm + VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; +} +pub trait VtkParallelReader: VtkReaderAlgorithm + VtkAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_file_name(&mut self, fname: core::ffi::c_char) -> (); + fn clear_file_names(&mut self) -> (); + fn get_number_of_file_names(&mut self) -> core::ffi::c_int; + fn get_file_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char; + fn get_current_file_name(&mut self) -> *const core::ffi::c_char; + fn read_meta_data(&mut self, metadata: *mut core::ffi::c_void) -> core::ffi::c_int; + fn read_mesh( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_points( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_arrays( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkPartitionedDataSetAlgorithm: VtkAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; +} +pub trait VtkPartitionedDataSetCollectionAlgorithm: VtkAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; +} +pub trait VtkPassInputTypeAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void; + fn get_image_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_graph_output(&mut self) -> *mut core::ffi::c_void; + fn get_molecule_output(&mut self) -> *mut core::ffi::c_void; + fn get_table_output(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkPiecewiseFunctionAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkPiecewiseFunctionShiftScale: VtkPiecewiseFunctionAlgorithm + VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_position_shift(&mut self, _arg: core::ffi::c_double) -> (); + fn set_position_scale(&mut self, _arg: core::ffi::c_double) -> (); + fn set_value_shift(&mut self, _arg: core::ffi::c_double) -> (); + fn set_value_scale(&mut self, _arg: core::ffi::c_double) -> (); + fn get_position_shift(&mut self) -> core::ffi::c_double; + fn get_position_scale(&mut self) -> core::ffi::c_double; + fn get_value_shift(&mut self) -> core::ffi::c_double; + fn get_value_scale(&mut self) -> core::ffi::c_double; +} +pub trait VtkPointSetAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkPolyDataAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_poly_data_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkProgressObserver { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn update_progress(&mut self, amount: core::ffi::c_double) -> (); + fn get_progress(&mut self) -> core::ffi::c_double; +} +pub trait VtkReaderAlgorithm: VtkAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn create_output( + &mut self, + currentOutput: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn read_meta_data(&mut self, metadata: *mut core::ffi::c_void) -> core::ffi::c_int; + fn read_time_dependent_meta_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_mesh( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_points( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_arrays( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkReaderExecutive: VtkStreamingDemandDrivenPipeline + VtkDemandDrivenPipeline + VtkExecutive { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkRectilinearGridAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_rectilinear_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkSMPProgressObserver: VtkProgressObserver { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn update_progress(&mut self, progress: core::ffi::c_double) -> (); + fn get_local_observer(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkScalarTree { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, stree: *mut core::ffi::c_void) -> (); + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn set_scalars(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_scalars(&mut self) -> *mut core::ffi::c_void; + fn build_tree(&mut self) -> (); + fn initialize(&mut self) -> (); + fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> (); + fn get_next_cell( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_scalar_value(&mut self) -> core::ffi::c_double; + fn get_number_of_cell_batches( + &mut self, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn get_cell_batch( + &mut self, + batchNum: core::ffi::c_uchar, + numCells: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; +} +pub trait VtkSelectionAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkSimpleImageToImageFilter: VtkImageAlgorithm + VtkAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkSimpleReader: VtkReaderAlgorithm + VtkAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_file_name(&mut self, fname: core::ffi::c_char) -> (); + fn clear_file_names(&mut self) -> (); + fn get_number_of_file_names(&mut self) -> core::ffi::c_int; + fn get_file_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char; + fn get_current_file_name(&mut self) -> *const core::ffi::c_char; + fn read_time_dependent_meta_data( + &mut self, + timestep: core::ffi::c_int, + metadata: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_meta_data(&mut self, metadata: *mut core::ffi::c_void) -> core::ffi::c_int; + fn read_mesh( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_points( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_arrays( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_time_value(&mut self, fname: &str) -> core::ffi::c_double; + fn read_meta_data_simple( + &mut self, + p0: &str, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_mesh_simple( + &mut self, + fname: &str, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_points_simple( + &mut self, + fname: &str, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_arrays_simple( + &mut self, + fname: &str, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkSimpleScalarTree: VtkScalarTree { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_branching_factor(&mut self, _arg: core::ffi::c_int) -> (); + fn get_branching_factor_min_value(&mut self) -> core::ffi::c_int; + fn get_branching_factor_max_value(&mut self) -> core::ffi::c_int; + fn get_branching_factor(&mut self) -> core::ffi::c_int; + fn get_level(&mut self) -> core::ffi::c_int; + fn set_max_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_level_min_value(&mut self) -> core::ffi::c_int; + fn get_max_level_max_value(&mut self) -> core::ffi::c_int; + fn get_max_level(&mut self) -> core::ffi::c_int; + fn build_tree(&mut self) -> (); + fn initialize(&mut self) -> (); + fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> (); + fn get_next_cell( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_number_of_cell_batches( + &mut self, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn get_cell_batch( + &mut self, + batchNum: core::ffi::c_uchar, + numCells: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; +} +pub trait VtkSpanSpace: VtkScalarTree { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_scalar_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_scalar_range(&mut self, _arg: core::ffi::c_double) -> (); + fn get_scalar_range(&mut self) -> *mut core::ffi::c_double; + fn get_scalar_range(&mut self, data: core::ffi::c_double) -> (); + fn set_compute_scalar_range(&mut self, _arg: core::ffi::c_int) -> (); + fn get_compute_scalar_range(&mut self) -> core::ffi::c_int; + fn compute_scalar_range_on(&mut self) -> (); + fn compute_scalar_range_off(&mut self) -> (); + fn set_resolution(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_uchar; + fn get_resolution_max_value(&mut self) -> core::ffi::c_uchar; + fn get_resolution(&mut self) -> core::ffi::c_uchar; + fn set_compute_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_compute_resolution(&mut self) -> core::ffi::c_int; + fn compute_resolution_on(&mut self) -> (); + fn compute_resolution_off(&mut self) -> (); + fn set_number_of_cells_per_bucket(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_cells_per_bucket_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_cells_per_bucket_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_cells_per_bucket(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn build_tree(&mut self) -> (); + fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> (); + fn get_next_cell( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_number_of_cell_batches( + &mut self, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_uchar; + fn get_cell_batch( + &mut self, + batchNum: core::ffi::c_uchar, + numCells: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn set_batch_size(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_batch_size_min_value(&mut self) -> core::ffi::c_uchar; + fn get_batch_size_max_value(&mut self) -> core::ffi::c_uchar; + fn get_batch_size(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkSphereTree { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn build(&mut self) -> (); + fn build(&mut self, input: *mut core::ffi::c_void) -> (); + fn set_build_hierarchy(&mut self, _arg: bool) -> (); + fn get_build_hierarchy(&mut self) -> bool; + fn build_hierarchy_on(&mut self) -> (); + fn build_hierarchy_off(&mut self) -> (); + fn select_point( + &mut self, + point: core::ffi::c_double, + numSelected: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn select_line( + &mut self, + origin: core::ffi::c_double, + ray: core::ffi::c_double, + numSelected: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn select_plane( + &mut self, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + numSelected: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + fn select_point( + &mut self, + point: core::ffi::c_double, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn select_line( + &mut self, + origin: core::ffi::c_double, + ray: core::ffi::c_double, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn select_plane( + &mut self, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_max_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_level_min_value(&mut self) -> core::ffi::c_int; + fn get_max_level_max_value(&mut self) -> core::ffi::c_int; + fn get_max_level(&mut self) -> core::ffi::c_int; + fn get_number_of_levels(&mut self) -> core::ffi::c_int; + fn get_cell_spheres(&mut self) -> *const core::ffi::c_double; + fn get_tree_spheres( + &mut self, + level: core::ffi::c_int, + numSpheres: core::ffi::c_uchar, + ) -> *const core::ffi::c_double; +} +pub trait VtkStreamingDemandDrivenPipeline: VtkDemandDrivenPipeline + VtkExecutive { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn update(&mut self) -> core::ffi::c_int; + fn update_whole_extent(&mut self) -> core::ffi::c_int; + fn update( + &mut self, + port: core::ffi::c_int, + requests: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn propagate_update_extent( + &mut self, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + fn propagate_time(&mut self, outputPort: core::ffi::c_int) -> core::ffi::c_int; + fn update_time_dependent_information( + &mut self, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_whole_extent( + &mut self, + p0: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_whole_extent( + &mut self, + p0: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> (); + fn get_whole_extent(&mut self, p0: *mut core::ffi::c_void) -> *mut core::ffi::c_int; + fn set_request_exact_extent( + &mut self, + port: core::ffi::c_int, + flag: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_request_exact_extent(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; + fn request_update_extent(&mut self) -> *mut core::ffi::c_void; + fn request_update_time(&mut self) -> *mut core::ffi::c_void; + fn request_time_dependent_information(&mut self) -> *mut core::ffi::c_void; + fn continue_executing(&mut self) -> *mut core::ffi::c_void; + fn update_extent_initialized(&mut self) -> *mut core::ffi::c_void; + fn update_extent(&mut self) -> *mut core::ffi::c_void; + fn update_piece_number(&mut self) -> *mut core::ffi::c_void; + fn update_number_of_pieces(&mut self) -> *mut core::ffi::c_void; + fn update_number_of_ghost_levels(&mut self) -> *mut core::ffi::c_void; + fn combined_update_extent(&mut self) -> *mut core::ffi::c_void; + fn whole_extent(&mut self) -> *mut core::ffi::c_void; + fn unrestricted_update_extent(&mut self) -> *mut core::ffi::c_void; + fn exact_extent(&mut self) -> *mut core::ffi::c_void; + fn time_steps(&mut self) -> *mut core::ffi::c_void; + fn time_range(&mut self) -> *mut core::ffi::c_void; + fn update_time_step(&mut self) -> *mut core::ffi::c_void; + fn time_dependent_information(&mut self) -> *mut core::ffi::c_void; + fn bounds(&mut self) -> *mut core::ffi::c_void; + fn get_update_extent( + &mut self, + p0: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> (); + fn get_update_extent(&mut self, p0: *mut core::ffi::c_void) -> *mut core::ffi::c_int; + fn get_update_piece(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_update_number_of_pieces( + &mut self, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_update_ghost_level(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int; +} +pub trait VtkStructuredGridAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_structured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkTableAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkThreadedCompositeDataPipeline: VtkCompositeDataPipeline + VtkStreamingDemandDrivenPipeline + VtkDemandDrivenPipeline + VtkExecutive { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkThreadedImageAlgorithm: VtkImageAlgorithm + VtkAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn threaded_request_data( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + inData: *mut core::ffi::c_void, + outData: *mut core::ffi::c_void, + extent: core::ffi::c_int, + threadId: core::ffi::c_int, + ) -> (); + fn threaded_execute( + &mut self, + inData: *mut core::ffi::c_void, + outData: *mut core::ffi::c_void, + extent: core::ffi::c_int, + threadId: core::ffi::c_int, + ) -> (); + fn get_enable_smp(&mut self) -> bool; + fn set_enable_smp(&mut self, _arg: bool) -> (); + fn set_global_default_enable_smp(&mut self, enable: bool) -> (); + fn get_global_default_enable_smp(&mut self) -> bool; + fn set_minimum_piece_size( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> (); + fn set_minimum_piece_size(&mut self, _arg: core::ffi::c_int) -> (); + fn get_minimum_piece_size(&mut self) -> *mut core::ffi::c_int; + fn get_minimum_piece_size( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> (); + fn get_minimum_piece_size(&mut self, _arg: core::ffi::c_int) -> (); + fn set_desired_bytes_per_piece(&mut self, _arg: core::ffi::c_uchar) -> (); + fn get_desired_bytes_per_piece(&mut self) -> core::ffi::c_uchar; + fn set_split_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_split_mode_min_value(&mut self) -> core::ffi::c_int; + fn get_split_mode_max_value(&mut self) -> core::ffi::c_int; + fn set_split_mode_to_slab(&mut self) -> (); + fn set_split_mode_to_beam(&mut self) -> (); + fn set_split_mode_to_block(&mut self) -> (); + fn get_split_mode(&mut self) -> core::ffi::c_int; + fn set_number_of_threads(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_threads_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_threads_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_threads(&mut self) -> core::ffi::c_int; + fn split_extent( + &mut self, + splitExt: core::ffi::c_int, + startExt: core::ffi::c_int, + num: core::ffi::c_int, + total: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkTreeAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkTrivialConsumer: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkTrivialProducer: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_output(&mut self, output: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn set_whole_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn get_whole_extent(&mut self) -> *mut core::ffi::c_int; + fn get_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn get_whole_extent(&mut self, _arg: core::ffi::c_int) -> (); + fn fill_output_data_information( + &mut self, + output: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkUndirectedGraphAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkUniformGridAMRAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkUniformGridPartitioner: VtkMultiBlockDataSetAlgorithm + VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_partitions(&mut self) -> core::ffi::c_int; + fn set_number_of_partitions(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_ghost_layers(&mut self) -> core::ffi::c_int; + fn set_number_of_ghost_layers(&mut self, _arg: core::ffi::c_int) -> (); + fn get_duplicate_nodes(&mut self) -> core::ffi::c_int; + fn set_duplicate_nodes(&mut self, _arg: core::ffi::c_int) -> (); + fn duplicate_nodes_on(&mut self) -> (); + fn duplicate_nodes_off(&mut self) -> (); +} +pub trait VtkUnstructuredGridAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkUnstructuredGridBaseAlgorithm: VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +impl VtkAlgorithm for vtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_new_instance(self.0) } + } + fn has_executive(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_has_executive( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_has_executive(self.0) } + } + fn get_executive(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_executive( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_executive(self.0) } + } + fn set_executive(&mut self, executive: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_executive( + sself: *mut core::ffi::c_void, + executive: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_executive(self.0, executive) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_process_request(self.0, request, inInfo, outInfo) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_process_request(self.0, request, inInfo, outInfo) } + } + fn compute_pipeline_m_time( + &mut self, + request: *mut core::ffi::c_void, + inInfoVec: *mut core::ffi::c_void, + outInfoVec: *mut core::ffi::c_void, + requestFromOutputPort: core::ffi::c_int, + mtime: core::ffi::c_ulong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_compute_pipeline_m_time( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inInfoVec: *mut core::ffi::c_void, + outInfoVec: *mut core::ffi::c_void, + requestFromOutputPort: core::ffi::c_int, + mtime: core::ffi::c_ulong, + ) -> core::ffi::c_int; + } + unsafe { + vtk_algorithm_compute_pipeline_m_time( + self.0, + request, + inInfoVec, + outInfoVec, + requestFromOutputPort, + mtime, + ) + } + } + fn modify_request( + &mut self, + request: *mut core::ffi::c_void, + when: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_modify_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + when: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_modify_request(self.0, request, when) } + } + fn get_input_port_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_port_information( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_port_information(self.0, port) } + } + fn get_output_port_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_output_port_information( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_output_port_information(self.0, port) } + } + fn get_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_information(self.0) } + } + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_information( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_information(self.0, p0) } + } + fn get_number_of_input_ports(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_number_of_input_ports( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_number_of_input_ports(self.0) } + } + fn get_number_of_output_ports(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_number_of_output_ports( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_number_of_output_ports(self.0) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_register(self.0, o) } + } + fn set_abort_execute(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_abort_execute( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_set_abort_execute(self.0, _arg) } + } + fn get_abort_execute(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_abort_execute( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_abort_execute(self.0) } + } + fn abort_execute_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_abort_execute_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_abort_execute_on(self.0) } + } + fn abort_execute_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_abort_execute_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_abort_execute_off(self.0) } + } + fn get_progress(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_algorithm_get_progress( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_algorithm_get_progress(self.0) } + } + fn set_progress(&mut self, p0: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_progress( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + ); + } + unsafe { vtk_algorithm_set_progress(self.0, p0) } + } + fn update_progress(&mut self, amount: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_algorithm_update_progress( + sself: *mut core::ffi::c_void, + amount: core::ffi::c_double, + ); + } + unsafe { vtk_algorithm_update_progress(self.0, amount) } + } + fn set_progress_shift_scale( + &mut self, + shift: core::ffi::c_double, + scale: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_progress_shift_scale( + sself: *mut core::ffi::c_void, + shift: core::ffi::c_double, + scale: core::ffi::c_double, + ); + } + unsafe { vtk_algorithm_set_progress_shift_scale(self.0, shift, scale) } + } + fn get_progress_shift(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_algorithm_get_progress_shift( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_algorithm_get_progress_shift(self.0) } + } + fn get_progress_scale(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_algorithm_get_progress_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_algorithm_get_progress_scale(self.0) } + } + fn set_progress_text(&mut self, ptext: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_progress_text( + sself: *mut core::ffi::c_void, + ptext: core::ffi::c_char, + ); + } + unsafe { vtk_algorithm_set_progress_text(self.0, ptext) } + } + fn get_progress_text(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_algorithm_get_progress_text( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_algorithm_get_progress_text(self.0) } + } + fn get_error_code(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_algorithm_get_error_code( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_algorithm_get_error_code(self.0) } + } + fn input_is_optional(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_is_optional( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_is_optional(self.0) } + } + fn input_is_repeatable(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_is_repeatable( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_is_repeatable(self.0) } + } + fn input_required_fields(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_required_fields( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_required_fields(self.0) } + } + fn input_required_data_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_required_data_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_required_data_type(self.0) } + } + fn input_arrays_to_process(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_arrays_to_process( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_arrays_to_process(self.0) } + } + fn input_port(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_port( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_port(self.0) } + } + fn input_connection(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_connection( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_connection(self.0) } + } + fn can_produce_sub_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_can_produce_sub_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_can_produce_sub_extent(self.0) } + } + fn can_handle_piece_request(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_can_handle_piece_request( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_can_handle_piece_request(self.0) } + } + fn set_input_array_to_process( + &mut self, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_int, + name: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_input_array_to_process( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_int, + name: core::ffi::c_char, + ); + } + unsafe { + vtk_algorithm_set_input_array_to_process( + self.0, + idx, + port, + connection, + fieldAssociation, + name, + ) + } + } + fn set_input_array_to_process( + &mut self, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_int, + fieldAttributeType: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_input_array_to_process( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_int, + fieldAttributeType: core::ffi::c_int, + ); + } + unsafe { + vtk_algorithm_set_input_array_to_process( + self.0, + idx, + port, + connection, + fieldAssociation, + fieldAttributeType, + ) + } + } + fn set_input_array_to_process( + &mut self, + idx: core::ffi::c_int, + info: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_input_array_to_process( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_input_array_to_process(self.0, idx, info) } + } + fn set_input_array_to_process( + &mut self, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_char, + attributeTypeorName: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_input_array_to_process( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_char, + attributeTypeorName: core::ffi::c_char, + ); + } + unsafe { + vtk_algorithm_set_input_array_to_process( + self.0, + idx, + port, + connection, + fieldAssociation, + attributeTypeorName, + ) + } + } + fn get_input_array_information( + &mut self, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_array_information( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_array_information(self.0, idx) } + } + fn remove_all_inputs(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_remove_all_inputs(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_remove_all_inputs(self.0) } + } + fn get_output_data_object( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_output_data_object( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_output_data_object(self.0, port) } + } + fn get_input_data_object( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_data_object( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_data_object(self.0, port, connection) } + } + fn set_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_input_connection( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_input_connection(self.0, port, input) } + } + fn set_input_connection(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_input_connection( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_input_connection(self.0, input) } + } + fn add_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_add_input_connection( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_add_input_connection(self.0, port, input) } + } + fn add_input_connection(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_add_input_connection( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_add_input_connection(self.0, input) } + } + fn remove_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_remove_input_connection( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_remove_input_connection(self.0, port, input) } + } + fn remove_input_connection( + &mut self, + port: core::ffi::c_int, + idx: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_remove_input_connection( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + idx: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_remove_input_connection(self.0, port, idx) } + } + fn remove_all_input_connections(&mut self, port: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_remove_all_input_connections( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_remove_all_input_connections(self.0, port) } + } + fn set_input_data_object( + &mut self, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_input_data_object( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_input_data_object(self.0, port, data) } + } + fn set_input_data_object(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_input_data_object( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_input_data_object(self.0, data) } + } + fn add_input_data_object( + &mut self, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_add_input_data_object( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_add_input_data_object(self.0, port, data) } + } + fn add_input_data_object(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_add_input_data_object( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_add_input_data_object(self.0, data) } + } + fn get_output_port(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_output_port( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_output_port(self.0, index) } + } + fn get_output_port(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_output_port( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_output_port(self.0) } + } + fn get_number_of_input_connections( + &mut self, + port: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_number_of_input_connections( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_number_of_input_connections(self.0, port) } + } + fn get_total_number_of_input_connections(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_total_number_of_input_connections( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_total_number_of_input_connections(self.0) } + } + fn get_input_connection( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_connection( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_connection(self.0, port, index) } + } + fn get_input_algorithm( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + algPort: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_algorithm( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + index: core::ffi::c_int, + algPort: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_algorithm(self.0, port, index, algPort) } + } + fn get_input_algorithm( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_algorithm( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_algorithm(self.0, port, index) } + } + fn get_input_algorithm(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_algorithm( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_algorithm(self.0) } + } + fn get_input_executive( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_executive( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_executive(self.0, port, index) } + } + fn get_input_executive(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_executive( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_executive(self.0) } + } + fn get_input_information( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_information( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_information(self.0, port, index) } + } + fn get_input_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_information(self.0) } + } + fn get_output_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_output_information( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_output_information(self.0, port) } + } + fn update(&mut self, port: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_update( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_update(self.0, port) } + } + fn update(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_update(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_update(self.0) } + } + fn update( + &mut self, + port: core::ffi::c_int, + requests: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_update( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + requests: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_update(self.0, port, requests) } + } + fn update(&mut self, requests: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_update( + sself: *mut core::ffi::c_void, + requests: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_update(self.0, requests) } + } + fn update_piece( + &mut self, + piece: core::ffi::c_int, + numPieces: core::ffi::c_int, + ghostLevels: core::ffi::c_int, + extents: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_update_piece( + sself: *mut core::ffi::c_void, + piece: core::ffi::c_int, + numPieces: core::ffi::c_int, + ghostLevels: core::ffi::c_int, + extents: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_algorithm_update_piece(self.0, piece, numPieces, ghostLevels, extents) + } + } + fn update_extent(&mut self, extents: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_update_extent( + sself: *mut core::ffi::c_void, + extents: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_update_extent(self.0, extents) } + } + fn update_time_step( + &mut self, + time: core::ffi::c_double, + piece: core::ffi::c_int, + numPieces: core::ffi::c_int, + ghostLevels: core::ffi::c_int, + extents: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_update_time_step( + sself: *mut core::ffi::c_void, + time: core::ffi::c_double, + piece: core::ffi::c_int, + numPieces: core::ffi::c_int, + ghostLevels: core::ffi::c_int, + extents: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_algorithm_update_time_step( + self.0, + time, + piece, + numPieces, + ghostLevels, + extents, + ) + } + } + fn update_information(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_update_information(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_update_information(self.0) } + } + fn update_data_object(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_update_data_object(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_update_data_object(self.0) } + } + fn propagate_update_extent(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_propagate_update_extent(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_propagate_update_extent(self.0) } + } + fn update_whole_extent(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_update_whole_extent(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_update_whole_extent(self.0) } + } + fn convert_total_input_to_port_connection( + &mut self, + ind: core::ffi::c_int, + port: core::ffi::c_int, + conn: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_convert_total_input_to_port_connection( + sself: *mut core::ffi::c_void, + ind: core::ffi::c_int, + port: core::ffi::c_int, + conn: core::ffi::c_int, + ); + } + unsafe { + vtk_algorithm_convert_total_input_to_port_connection(self.0, ind, port, conn) + } + } + fn set_release_data_flag(&mut self, p0: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_release_data_flag( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_set_release_data_flag(self.0, p0) } + } + fn get_release_data_flag(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_release_data_flag( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_release_data_flag(self.0) } + } + fn release_data_flag_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_release_data_flag_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_release_data_flag_on(self.0) } + } + fn release_data_flag_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_release_data_flag_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_release_data_flag_off(self.0) } + } + fn update_extent_is_empty( + &mut self, + pinfo: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_update_extent_is_empty( + sself: *mut core::ffi::c_void, + pinfo: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_update_extent_is_empty(self.0, pinfo, output) } + } + fn update_extent_is_empty( + &mut self, + pinfo: *mut core::ffi::c_void, + extentType: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_update_extent_is_empty( + sself: *mut core::ffi::c_void, + pinfo: *mut core::ffi::c_void, + extentType: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_update_extent_is_empty(self.0, pinfo, extentType) } + } + fn set_default_executive_prototype(&mut self, proto: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_default_executive_prototype( + sself: *mut core::ffi::c_void, + proto: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_default_executive_prototype(self.0, proto) } + } + fn get_update_extent(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_extent(self.0) } + } + fn get_update_extent(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_extent( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_extent(self.0, port) } + } + fn get_update_extent( + &mut self, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_get_update_extent( + sself: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_get_update_extent(self.0, x0, x1, y0, y1, z0, z1) } + } + fn get_update_extent( + &mut self, + port: core::ffi::c_int, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_get_update_extent( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_get_update_extent(self.0, port, x0, x1, y0, y1, z0, z1) } + } + fn get_update_extent(&mut self, extent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_get_update_extent( + sself: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_get_update_extent(self.0, extent) } + } + fn get_update_extent( + &mut self, + port: core::ffi::c_int, + extent: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_get_update_extent( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_get_update_extent(self.0, port, extent) } + } + fn get_update_piece(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_piece( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_piece(self.0) } + } + fn get_update_piece(&mut self, port: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_piece( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_piece(self.0, port) } + } + fn get_update_number_of_pieces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_number_of_pieces(self.0) } + } + fn get_update_number_of_pieces( + &mut self, + port: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_number_of_pieces( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_number_of_pieces(self.0, port) } + } + fn get_update_ghost_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_ghost_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_ghost_level(self.0) } + } + fn get_update_ghost_level(&mut self, port: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_ghost_level( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_ghost_level(self.0, port) } + } + fn set_progress_observer(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_progress_observer( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_progress_observer(self.0, p0) } + } + fn get_progress_observer(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_progress_observer( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_progress_observer(self.0) } + } +} +impl VtkAlgorithmOutput for vtkAlgorithmOutput { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_output_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_output_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_output_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_output_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_output_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_output_new_instance(self.0) } + } + fn set_index(&mut self, index: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_output_set_index( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_output_set_index(self.0, index) } + } + fn get_index(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_output_get_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_output_get_index(self.0) } + } + fn get_producer(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_output_get_producer( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_output_get_producer(self.0) } + } + fn set_producer(&mut self, producer: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_output_set_producer( + sself: *mut core::ffi::c_void, + producer: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_output_set_producer(self.0, producer) } + } +} +impl VtkAnnotationLayersAlgorithm for vtkAnnotationLayersAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_algorithm_new_instance(self.0) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_annotation_layers_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_algorithm_get_output(self.0) } + } + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_get_output( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_algorithm_get_output(self.0, index) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_algorithm_set_input_data(self.0, obj) } + } + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_algorithm_set_input_data(self.0, index, obj) } + } +} +impl VtkArrayDataAlgorithm for vtkArrayDataAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_algorithm_new_instance(self.0) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_array_data_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_array_data_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_algorithm_get_output(self.0) } + } + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_algorithm_get_output( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_algorithm_get_output(self.0, index) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_array_data_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_array_data_algorithm_set_input_data(self.0, obj) } + } + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_array_data_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_array_data_algorithm_set_input_data(self.0, index, obj) } + } +} +impl VtkCachedStreamingDemandDrivenPipeline for vtkCachedStreamingDemandDrivenPipeline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cached_streaming_demand_driven_pipeline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cached_streaming_demand_driven_pipeline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cached_streaming_demand_driven_pipeline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cached_streaming_demand_driven_pipeline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cached_streaming_demand_driven_pipeline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cached_streaming_demand_driven_pipeline_new_instance(self.0) } + } + fn set_cache_size(&mut self, size: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cached_streaming_demand_driven_pipeline_set_cache_size( + sself: *mut core::ffi::c_void, + size: core::ffi::c_int, + ); + } + unsafe { + vtk_cached_streaming_demand_driven_pipeline_set_cache_size(self.0, size) + } + } + fn get_cache_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cached_streaming_demand_driven_pipeline_get_cache_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cached_streaming_demand_driven_pipeline_get_cache_size(self.0) } + } +} +impl VtkCastToConcrete for vtkCastToConcrete { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cast_to_concrete_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cast_to_concrete_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cast_to_concrete_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cast_to_concrete_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cast_to_concrete_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cast_to_concrete_new_instance(self.0) } + } +} +impl VtkCompositeDataPipeline for vtkCompositeDataPipeline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_new_instance(self.0) } + } + fn get_composite_output_data( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_get_composite_output_data( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_get_composite_output_data(self.0, port) } + } + fn get_composite_input_data( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + inInfoVec: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_get_composite_input_data( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + index: core::ffi::c_int, + inInfoVec: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_composite_data_pipeline_get_composite_input_data( + self.0, + port, + index, + inInfoVec, + ) + } + } + fn load_requested_blocks(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_load_requested_blocks( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_load_requested_blocks(self.0) } + } + fn composite_data_meta_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_composite_data_meta_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_composite_data_meta_data(self.0) } + } + fn update_composite_indices(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_update_composite_indices( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_update_composite_indices(self.0) } + } + fn block_amount_of_detail(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_block_amount_of_detail( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_block_amount_of_detail(self.0) } + } +} +impl VtkCompositeDataSetAlgorithm for vtkCompositeDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_set_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_set_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_set_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_set_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_set_algorithm_get_output(self.0, p0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_composite_data_set_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_composite_data_set_algorithm_set_input_data(self.0, p0, p1) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_composite_data_set_algorithm_process_request( + self.0, + request, + inputVector, + outputVector, + ) + } + } +} +impl VtkDataObjectAlgorithm for vtkDataObjectAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_get_output(self.0, p0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_algorithm_set_output(self.0, d) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_get_input(self.0) } + } + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_get_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_get_input(self.0, port) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_data_object_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_data_object_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_algorithm_add_input_data(self.0, p0, p1) } + } +} +impl VtkDataSetAlgorithm for vtkDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_output(self.0, p0) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_input(self.0) } + } + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_poly_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_poly_data_output(self.0) } + } + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_structured_points_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_structured_points_output(self.0) } + } + fn get_image_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_image_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_image_data_output(self.0) } + } + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_structured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_structured_grid_output(self.0) } + } + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_unstructured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_unstructured_grid_output(self.0) } + } + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_rectilinear_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_rectilinear_grid_output(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_algorithm_set_input_data(self.0, p0, p1) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_algorithm_add_input_data(self.0, p0, p1) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_algorithm_add_input_data(self.0, p0, p1) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_algorithm_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_set_algorithm_process_request( + self.0, + request, + inputVector, + outputVector, + ) + } + } +} +impl VtkDemandDrivenPipeline for vtkDemandDrivenPipeline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_new_instance(self.0) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_demand_driven_pipeline_process_request(self.0, request, inInfo, outInfo) + } + } + fn compute_pipeline_m_time( + &mut self, + request: *mut core::ffi::c_void, + inInfoVec: *mut core::ffi::c_void, + outInfoVec: *mut core::ffi::c_void, + requestFromOutputPort: core::ffi::c_int, + mtime: core::ffi::c_ulong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_compute_pipeline_m_time( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inInfoVec: *mut core::ffi::c_void, + outInfoVec: *mut core::ffi::c_void, + requestFromOutputPort: core::ffi::c_int, + mtime: core::ffi::c_ulong, + ) -> core::ffi::c_int; + } + unsafe { + vtk_demand_driven_pipeline_compute_pipeline_m_time( + self.0, + request, + inInfoVec, + outInfoVec, + requestFromOutputPort, + mtime, + ) + } + } + fn get_pipeline_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_get_pipeline_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_demand_driven_pipeline_get_pipeline_m_time(self.0) } + } + fn set_release_data_flag( + &mut self, + port: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_set_release_data_flag( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_demand_driven_pipeline_set_release_data_flag(self.0, port, n) } + } + fn get_release_data_flag(&mut self, port: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_get_release_data_flag( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_demand_driven_pipeline_get_release_data_flag(self.0, port) } + } + fn update_pipeline_m_time(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_update_pipeline_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_demand_driven_pipeline_update_pipeline_m_time(self.0) } + } + fn update_data_object(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_update_data_object( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_demand_driven_pipeline_update_data_object(self.0) } + } + fn update_data(&mut self, outputPort: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_update_data( + sself: *mut core::ffi::c_void, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_demand_driven_pipeline_update_data(self.0, outputPort) } + } + fn request_data_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_request_data_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_request_data_object(self.0) } + } + fn request_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_request_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_request_information(self.0) } + } + fn request_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_request_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_request_data(self.0) } + } + fn request_data_not_generated(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_request_data_not_generated( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_request_data_not_generated(self.0) } + } + fn release_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_release_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_release_data(self.0) } + } + fn data_not_generated(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_data_not_generated( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_data_not_generated(self.0) } + } + fn new_data_object(&mut self, type_: core::ffi::c_char) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_new_data_object( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_new_data_object(self.0, type_) } + } +} +impl VtkDirectedGraphAlgorithm for vtkDirectedGraphAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_algorithm_new_instance(self.0) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_directed_graph_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_algorithm_get_output(self.0) } + } + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_get_output( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_algorithm_get_output(self.0, index) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_directed_graph_algorithm_set_input_data(self.0, obj) } + } + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_directed_graph_algorithm_set_input_data(self.0, index, obj) } + } +} +impl VtkEnsembleSource for vtkEnsembleSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ensemble_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ensemble_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ensemble_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ensemble_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ensemble_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ensemble_source_new_instance(self.0) } + } + fn add_member(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_ensemble_source_add_member( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_ensemble_source_add_member(self.0, p0) } + } + fn remove_all_members(&mut self) -> () { + unsafe extern "C" { + fn vtk_ensemble_source_remove_all_members(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ensemble_source_remove_all_members(self.0) } + } + fn get_number_of_members(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_ensemble_source_get_number_of_members( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_ensemble_source_get_number_of_members(self.0) } + } + fn set_current_member(&mut self, _arg: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_ensemble_source_set_current_member( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uint, + ); + } + unsafe { vtk_ensemble_source_set_current_member(self.0, _arg) } + } + fn get_current_member(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_ensemble_source_get_current_member( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_ensemble_source_get_current_member(self.0) } + } + fn set_meta_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_ensemble_source_set_meta_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_ensemble_source_set_meta_data(self.0, p0) } + } + fn meta_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ensemble_source_meta_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ensemble_source_meta_data(self.0) } + } + fn update_member(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ensemble_source_update_member( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ensemble_source_update_member(self.0) } + } +} +impl VtkExplicitStructuredGridAlgorithm for vtkExplicitStructuredGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_get_output(self.0, p0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_algorithm_set_output(self.0, d) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_explicit_structured_grid_algorithm_process_request(self.0, p0, p1, p2) + } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_get_input(self.0) } + } + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_get_input(self.0, port) } + } + fn get_explicit_structured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_get_explicit_structured_grid_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_explicit_structured_grid_algorithm_get_explicit_structured_grid_input( + self.0, + port, + ) + } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_algorithm_add_input_data(self.0, p0, p1) } + } +} +impl VtkExtentRCBPartitioner for vtkExtentRCBPartitioner { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_rcb_partitioner_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_rcb_partitioner_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_rcb_partitioner_new_instance(self.0) } + } + fn set_number_of_partitions(&mut self, N: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_set_number_of_partitions( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + ); + } + unsafe { vtk_extent_rcb_partitioner_set_number_of_partitions(self.0, N) } + } + fn set_global_extent( + &mut self, + imin: core::ffi::c_int, + imax: core::ffi::c_int, + jmin: core::ffi::c_int, + jmax: core::ffi::c_int, + kmin: core::ffi::c_int, + kmax: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_set_global_extent( + sself: *mut core::ffi::c_void, + imin: core::ffi::c_int, + imax: core::ffi::c_int, + jmin: core::ffi::c_int, + jmax: core::ffi::c_int, + kmin: core::ffi::c_int, + kmax: core::ffi::c_int, + ); + } + unsafe { + vtk_extent_rcb_partitioner_set_global_extent( + self.0, + imin, + imax, + jmin, + jmax, + kmin, + kmax, + ) + } + } + fn set_global_extent(&mut self, ext: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_set_global_extent( + sself: *mut core::ffi::c_void, + ext: core::ffi::c_int, + ); + } + unsafe { vtk_extent_rcb_partitioner_set_global_extent(self.0, ext) } + } + fn set_duplicate_nodes(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_set_duplicate_nodes( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_rcb_partitioner_set_duplicate_nodes(self.0, _arg) } + } + fn get_duplicate_nodes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_get_duplicate_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_rcb_partitioner_get_duplicate_nodes(self.0) } + } + fn duplicate_nodes_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_duplicate_nodes_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_rcb_partitioner_duplicate_nodes_on(self.0) } + } + fn duplicate_nodes_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_duplicate_nodes_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_rcb_partitioner_duplicate_nodes_off(self.0) } + } + fn set_number_of_ghost_layers(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_set_number_of_ghost_layers( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_rcb_partitioner_set_number_of_ghost_layers(self.0, _arg) } + } + fn get_number_of_ghost_layers(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_get_number_of_ghost_layers( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_rcb_partitioner_get_number_of_ghost_layers(self.0) } + } + fn get_num_extents(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_get_num_extents( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_rcb_partitioner_get_num_extents(self.0) } + } + fn partition(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_partition(sself: *mut core::ffi::c_void); + } + unsafe { vtk_extent_rcb_partitioner_partition(self.0) } + } + fn get_partition_extent( + &mut self, + idx: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_get_partition_extent( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ext: core::ffi::c_int, + ); + } + unsafe { vtk_extent_rcb_partitioner_get_partition_extent(self.0, idx, ext) } + } +} +impl VtkExtentSplitter for vtkExtentSplitter { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_splitter_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_splitter_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_splitter_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_splitter_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_splitter_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_splitter_new(self.0) } + } + fn add_extent_source( + &mut self, + id: core::ffi::c_int, + priority: core::ffi::c_int, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_add_extent_source( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + priority: core::ffi::c_int, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ); + } + unsafe { + vtk_extent_splitter_add_extent_source( + self.0, + id, + priority, + x0, + x1, + y0, + y1, + z0, + z1, + ) + } + } + fn add_extent_source( + &mut self, + id: core::ffi::c_int, + priority: core::ffi::c_int, + extent: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_add_extent_source( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + priority: core::ffi::c_int, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_extent_splitter_add_extent_source(self.0, id, priority, extent) } + } + fn remove_extent_source(&mut self, id: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_remove_extent_source( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ); + } + unsafe { vtk_extent_splitter_remove_extent_source(self.0, id) } + } + fn remove_all_extent_sources(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_remove_all_extent_sources( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_splitter_remove_all_extent_sources(self.0) } + } + fn add_extent( + &mut self, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_add_extent( + sself: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ); + } + unsafe { vtk_extent_splitter_add_extent(self.0, x0, x1, y0, y1, z0, z1) } + } + fn add_extent(&mut self, extent: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_add_extent( + sself: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_extent_splitter_add_extent(self.0, extent) } + } + fn compute_sub_extents(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_splitter_compute_sub_extents( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_splitter_compute_sub_extents(self.0) } + } + fn get_number_of_sub_extents(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_splitter_get_number_of_sub_extents( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_splitter_get_number_of_sub_extents(self.0) } + } + fn get_sub_extent(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_splitter_get_sub_extent( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_extent_splitter_get_sub_extent(self.0, index) } + } + fn get_sub_extent( + &mut self, + index: core::ffi::c_int, + extent: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_get_sub_extent( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + extent: core::ffi::c_int, + ); + } + unsafe { vtk_extent_splitter_get_sub_extent(self.0, index, extent) } + } + fn get_sub_extent_source(&mut self, index: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_splitter_get_sub_extent_source( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_splitter_get_sub_extent_source(self.0, index) } + } + fn get_point_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_splitter_get_point_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_splitter_get_point_mode(self.0) } + } + fn set_point_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_set_point_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_splitter_set_point_mode(self.0, _arg) } + } + fn point_mode_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_point_mode_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_extent_splitter_point_mode_on(self.0) } + } + fn point_mode_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_point_mode_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_extent_splitter_point_mode_off(self.0) } + } +} +impl VtkExtentTranslator for vtkExtentTranslator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_translator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_translator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_translator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_translator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_translator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_translator_new_instance(self.0) } + } + fn set_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_whole_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_extent_translator_set_whole_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn set_whole_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_whole_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_set_whole_extent(self.0, _arg) } + } + fn get_whole_extent(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_get_whole_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_extent_translator_get_whole_extent(self.0) } + } + fn get_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_translator_get_whole_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_extent_translator_get_whole_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn get_whole_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_translator_get_whole_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_get_whole_extent(self.0, _arg) } + } + fn set_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_extent_translator_set_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn set_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_set_extent(self.0, _arg) } + } + fn get_extent(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_get_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_extent_translator_get_extent(self.0) } + } + fn get_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_translator_get_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_extent_translator_get_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_translator_get_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_get_extent(self.0, _arg) } + } + fn set_piece(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_piece( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_set_piece(self.0, _arg) } + } + fn get_piece(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_get_piece( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_get_piece(self.0) } + } + fn set_number_of_pieces(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_number_of_pieces( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_set_number_of_pieces(self.0, _arg) } + } + fn get_number_of_pieces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_get_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_get_number_of_pieces(self.0) } + } + fn set_ghost_level(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_ghost_level( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_set_ghost_level(self.0, _arg) } + } + fn get_ghost_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_get_ghost_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_get_ghost_level(self.0) } + } + fn piece_to_extent(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_piece_to_extent( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_piece_to_extent(self.0) } + } + fn piece_to_extent_by_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_piece_to_extent_by_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_piece_to_extent_by_points(self.0) } + } + fn piece_to_extent_thread_safe( + &mut self, + piece: core::ffi::c_int, + numPieces: core::ffi::c_int, + ghostLevel: core::ffi::c_int, + wholeExtent: core::ffi::c_int, + resultExtent: core::ffi::c_int, + splitMode: core::ffi::c_int, + byPoints: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_piece_to_extent_thread_safe( + sself: *mut core::ffi::c_void, + piece: core::ffi::c_int, + numPieces: core::ffi::c_int, + ghostLevel: core::ffi::c_int, + wholeExtent: core::ffi::c_int, + resultExtent: core::ffi::c_int, + splitMode: core::ffi::c_int, + byPoints: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_extent_translator_piece_to_extent_thread_safe( + self.0, + piece, + numPieces, + ghostLevel, + wholeExtent, + resultExtent, + splitMode, + byPoints, + ) + } + } + fn set_split_mode_to_block(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_split_mode_to_block( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_translator_set_split_mode_to_block(self.0) } + } + fn set_split_mode_to_x_slab(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_split_mode_to_x_slab( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_translator_set_split_mode_to_x_slab(self.0) } + } + fn set_split_mode_to_y_slab(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_split_mode_to_y_slab( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_translator_set_split_mode_to_y_slab(self.0) } + } + fn set_split_mode_to_z_slab(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_split_mode_to_z_slab( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_translator_set_split_mode_to_z_slab(self.0) } + } + fn get_split_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_get_split_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_get_split_mode(self.0) } + } + fn set_split_path( + &mut self, + len: core::ffi::c_int, + splitpath: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_split_path( + sself: *mut core::ffi::c_void, + len: core::ffi::c_int, + splitpath: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_set_split_path(self.0, len, splitpath) } + } + fn update_split_mode(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_translator_update_split_mode( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_translator_update_split_mode(self.0) } + } +} +impl VtkGraphAlgorithm for vtkGraphAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_algorithm_new_instance(self.0) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_graph_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_graph_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_algorithm_get_output(self.0) } + } + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_algorithm_get_output( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_algorithm_get_output(self.0, index) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_graph_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_graph_algorithm_set_input_data(self.0, obj) } + } + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_graph_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_graph_algorithm_set_input_data(self.0, index, obj) } + } +} +impl VtkHierarchicalBoxDataSetAlgorithm for vtkHierarchicalBoxDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_algorithm_get_output(self.0, p0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hierarchical_box_data_set_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hierarchical_box_data_set_algorithm_set_input_data(self.0, p0, p1) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_hierarchical_box_data_set_algorithm_process_request( + self.0, + request, + inputVector, + outputVector, + ) + } + } +} +impl VtkImageToStructuredGrid for vtkImageToStructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_grid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_grid_new_instance(self.0) } + } +} +impl VtkImageToStructuredPoints for vtkImageToStructuredPoints { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_points_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_points_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_points_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_points_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_points_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_points_new_instance(self.0) } + } + fn set_vector_input_data(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_image_to_structured_points_set_vector_input_data( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_to_structured_points_set_vector_input_data(self.0, input) } + } + fn get_vector_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_points_get_vector_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_points_get_vector_input(self.0) } + } + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_points_get_structured_points_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_points_get_structured_points_output(self.0) } + } +} +impl VtkMoleculeAlgorithm for vtkMoleculeAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_get_output(self.0, p0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_algorithm_set_output(self.0, d) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_molecule_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_molecule_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_get_input(self.0) } + } + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_get_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_get_input(self.0, port) } + } + fn get_molecule_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_get_molecule_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_get_molecule_input(self.0, port) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_algorithm_add_input_data(self.0, p0, p1) } + } +} +impl VtkMultiBlockDataSetAlgorithm for vtkMultiBlockDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_algorithm_get_output(self.0, p0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_multi_block_data_set_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_multi_block_data_set_algorithm_set_input_data(self.0, p0, p1) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_multi_block_data_set_algorithm_process_request( + self.0, + request, + inputVector, + outputVector, + ) + } + } +} +impl VtkMultiTimeStepAlgorithm for vtkMultiTimeStepAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_time_step_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_time_step_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_time_step_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_time_step_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_time_step_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_time_step_algorithm_new_instance(self.0) } + } +} +impl VtkNonOverlappingAMRAlgorithm for vtkNonOverlappingAMRAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_algorithm_get_output(self.0, p0) } + } +} +impl VtkOverlappingAMRAlgorithm for vtkOverlappingAMRAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_algorithm_get_output(self.0, p0) } + } +} +impl VtkPassInputTypeAlgorithm for vtkPassInputTypeAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_output(self.0, p0) } + } + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_poly_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_poly_data_output(self.0) } + } + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_structured_points_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_structured_points_output(self.0) } + } + fn get_image_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_image_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_image_data_output(self.0) } + } + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_structured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_structured_grid_output(self.0) } + } + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_unstructured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_unstructured_grid_output(self.0) } + } + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_rectilinear_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_rectilinear_grid_output(self.0) } + } + fn get_graph_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_graph_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_graph_output(self.0) } + } + fn get_molecule_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_molecule_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_molecule_output(self.0) } + } + fn get_table_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_table_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_table_output(self.0) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_input(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_pass_input_type_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_pass_input_type_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_pass_input_type_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_pass_input_type_algorithm_add_input_data(self.0, p0, p1) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_pass_input_type_algorithm_process_request( + self.0, + request, + inputVector, + outputVector, + ) + } + } +} +impl VtkPiecewiseFunctionAlgorithm for vtkPiecewiseFunctionAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_get_output(self.0, p0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_algorithm_set_output(self.0, d) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_get_input(self.0) } + } + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_get_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_get_input(self.0, port) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_algorithm_add_input_data(self.0, p0, p1) } + } +} +impl VtkPiecewiseFunctionShiftScale for vtkPiecewiseFunctionShiftScale { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_shift_scale_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_shift_scale_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_shift_scale_new_instance(self.0) } + } + fn set_position_shift(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_set_position_shift( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_shift_scale_set_position_shift(self.0, _arg) } + } + fn set_position_scale(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_set_position_scale( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_shift_scale_set_position_scale(self.0, _arg) } + } + fn set_value_shift(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_set_value_shift( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_shift_scale_set_value_shift(self.0, _arg) } + } + fn set_value_scale(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_set_value_scale( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_shift_scale_set_value_scale(self.0, _arg) } + } + fn get_position_shift(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_get_position_shift( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_shift_scale_get_position_shift(self.0) } + } + fn get_position_scale(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_get_position_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_shift_scale_get_position_scale(self.0) } + } + fn get_value_shift(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_get_value_shift( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_shift_scale_get_value_shift(self.0) } + } + fn get_value_scale(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_get_value_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_shift_scale_get_value_scale(self.0) } + } +} +impl VtkPointSetAlgorithm for vtkPointSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_output(self.0, p0) } + } + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_poly_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_poly_data_output(self.0) } + } + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_structured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_structured_grid_output(self.0) } + } + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_unstructured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_unstructured_grid_output(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_algorithm_set_input_data(self.0, p0, p1) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_set_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_algorithm_add_input_data(self.0, p0, p1) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_set_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_algorithm_add_input_data(self.0, p0, p1) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_input(self.0) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_set_algorithm_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_point_set_algorithm_process_request( + self.0, + request, + inputVector, + outputVector, + ) + } + } +} +impl VtkPolyDataAlgorithm for vtkPolyDataAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_get_output(self.0, p0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_algorithm_set_output(self.0, d) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_get_input(self.0) } + } + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_get_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_get_input(self.0, port) } + } + fn get_poly_data_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_get_poly_data_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_get_poly_data_input(self.0, port) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_algorithm_add_input_data(self.0, p0, p1) } + } +} +impl VtkProgressObserver for vtkProgressObserver { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_progress_observer_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_progress_observer_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_progress_observer_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_progress_observer_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_progress_observer_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_progress_observer_new_instance(self.0) } + } + fn update_progress(&mut self, amount: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_progress_observer_update_progress( + sself: *mut core::ffi::c_void, + amount: core::ffi::c_double, + ); + } + unsafe { vtk_progress_observer_update_progress(self.0, amount) } + } + fn get_progress(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_progress_observer_get_progress( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_progress_observer_get_progress(self.0) } + } +} +impl VtkReaderExecutive for vtkReaderExecutive { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reader_executive_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reader_executive_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reader_executive_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reader_executive_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reader_executive_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reader_executive_new_instance(self.0) } + } +} +impl VtkRectilinearGridAlgorithm for vtkRectilinearGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_get_output(self.0, p0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_algorithm_set_output(self.0, d) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_get_input(self.0) } + } + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_get_input(self.0, port) } + } + fn get_rectilinear_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_get_rectilinear_grid_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_rectilinear_grid_algorithm_get_rectilinear_grid_input(self.0, port) + } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_algorithm_add_input_data(self.0, p0, p1) } + } +} +impl VtkSMPProgressObserver for vtkSMPProgressObserver { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smp_progress_observer_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smp_progress_observer_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smp_progress_observer_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smp_progress_observer_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smp_progress_observer_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smp_progress_observer_new_instance(self.0) } + } + fn update_progress(&mut self, progress: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_smp_progress_observer_update_progress( + sself: *mut core::ffi::c_void, + progress: core::ffi::c_double, + ); + } + unsafe { vtk_smp_progress_observer_update_progress(self.0, progress) } + } + fn get_local_observer(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smp_progress_observer_get_local_observer( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smp_progress_observer_get_local_observer(self.0) } + } +} +impl VtkSelectionAlgorithm for vtkSelectionAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_algorithm_new_instance(self.0) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_algorithm_get_output(self.0) } + } + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_algorithm_get_output( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_algorithm_get_output(self.0, index) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_algorithm_set_input_data(self.0, obj) } + } + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_selection_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_algorithm_set_input_data(self.0, index, obj) } + } +} +impl VtkSimpleScalarTree for vtkSimpleScalarTree { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_scalar_tree_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_scalar_tree_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_scalar_tree_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_scalar_tree_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_scalar_tree_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_scalar_tree_new_instance(self.0) } + } + fn set_branching_factor(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_simple_scalar_tree_set_branching_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_simple_scalar_tree_set_branching_factor(self.0, _arg) } + } + fn get_branching_factor_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_branching_factor_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_branching_factor_min_value(self.0) } + } + fn get_branching_factor_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_branching_factor_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_branching_factor_max_value(self.0) } + } + fn get_branching_factor(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_branching_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_branching_factor(self.0) } + } + fn get_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_level(self.0) } + } + fn set_max_level(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_simple_scalar_tree_set_max_level( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_simple_scalar_tree_set_max_level(self.0, _arg) } + } + fn get_max_level_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_max_level_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_max_level_min_value(self.0) } + } + fn get_max_level_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_max_level_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_max_level_max_value(self.0) } + } + fn get_max_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_max_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_max_level(self.0) } + } + fn build_tree(&mut self) -> () { + unsafe extern "C" { + fn vtk_simple_scalar_tree_build_tree(sself: *mut core::ffi::c_void); + } + unsafe { vtk_simple_scalar_tree_build_tree(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_simple_scalar_tree_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_simple_scalar_tree_initialize(self.0) } + } + fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_simple_scalar_tree_init_traversal( + sself: *mut core::ffi::c_void, + scalarValue: core::ffi::c_double, + ); + } + unsafe { vtk_simple_scalar_tree_init_traversal(self.0, scalarValue) } + } + fn get_next_cell( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_next_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_simple_scalar_tree_get_next_cell(self.0, cellId, ptIds, cellScalars) + } + } + fn get_number_of_cell_batches( + &mut self, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_number_of_cell_batches( + sself: *mut core::ffi::c_void, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_simple_scalar_tree_get_number_of_cell_batches(self.0, scalarValue) } + } + fn get_cell_batch( + &mut self, + batchNum: core::ffi::c_uchar, + numCells: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_cell_batch( + sself: *mut core::ffi::c_void, + batchNum: core::ffi::c_uchar, + numCells: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_simple_scalar_tree_get_cell_batch(self.0, batchNum, numCells) } + } +} +impl VtkSpanSpace for vtkSpanSpace { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_span_space_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_span_space_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_span_space_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_span_space_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_span_space_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_span_space_new_instance(self.0) } + } + fn set_scalar_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_span_space_set_scalar_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_span_space_set_scalar_range(self.0, _arg1, _arg2) } + } + fn set_scalar_range(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_span_space_set_scalar_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_span_space_set_scalar_range(self.0, _arg) } + } + fn get_scalar_range(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_span_space_get_scalar_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_span_space_get_scalar_range(self.0) } + } + fn get_scalar_range(&mut self, data: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_span_space_get_scalar_range( + sself: *mut core::ffi::c_void, + data: core::ffi::c_double, + ); + } + unsafe { vtk_span_space_get_scalar_range(self.0, data) } + } + fn set_compute_scalar_range(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_span_space_set_compute_scalar_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_span_space_set_compute_scalar_range(self.0, _arg) } + } + fn get_compute_scalar_range(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_span_space_get_compute_scalar_range( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_span_space_get_compute_scalar_range(self.0) } + } + fn compute_scalar_range_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_compute_scalar_range_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_compute_scalar_range_on(self.0) } + } + fn compute_scalar_range_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_compute_scalar_range_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_compute_scalar_range_off(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_span_space_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_span_space_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_span_space_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_span_space_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_span_space_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_span_space_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_span_space_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_span_space_get_resolution(self.0) } + } + fn set_compute_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_span_space_set_compute_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_span_space_set_compute_resolution(self.0, _arg) } + } + fn get_compute_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_span_space_get_compute_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_span_space_get_compute_resolution(self.0) } + } + fn compute_resolution_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_compute_resolution_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_compute_resolution_on(self.0) } + } + fn compute_resolution_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_compute_resolution_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_compute_resolution_off(self.0) } + } + fn set_number_of_cells_per_bucket(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_span_space_set_number_of_cells_per_bucket( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_span_space_set_number_of_cells_per_bucket(self.0, _arg) } + } + fn get_number_of_cells_per_bucket_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_span_space_get_number_of_cells_per_bucket_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_span_space_get_number_of_cells_per_bucket_min_value(self.0) } + } + fn get_number_of_cells_per_bucket_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_span_space_get_number_of_cells_per_bucket_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_span_space_get_number_of_cells_per_bucket_max_value(self.0) } + } + fn get_number_of_cells_per_bucket(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_span_space_get_number_of_cells_per_bucket( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_span_space_get_number_of_cells_per_bucket(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_initialize(self.0) } + } + fn build_tree(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_build_tree(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_build_tree(self.0) } + } + fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_span_space_init_traversal( + sself: *mut core::ffi::c_void, + scalarValue: core::ffi::c_double, + ); + } + unsafe { vtk_span_space_init_traversal(self.0, scalarValue) } + } + fn get_next_cell( + &mut self, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_span_space_get_next_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_uchar, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_span_space_get_next_cell(self.0, cellId, ptIds, cellScalars) } + } + fn get_number_of_cell_batches( + &mut self, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_span_space_get_number_of_cell_batches( + sself: *mut core::ffi::c_void, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_span_space_get_number_of_cell_batches(self.0, scalarValue) } + } + fn get_cell_batch( + &mut self, + batchNum: core::ffi::c_uchar, + numCells: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_span_space_get_cell_batch( + sself: *mut core::ffi::c_void, + batchNum: core::ffi::c_uchar, + numCells: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_span_space_get_cell_batch(self.0, batchNum, numCells) } + } + fn set_batch_size(&mut self, _arg: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_span_space_set_batch_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uchar, + ); + } + unsafe { vtk_span_space_set_batch_size(self.0, _arg) } + } + fn get_batch_size_min_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_span_space_get_batch_size_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_span_space_get_batch_size_min_value(self.0) } + } + fn get_batch_size_max_value(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_span_space_get_batch_size_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_span_space_get_batch_size_max_value(self.0) } + } + fn get_batch_size(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_span_space_get_batch_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_span_space_get_batch_size(self.0) } + } +} +impl VtkSphereTree for vtkSphereTree { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_tree_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_tree_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_tree_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_tree_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_tree_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_tree_new_instance(self.0) } + } + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_set_data_set( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sphere_tree_set_data_set(self.0, p0) } + } + fn get_data_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_tree_get_data_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_tree_get_data_set(self.0) } + } + fn build(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_build(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_tree_build(self.0) } + } + fn build(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_build( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sphere_tree_build(self.0, input) } + } + fn set_build_hierarchy(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_set_build_hierarchy( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_sphere_tree_set_build_hierarchy(self.0, _arg) } + } + fn get_build_hierarchy(&mut self) -> bool { + unsafe extern "C" { + fn vtk_sphere_tree_get_build_hierarchy( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_sphere_tree_get_build_hierarchy(self.0) } + } + fn build_hierarchy_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_build_hierarchy_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_tree_build_hierarchy_on(self.0) } + } + fn build_hierarchy_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_build_hierarchy_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_tree_build_hierarchy_off(self.0) } + } + fn select_point( + &mut self, + point: core::ffi::c_double, + numSelected: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_sphere_tree_select_point( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + numSelected: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_sphere_tree_select_point(self.0, point, numSelected) } + } + fn select_line( + &mut self, + origin: core::ffi::c_double, + ray: core::ffi::c_double, + numSelected: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_sphere_tree_select_line( + sself: *mut core::ffi::c_void, + origin: core::ffi::c_double, + ray: core::ffi::c_double, + numSelected: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_sphere_tree_select_line(self.0, origin, ray, numSelected) } + } + fn select_plane( + &mut self, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + numSelected: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_sphere_tree_select_plane( + sself: *mut core::ffi::c_void, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + numSelected: core::ffi::c_uchar, + ) -> *const core::ffi::c_uchar; + } + unsafe { vtk_sphere_tree_select_plane(self.0, origin, normal, numSelected) } + } + fn select_point( + &mut self, + point: core::ffi::c_double, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_select_point( + sself: *mut core::ffi::c_void, + point: core::ffi::c_double, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sphere_tree_select_point(self.0, point, cellIds) } + } + fn select_line( + &mut self, + origin: core::ffi::c_double, + ray: core::ffi::c_double, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_select_line( + sself: *mut core::ffi::c_void, + origin: core::ffi::c_double, + ray: core::ffi::c_double, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sphere_tree_select_line(self.0, origin, ray, cellIds) } + } + fn select_plane( + &mut self, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_select_plane( + sself: *mut core::ffi::c_void, + origin: core::ffi::c_double, + normal: core::ffi::c_double, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sphere_tree_select_plane(self.0, origin, normal, cellIds) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_tree_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_resolution(self.0) } + } + fn set_max_level(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_set_max_level( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_tree_set_max_level(self.0, _arg) } + } + fn get_max_level_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_max_level_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_max_level_min_value(self.0) } + } + fn get_max_level_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_max_level_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_max_level_max_value(self.0) } + } + fn get_max_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_max_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_max_level(self.0) } + } + fn get_number_of_levels(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_number_of_levels( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_number_of_levels(self.0) } + } + fn get_cell_spheres(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_tree_get_cell_spheres( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_sphere_tree_get_cell_spheres(self.0) } + } + fn get_tree_spheres( + &mut self, + level: core::ffi::c_int, + numSpheres: core::ffi::c_uchar, + ) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_tree_get_tree_spheres( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + numSpheres: core::ffi::c_uchar, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_sphere_tree_get_tree_spheres(self.0, level, numSpheres) } + } +} +impl VtkStreamingDemandDrivenPipeline for vtkStreamingDemandDrivenPipeline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_new_instance(self.0) } + } + fn update(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_streaming_demand_driven_pipeline_update(self.0) } + } + fn update_whole_extent(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_whole_extent( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_whole_extent(self.0) } + } + fn update( + &mut self, + port: core::ffi::c_int, + requests: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + requests: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_streaming_demand_driven_pipeline_update(self.0, port, requests) } + } + fn propagate_update_extent( + &mut self, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_propagate_update_extent( + sself: *mut core::ffi::c_void, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_propagate_update_extent( + self.0, + outputPort, + ) + } + } + fn propagate_time(&mut self, outputPort: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_propagate_time( + sself: *mut core::ffi::c_void, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_propagate_time(self.0, outputPort) + } + } + fn update_time_dependent_information( + &mut self, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_time_dependent_information( + sself: *mut core::ffi::c_void, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_update_time_dependent_information( + self.0, + outputPort, + ) + } + } + fn set_whole_extent( + &mut self, + p0: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_set_whole_extent( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_set_whole_extent(self.0, p0, extent) + } + } + fn get_whole_extent( + &mut self, + p0: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_whole_extent( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ); + } + unsafe { + vtk_streaming_demand_driven_pipeline_get_whole_extent(self.0, p0, extent) + } + } + fn get_whole_extent(&mut self, p0: *mut core::ffi::c_void) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_whole_extent( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_streaming_demand_driven_pipeline_get_whole_extent(self.0, p0) } + } + fn set_request_exact_extent( + &mut self, + port: core::ffi::c_int, + flag: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_set_request_exact_extent( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + flag: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_set_request_exact_extent( + self.0, + port, + flag, + ) + } + } + fn get_request_exact_extent(&mut self, port: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_request_exact_extent( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_get_request_exact_extent(self.0, port) + } + } + fn request_update_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_request_update_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_request_update_extent(self.0) } + } + fn request_update_time(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_request_update_time( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_request_update_time(self.0) } + } + fn request_time_dependent_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_request_time_dependent_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_streaming_demand_driven_pipeline_request_time_dependent_information( + self.0, + ) + } + } + fn continue_executing(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_continue_executing( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_continue_executing(self.0) } + } + fn update_extent_initialized(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_extent_initialized( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_extent_initialized(self.0) } + } + fn update_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_extent(self.0) } + } + fn update_piece_number(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_piece_number( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_piece_number(self.0) } + } + fn update_number_of_pieces(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_number_of_pieces(self.0) } + } + fn update_number_of_ghost_levels(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_number_of_ghost_levels( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_streaming_demand_driven_pipeline_update_number_of_ghost_levels(self.0) + } + } + fn combined_update_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_combined_update_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_combined_update_extent(self.0) } + } + fn whole_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_whole_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_whole_extent(self.0) } + } + fn unrestricted_update_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_unrestricted_update_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_streaming_demand_driven_pipeline_unrestricted_update_extent(self.0) + } + } + fn exact_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_exact_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_exact_extent(self.0) } + } + fn time_steps(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_time_steps( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_time_steps(self.0) } + } + fn time_range(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_time_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_time_range(self.0) } + } + fn update_time_step(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_time_step( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_time_step(self.0) } + } + fn time_dependent_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_time_dependent_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_streaming_demand_driven_pipeline_time_dependent_information(self.0) + } + } + fn bounds(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_bounds(self.0) } + } + fn get_update_extent( + &mut self, + p0: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_update_extent( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + extent: core::ffi::c_int, + ); + } + unsafe { + vtk_streaming_demand_driven_pipeline_get_update_extent(self.0, p0, extent) + } + } + fn get_update_extent( + &mut self, + p0: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_update_extent( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_streaming_demand_driven_pipeline_get_update_extent(self.0, p0) } + } + fn get_update_piece(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_update_piece( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_streaming_demand_driven_pipeline_get_update_piece(self.0, p0) } + } + fn get_update_number_of_pieces( + &mut self, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_update_number_of_pieces( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_get_update_number_of_pieces(self.0, p0) + } + } + fn get_update_ghost_level( + &mut self, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_update_ghost_level( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_get_update_ghost_level(self.0, p0) + } + } +} +impl VtkStructuredGridAlgorithm for vtkStructuredGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_get_output(self.0, p0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_algorithm_set_output(self.0, d) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_grid_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_get_input(self.0) } + } + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_get_input(self.0, port) } + } + fn get_structured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_get_structured_grid_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_get_structured_grid_input(self.0, port) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_algorithm_add_input_data(self.0, p0, p1) } + } +} +impl VtkTableAlgorithm for vtkTableAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_algorithm_new_instance(self.0) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_table_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_table_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_algorithm_get_output(self.0) } + } + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_algorithm_get_output( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_algorithm_get_output(self.0, index) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_table_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_algorithm_set_input_data(self.0, obj) } + } + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_table_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_algorithm_set_input_data(self.0, index, obj) } + } +} +impl VtkThreadedCompositeDataPipeline for vtkThreadedCompositeDataPipeline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_threaded_composite_data_pipeline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_threaded_composite_data_pipeline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_threaded_composite_data_pipeline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_threaded_composite_data_pipeline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_threaded_composite_data_pipeline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_threaded_composite_data_pipeline_new_instance(self.0) } + } +} +impl VtkTreeAlgorithm for vtkTreeAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_algorithm_new_instance(self.0) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tree_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tree_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_algorithm_get_output(self.0) } + } + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_algorithm_get_output( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_algorithm_get_output(self.0, index) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_tree_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tree_algorithm_set_input_data(self.0, obj) } + } + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_tree_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tree_algorithm_set_input_data(self.0, index, obj) } + } +} +impl VtkTrivialConsumer for vtkTrivialConsumer { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_consumer_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_consumer_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_consumer_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_consumer_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_consumer_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_consumer_new_instance(self.0) } + } +} +impl VtkTrivialProducer for vtkTrivialProducer { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_producer_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_producer_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_producer_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_producer_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_producer_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_producer_new_instance(self.0) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_trivial_producer_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_trivial_producer_process_request(self.0, p0, p1, p2) } + } + fn set_output(&mut self, output: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_trivial_producer_set_output( + sself: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ); + } + unsafe { vtk_trivial_producer_set_output(self.0, output) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_trivial_producer_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_trivial_producer_get_m_time(self.0) } + } + fn set_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_trivial_producer_set_whole_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_trivial_producer_set_whole_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn set_whole_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_trivial_producer_set_whole_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_trivial_producer_set_whole_extent(self.0, _arg) } + } + fn get_whole_extent(&mut self) -> *mut core::ffi::c_int { + unsafe extern "C" { + fn vtk_trivial_producer_get_whole_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_int; + } + unsafe { vtk_trivial_producer_get_whole_extent(self.0) } + } + fn get_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_trivial_producer_get_whole_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_trivial_producer_get_whole_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn get_whole_extent(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_trivial_producer_get_whole_extent( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_trivial_producer_get_whole_extent(self.0, _arg) } + } + fn fill_output_data_information( + &mut self, + output: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_trivial_producer_fill_output_data_information( + sself: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_trivial_producer_fill_output_data_information(self.0, output, outInfo) + } + } +} +impl VtkUndirectedGraphAlgorithm for vtkUndirectedGraphAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_algorithm_new_instance(self.0) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_undirected_graph_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_algorithm_get_output(self.0) } + } + fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_get_output( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_algorithm_get_output(self.0, index) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_undirected_graph_algorithm_set_input_data(self.0, obj) } + } + fn set_input_data( + &mut self, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_undirected_graph_algorithm_set_input_data(self.0, index, obj) } + } +} +impl VtkUniformGridAMRAlgorithm for vtkUniformGridAMRAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_algorithm_get_output(self.0, p0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_algorithm_set_input_data(self.0, p0, p1) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inputVector: *mut core::ffi::c_void, + outputVector: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_uniform_grid_amr_algorithm_process_request( + self.0, + request, + inputVector, + outputVector, + ) + } + } +} +impl VtkUniformGridPartitioner for vtkUniformGridPartitioner { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_partitioner_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_partitioner_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_partitioner_new_instance(self.0) } + } + fn get_number_of_partitions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_get_number_of_partitions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_partitioner_get_number_of_partitions(self.0) } + } + fn set_number_of_partitions(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_set_number_of_partitions( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_partitioner_set_number_of_partitions(self.0, _arg) } + } + fn get_number_of_ghost_layers(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_get_number_of_ghost_layers( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_partitioner_get_number_of_ghost_layers(self.0) } + } + fn set_number_of_ghost_layers(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_set_number_of_ghost_layers( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_partitioner_set_number_of_ghost_layers(self.0, _arg) } + } + fn get_duplicate_nodes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_get_duplicate_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_partitioner_get_duplicate_nodes(self.0) } + } + fn set_duplicate_nodes(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_set_duplicate_nodes( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_partitioner_set_duplicate_nodes(self.0, _arg) } + } + fn duplicate_nodes_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_duplicate_nodes_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_partitioner_duplicate_nodes_on(self.0) } + } + fn duplicate_nodes_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_duplicate_nodes_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_partitioner_duplicate_nodes_off(self.0) } + } +} +impl VtkUnstructuredGridAlgorithm for vtkUnstructuredGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_get_output(self.0, p0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_algorithm_set_output(self.0, d) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_algorithm_process_request(self.0, p0, p1, p2) } + } + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_get_input(self.0, port) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_get_input(self.0) } + } + fn get_unstructured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_get_unstructured_grid_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_unstructured_grid_algorithm_get_unstructured_grid_input(self.0, port) + } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_algorithm_add_input_data(self.0, p0, p1) } + } +} +impl VtkUnstructuredGridBaseAlgorithm for vtkUnstructuredGridBaseAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_base_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_base_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_base_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_base_algorithm_get_output(self.0) } + } + fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_get_output( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_base_algorithm_get_output(self.0, p0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_base_algorithm_set_output(self.0, d) } + } + fn process_request( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_process_request( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_unstructured_grid_base_algorithm_process_request(self.0, p0, p1, p2) + } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_base_algorithm_set_input_data(self.0, p0) } + } + fn set_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_base_algorithm_set_input_data(self.0, p0, p1) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_base_algorithm_add_input_data(self.0, p0) } + } + fn add_input_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_base_algorithm_add_input_data(self.0, p0, p1) } + } +} /// Superclass for all sources, filters, and sinks in VTK. /// /// @@ -364,7 +9321,7 @@ fn test_vtkCastToConcrete_create_drop() { /// * REQUEST_INFORMATION: The producers have to provide information about /// the contents of the composite dataset in this pass. /// Sources that can produce more than one piece (note that a piece is -/// different than a block; each piece consists of 0 or more blocks) should +/// different than a block; each piece consistes of 0 or more blocks) should /// set CAN_HANDLE_PIECE_REQUEST. /// /// * REQUEST_UPDATE_EXTENT: This pass is identical to the one implemented diff --git a/vtk-rs-9.1/src/vtkCommonMath.rs b/vtk-rs-9.1/src/vtkCommonMath.rs index 4d14109..01ed117 100644 --- a/vtk-rs-9.1/src/vtkCommonMath.rs +++ b/vtk-rs-9.1/src/vtkCommonMath.rs @@ -1,3 +1,2973 @@ +pub trait VtkAmoebaMinimizer { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_function(&mut self, f: *mut core::ffi::c_void, arg: ()) -> (); + fn set_function_arg_delete(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_parameter_value( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_double, + ) -> (); + fn set_parameter_value( + &mut self, + i: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn set_parameter_scale( + &mut self, + name: core::ffi::c_char, + scale: core::ffi::c_double, + ) -> (); + fn get_parameter_scale(&mut self, name: core::ffi::c_char) -> core::ffi::c_double; + fn set_parameter_scale( + &mut self, + i: core::ffi::c_int, + scale: core::ffi::c_double, + ) -> (); + fn get_parameter_scale(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn get_parameter_value(&mut self, name: core::ffi::c_char) -> core::ffi::c_double; + fn get_parameter_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn get_parameter_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char; + fn get_number_of_parameters(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn minimize(&mut self) -> (); + fn iterate(&mut self) -> core::ffi::c_int; + fn set_function_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_function_value(&mut self) -> core::ffi::c_double; + fn set_contraction_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_contraction_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_contraction_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_contraction_ratio(&mut self) -> core::ffi::c_double; + fn set_expansion_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_expansion_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_expansion_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_expansion_ratio(&mut self) -> core::ffi::c_double; + fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tolerance(&mut self) -> core::ffi::c_double; + fn set_parameter_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_parameter_tolerance(&mut self) -> core::ffi::c_double; + fn set_max_iterations(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_iterations(&mut self) -> core::ffi::c_int; + fn get_iterations(&mut self) -> core::ffi::c_int; + fn get_function_evaluations(&mut self) -> core::ffi::c_int; + fn evaluate_function(&mut self) -> (); +} +pub trait VtkFFT { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fft(&mut self, in_: Vec) -> Vec; + fn fft(&mut self, in_: Vec) -> Vec; + fn r_fft(&mut self, in_: Vec) -> Vec; + fn i_fft(&mut self, in_: Vec) -> Vec; + fn ir_fft(&mut self, in_: Vec) -> Vec; + fn abs(&mut self, in_: kiss_fft_cpx) -> core::ffi::c_double; + fn squared_abs(&mut self, in_: kiss_fft_cpx) -> core::ffi::c_double; + fn fft_freq( + &mut self, + windowLength: core::ffi::c_int, + sampleSpacing: core::ffi::c_double, + ) -> Vec; + fn r_fft_freq( + &mut self, + windowLength: core::ffi::c_int, + sampleSpacing: core::ffi::c_double, + ) -> Vec; + fn hanning_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; + fn bartlett_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; + fn sine_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; + fn blackman_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; + fn rectangular_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; +} +pub trait VtkFunctionSet { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn function_values( + &mut self, + x: core::ffi::c_double, + f: core::ffi::c_double, + ) -> core::ffi::c_int; + fn function_values( + &mut self, + x: core::ffi::c_double, + f: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; + fn get_number_of_functions(&mut self) -> core::ffi::c_int; + fn get_number_of_independent_variables(&mut self) -> core::ffi::c_int; +} +pub trait VtkInitialValueProblemSolver { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + ) -> core::ffi::c_int; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + dxprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + ) -> core::ffi::c_int; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + dxprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + delTActual: core::ffi::c_double, + minStep: core::ffi::c_double, + maxStep: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + ) -> core::ffi::c_int; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + delTActual: core::ffi::c_double, + minStep: core::ffi::c_double, + maxStep: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + dxprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + delTActual: core::ffi::c_double, + minStep: core::ffi::c_double, + maxStep: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + ) -> core::ffi::c_int; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + dxprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + delTActual: core::ffi::c_double, + minStep: core::ffi::c_double, + maxStep: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; + fn set_function_set(&mut self, fset: *mut core::ffi::c_void) -> (); + fn get_function_set(&mut self) -> *mut core::ffi::c_void; + fn is_adaptive(&mut self) -> core::ffi::c_int; +} +pub trait VtkMatrix3x3 { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, source: *mut core::ffi::c_void) -> (); + fn deep_copy( + &mut self, + elements: core::ffi::c_double, + source: *mut core::ffi::c_void, + ) -> (); + fn deep_copy( + &mut self, + elements: core::ffi::c_double, + newElements: core::ffi::c_double, + ) -> (); + fn deep_copy(&mut self, elements: core::ffi::c_double) -> (); + fn zero(&mut self) -> (); + fn zero(&mut self, elements: core::ffi::c_double) -> (); + fn identity(&mut self) -> (); + fn identity(&mut self, elements: core::ffi::c_double) -> (); + fn invert(&mut self, in_: *mut core::ffi::c_void, out: *mut core::ffi::c_void) -> (); + fn invert(&mut self) -> (); + fn invert( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> (); + fn transpose( + &mut self, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ) -> (); + fn transpose(&mut self) -> (); + fn transpose( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> (); + fn multiply_point(&mut self, in_: core::ffi::c_float, out: core::ffi::c_float) -> (); + fn multiply_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn multiply_point( + &mut self, + elements: core::ffi::c_double, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn multiply_point( + &mut self, + elements: core::ffi::c_double, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn multiply_3_x_3( + &mut self, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ) -> (); + fn multiply_3_x_3( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> (); + fn adjoint( + &mut self, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ) -> (); + fn adjoint( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> (); + fn determinant(&mut self) -> core::ffi::c_double; + fn determinant(&mut self, elements: core::ffi::c_double) -> core::ffi::c_double; + fn set_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double; + fn is_identity(&mut self) -> bool; + fn get_data(&mut self) -> *mut core::ffi::c_double; + fn get_data(&mut self) -> *const core::ffi::c_double; +} +pub trait VtkMatrix4x4 { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, source: vtkMatrix4x4) -> (); + fn deep_copy( + &mut self, + destination: core::ffi::c_double, + source: vtkMatrix4x4, + ) -> (); + fn deep_copy( + &mut self, + destination: core::ffi::c_double, + source: core::ffi::c_double, + ) -> (); + fn deep_copy(&mut self, elements: core::ffi::c_double) -> (); + fn zero(&mut self) -> (); + fn zero(&mut self, elements: core::ffi::c_double) -> (); + fn identity(&mut self) -> (); + fn identity(&mut self, elements: core::ffi::c_double) -> (); + fn is_identity(&mut self) -> bool; + fn invert(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> (); + fn invert(&mut self) -> (); + fn invert( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> (); + fn transpose(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> (); + fn transpose(&mut self) -> (); + fn transpose( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> (); + fn multiply_point(&mut self, in_: core::ffi::c_float, out: core::ffi::c_float) -> (); + fn multiply_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn multiply_point( + &mut self, + elements: core::ffi::c_double, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn multiply_point( + &mut self, + elements: core::ffi::c_double, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn multiply_point(&mut self, in_: core::ffi::c_float) -> *mut core::ffi::c_float; + fn multiply_point(&mut self, in_: core::ffi::c_double) -> *mut core::ffi::c_double; + fn multiply_float_point( + &mut self, + in_: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + fn multiply_double_point( + &mut self, + in_: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn multiply_4_x_4( + &mut self, + a: vtkMatrix4x4, + b: vtkMatrix4x4, + c: *mut core::ffi::c_void, + ) -> (); + fn multiply_4_x_4( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> (); + fn multiply_4_x_4( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_float, + ) -> (); + fn multiply_and_transpose_4_x_4( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_float, + ) -> (); + fn adjoint(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> (); + fn adjoint( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> (); + fn determinant(&mut self) -> core::ffi::c_double; + fn determinant(&mut self, elements: core::ffi::c_double) -> core::ffi::c_double; + fn set_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double; + fn get_data(&mut self) -> *mut core::ffi::c_double; + fn get_data(&mut self) -> *const core::ffi::c_double; +} +pub trait VtkPolynomialSolversUnivariate { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn habicht_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + fn habicht_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + ) -> core::ffi::c_int; + fn habicht_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + divideGCD: bool, + ) -> core::ffi::c_int; + fn sturm_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + fn sturm_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + ) -> core::ffi::c_int; + fn sturm_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + divideGCD: bool, + ) -> core::ffi::c_int; + fn filter_roots( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + upperBnds: core::ffi::c_double, + rootcount: core::ffi::c_int, + diameter: core::ffi::c_double, + ) -> core::ffi::c_int; + fn lin_bairstow_solve( + &mut self, + c: core::ffi::c_double, + d: core::ffi::c_int, + r: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int; + fn ferrari_solve( + &mut self, + c: core::ffi::c_double, + r: core::ffi::c_double, + m: core::ffi::c_int, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + fn tartaglia_cardan_solve( + &mut self, + c: core::ffi::c_double, + r: core::ffi::c_double, + m: core::ffi::c_int, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + fn solve_cubic( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn solve_quadratic( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn solve_linear( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn solve_cubic( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + r1: core::ffi::c_double, + r2: core::ffi::c_double, + r3: core::ffi::c_double, + num_roots: core::ffi::c_int, + ) -> core::ffi::c_int; + fn solve_quadratic( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + r1: core::ffi::c_double, + r2: core::ffi::c_double, + num_roots: core::ffi::c_int, + ) -> core::ffi::c_int; + fn solve_quadratic( + &mut self, + c: core::ffi::c_double, + r: core::ffi::c_double, + m: core::ffi::c_int, + ) -> core::ffi::c_int; + fn solve_linear( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + r1: core::ffi::c_double, + num_roots: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_division_tolerance(&mut self, tol: core::ffi::c_double) -> (); + fn get_division_tolerance(&mut self) -> core::ffi::c_double; +} +pub trait VtkQuaternion: VtkTuple { + fn squared_norm(&mut self) -> *mut core::ffi::c_void; + fn norm(&mut self) -> *mut core::ffi::c_void; + fn to_identity(&mut self) -> (); + fn normalize(&mut self) -> *mut core::ffi::c_void; + fn conjugate(&mut self) -> (); + fn invert(&mut self) -> (); + fn to_unit_log(&mut self) -> (); + fn to_unit_exp(&mut self) -> (); + fn normalize_with_angle_in_degrees(&mut self) -> (); + fn set(&mut self, w: T, x: T, y: T, z: T) -> (); + fn set(&mut self, quat: *mut core::ffi::c_void) -> (); + fn get(&mut self, quat: *mut core::ffi::c_void) -> (); + fn set_w(&mut self, w: T) -> (); + fn get_w(&mut self) -> T; + fn set_x(&mut self, x: T) -> (); + fn get_x(&mut self) -> T; + fn set_y(&mut self, y: T) -> (); + fn get_y(&mut self) -> T; + fn set_z(&mut self, z: T) -> (); + fn get_z(&mut self) -> T; + fn get_rotation_angle_and_axis( + &mut self, + axis: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn set_rotation_angle_and_axis( + &mut self, + angle: *mut core::ffi::c_void, + axis: *mut core::ffi::c_void, + ) -> (); + fn set_rotation_angle_and_axis(&mut self, angle: T, x: T, y: T, z: T) -> (); + fn to_matrix_3_x_3(&mut self, A: *mut core::ffi::c_void) -> (); + fn from_matrix_3_x_3(&mut self, A: T) -> (); +} +pub trait VtkQuaternionInterpolator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_quaternions(&mut self) -> core::ffi::c_int; + fn get_minimum_t(&mut self) -> core::ffi::c_double; + fn get_maximum_t(&mut self) -> core::ffi::c_double; + fn initialize(&mut self) -> (); + fn add_quaternion(&mut self, t: core::ffi::c_double, q: vtkQuaterniond) -> (); + fn add_quaternion(&mut self, t: core::ffi::c_double, q: core::ffi::c_double) -> (); + fn remove_quaternion(&mut self, t: core::ffi::c_double) -> (); + fn interpolate_quaternion( + &mut self, + t: core::ffi::c_double, + q: *mut core::ffi::c_void, + ) -> (); + fn interpolate_quaternion( + &mut self, + t: core::ffi::c_double, + q: core::ffi::c_double, + ) -> (); + fn get_search_method(&mut self) -> core::ffi::c_int; + fn set_search_method(&mut self, type_: core::ffi::c_int) -> (); + fn set_interpolation_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_interpolation_type_min_value(&mut self) -> core::ffi::c_int; + fn get_interpolation_type_max_value(&mut self) -> core::ffi::c_int; + fn get_interpolation_type(&mut self) -> core::ffi::c_int; + fn set_interpolation_type_to_linear(&mut self) -> (); + fn set_interpolation_type_to_spline(&mut self) -> (); +} +pub trait VtkQuaterniond: VtkQuaternion + VtkTuple { + fn identity(&mut self) -> *mut core::ffi::c_void; + fn normalized(&mut self) -> *mut core::ffi::c_void; + fn conjugated(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> *mut core::ffi::c_void; + fn unit_log(&mut self) -> *mut core::ffi::c_void; + fn unit_exp(&mut self) -> *mut core::ffi::c_void; + fn normalized_with_angle_in_degrees(&mut self) -> *mut core::ffi::c_void; + fn slerp( + &mut self, + t: core::ffi::c_double, + q: vtkQuaterniond, + ) -> *mut core::ffi::c_void; + fn inner_point( + &mut self, + q1: vtkQuaterniond, + q2: vtkQuaterniond, + ) -> *mut core::ffi::c_void; + fn squared_norm(&mut self) -> core::ffi::c_double; + fn norm(&mut self) -> core::ffi::c_double; + fn normalize(&mut self) -> core::ffi::c_double; + fn set( + &mut self, + w: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set(&mut self, quat: core::ffi::c_double) -> (); + fn get(&mut self, quat: core::ffi::c_double) -> (); + fn set_w(&mut self, w: core::ffi::c_double) -> (); + fn get_w(&mut self) -> core::ffi::c_double; + fn set_x(&mut self, x: core::ffi::c_double) -> (); + fn get_x(&mut self) -> core::ffi::c_double; + fn set_y(&mut self, y: core::ffi::c_double) -> (); + fn get_y(&mut self) -> core::ffi::c_double; + fn set_z(&mut self, z: core::ffi::c_double) -> (); + fn get_z(&mut self) -> core::ffi::c_double; + fn get_rotation_angle_and_axis( + &mut self, + axis: core::ffi::c_double, + ) -> core::ffi::c_double; + fn set_rotation_angle_and_axis( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_double, + ) -> (); + fn set_rotation_angle_and_axis( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn to_matrix_3_x_3(&mut self, A: core::ffi::c_double) -> (); + fn from_matrix_3_x_3(&mut self, A: core::ffi::c_double) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_double; + fn get_data(&mut self) -> *const core::ffi::c_double; +} +pub trait VtkQuaternionf: VtkQuaternion + VtkTuple { + fn identity(&mut self) -> *mut core::ffi::c_void; + fn normalized(&mut self) -> *mut core::ffi::c_void; + fn conjugated(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> *mut core::ffi::c_void; + fn unit_log(&mut self) -> *mut core::ffi::c_void; + fn unit_exp(&mut self) -> *mut core::ffi::c_void; + fn normalized_with_angle_in_degrees(&mut self) -> *mut core::ffi::c_void; + fn slerp( + &mut self, + t: core::ffi::c_float, + q: vtkQuaternionf, + ) -> *mut core::ffi::c_void; + fn inner_point( + &mut self, + q1: vtkQuaternionf, + q2: vtkQuaternionf, + ) -> *mut core::ffi::c_void; + fn squared_norm(&mut self) -> core::ffi::c_float; + fn norm(&mut self) -> core::ffi::c_float; + fn normalize(&mut self) -> core::ffi::c_float; + fn set( + &mut self, + w: core::ffi::c_float, + x: core::ffi::c_float, + y: core::ffi::c_float, + z: core::ffi::c_float, + ) -> (); + fn set(&mut self, quat: core::ffi::c_float) -> (); + fn get(&mut self, quat: core::ffi::c_float) -> (); + fn set_w(&mut self, w: core::ffi::c_float) -> (); + fn get_w(&mut self) -> core::ffi::c_float; + fn set_x(&mut self, x: core::ffi::c_float) -> (); + fn get_x(&mut self) -> core::ffi::c_float; + fn set_y(&mut self, y: core::ffi::c_float) -> (); + fn get_y(&mut self) -> core::ffi::c_float; + fn set_z(&mut self, z: core::ffi::c_float) -> (); + fn get_z(&mut self) -> core::ffi::c_float; + fn get_rotation_angle_and_axis( + &mut self, + axis: core::ffi::c_float, + ) -> core::ffi::c_float; + fn set_rotation_angle_and_axis( + &mut self, + angle: core::ffi::c_float, + axis: core::ffi::c_float, + ) -> (); + fn set_rotation_angle_and_axis( + &mut self, + angle: core::ffi::c_float, + x: core::ffi::c_float, + y: core::ffi::c_float, + z: core::ffi::c_float, + ) -> (); + fn to_matrix_3_x_3(&mut self, A: core::ffi::c_float) -> (); + fn from_matrix_3_x_3(&mut self, A: core::ffi::c_float) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_float; + fn get_data(&mut self) -> *const core::ffi::c_float; +} +pub trait VtkRungeKutta2: VtkInitialValueProblemSolver { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; +} +pub trait VtkRungeKutta4: VtkInitialValueProblemSolver { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; +} +pub trait VtkRungeKutta45: VtkInitialValueProblemSolver { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + dxprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + delTActual: core::ffi::c_double, + minStep: core::ffi::c_double, + maxStep: core::ffi::c_double, + maxError: core::ffi::c_double, + estErr: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; +} +pub trait VtkTuple { + fn get_size(&mut self) -> core::ffi::c_int; + fn get_data(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self) -> *const T; +} +impl VtkAmoebaMinimizer for vtkAmoebaMinimizer { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amoeba_minimizer_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amoeba_minimizer_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amoeba_minimizer_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amoeba_minimizer_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amoeba_minimizer_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amoeba_minimizer_new_instance(self.0) } + } + fn set_function(&mut self, f: *mut core::ffi::c_void, arg: ()) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_function( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + arg: (), + ); + } + unsafe { vtk_amoeba_minimizer_set_function(self.0, f, arg) } + } + fn set_function_arg_delete(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_function_arg_delete( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_amoeba_minimizer_set_function_arg_delete(self.0, f) } + } + fn set_parameter_value( + &mut self, + name: core::ffi::c_char, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_parameter_value( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_parameter_value(self.0, name, value) } + } + fn set_parameter_value( + &mut self, + i: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_parameter_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_parameter_value(self.0, i, value) } + } + fn set_parameter_scale( + &mut self, + name: core::ffi::c_char, + scale: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_parameter_scale( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + scale: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_parameter_scale(self.0, name, scale) } + } + fn get_parameter_scale(&mut self, name: core::ffi::c_char) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_parameter_scale( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_parameter_scale(self.0, name) } + } + fn set_parameter_scale( + &mut self, + i: core::ffi::c_int, + scale: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_parameter_scale( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + scale: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_parameter_scale(self.0, i, scale) } + } + fn get_parameter_scale(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_parameter_scale( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_parameter_scale(self.0, i) } + } + fn get_parameter_value(&mut self, name: core::ffi::c_char) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_parameter_value( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_parameter_value(self.0, name) } + } + fn get_parameter_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_parameter_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_parameter_value(self.0, i) } + } + fn get_parameter_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_parameter_name( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_amoeba_minimizer_get_parameter_name(self.0, i) } + } + fn get_number_of_parameters(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_number_of_parameters( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_amoeba_minimizer_get_number_of_parameters(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_amoeba_minimizer_initialize(self.0) } + } + fn minimize(&mut self) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_minimize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_amoeba_minimizer_minimize(self.0) } + } + fn iterate(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_amoeba_minimizer_iterate( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_amoeba_minimizer_iterate(self.0) } + } + fn set_function_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_function_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_function_value(self.0, _arg) } + } + fn get_function_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_function_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_function_value(self.0) } + } + fn set_contraction_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_contraction_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_contraction_ratio(self.0, _arg) } + } + fn get_contraction_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_contraction_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_contraction_ratio_min_value(self.0) } + } + fn get_contraction_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_contraction_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_contraction_ratio_max_value(self.0) } + } + fn get_contraction_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_contraction_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_contraction_ratio(self.0) } + } + fn set_expansion_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_expansion_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_expansion_ratio(self.0, _arg) } + } + fn get_expansion_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_expansion_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_expansion_ratio_min_value(self.0) } + } + fn get_expansion_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_expansion_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_expansion_ratio_max_value(self.0) } + } + fn get_expansion_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_expansion_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_expansion_ratio(self.0) } + } + fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_tolerance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_tolerance(self.0, _arg) } + } + fn get_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_tolerance(self.0) } + } + fn set_parameter_tolerance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_parameter_tolerance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_parameter_tolerance(self.0, _arg) } + } + fn get_parameter_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_parameter_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_parameter_tolerance(self.0) } + } + fn set_max_iterations(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_max_iterations( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_amoeba_minimizer_set_max_iterations(self.0, _arg) } + } + fn get_max_iterations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_max_iterations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_amoeba_minimizer_get_max_iterations(self.0) } + } + fn get_iterations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_iterations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_amoeba_minimizer_get_iterations(self.0) } + } + fn get_function_evaluations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_function_evaluations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_amoeba_minimizer_get_function_evaluations(self.0) } + } + fn evaluate_function(&mut self) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_evaluate_function(sself: *mut core::ffi::c_void); + } + unsafe { vtk_amoeba_minimizer_evaluate_function(self.0) } + } +} +impl VtkFFT for vtkFFT { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_fft_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_fft_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_fft_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_fft_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_fft_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_fft_new_instance(self.0) } + } + fn fft(&mut self, in_: Vec) -> Vec { + unsafe extern "C" { + fn vtk_fft_fft( + sself: *mut core::ffi::c_void, + in_: Vec, + ) -> Vec; + } + unsafe { vtk_fft_fft(self.0, in_) } + } + fn fft(&mut self, in_: Vec) -> Vec { + unsafe extern "C" { + fn vtk_fft_fft( + sself: *mut core::ffi::c_void, + in_: Vec, + ) -> Vec; + } + unsafe { vtk_fft_fft(self.0, in_) } + } + fn r_fft(&mut self, in_: Vec) -> Vec { + unsafe extern "C" { + fn vtk_fft_r_fft( + sself: *mut core::ffi::c_void, + in_: Vec, + ) -> Vec; + } + unsafe { vtk_fft_r_fft(self.0, in_) } + } + fn i_fft(&mut self, in_: Vec) -> Vec { + unsafe extern "C" { + fn vtk_fft_i_fft( + sself: *mut core::ffi::c_void, + in_: Vec, + ) -> Vec; + } + unsafe { vtk_fft_i_fft(self.0, in_) } + } + fn ir_fft(&mut self, in_: Vec) -> Vec { + unsafe extern "C" { + fn vtk_fft_ir_fft( + sself: *mut core::ffi::c_void, + in_: Vec, + ) -> Vec; + } + unsafe { vtk_fft_ir_fft(self.0, in_) } + } + fn abs(&mut self, in_: kiss_fft_cpx) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_abs( + sself: *mut core::ffi::c_void, + in_: kiss_fft_cpx, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_abs(self.0, in_) } + } + fn squared_abs(&mut self, in_: kiss_fft_cpx) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_squared_abs( + sself: *mut core::ffi::c_void, + in_: kiss_fft_cpx, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_squared_abs(self.0, in_) } + } + fn fft_freq( + &mut self, + windowLength: core::ffi::c_int, + sampleSpacing: core::ffi::c_double, + ) -> Vec { + unsafe extern "C" { + fn vtk_fft_fft_freq( + sself: *mut core::ffi::c_void, + windowLength: core::ffi::c_int, + sampleSpacing: core::ffi::c_double, + ) -> Vec; + } + unsafe { vtk_fft_fft_freq(self.0, windowLength, sampleSpacing) } + } + fn r_fft_freq( + &mut self, + windowLength: core::ffi::c_int, + sampleSpacing: core::ffi::c_double, + ) -> Vec { + unsafe extern "C" { + fn vtk_fft_r_fft_freq( + sself: *mut core::ffi::c_void, + windowLength: core::ffi::c_int, + sampleSpacing: core::ffi::c_double, + ) -> Vec; + } + unsafe { vtk_fft_r_fft_freq(self.0, windowLength, sampleSpacing) } + } + fn hanning_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_hanning_generator( + sself: *mut core::ffi::c_void, + x: usize, + size: usize, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_hanning_generator(self.0, x, size) } + } + fn bartlett_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_bartlett_generator( + sself: *mut core::ffi::c_void, + x: usize, + size: usize, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_bartlett_generator(self.0, x, size) } + } + fn sine_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_sine_generator( + sself: *mut core::ffi::c_void, + x: usize, + size: usize, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_sine_generator(self.0, x, size) } + } + fn blackman_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_blackman_generator( + sself: *mut core::ffi::c_void, + x: usize, + size: usize, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_blackman_generator(self.0, x, size) } + } + fn rectangular_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_rectangular_generator( + sself: *mut core::ffi::c_void, + x: usize, + size: usize, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_rectangular_generator(self.0, x, size) } + } +} +impl VtkMatrix3x3 for vtkMatrix3x3 { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_3_x_3_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_3_x_3_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_3_x_3_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_3_x_3_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_3_x_3_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_3_x_3_new_instance(self.0) } + } + fn deep_copy(&mut self, source: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_deep_copy( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_deep_copy(self.0, source) } + } + fn deep_copy( + &mut self, + elements: core::ffi::c_double, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_deep_copy( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_deep_copy(self.0, elements, source) } + } + fn deep_copy( + &mut self, + elements: core::ffi::c_double, + newElements: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_deep_copy( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + newElements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_deep_copy(self.0, elements, newElements) } + } + fn deep_copy(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_deep_copy( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_deep_copy(self.0, elements) } + } + fn zero(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_zero(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_3_x_3_zero(self.0) } + } + fn zero(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_zero( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_zero(self.0, elements) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_3_x_3_identity(self.0) } + } + fn identity(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_identity( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_identity(self.0, elements) } + } + fn invert( + &mut self, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_invert( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_invert(self.0, in_, out) } + } + fn invert(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_invert(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_3_x_3_invert(self.0) } + } + fn invert( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_invert( + sself: *mut core::ffi::c_void, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_invert(self.0, inElements, outElements) } + } + fn transpose( + &mut self, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_transpose( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_transpose(self.0, in_, out) } + } + fn transpose(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_transpose(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_3_x_3_transpose(self.0) } + } + fn transpose( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_transpose( + sself: *mut core::ffi::c_void, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_transpose(self.0, inElements, outElements) } + } + fn multiply_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_multiply_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ); + } + unsafe { vtk_matrix_3_x_3_multiply_point(self.0, in_, out) } + } + fn multiply_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_multiply_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_multiply_point(self.0, in_, out) } + } + fn multiply_point( + &mut self, + elements: core::ffi::c_double, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_multiply_point( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ); + } + unsafe { vtk_matrix_3_x_3_multiply_point(self.0, elements, in_, out) } + } + fn multiply_point( + &mut self, + elements: core::ffi::c_double, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_multiply_point( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_multiply_point(self.0, elements, in_, out) } + } + fn multiply_3_x_3( + &mut self, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_multiply_3_x_3( + sself: *mut core::ffi::c_void, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_multiply_3_x_3(self.0, a, b, c) } + } + fn multiply_3_x_3( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_multiply_3_x_3( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_multiply_3_x_3(self.0, a, b, c) } + } + fn adjoint( + &mut self, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_adjoint( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_adjoint(self.0, in_, out) } + } + fn adjoint( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_adjoint( + sself: *mut core::ffi::c_void, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_adjoint(self.0, inElements, outElements) } + } + fn determinant(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_3_x_3_determinant( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_matrix_3_x_3_determinant(self.0) } + } + fn determinant(&mut self, elements: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_3_x_3_determinant( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_matrix_3_x_3_determinant(self.0, elements) } + } + fn set_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_set_element( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_set_element(self.0, i, j, value) } + } + fn get_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_3_x_3_get_element( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_matrix_3_x_3_get_element(self.0, i, j) } + } + fn is_identity(&mut self) -> bool { + unsafe extern "C" { + fn vtk_matrix_3_x_3_is_identity(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_matrix_3_x_3_is_identity(self.0) } + } + fn get_data(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_3_x_3_get_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_matrix_3_x_3_get_data(self.0) } + } + fn get_data(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_3_x_3_get_data( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_matrix_3_x_3_get_data(self.0) } + } +} +impl VtkMatrix4x4 for vtkMatrix4x4 { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_4_x_4_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_4_x_4_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_4_x_4_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_4_x_4_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_4_x_4_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_4_x_4_new_instance(self.0) } + } + fn deep_copy(&mut self, source: vtkMatrix4x4) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_deep_copy( + sself: *mut core::ffi::c_void, + source: vtkMatrix4x4, + ); + } + unsafe { vtk_matrix_4_x_4_deep_copy(self.0, source) } + } + fn deep_copy( + &mut self, + destination: core::ffi::c_double, + source: vtkMatrix4x4, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_deep_copy( + sself: *mut core::ffi::c_void, + destination: core::ffi::c_double, + source: vtkMatrix4x4, + ); + } + unsafe { vtk_matrix_4_x_4_deep_copy(self.0, destination, source) } + } + fn deep_copy( + &mut self, + destination: core::ffi::c_double, + source: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_deep_copy( + sself: *mut core::ffi::c_void, + destination: core::ffi::c_double, + source: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_deep_copy(self.0, destination, source) } + } + fn deep_copy(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_deep_copy( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_deep_copy(self.0, elements) } + } + fn zero(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_zero(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_4_x_4_zero(self.0) } + } + fn zero(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_zero( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_zero(self.0, elements) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_4_x_4_identity(self.0) } + } + fn identity(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_identity( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_identity(self.0, elements) } + } + fn is_identity(&mut self) -> bool { + unsafe extern "C" { + fn vtk_matrix_4_x_4_is_identity(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_matrix_4_x_4_is_identity(self.0) } + } + fn invert(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_invert( + sself: *mut core::ffi::c_void, + in_: vtkMatrix4x4, + out: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_4_x_4_invert(self.0, in_, out) } + } + fn invert(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_invert(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_4_x_4_invert(self.0) } + } + fn invert( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_invert( + sself: *mut core::ffi::c_void, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_invert(self.0, inElements, outElements) } + } + fn transpose(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_transpose( + sself: *mut core::ffi::c_void, + in_: vtkMatrix4x4, + out: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_4_x_4_transpose(self.0, in_, out) } + } + fn transpose(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_transpose(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_4_x_4_transpose(self.0) } + } + fn transpose( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_transpose( + sself: *mut core::ffi::c_void, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_transpose(self.0, inElements, outElements) } + } + fn multiply_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ); + } + unsafe { vtk_matrix_4_x_4_multiply_point(self.0, in_, out) } + } + fn multiply_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_multiply_point(self.0, in_, out) } + } + fn multiply_point( + &mut self, + elements: core::ffi::c_double, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_point( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ); + } + unsafe { vtk_matrix_4_x_4_multiply_point(self.0, elements, in_, out) } + } + fn multiply_point( + &mut self, + elements: core::ffi::c_double, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_point( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_multiply_point(self.0, elements, in_, out) } + } + fn multiply_point(&mut self, in_: core::ffi::c_float) -> *mut core::ffi::c_float { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + } + unsafe { vtk_matrix_4_x_4_multiply_point(self.0, in_) } + } + fn multiply_point(&mut self, in_: core::ffi::c_double) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_matrix_4_x_4_multiply_point(self.0, in_) } + } + fn multiply_float_point( + &mut self, + in_: core::ffi::c_float, + ) -> *mut core::ffi::c_float { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_float_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + } + unsafe { vtk_matrix_4_x_4_multiply_float_point(self.0, in_) } + } + fn multiply_double_point( + &mut self, + in_: core::ffi::c_double, + ) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_double_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_matrix_4_x_4_multiply_double_point(self.0, in_) } + } + fn multiply_4_x_4( + &mut self, + a: vtkMatrix4x4, + b: vtkMatrix4x4, + c: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_4_x_4( + sself: *mut core::ffi::c_void, + a: vtkMatrix4x4, + b: vtkMatrix4x4, + c: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_4_x_4_multiply_4_x_4(self.0, a, b, c) } + } + fn multiply_4_x_4( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_4_x_4( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_multiply_4_x_4(self.0, a, b, c) } + } + fn multiply_4_x_4( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_4_x_4( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_float, + ); + } + unsafe { vtk_matrix_4_x_4_multiply_4_x_4(self.0, a, b, c) } + } + fn multiply_and_transpose_4_x_4( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_multiply_and_transpose_4_x_4( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_float, + ); + } + unsafe { vtk_matrix_4_x_4_multiply_and_transpose_4_x_4(self.0, a, b, c) } + } + fn adjoint(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_adjoint( + sself: *mut core::ffi::c_void, + in_: vtkMatrix4x4, + out: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_4_x_4_adjoint(self.0, in_, out) } + } + fn adjoint( + &mut self, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_adjoint( + sself: *mut core::ffi::c_void, + inElements: core::ffi::c_double, + outElements: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_adjoint(self.0, inElements, outElements) } + } + fn determinant(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_4_x_4_determinant( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_matrix_4_x_4_determinant(self.0) } + } + fn determinant(&mut self, elements: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_4_x_4_determinant( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_matrix_4_x_4_determinant(self.0, elements) } + } + fn set_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_set_element( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_set_element(self.0, i, j, value) } + } + fn get_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_4_x_4_get_element( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_matrix_4_x_4_get_element(self.0, i, j) } + } + fn get_data(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_4_x_4_get_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_matrix_4_x_4_get_data(self.0) } + } + fn get_data(&mut self) -> *const core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_4_x_4_get_data( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_double; + } + unsafe { vtk_matrix_4_x_4_get_data(self.0) } + } +} +impl VtkPolynomialSolversUnivariate for vtkPolynomialSolversUnivariate { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polynomial_solvers_univariate_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polynomial_solvers_univariate_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polynomial_solvers_univariate_new_instance(self.0) } + } + fn habicht_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_habicht_bisection_solve( + sself: *mut core::ffi::c_void, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_habicht_bisection_solve( + self.0, + P, + d, + a, + upperBnds, + tol, + ) + } + } + fn habicht_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_habicht_bisection_solve( + sself: *mut core::ffi::c_void, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_habicht_bisection_solve( + self.0, + P, + d, + a, + upperBnds, + tol, + intervalType, + ) + } + } + fn habicht_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + divideGCD: bool, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_habicht_bisection_solve( + sself: *mut core::ffi::c_void, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + divideGCD: bool, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_habicht_bisection_solve( + self.0, + P, + d, + a, + upperBnds, + tol, + intervalType, + divideGCD, + ) + } + } + fn sturm_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_sturm_bisection_solve( + sself: *mut core::ffi::c_void, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_sturm_bisection_solve( + self.0, + P, + d, + a, + upperBnds, + tol, + ) + } + } + fn sturm_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_sturm_bisection_solve( + sself: *mut core::ffi::c_void, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_sturm_bisection_solve( + self.0, + P, + d, + a, + upperBnds, + tol, + intervalType, + ) + } + } + fn sturm_bisection_solve( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + divideGCD: bool, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_sturm_bisection_solve( + sself: *mut core::ffi::c_void, + P: core::ffi::c_double, + d: core::ffi::c_int, + a: core::ffi::c_double, + upperBnds: core::ffi::c_double, + tol: core::ffi::c_double, + intervalType: core::ffi::c_int, + divideGCD: bool, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_sturm_bisection_solve( + self.0, + P, + d, + a, + upperBnds, + tol, + intervalType, + divideGCD, + ) + } + } + fn filter_roots( + &mut self, + P: core::ffi::c_double, + d: core::ffi::c_int, + upperBnds: core::ffi::c_double, + rootcount: core::ffi::c_int, + diameter: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_filter_roots( + sself: *mut core::ffi::c_void, + P: core::ffi::c_double, + d: core::ffi::c_int, + upperBnds: core::ffi::c_double, + rootcount: core::ffi::c_int, + diameter: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_filter_roots( + self.0, + P, + d, + upperBnds, + rootcount, + diameter, + ) + } + } + fn lin_bairstow_solve( + &mut self, + c: core::ffi::c_double, + d: core::ffi::c_int, + r: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_lin_bairstow_solve( + sself: *mut core::ffi::c_void, + c: core::ffi::c_double, + d: core::ffi::c_int, + r: core::ffi::c_double, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_lin_bairstow_solve( + self.0, + c, + d, + r, + tolerance, + ) + } + } + fn ferrari_solve( + &mut self, + c: core::ffi::c_double, + r: core::ffi::c_double, + m: core::ffi::c_int, + tol: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_ferrari_solve( + sself: *mut core::ffi::c_void, + c: core::ffi::c_double, + r: core::ffi::c_double, + m: core::ffi::c_int, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_polynomial_solvers_univariate_ferrari_solve(self.0, c, r, m, tol) } + } + fn tartaglia_cardan_solve( + &mut self, + c: core::ffi::c_double, + r: core::ffi::c_double, + m: core::ffi::c_int, + tol: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_tartaglia_cardan_solve( + sself: *mut core::ffi::c_void, + c: core::ffi::c_double, + r: core::ffi::c_double, + m: core::ffi::c_int, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_tartaglia_cardan_solve( + self.0, + c, + r, + m, + tol, + ) + } + } + fn solve_cubic( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_solve_cubic( + sself: *mut core::ffi::c_void, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_polynomial_solvers_univariate_solve_cubic(self.0, c0, c1, c2, c3) } + } + fn solve_quadratic( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + ) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_solve_quadratic( + sself: *mut core::ffi::c_void, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_polynomial_solvers_univariate_solve_quadratic(self.0, c0, c1, c2) } + } + fn solve_linear( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + ) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_solve_linear( + sself: *mut core::ffi::c_void, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_polynomial_solvers_univariate_solve_linear(self.0, c0, c1) } + } + fn solve_cubic( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + r1: core::ffi::c_double, + r2: core::ffi::c_double, + r3: core::ffi::c_double, + num_roots: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_solve_cubic( + sself: *mut core::ffi::c_void, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + r1: core::ffi::c_double, + r2: core::ffi::c_double, + r3: core::ffi::c_double, + num_roots: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_solve_cubic( + self.0, + c0, + c1, + c2, + c3, + r1, + r2, + r3, + num_roots, + ) + } + } + fn solve_quadratic( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + r1: core::ffi::c_double, + r2: core::ffi::c_double, + num_roots: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_solve_quadratic( + sself: *mut core::ffi::c_void, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + r1: core::ffi::c_double, + r2: core::ffi::c_double, + num_roots: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_solve_quadratic( + self.0, + c0, + c1, + c2, + r1, + r2, + num_roots, + ) + } + } + fn solve_quadratic( + &mut self, + c: core::ffi::c_double, + r: core::ffi::c_double, + m: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_solve_quadratic( + sself: *mut core::ffi::c_void, + c: core::ffi::c_double, + r: core::ffi::c_double, + m: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_polynomial_solvers_univariate_solve_quadratic(self.0, c, r, m) } + } + fn solve_linear( + &mut self, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + r1: core::ffi::c_double, + num_roots: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_solve_linear( + sself: *mut core::ffi::c_void, + c0: core::ffi::c_double, + c1: core::ffi::c_double, + r1: core::ffi::c_double, + num_roots: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_polynomial_solvers_univariate_solve_linear(self.0, c0, c1, r1, num_roots) + } + } + fn set_division_tolerance(&mut self, tol: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_set_division_tolerance( + sself: *mut core::ffi::c_void, + tol: core::ffi::c_double, + ); + } + unsafe { vtk_polynomial_solvers_univariate_set_division_tolerance(self.0, tol) } + } + fn get_division_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_get_division_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_polynomial_solvers_univariate_get_division_tolerance(self.0) } + } +} +impl VtkQuaternionInterpolator for vtkQuaternionInterpolator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quaternion_interpolator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quaternion_interpolator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quaternion_interpolator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quaternion_interpolator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quaternion_interpolator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quaternion_interpolator_new(self.0) } + } + fn get_number_of_quaternions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_number_of_quaternions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quaternion_interpolator_get_number_of_quaternions(self.0) } + } + fn get_minimum_t(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_minimum_t( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_quaternion_interpolator_get_minimum_t(self.0) } + } + fn get_maximum_t(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_maximum_t( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_quaternion_interpolator_get_maximum_t(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_quaternion_interpolator_initialize(self.0) } + } + fn add_quaternion(&mut self, t: core::ffi::c_double, q: vtkQuaterniond) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_add_quaternion( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + q: vtkQuaterniond, + ); + } + unsafe { vtk_quaternion_interpolator_add_quaternion(self.0, t, q) } + } + fn add_quaternion(&mut self, t: core::ffi::c_double, q: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_add_quaternion( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + q: core::ffi::c_double, + ); + } + unsafe { vtk_quaternion_interpolator_add_quaternion(self.0, t, q) } + } + fn remove_quaternion(&mut self, t: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_remove_quaternion( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + ); + } + unsafe { vtk_quaternion_interpolator_remove_quaternion(self.0, t) } + } + fn interpolate_quaternion( + &mut self, + t: core::ffi::c_double, + q: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_interpolate_quaternion( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + q: *mut core::ffi::c_void, + ); + } + unsafe { vtk_quaternion_interpolator_interpolate_quaternion(self.0, t, q) } + } + fn interpolate_quaternion( + &mut self, + t: core::ffi::c_double, + q: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_interpolate_quaternion( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + q: core::ffi::c_double, + ); + } + unsafe { vtk_quaternion_interpolator_interpolate_quaternion(self.0, t, q) } + } + fn get_search_method(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_search_method( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quaternion_interpolator_get_search_method(self.0) } + } + fn set_search_method(&mut self, type_: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_set_search_method( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ); + } + unsafe { vtk_quaternion_interpolator_set_search_method(self.0, type_) } + } + fn set_interpolation_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_set_interpolation_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_quaternion_interpolator_set_interpolation_type(self.0, _arg) } + } + fn get_interpolation_type_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_interpolation_type_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quaternion_interpolator_get_interpolation_type_min_value(self.0) } + } + fn get_interpolation_type_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_interpolation_type_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quaternion_interpolator_get_interpolation_type_max_value(self.0) } + } + fn get_interpolation_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_interpolation_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quaternion_interpolator_get_interpolation_type(self.0) } + } + fn set_interpolation_type_to_linear(&mut self) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_set_interpolation_type_to_linear( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_quaternion_interpolator_set_interpolation_type_to_linear(self.0) } + } + fn set_interpolation_type_to_spline(&mut self) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_set_interpolation_type_to_spline( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_quaternion_interpolator_set_interpolation_type_to_spline(self.0) } + } +} +impl VtkRungeKutta2 for vtkRungeKutta2 { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_2_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_2_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_2_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_2_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_2_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_2_new(self.0) } + } + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_runge_kutta_2_compute_next_step( + sself: *mut core::ffi::c_void, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; + } + unsafe { + vtk_runge_kutta_2_compute_next_step( + self.0, + xprev, + xnext, + t, + delT, + maxError, + error, + userData, + ) + } + } +} +impl VtkRungeKutta4 for vtkRungeKutta4 { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_4_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_4_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_4_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_4_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_4_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_4_new(self.0) } + } + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_runge_kutta_4_compute_next_step( + sself: *mut core::ffi::c_void, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; + } + unsafe { + vtk_runge_kutta_4_compute_next_step( + self.0, + xprev, + xnext, + t, + delT, + maxError, + error, + userData, + ) + } + } +} +impl VtkRungeKutta45 for vtkRungeKutta45 { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_45_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_45_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_45_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_45_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_45_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_45_new(self.0) } + } + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_runge_kutta_45_compute_next_step( + sself: *mut core::ffi::c_void, + xprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + maxError: core::ffi::c_double, + error: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; + } + unsafe { + vtk_runge_kutta_45_compute_next_step( + self.0, + xprev, + xnext, + t, + delT, + maxError, + error, + userData, + ) + } + } + fn compute_next_step( + &mut self, + xprev: core::ffi::c_double, + dxprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + delTActual: core::ffi::c_double, + minStep: core::ffi::c_double, + maxStep: core::ffi::c_double, + maxError: core::ffi::c_double, + estErr: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_runge_kutta_45_compute_next_step( + sself: *mut core::ffi::c_void, + xprev: core::ffi::c_double, + dxprev: core::ffi::c_double, + xnext: core::ffi::c_double, + t: core::ffi::c_double, + delT: core::ffi::c_double, + delTActual: core::ffi::c_double, + minStep: core::ffi::c_double, + maxStep: core::ffi::c_double, + maxError: core::ffi::c_double, + estErr: core::ffi::c_double, + userData: (), + ) -> core::ffi::c_int; + } + unsafe { + vtk_runge_kutta_45_compute_next_step( + self.0, + xprev, + dxprev, + xnext, + t, + delT, + delTActual, + minStep, + maxStep, + maxError, + estErr, + userData, + ) + } + } +} /// nonlinear optimization with a simplex /// /// @@ -62,7 +3032,7 @@ fn test_vtkAmoebaMinimizer_create_drop() { /// The current implementation uses the third-party library kissfft. /// /// The terminology tries to follow the Numpy terminology, that is : -/// - Fft means the Fast Fourier Transform algorithm +/// - Fft means the Fast Fourier Tranform algorithm /// - Prefix `R` stands for Real (meaning optimized function for real inputs) /// - Prefix `I` stands for Inverse #[allow(non_camel_case_types)] diff --git a/vtk-rs-9.1/src/vtkCommonMisc.rs b/vtk-rs-9.1/src/vtkCommonMisc.rs index 639ff5f..63eea59 100644 --- a/vtk-rs-9.1/src/vtkCommonMisc.rs +++ b/vtk-rs-9.1/src/vtkCommonMisc.rs @@ -1,3 +1,1860 @@ +pub trait VtkContourValues { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_value(&mut self, i: core::ffi::c_int, value: core::ffi::c_double) -> (); + fn get_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn get_values(&mut self) -> *mut core::ffi::c_double; + fn get_values(&mut self, contourValues: core::ffi::c_double) -> (); + fn set_number_of_contours(&mut self, number: core::ffi::c_int) -> (); + fn get_number_of_contours(&mut self) -> core::ffi::c_int; + fn generate_values( + &mut self, + numContours: core::ffi::c_int, + range: core::ffi::c_double, + ) -> (); + fn generate_values( + &mut self, + numContours: core::ffi::c_int, + rangeStart: core::ffi::c_double, + rangeEnd: core::ffi::c_double, + ) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); +} +pub trait VtkErrorCode { + fn get_string_from_error_code( + &mut self, + error: core::ffi::c_ulong, + ) -> *const core::ffi::c_char; + fn get_error_code_from_string( + &mut self, + error: core::ffi::c_char, + ) -> core::ffi::c_ulong; + fn get_last_system_error(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkExprTkFunctionParser { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_function(&mut self, function: core::ffi::c_char) -> (); + fn get_function(&mut self) -> *const core::ffi::c_char; + fn is_scalar_result(&mut self) -> core::ffi::c_int; + fn is_vector_result(&mut self) -> core::ffi::c_int; + fn get_scalar_result(&mut self) -> core::ffi::c_double; + fn get_vector_result(&mut self) -> *mut core::ffi::c_double; + fn get_vector_result(&mut self, result: core::ffi::c_double) -> (); + fn set_scalar_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> (); + fn set_scalar_variable_value( + &mut self, + i: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double; + fn get_scalar_variable_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn set_vector_variable_value( + &mut self, + variableName: &str, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> (); + fn set_vector_variable_value( + &mut self, + variableName: &str, + values: core::ffi::c_double, + ) -> (); + fn set_vector_variable_value( + &mut self, + i: core::ffi::c_int, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> (); + fn set_vector_variable_value( + &mut self, + i: core::ffi::c_int, + values: core::ffi::c_double, + ) -> (); + fn get_vector_variable_value( + &mut self, + variableName: &str, + ) -> *mut core::ffi::c_double; + fn get_vector_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> (); + fn get_vector_variable_value( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_double; + fn get_vector_variable_value( + &mut self, + i: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int; + fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_number_of_vector_variables(&mut self) -> core::ffi::c_int; + fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_scalar_variable_name(&mut self, i: core::ffi::c_int) -> &str; + fn get_vector_variable_name(&mut self, i: core::ffi::c_int) -> &str; + fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool; + fn get_scalar_variable_needed(&mut self, variableName: &str) -> bool; + fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool; + fn get_vector_variable_needed(&mut self, variableName: &str) -> bool; + fn remove_all_variables(&mut self) -> (); + fn remove_scalar_variables(&mut self) -> (); + fn remove_vector_variables(&mut self) -> (); + fn set_replace_invalid_values(&mut self, _arg: core::ffi::c_int) -> (); + fn get_replace_invalid_values(&mut self) -> core::ffi::c_int; + fn replace_invalid_values_on(&mut self) -> (); + fn replace_invalid_values_off(&mut self) -> (); + fn set_replacement_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_replacement_value(&mut self) -> core::ffi::c_double; + fn invalidate_function(&mut self) -> (); + fn sanitize_name(&mut self, name: core::ffi::c_char) -> &str; +} +pub trait VtkFunctionParser { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_function(&mut self, function: core::ffi::c_char) -> (); + fn get_function(&mut self) -> *mut core::ffi::c_char; + fn is_scalar_result(&mut self) -> core::ffi::c_int; + fn is_vector_result(&mut self) -> core::ffi::c_int; + fn get_scalar_result(&mut self) -> core::ffi::c_double; + fn get_vector_result(&mut self) -> *mut core::ffi::c_double; + fn get_vector_result(&mut self, result: core::ffi::c_double) -> (); + fn set_scalar_variable_value( + &mut self, + variableName: core::ffi::c_char, + value: core::ffi::c_double, + ) -> (); + fn set_scalar_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> (); + fn set_scalar_variable_value( + &mut self, + i: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_scalar_variable_value( + &mut self, + variableName: core::ffi::c_char, + ) -> core::ffi::c_double; + fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double; + fn get_scalar_variable_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn set_vector_variable_value( + &mut self, + variableName: core::ffi::c_char, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> (); + fn set_vector_variable_value( + &mut self, + variableName: &str, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> (); + fn set_vector_variable_value( + &mut self, + variableName: core::ffi::c_char, + values: core::ffi::c_double, + ) -> (); + fn set_vector_variable_value( + &mut self, + variableName: &str, + values: core::ffi::c_double, + ) -> (); + fn set_vector_variable_value( + &mut self, + i: core::ffi::c_int, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> (); + fn set_vector_variable_value( + &mut self, + i: core::ffi::c_int, + values: core::ffi::c_double, + ) -> (); + fn get_vector_variable_value( + &mut self, + variableName: core::ffi::c_char, + ) -> *mut core::ffi::c_double; + fn get_vector_variable_value( + &mut self, + variableName: &str, + ) -> *mut core::ffi::c_double; + fn get_vector_variable_value( + &mut self, + variableName: core::ffi::c_char, + value: core::ffi::c_double, + ) -> (); + fn get_vector_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> (); + fn get_vector_variable_value( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_double; + fn get_vector_variable_value( + &mut self, + i: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int; + fn get_scalar_variable_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_number_of_vector_variables(&mut self) -> core::ffi::c_int; + fn get_vector_variable_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_scalar_variable_name( + &mut self, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn get_vector_variable_name( + &mut self, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool; + fn get_scalar_variable_needed(&mut self, variableName: core::ffi::c_char) -> bool; + fn get_scalar_variable_needed(&mut self, variableName: &str) -> bool; + fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool; + fn get_vector_variable_needed(&mut self, variableName: core::ffi::c_char) -> bool; + fn get_vector_variable_needed(&mut self, variableName: &str) -> bool; + fn remove_all_variables(&mut self) -> (); + fn remove_scalar_variables(&mut self) -> (); + fn remove_vector_variables(&mut self) -> (); + fn set_replace_invalid_values(&mut self, _arg: core::ffi::c_int) -> (); + fn get_replace_invalid_values(&mut self) -> core::ffi::c_int; + fn replace_invalid_values_on(&mut self) -> (); + fn replace_invalid_values_off(&mut self) -> (); + fn set_replacement_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_replacement_value(&mut self) -> core::ffi::c_double; + fn check_expression( + &mut self, + pos: core::ffi::c_int, + error: core::ffi::c_char, + ) -> (); + fn invalidate_function(&mut self) -> (); +} +pub trait VtkHeap { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate_memory(&mut self, n: usize) -> *mut (); + fn set_block_size(&mut self, p0: usize) -> (); + fn get_block_size(&mut self) -> usize; + fn get_number_of_blocks(&mut self) -> core::ffi::c_int; + fn get_number_of_allocations(&mut self) -> core::ffi::c_int; + fn reset(&mut self) -> (); + fn string_dup(&mut self, str: core::ffi::c_char) -> *mut core::ffi::c_char; +} +pub trait VtkPolygonBuilder { + fn insert_triangle(&mut self, abc: core::ffi::c_uchar) -> (); + fn get_polygons(&mut self, polys: *mut core::ffi::c_void) -> (); + fn reset(&mut self) -> (); +} +pub trait VtkResourceFileLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_print_debug_information(&mut self, p0: bool) -> (); + fn get_print_debug_information(&mut self) -> bool; + fn print_debug_information_on(&mut self) -> (); + fn print_debug_information_off(&mut self) -> (); + fn set_log_verbosity(&mut self, _arg: core::ffi::c_int) -> (); + fn get_log_verbosity(&mut self) -> core::ffi::c_int; + fn locate(&mut self, anchor: &str, landmark: &str, defaultDir: &str) -> &str; + fn locate( + &mut self, + anchor: &str, + landmark_prefixes: Vec, + landmark: &str, + defaultDir: &str, + ) -> &str; + fn get_library_path_for_symbol_unix( + &mut self, + symbolname: core::ffi::c_char, + ) -> &str; + fn get_library_path_for_symbol_win_32(&mut self, fptr: ()) -> &str; +} +impl VtkContourValues for vtkContourValues { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_contour_values_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_contour_values_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_contour_values_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_contour_values_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_contour_values_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_contour_values_new_instance(self.0) } + } + fn set_value(&mut self, i: core::ffi::c_int, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_contour_values_set_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_contour_values_set_value(self.0, i, value) } + } + fn get_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_contour_values_get_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_contour_values_get_value(self.0, i) } + } + fn get_values(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_contour_values_get_values( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_contour_values_get_values(self.0) } + } + fn get_values(&mut self, contourValues: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_contour_values_get_values( + sself: *mut core::ffi::c_void, + contourValues: core::ffi::c_double, + ); + } + unsafe { vtk_contour_values_get_values(self.0, contourValues) } + } + fn set_number_of_contours(&mut self, number: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_contour_values_set_number_of_contours( + sself: *mut core::ffi::c_void, + number: core::ffi::c_int, + ); + } + unsafe { vtk_contour_values_set_number_of_contours(self.0, number) } + } + fn get_number_of_contours(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_contour_values_get_number_of_contours( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_contour_values_get_number_of_contours(self.0) } + } + fn generate_values( + &mut self, + numContours: core::ffi::c_int, + range: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_contour_values_generate_values( + sself: *mut core::ffi::c_void, + numContours: core::ffi::c_int, + range: core::ffi::c_double, + ); + } + unsafe { vtk_contour_values_generate_values(self.0, numContours, range) } + } + fn generate_values( + &mut self, + numContours: core::ffi::c_int, + rangeStart: core::ffi::c_double, + rangeEnd: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_contour_values_generate_values( + sself: *mut core::ffi::c_void, + numContours: core::ffi::c_int, + rangeStart: core::ffi::c_double, + rangeEnd: core::ffi::c_double, + ); + } + unsafe { + vtk_contour_values_generate_values(self.0, numContours, rangeStart, rangeEnd) + } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_contour_values_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_contour_values_deep_copy(self.0, other) } + } +} +impl VtkExprTkFunctionParser for vtkExprTkFunctionParser { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_expr_tk_function_parser_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_expr_tk_function_parser_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_expr_tk_function_parser_new_instance(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_expr_tk_function_parser_get_m_time(self.0) } + } + fn set_function(&mut self, function: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_function( + sself: *mut core::ffi::c_void, + function: core::ffi::c_char, + ); + } + unsafe { vtk_expr_tk_function_parser_set_function(self.0, function) } + } + fn get_function(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_function( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_expr_tk_function_parser_get_function(self.0) } + } + fn is_scalar_result(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_is_scalar_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_expr_tk_function_parser_is_scalar_result(self.0) } + } + fn is_vector_result(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_is_vector_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_expr_tk_function_parser_is_vector_result(self.0) } + } + fn get_scalar_result(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_expr_tk_function_parser_get_scalar_result(self.0) } + } + fn get_vector_result(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_result( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_expr_tk_function_parser_get_vector_result(self.0) } + } + fn get_vector_result(&mut self, result: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_result( + sself: *mut core::ffi::c_void, + result: core::ffi::c_double, + ); + } + unsafe { vtk_expr_tk_function_parser_get_vector_result(self.0, result) } + } + fn set_scalar_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_scalar_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_expr_tk_function_parser_set_scalar_variable_value( + self.0, + c_variableName.as_ptr(), + value, + ) + } + } + fn set_scalar_variable_value( + &mut self, + i: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_scalar_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_expr_tk_function_parser_set_scalar_variable_value(self.0, i, value) + } + } + fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + ) -> core::ffi::c_double; + } + unsafe { + vtk_expr_tk_function_parser_get_scalar_variable_value( + self.0, + c_variableName.as_ptr(), + ) + } + } + fn get_scalar_variable_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_expr_tk_function_parser_get_scalar_variable_value(self.0, i) } + } + fn set_vector_variable_value( + &mut self, + variableName: &str, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ); + } + unsafe { + vtk_expr_tk_function_parser_set_vector_variable_value( + self.0, + c_variableName.as_ptr(), + xValue, + yValue, + zValue, + ) + } + } + fn set_vector_variable_value( + &mut self, + variableName: &str, + values: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + values: core::ffi::c_double, + ); + } + unsafe { + vtk_expr_tk_function_parser_set_vector_variable_value( + self.0, + c_variableName.as_ptr(), + values, + ) + } + } + fn set_vector_variable_value( + &mut self, + i: core::ffi::c_int, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ); + } + unsafe { + vtk_expr_tk_function_parser_set_vector_variable_value( + self.0, + i, + xValue, + yValue, + zValue, + ) + } + } + fn set_vector_variable_value( + &mut self, + i: core::ffi::c_int, + values: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + values: core::ffi::c_double, + ); + } + unsafe { + vtk_expr_tk_function_parser_set_vector_variable_value(self.0, i, values) + } + } + fn get_vector_variable_value( + &mut self, + variableName: &str, + ) -> *mut core::ffi::c_double { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + ) -> *mut core::ffi::c_double; + } + unsafe { + vtk_expr_tk_function_parser_get_vector_variable_value( + self.0, + c_variableName.as_ptr(), + ) + } + } + fn get_vector_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_expr_tk_function_parser_get_vector_variable_value( + self.0, + c_variableName.as_ptr(), + value, + ) + } + } + fn get_vector_variable_value( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_expr_tk_function_parser_get_vector_variable_value(self.0, i) } + } + fn get_vector_variable_value( + &mut self, + i: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_expr_tk_function_parser_get_vector_variable_value(self.0, i, value) + } + } + fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_number_of_scalar_variables( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_expr_tk_function_parser_get_number_of_scalar_variables(self.0) } + } + fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_variable_index( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_expr_tk_function_parser_get_scalar_variable_index( + self.0, + c_name.as_ptr(), + ) + } + } + fn get_number_of_vector_variables(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_number_of_vector_variables( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_expr_tk_function_parser_get_number_of_vector_variables(self.0) } + } + fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_variable_index( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_expr_tk_function_parser_get_vector_variable_index( + self.0, + c_name.as_ptr(), + ) + } + } + fn get_scalar_variable_name(&mut self, i: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_variable_name( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_expr_tk_function_parser_get_scalar_variable_name(self.0, i) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_vector_variable_name(&mut self, i: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_variable_name( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_expr_tk_function_parser_get_vector_variable_name(self.0, i) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_variable_needed( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_expr_tk_function_parser_get_scalar_variable_needed(self.0, i) } + } + fn get_scalar_variable_needed(&mut self, variableName: &str) -> bool { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_variable_needed( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + ) -> bool; + } + unsafe { + vtk_expr_tk_function_parser_get_scalar_variable_needed( + self.0, + c_variableName.as_ptr(), + ) + } + } + fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_variable_needed( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_expr_tk_function_parser_get_vector_variable_needed(self.0, i) } + } + fn get_vector_variable_needed(&mut self, variableName: &str) -> bool { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_variable_needed( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + ) -> bool; + } + unsafe { + vtk_expr_tk_function_parser_get_vector_variable_needed( + self.0, + c_variableName.as_ptr(), + ) + } + } + fn remove_all_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_remove_all_variables( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_remove_all_variables(self.0) } + } + fn remove_scalar_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_remove_scalar_variables( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_remove_scalar_variables(self.0) } + } + fn remove_vector_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_remove_vector_variables( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_remove_vector_variables(self.0) } + } + fn set_replace_invalid_values(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_replace_invalid_values( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_expr_tk_function_parser_set_replace_invalid_values(self.0, _arg) } + } + fn get_replace_invalid_values(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_replace_invalid_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_expr_tk_function_parser_get_replace_invalid_values(self.0) } + } + fn replace_invalid_values_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_replace_invalid_values_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_replace_invalid_values_on(self.0) } + } + fn replace_invalid_values_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_replace_invalid_values_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_replace_invalid_values_off(self.0) } + } + fn set_replacement_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_replacement_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_expr_tk_function_parser_set_replacement_value(self.0, _arg) } + } + fn get_replacement_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_replacement_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_expr_tk_function_parser_get_replacement_value(self.0) } + } + fn invalidate_function(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_invalidate_function( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_invalidate_function(self.0) } + } + fn sanitize_name(&mut self, name: core::ffi::c_char) -> &str { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_sanitize_name( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_expr_tk_function_parser_sanitize_name(self.0, name) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} +impl VtkFunctionParser for vtkFunctionParser { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_function_parser_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_function_parser_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_function_parser_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_function_parser_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_function_parser_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_function_parser_new_instance(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_function_parser_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_function_parser_get_m_time(self.0) } + } + fn set_function(&mut self, function: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_function( + sself: *mut core::ffi::c_void, + function: core::ffi::c_char, + ); + } + unsafe { vtk_function_parser_set_function(self.0, function) } + } + fn get_function(&mut self) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_function_parser_get_function( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_function_parser_get_function(self.0) } + } + fn is_scalar_result(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_is_scalar_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_is_scalar_result(self.0) } + } + fn is_vector_result(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_is_vector_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_is_vector_result(self.0) } + } + fn get_scalar_result(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_function_parser_get_scalar_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_function_parser_get_scalar_result(self.0) } + } + fn get_vector_result(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_function_parser_get_vector_result( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_function_parser_get_vector_result(self.0) } + } + fn get_vector_result(&mut self, result: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_function_parser_get_vector_result( + sself: *mut core::ffi::c_void, + result: core::ffi::c_double, + ); + } + unsafe { vtk_function_parser_get_vector_result(self.0, result) } + } + fn set_scalar_variable_value( + &mut self, + variableName: core::ffi::c_char, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_scalar_variable_value( + sself: *mut core::ffi::c_void, + variableName: core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_set_scalar_variable_value(self.0, variableName, value) + } + } + fn set_scalar_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_set_scalar_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_set_scalar_variable_value( + self.0, + c_variableName.as_ptr(), + value, + ) + } + } + fn set_scalar_variable_value( + &mut self, + i: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_scalar_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_function_parser_set_scalar_variable_value(self.0, i, value) } + } + fn get_scalar_variable_value( + &mut self, + variableName: core::ffi::c_char, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_value( + sself: *mut core::ffi::c_void, + variableName: core::ffi::c_char, + ) -> core::ffi::c_double; + } + unsafe { vtk_function_parser_get_scalar_variable_value(self.0, variableName) } + } + fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + ) -> core::ffi::c_double; + } + unsafe { + vtk_function_parser_get_scalar_variable_value( + self.0, + c_variableName.as_ptr(), + ) + } + } + fn get_scalar_variable_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_function_parser_get_scalar_variable_value(self.0, i) } + } + fn set_vector_variable_value( + &mut self, + variableName: core::ffi::c_char, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: core::ffi::c_char, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_set_vector_variable_value( + self.0, + variableName, + xValue, + yValue, + zValue, + ) + } + } + fn set_vector_variable_value( + &mut self, + variableName: &str, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_set_vector_variable_value( + self.0, + c_variableName.as_ptr(), + xValue, + yValue, + zValue, + ) + } + } + fn set_vector_variable_value( + &mut self, + variableName: core::ffi::c_char, + values: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: core::ffi::c_char, + values: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_set_vector_variable_value(self.0, variableName, values) + } + } + fn set_vector_variable_value( + &mut self, + variableName: &str, + values: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + values: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_set_vector_variable_value( + self.0, + c_variableName.as_ptr(), + values, + ) + } + } + fn set_vector_variable_value( + &mut self, + i: core::ffi::c_int, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_set_vector_variable_value( + self.0, + i, + xValue, + yValue, + zValue, + ) + } + } + fn set_vector_variable_value( + &mut self, + i: core::ffi::c_int, + values: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + values: core::ffi::c_double, + ); + } + unsafe { vtk_function_parser_set_vector_variable_value(self.0, i, values) } + } + fn get_vector_variable_value( + &mut self, + variableName: core::ffi::c_char, + ) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: core::ffi::c_char, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_function_parser_get_vector_variable_value(self.0, variableName) } + } + fn get_vector_variable_value( + &mut self, + variableName: &str, + ) -> *mut core::ffi::c_double { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + ) -> *mut core::ffi::c_double; + } + unsafe { + vtk_function_parser_get_vector_variable_value( + self.0, + c_variableName.as_ptr(), + ) + } + } + fn get_vector_variable_value( + &mut self, + variableName: core::ffi::c_char, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_get_vector_variable_value(self.0, variableName, value) + } + } + fn get_vector_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_get_vector_variable_value( + self.0, + c_variableName.as_ptr(), + value, + ) + } + } + fn get_vector_variable_value( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_function_parser_get_vector_variable_value(self.0, i) } + } + fn get_vector_variable_value( + &mut self, + i: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_function_parser_get_vector_variable_value(self.0, i, value) } + } + fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_get_number_of_scalar_variables( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_number_of_scalar_variables(self.0) } + } + fn get_scalar_variable_index( + &mut self, + name: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_index( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_scalar_variable_index(self.0, name) } + } + fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_index( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_scalar_variable_index(self.0, c_name.as_ptr()) } + } + fn get_number_of_vector_variables(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_get_number_of_vector_variables( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_number_of_vector_variables(self.0) } + } + fn get_vector_variable_index( + &mut self, + name: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_index( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_vector_variable_index(self.0, name) } + } + fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_index( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_vector_variable_index(self.0, c_name.as_ptr()) } + } + fn get_scalar_variable_name( + &mut self, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_name( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_function_parser_get_scalar_variable_name(self.0, i) } + } + fn get_vector_variable_name( + &mut self, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_name( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_function_parser_get_vector_variable_name(self.0, i) } + } + fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_needed( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_function_parser_get_scalar_variable_needed(self.0, i) } + } + fn get_scalar_variable_needed(&mut self, variableName: core::ffi::c_char) -> bool { + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_needed( + sself: *mut core::ffi::c_void, + variableName: core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_function_parser_get_scalar_variable_needed(self.0, variableName) } + } + fn get_scalar_variable_needed(&mut self, variableName: &str) -> bool { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_needed( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + ) -> bool; + } + unsafe { + vtk_function_parser_get_scalar_variable_needed( + self.0, + c_variableName.as_ptr(), + ) + } + } + fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_needed( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_function_parser_get_vector_variable_needed(self.0, i) } + } + fn get_vector_variable_needed(&mut self, variableName: core::ffi::c_char) -> bool { + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_needed( + sself: *mut core::ffi::c_void, + variableName: core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_function_parser_get_vector_variable_needed(self.0, variableName) } + } + fn get_vector_variable_needed(&mut self, variableName: &str) -> bool { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_needed( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + ) -> bool; + } + unsafe { + vtk_function_parser_get_vector_variable_needed( + self.0, + c_variableName.as_ptr(), + ) + } + } + fn remove_all_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_remove_all_variables(sself: *mut core::ffi::c_void); + } + unsafe { vtk_function_parser_remove_all_variables(self.0) } + } + fn remove_scalar_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_remove_scalar_variables( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_function_parser_remove_scalar_variables(self.0) } + } + fn remove_vector_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_remove_vector_variables( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_function_parser_remove_vector_variables(self.0) } + } + fn set_replace_invalid_values(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_replace_invalid_values( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_function_parser_set_replace_invalid_values(self.0, _arg) } + } + fn get_replace_invalid_values(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_get_replace_invalid_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_replace_invalid_values(self.0) } + } + fn replace_invalid_values_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_replace_invalid_values_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_function_parser_replace_invalid_values_on(self.0) } + } + fn replace_invalid_values_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_replace_invalid_values_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_function_parser_replace_invalid_values_off(self.0) } + } + fn set_replacement_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_replacement_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_function_parser_set_replacement_value(self.0, _arg) } + } + fn get_replacement_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_function_parser_get_replacement_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_function_parser_get_replacement_value(self.0) } + } + fn check_expression( + &mut self, + pos: core::ffi::c_int, + error: core::ffi::c_char, + ) -> () { + unsafe extern "C" { + fn vtk_function_parser_check_expression( + sself: *mut core::ffi::c_void, + pos: core::ffi::c_int, + error: core::ffi::c_char, + ); + } + unsafe { vtk_function_parser_check_expression(self.0, pos, error) } + } + fn invalidate_function(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_invalidate_function(sself: *mut core::ffi::c_void); + } + unsafe { vtk_function_parser_invalidate_function(self.0) } + } +} +impl VtkHeap for vtkHeap { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_heap_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_heap_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_heap_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_heap_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_heap_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_heap_new_instance(self.0) } + } + fn allocate_memory(&mut self, n: usize) -> *mut () { + unsafe extern "C" { + fn vtk_heap_allocate_memory( + sself: *mut core::ffi::c_void, + n: usize, + ) -> *mut (); + } + unsafe { vtk_heap_allocate_memory(self.0, n) } + } + fn set_block_size(&mut self, p0: usize) -> () { + unsafe extern "C" { + fn vtk_heap_set_block_size(sself: *mut core::ffi::c_void, p0: usize); + } + unsafe { vtk_heap_set_block_size(self.0, p0) } + } + fn get_block_size(&mut self) -> usize { + unsafe extern "C" { + fn vtk_heap_get_block_size(sself: *mut core::ffi::c_void) -> usize; + } + unsafe { vtk_heap_get_block_size(self.0) } + } + fn get_number_of_blocks(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_heap_get_number_of_blocks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_heap_get_number_of_blocks(self.0) } + } + fn get_number_of_allocations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_heap_get_number_of_allocations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_heap_get_number_of_allocations(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_heap_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_heap_reset(self.0) } + } + fn string_dup(&mut self, str: core::ffi::c_char) -> *mut core::ffi::c_char { + unsafe extern "C" { + fn vtk_heap_string_dup( + sself: *mut core::ffi::c_void, + str: core::ffi::c_char, + ) -> *mut core::ffi::c_char; + } + unsafe { vtk_heap_string_dup(self.0, str) } + } +} +impl VtkResourceFileLocator for vtkResourceFileLocator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_resource_file_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_resource_file_locator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_resource_file_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_resource_file_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_resource_file_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_resource_file_locator_new_instance(self.0) } + } + fn set_print_debug_information(&mut self, p0: bool) -> () { + unsafe extern "C" { + fn vtk_resource_file_locator_set_print_debug_information( + sself: *mut core::ffi::c_void, + p0: bool, + ); + } + unsafe { vtk_resource_file_locator_set_print_debug_information(self.0, p0) } + } + fn get_print_debug_information(&mut self) -> bool { + unsafe extern "C" { + fn vtk_resource_file_locator_get_print_debug_information( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_resource_file_locator_get_print_debug_information(self.0) } + } + fn print_debug_information_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_resource_file_locator_print_debug_information_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_resource_file_locator_print_debug_information_on(self.0) } + } + fn print_debug_information_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_resource_file_locator_print_debug_information_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_resource_file_locator_print_debug_information_off(self.0) } + } + fn set_log_verbosity(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_resource_file_locator_set_log_verbosity( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_resource_file_locator_set_log_verbosity(self.0, _arg) } + } + fn get_log_verbosity(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_resource_file_locator_get_log_verbosity( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_resource_file_locator_get_log_verbosity(self.0) } + } + fn locate(&mut self, anchor: &str, landmark: &str, defaultDir: &str) -> &str { + let c_anchor = std::ffi::CString::new(anchor).expect("CString::new failed"); + let c_landmark = std::ffi::CString::new(landmark).expect("CString::new failed"); + let c_defaultDir = std::ffi::CString::new(defaultDir) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_resource_file_locator_locate( + sself: *mut core::ffi::c_void, + anchor: *const core::ffi::c_char, + landmark: *const core::ffi::c_char, + defaultDir: *const core::ffi::c_char, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_resource_file_locator_locate( + self.0, + c_anchor.as_ptr(), + c_landmark.as_ptr(), + c_defaultDir.as_ptr(), + ) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn locate( + &mut self, + anchor: &str, + landmark_prefixes: Vec, + landmark: &str, + defaultDir: &str, + ) -> &str { + let c_anchor = std::ffi::CString::new(anchor).expect("CString::new failed"); + let c_landmark = std::ffi::CString::new(landmark).expect("CString::new failed"); + let c_defaultDir = std::ffi::CString::new(defaultDir) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_resource_file_locator_locate( + sself: *mut core::ffi::c_void, + anchor: *const core::ffi::c_char, + landmark_prefixes: Vec, + landmark: *const core::ffi::c_char, + defaultDir: *const core::ffi::c_char, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_resource_file_locator_locate( + self.0, + c_anchor.as_ptr(), + landmark_prefixes, + c_landmark.as_ptr(), + c_defaultDir.as_ptr(), + ) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_library_path_for_symbol_unix( + &mut self, + symbolname: core::ffi::c_char, + ) -> &str { + unsafe extern "C" { + fn vtk_resource_file_locator_get_library_path_for_symbol_unix( + sself: *mut core::ffi::c_void, + symbolname: core::ffi::c_char, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_resource_file_locator_get_library_path_for_symbol_unix( + self.0, + symbolname, + ) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_library_path_for_symbol_win_32(&mut self, fptr: ()) -> &str { + unsafe extern "C" { + fn vtk_resource_file_locator_get_library_path_for_symbol_win_32( + sself: *mut core::ffi::c_void, + fptr: (), + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_resource_file_locator_get_library_path_for_symbol_win_32(self.0, fptr) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} /// helper object to manage setting and generating contour values /// /// diff --git a/vtk-rs-9.1/src/vtkCommonSystem.rs b/vtk-rs-9.1/src/vtkCommonSystem.rs index b14eeba..4342946 100644 --- a/vtk-rs-9.1/src/vtkCommonSystem.rs +++ b/vtk-rs-9.1/src/vtkCommonSystem.rs @@ -1,3 +1,821 @@ +pub trait VtkClientSocket: VtkSocket { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn connect_to_server( + &mut self, + hostname: core::ffi::c_char, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_connecting_side(&mut self) -> bool; +} +pub trait VtkDirectory { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn open(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int; + fn get_number_of_files(&mut self) -> core::ffi::c_uchar; + fn get_file(&mut self, index: core::ffi::c_uchar) -> *const core::ffi::c_char; + fn file_is_directory(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_files(&mut self) -> *mut core::ffi::c_void; + fn get_current_working_directory( + &mut self, + buf: core::ffi::c_char, + len: core::ffi::c_uint, + ) -> *const core::ffi::c_char; + fn make_directory(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int; + fn delete_directory(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int; + fn rename( + &mut self, + oldname: core::ffi::c_char, + newname: core::ffi::c_char, + ) -> core::ffi::c_int; +} +pub trait VtkExecutableRunner { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn execute(&mut self) -> (); + fn set_timeout(&mut self, _arg: core::ffi::c_double) -> (); + fn get_timeout(&mut self) -> core::ffi::c_double; + fn set_right_trim_result(&mut self, _arg: bool) -> (); + fn get_right_trim_result(&mut self) -> bool; + fn right_trim_result_on(&mut self) -> (); + fn right_trim_result_off(&mut self) -> (); + fn get_command(&mut self) -> *const core::ffi::c_char; + fn set_command(&mut self, arg: core::ffi::c_char) -> (); + fn get_std_out(&mut self) -> *const core::ffi::c_char; + fn get_std_err(&mut self) -> *const core::ffi::c_char; + fn get_return_value(&mut self) -> core::ffi::c_int; +} +pub trait VtkServerSocket: VtkSocket { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn create_server(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; + fn wait_for_connection( + &mut self, + msec: core::ffi::c_ulong, + ) -> *mut core::ffi::c_void; + fn get_server_port(&mut self) -> core::ffi::c_int; +} +pub trait VtkSocket { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_connected(&mut self) -> core::ffi::c_int; + fn close_socket(&mut self) -> (); + fn send(&mut self, data: (), length: core::ffi::c_int) -> core::ffi::c_int; + fn receive( + &mut self, + data: (), + length: core::ffi::c_int, + readFully: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_socket_descriptor(&mut self) -> core::ffi::c_int; + fn select_sockets( + &mut self, + sockets_to_select: core::ffi::c_int, + size: core::ffi::c_int, + msec: core::ffi::c_ulong, + selected_index: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkSocketCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, soc: *mut core::ffi::c_void) -> (); + fn select_sockets(&mut self, msec: core::ffi::c_ulong) -> core::ffi::c_int; + fn get_last_selected_socket(&mut self) -> *mut core::ffi::c_void; + fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkThreadMessager { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn wait_for_message(&mut self) -> (); + fn send_wake_message(&mut self) -> (); + fn enable_wait_for_receiver(&mut self) -> (); + fn disable_wait_for_receiver(&mut self) -> (); + fn wait_for_receiver(&mut self) -> (); +} +pub trait VtkTimerLog { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_logging(&mut self, v: core::ffi::c_int) -> (); + fn get_logging(&mut self) -> core::ffi::c_int; + fn logging_on(&mut self) -> (); + fn logging_off(&mut self) -> (); + fn set_max_entries(&mut self, a: core::ffi::c_int) -> (); + fn get_max_entries(&mut self) -> core::ffi::c_int; + fn dump_log(&mut self, filename: core::ffi::c_char) -> (); + fn mark_start_event(&mut self, EventString: core::ffi::c_char) -> (); + fn mark_end_event(&mut self, EventString: core::ffi::c_char) -> (); + fn insert_timed_event( + &mut self, + EventString: core::ffi::c_char, + time: core::ffi::c_double, + cpuTicks: core::ffi::c_int, + ) -> (); + fn get_number_of_events(&mut self) -> core::ffi::c_int; + fn get_event_indent(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; + fn get_event_wall_time(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn get_event_string(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char; + fn get_event_type(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn mark_event(&mut self, EventString: core::ffi::c_char) -> (); + fn reset_log(&mut self) -> (); + fn cleanup_log(&mut self) -> (); + fn get_universal_time(&mut self) -> core::ffi::c_double; + fn get_cpu_time(&mut self) -> core::ffi::c_double; + fn start_timer(&mut self) -> (); + fn stop_timer(&mut self) -> (); + fn get_elapsed_time(&mut self) -> core::ffi::c_double; +} +impl VtkClientSocket for vtkClientSocket { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_client_socket_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_client_socket_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_client_socket_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_client_socket_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_client_socket_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_client_socket_new_instance(self.0) } + } + fn connect_to_server( + &mut self, + hostname: core::ffi::c_char, + port: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_client_socket_connect_to_server( + sself: *mut core::ffi::c_void, + hostname: core::ffi::c_char, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_client_socket_connect_to_server(self.0, hostname, port) } + } + fn get_connecting_side(&mut self) -> bool { + unsafe extern "C" { + fn vtk_client_socket_get_connecting_side( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_client_socket_get_connecting_side(self.0) } + } +} +impl VtkDirectory for vtkDirectory { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directory_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directory_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directory_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directory_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directory_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directory_new(self.0) } + } + fn open(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_directory_open( + sself: *mut core::ffi::c_void, + dir: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_directory_open(self.0, dir) } + } + fn get_number_of_files(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_directory_get_number_of_files( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_directory_get_number_of_files(self.0) } + } + fn get_file(&mut self, index: core::ffi::c_uchar) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_directory_get_file( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uchar, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_directory_get_file(self.0, index) } + } + fn file_is_directory(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_directory_file_is_directory( + sself: *mut core::ffi::c_void, + name: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_directory_file_is_directory(self.0, name) } + } + fn get_files(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directory_get_files( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directory_get_files(self.0) } + } + fn get_current_working_directory( + &mut self, + buf: core::ffi::c_char, + len: core::ffi::c_uint, + ) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_directory_get_current_working_directory( + sself: *mut core::ffi::c_void, + buf: core::ffi::c_char, + len: core::ffi::c_uint, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_directory_get_current_working_directory(self.0, buf, len) } + } + fn make_directory(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_directory_make_directory( + sself: *mut core::ffi::c_void, + dir: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_directory_make_directory(self.0, dir) } + } + fn delete_directory(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_directory_delete_directory( + sself: *mut core::ffi::c_void, + dir: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_directory_delete_directory(self.0, dir) } + } + fn rename( + &mut self, + oldname: core::ffi::c_char, + newname: core::ffi::c_char, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_directory_rename( + sself: *mut core::ffi::c_void, + oldname: core::ffi::c_char, + newname: core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_directory_rename(self.0, oldname, newname) } + } +} +impl VtkExecutableRunner for vtkExecutableRunner { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_executable_runner_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_executable_runner_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_executable_runner_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_executable_runner_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_executable_runner_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_executable_runner_new_instance(self.0) } + } + fn execute(&mut self) -> () { + unsafe extern "C" { + fn vtk_executable_runner_execute(sself: *mut core::ffi::c_void); + } + unsafe { vtk_executable_runner_execute(self.0) } + } + fn set_timeout(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_executable_runner_set_timeout( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_executable_runner_set_timeout(self.0, _arg) } + } + fn get_timeout(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_executable_runner_get_timeout( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_executable_runner_get_timeout(self.0) } + } + fn set_right_trim_result(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_executable_runner_set_right_trim_result( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_executable_runner_set_right_trim_result(self.0, _arg) } + } + fn get_right_trim_result(&mut self) -> bool { + unsafe extern "C" { + fn vtk_executable_runner_get_right_trim_result( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_executable_runner_get_right_trim_result(self.0) } + } + fn right_trim_result_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_executable_runner_right_trim_result_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_executable_runner_right_trim_result_on(self.0) } + } + fn right_trim_result_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_executable_runner_right_trim_result_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_executable_runner_right_trim_result_off(self.0) } + } + fn get_command(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_executable_runner_get_command( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_executable_runner_get_command(self.0) } + } + fn set_command(&mut self, arg: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_executable_runner_set_command( + sself: *mut core::ffi::c_void, + arg: core::ffi::c_char, + ); + } + unsafe { vtk_executable_runner_set_command(self.0, arg) } + } + fn get_std_out(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_executable_runner_get_std_out( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_executable_runner_get_std_out(self.0) } + } + fn get_std_err(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_executable_runner_get_std_err( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_executable_runner_get_std_err(self.0) } + } + fn get_return_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_executable_runner_get_return_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_executable_runner_get_return_value(self.0) } + } +} +impl VtkServerSocket for vtkServerSocket { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_server_socket_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_server_socket_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_server_socket_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_server_socket_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_server_socket_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_server_socket_new_instance(self.0) } + } + fn create_server(&mut self, port: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_server_socket_create_server( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_server_socket_create_server(self.0, port) } + } + fn wait_for_connection( + &mut self, + msec: core::ffi::c_ulong, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_server_socket_wait_for_connection( + sself: *mut core::ffi::c_void, + msec: core::ffi::c_ulong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_server_socket_wait_for_connection(self.0, msec) } + } + fn get_server_port(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_server_socket_get_server_port( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_server_socket_get_server_port(self.0) } + } +} +impl VtkSocketCollection for vtkSocketCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_socket_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_socket_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_socket_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_socket_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_socket_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_socket_collection_new_instance(self.0) } + } + fn add_item(&mut self, soc: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_socket_collection_add_item( + sself: *mut core::ffi::c_void, + soc: *mut core::ffi::c_void, + ); + } + unsafe { vtk_socket_collection_add_item(self.0, soc) } + } + fn select_sockets(&mut self, msec: core::ffi::c_ulong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_socket_collection_select_sockets( + sself: *mut core::ffi::c_void, + msec: core::ffi::c_ulong, + ) -> core::ffi::c_int; + } + unsafe { vtk_socket_collection_select_sockets(self.0, msec) } + } + fn get_last_selected_socket(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_socket_collection_get_last_selected_socket( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_socket_collection_get_last_selected_socket(self.0) } + } + fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_socket_collection_replace_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_socket_collection_replace_item(self.0, i, p1) } + } +} +impl VtkThreadMessager for vtkThreadMessager { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thread_messager_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thread_messager_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thread_messager_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thread_messager_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thread_messager_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thread_messager_new_instance(self.0) } + } + fn wait_for_message(&mut self) -> () { + unsafe extern "C" { + fn vtk_thread_messager_wait_for_message(sself: *mut core::ffi::c_void); + } + unsafe { vtk_thread_messager_wait_for_message(self.0) } + } + fn send_wake_message(&mut self) -> () { + unsafe extern "C" { + fn vtk_thread_messager_send_wake_message(sself: *mut core::ffi::c_void); + } + unsafe { vtk_thread_messager_send_wake_message(self.0) } + } + fn enable_wait_for_receiver(&mut self) -> () { + unsafe extern "C" { + fn vtk_thread_messager_enable_wait_for_receiver( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thread_messager_enable_wait_for_receiver(self.0) } + } + fn disable_wait_for_receiver(&mut self) -> () { + unsafe extern "C" { + fn vtk_thread_messager_disable_wait_for_receiver( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thread_messager_disable_wait_for_receiver(self.0) } + } + fn wait_for_receiver(&mut self) -> () { + unsafe extern "C" { + fn vtk_thread_messager_wait_for_receiver(sself: *mut core::ffi::c_void); + } + unsafe { vtk_thread_messager_wait_for_receiver(self.0) } + } +} +impl VtkTimerLog for vtkTimerLog { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_timer_log_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_timer_log_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_timer_log_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_timer_log_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_timer_log_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_timer_log_new_instance(self.0) } + } + fn set_logging(&mut self, v: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_timer_log_set_logging( + sself: *mut core::ffi::c_void, + v: core::ffi::c_int, + ); + } + unsafe { vtk_timer_log_set_logging(self.0, v) } + } + fn get_logging(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_timer_log_get_logging( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_timer_log_get_logging(self.0) } + } + fn logging_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_logging_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_logging_on(self.0) } + } + fn logging_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_logging_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_logging_off(self.0) } + } + fn set_max_entries(&mut self, a: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_timer_log_set_max_entries( + sself: *mut core::ffi::c_void, + a: core::ffi::c_int, + ); + } + unsafe { vtk_timer_log_set_max_entries(self.0, a) } + } + fn get_max_entries(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_timer_log_get_max_entries( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_timer_log_get_max_entries(self.0) } + } + fn dump_log(&mut self, filename: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_timer_log_dump_log( + sself: *mut core::ffi::c_void, + filename: core::ffi::c_char, + ); + } + unsafe { vtk_timer_log_dump_log(self.0, filename) } + } + fn mark_start_event(&mut self, EventString: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_timer_log_mark_start_event( + sself: *mut core::ffi::c_void, + EventString: core::ffi::c_char, + ); + } + unsafe { vtk_timer_log_mark_start_event(self.0, EventString) } + } + fn mark_end_event(&mut self, EventString: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_timer_log_mark_end_event( + sself: *mut core::ffi::c_void, + EventString: core::ffi::c_char, + ); + } + unsafe { vtk_timer_log_mark_end_event(self.0, EventString) } + } + fn insert_timed_event( + &mut self, + EventString: core::ffi::c_char, + time: core::ffi::c_double, + cpuTicks: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_timer_log_insert_timed_event( + sself: *mut core::ffi::c_void, + EventString: core::ffi::c_char, + time: core::ffi::c_double, + cpuTicks: core::ffi::c_int, + ); + } + unsafe { vtk_timer_log_insert_timed_event(self.0, EventString, time, cpuTicks) } + } + fn get_number_of_events(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_timer_log_get_number_of_events( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_timer_log_get_number_of_events(self.0) } + } + fn get_event_indent(&mut self, i: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_timer_log_get_event_indent( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_timer_log_get_event_indent(self.0, i) } + } + fn get_event_wall_time(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_timer_log_get_event_wall_time( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_timer_log_get_event_wall_time(self.0, i) } + } + fn get_event_string(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_timer_log_get_event_string( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_timer_log_get_event_string(self.0, i) } + } + fn get_event_type(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_timer_log_get_event_type( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_timer_log_get_event_type(self.0, i) } + } + fn mark_event(&mut self, EventString: core::ffi::c_char) -> () { + unsafe extern "C" { + fn vtk_timer_log_mark_event( + sself: *mut core::ffi::c_void, + EventString: core::ffi::c_char, + ); + } + unsafe { vtk_timer_log_mark_event(self.0, EventString) } + } + fn reset_log(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_reset_log(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_reset_log(self.0) } + } + fn cleanup_log(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_cleanup_log(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_cleanup_log(self.0) } + } + fn get_universal_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_timer_log_get_universal_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_timer_log_get_universal_time(self.0) } + } + fn get_cpu_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_timer_log_get_cpu_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_timer_log_get_cpu_time(self.0) } + } + fn start_timer(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_start_timer(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_start_timer(self.0) } + } + fn stop_timer(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_stop_timer(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_stop_timer(self.0) } + } + fn get_elapsed_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_timer_log_get_elapsed_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_timer_log_get_elapsed_time(self.0) } + } +} /// Encapsulates a client socket. /// #[allow(non_camel_case_types)] diff --git a/vtk-rs-9.1/src/vtkCommonTransforms.rs b/vtk-rs-9.1/src/vtkCommonTransforms.rs index 40447a0..09d247b 100644 --- a/vtk-rs-9.1/src/vtkCommonTransforms.rs +++ b/vtk-rs-9.1/src/vtkCommonTransforms.rs @@ -1,3 +1,3187 @@ +pub trait VtkAbstractTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn transform_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn transform_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn transform_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_point( + &mut self, + point: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_float_point( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + z: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + fn transform_float_point( + &mut self, + point: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + fn transform_double_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_double_point( + &mut self, + point: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_normal_at_point( + &mut self, + point: core::ffi::c_float, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn transform_normal_at_point( + &mut self, + point: core::ffi::c_double, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn transform_normal_at_point( + &mut self, + point: core::ffi::c_double, + normal: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_double_normal_at_point( + &mut self, + point: core::ffi::c_double, + normal: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_float_normal_at_point( + &mut self, + point: core::ffi::c_float, + normal: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + fn transform_vector_at_point( + &mut self, + point: core::ffi::c_float, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn transform_vector_at_point( + &mut self, + point: core::ffi::c_double, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn transform_vector_at_point( + &mut self, + point: core::ffi::c_double, + vector: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_double_vector_at_point( + &mut self, + point: core::ffi::c_double, + vector: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_float_vector_at_point( + &mut self, + point: core::ffi::c_float, + vector: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + fn transform_points( + &mut self, + inPts: *mut core::ffi::c_void, + outPts: *mut core::ffi::c_void, + ) -> (); + fn transform_points_normals_vectors( + &mut self, + inPts: *mut core::ffi::c_void, + outPts: *mut core::ffi::c_void, + inNms: *mut core::ffi::c_void, + outNms: *mut core::ffi::c_void, + inVrs: *mut core::ffi::c_void, + outVrs: *mut core::ffi::c_void, + nOptionalVectors: core::ffi::c_int, + inVrsArr: *mut core::ffi::c_void, + outVrsArr: *mut core::ffi::c_void, + ) -> (); + fn get_inverse(&mut self) -> *mut core::ffi::c_void; + fn set_inverse(&mut self, transform: *mut core::ffi::c_void) -> (); + fn inverse(&mut self) -> (); + fn deep_copy(&mut self, p0: *mut core::ffi::c_void) -> (); + fn update(&mut self) -> (); + fn internal_transform_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn internal_transform_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn internal_transform_derivative( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + derivative: core::ffi::c_float, + ) -> (); + fn internal_transform_derivative( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + derivative: core::ffi::c_double, + ) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; + fn circuit_check(&mut self, transform: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn un_register(&mut self, O: *mut core::ffi::c_void) -> (); +} +pub trait VtkCylindricalTransform: VtkWarpTransform + VtkAbstractTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkGeneralTransform: VtkAbstractTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn identity(&mut self) -> (); + fn inverse(&mut self) -> (); + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn translate(&mut self, x: core::ffi::c_double) -> (); + fn translate(&mut self, x: core::ffi::c_float) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_double, + ) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_float, + ) -> (); + fn rotate_x(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_y(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_z(&mut self, angle: core::ffi::c_double) -> (); + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn scale(&mut self, s: core::ffi::c_double) -> (); + fn scale(&mut self, s: core::ffi::c_float) -> (); + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn concatenate(&mut self, elements: core::ffi::c_double) -> (); + fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> (); + fn pre_multiply(&mut self) -> (); + fn post_multiply(&mut self) -> (); + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int; + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input(&mut self, input: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_inverse_flag(&mut self) -> core::ffi::c_int; + fn push(&mut self) -> (); + fn pop(&mut self) -> (); + fn internal_transform_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn internal_transform_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn internal_transform_derivative( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + derivative: core::ffi::c_float, + ) -> (); + fn internal_transform_derivative( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + derivative: core::ffi::c_double, + ) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkHomogeneousTransform: VtkAbstractTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_matrix(&mut self, m: *mut core::ffi::c_void) -> (); + fn get_matrix(&mut self) -> *mut core::ffi::c_void; + fn get_homogeneous_inverse(&mut self) -> *mut core::ffi::c_void; + fn internal_transform_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn internal_transform_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn internal_transform_derivative( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + derivative: core::ffi::c_float, + ) -> (); + fn internal_transform_derivative( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + derivative: core::ffi::c_double, + ) -> (); +} +pub trait VtkIdentityTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstractTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLandmarkTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstractTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_source_landmarks(&mut self, source: *mut core::ffi::c_void) -> (); + fn set_target_landmarks(&mut self, target: *mut core::ffi::c_void) -> (); + fn get_source_landmarks(&mut self) -> *mut core::ffi::c_void; + fn get_target_landmarks(&mut self) -> *mut core::ffi::c_void; + fn set_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn set_mode_to_rigid_body(&mut self) -> (); + fn set_mode_to_similarity(&mut self) -> (); + fn set_mode_to_affine(&mut self) -> (); + fn get_mode(&mut self) -> core::ffi::c_int; + fn get_mode_as_string(&mut self) -> *const core::ffi::c_char; + fn inverse(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLinearTransform: VtkHomogeneousTransform + VtkAbstractTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn transform_normal( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn transform_normal( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn transform_normal( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_normal( + &mut self, + normal: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_float_normal( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + z: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + fn transform_float_normal( + &mut self, + normal: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + fn transform_double_normal( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_double_normal( + &mut self, + normal: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_vector( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_vector( + &mut self, + normal: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_vector( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn transform_vector( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn transform_float_vector( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + z: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + fn transform_float_vector( + &mut self, + vec: core::ffi::c_float, + ) -> *mut core::ffi::c_float; + fn transform_double_vector( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_double_vector( + &mut self, + vec: core::ffi::c_double, + ) -> *mut core::ffi::c_double; + fn transform_normals( + &mut self, + inNms: *mut core::ffi::c_void, + outNms: *mut core::ffi::c_void, + ) -> (); + fn transform_vectors( + &mut self, + inVrs: *mut core::ffi::c_void, + outVrs: *mut core::ffi::c_void, + ) -> (); + fn get_linear_inverse(&mut self) -> *mut core::ffi::c_void; + fn internal_transform_normal( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn internal_transform_normal( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn internal_transform_vector( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn internal_transform_vector( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); +} +pub trait VtkMatrixToHomogeneousTransform: VtkHomogeneousTransform + VtkAbstractTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_input(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkMatrixToLinearTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstractTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_input(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPerspectiveTransform: VtkHomogeneousTransform + VtkAbstractTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn identity(&mut self) -> (); + fn inverse(&mut self) -> (); + fn adjust_viewport( + &mut self, + oldXMin: core::ffi::c_double, + oldXMax: core::ffi::c_double, + oldYMin: core::ffi::c_double, + oldYMax: core::ffi::c_double, + newXMin: core::ffi::c_double, + newXMax: core::ffi::c_double, + newYMin: core::ffi::c_double, + newYMax: core::ffi::c_double, + ) -> (); + fn adjust_z_buffer( + &mut self, + oldNearZ: core::ffi::c_double, + oldFarZ: core::ffi::c_double, + newNearZ: core::ffi::c_double, + newFarZ: core::ffi::c_double, + ) -> (); + fn ortho( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> (); + fn frustum( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> (); + fn perspective( + &mut self, + angle: core::ffi::c_double, + aspect: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> (); + fn shear( + &mut self, + dxdz: core::ffi::c_double, + dydz: core::ffi::c_double, + zplane: core::ffi::c_double, + ) -> (); + fn stereo( + &mut self, + angle: core::ffi::c_double, + focaldistance: core::ffi::c_double, + ) -> (); + fn setup_camera( + &mut self, + position: core::ffi::c_double, + focalpoint: core::ffi::c_double, + viewup: core::ffi::c_double, + ) -> (); + fn setup_camera( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + fp0: core::ffi::c_double, + fp1: core::ffi::c_double, + fp2: core::ffi::c_double, + vup0: core::ffi::c_double, + vup1: core::ffi::c_double, + vup2: core::ffi::c_double, + ) -> (); + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn translate(&mut self, x: core::ffi::c_double) -> (); + fn translate(&mut self, x: core::ffi::c_float) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_double, + ) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_float, + ) -> (); + fn rotate_x(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_y(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_z(&mut self, angle: core::ffi::c_double) -> (); + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn scale(&mut self, s: core::ffi::c_double) -> (); + fn scale(&mut self, s: core::ffi::c_float) -> (); + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn set_matrix(&mut self, elements: core::ffi::c_double) -> (); + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn concatenate(&mut self, elements: core::ffi::c_double) -> (); + fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> (); + fn pre_multiply(&mut self) -> (); + fn post_multiply(&mut self) -> (); + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int; + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input(&mut self, input: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_inverse_flag(&mut self) -> core::ffi::c_int; + fn push(&mut self) -> (); + fn pop(&mut self) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkSphericalTransform: VtkWarpTransform + VtkAbstractTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkThinPlateSplineTransform: VtkWarpTransform + VtkAbstractTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_sigma(&mut self) -> core::ffi::c_double; + fn set_sigma(&mut self, _arg: core::ffi::c_double) -> (); + fn set_basis(&mut self, basis: core::ffi::c_int) -> (); + fn get_basis(&mut self) -> core::ffi::c_int; + fn set_basis_to_r(&mut self) -> (); + fn set_basis_to_r_2_log_r(&mut self) -> (); + fn get_basis_as_string(&mut self) -> *const core::ffi::c_char; + fn set_basis_function(&mut self, U: *mut core::ffi::c_void) -> (); + fn set_basis_derivative(&mut self, dUdr: *mut core::ffi::c_void) -> (); + fn set_source_landmarks(&mut self, source: *mut core::ffi::c_void) -> (); + fn get_source_landmarks(&mut self) -> *mut core::ffi::c_void; + fn set_target_landmarks(&mut self, target: *mut core::ffi::c_void) -> (); + fn get_target_landmarks(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn make_transform(&mut self) -> *mut core::ffi::c_void; + fn get_regularize_bulk_transform(&mut self) -> bool; + fn set_regularize_bulk_transform(&mut self, _arg: bool) -> (); + fn regularize_bulk_transform_on(&mut self) -> (); + fn regularize_bulk_transform_off(&mut self) -> (); +} +pub trait VtkTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstractTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn identity(&mut self) -> (); + fn inverse(&mut self) -> (); + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn translate(&mut self, x: core::ffi::c_double) -> (); + fn translate(&mut self, x: core::ffi::c_float) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_double, + ) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_float, + ) -> (); + fn rotate_x(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_y(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_z(&mut self, angle: core::ffi::c_double) -> (); + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn scale(&mut self, s: core::ffi::c_double) -> (); + fn scale(&mut self, s: core::ffi::c_float) -> (); + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn set_matrix(&mut self, elements: core::ffi::c_double) -> (); + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn concatenate(&mut self, elements: core::ffi::c_double) -> (); + fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> (); + fn pre_multiply(&mut self) -> (); + fn post_multiply(&mut self) -> (); + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int; + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_orientation(&mut self, orient: core::ffi::c_double) -> (); + fn get_orientation(&mut self, orient: core::ffi::c_float) -> (); + fn get_orientation(&mut self) -> *mut core::ffi::c_double; + fn get_orientation( + &mut self, + orient: core::ffi::c_double, + matrix: *mut core::ffi::c_void, + ) -> (); + fn get_orientation_wxyz(&mut self, wxyz: core::ffi::c_double) -> (); + fn get_orientation_wxyz(&mut self, wxyz: core::ffi::c_float) -> (); + fn get_orientation_wxyz(&mut self) -> *mut core::ffi::c_double; + fn get_position(&mut self, pos: core::ffi::c_double) -> (); + fn get_position(&mut self, pos: core::ffi::c_float) -> (); + fn get_position(&mut self) -> *mut core::ffi::c_double; + fn get_scale(&mut self, scale: core::ffi::c_double) -> (); + fn get_scale(&mut self, scale: core::ffi::c_float) -> (); + fn get_scale(&mut self) -> *mut core::ffi::c_double; + fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> (); + fn get_transpose(&mut self, transpose: *mut core::ffi::c_void) -> (); + fn set_input(&mut self, input: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_inverse_flag(&mut self) -> core::ffi::c_int; + fn push(&mut self) -> (); + fn pop(&mut self) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn multiply_point(&mut self, in_: core::ffi::c_float, out: core::ffi::c_float) -> (); + fn multiply_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); +} +pub trait VtkTransform2D { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn identity(&mut self) -> (); + fn inverse(&mut self) -> (); + fn translate(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); + fn translate(&mut self, x: core::ffi::c_double) -> (); + fn translate(&mut self, x: core::ffi::c_float) -> (); + fn rotate(&mut self, angle: core::ffi::c_double) -> (); + fn scale(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); + fn scale(&mut self, s: core::ffi::c_double) -> (); + fn scale(&mut self, s: core::ffi::c_float) -> (); + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn set_matrix(&mut self, elements: core::ffi::c_double) -> (); + fn get_matrix(&mut self) -> *mut core::ffi::c_void; + fn get_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn get_position(&mut self, pos: core::ffi::c_double) -> (); + fn get_position(&mut self, pos: core::ffi::c_float) -> (); + fn get_scale(&mut self, scale: core::ffi::c_double) -> (); + fn get_scale(&mut self, pos: core::ffi::c_float) -> (); + fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> (); + fn get_transpose(&mut self, transpose: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn transform_points( + &mut self, + inPts: core::ffi::c_float, + outPts: core::ffi::c_float, + n: core::ffi::c_int, + ) -> (); + fn transform_points( + &mut self, + inPts: core::ffi::c_double, + outPts: core::ffi::c_double, + n: core::ffi::c_int, + ) -> (); + fn transform_points( + &mut self, + inPts: *mut core::ffi::c_void, + outPts: *mut core::ffi::c_void, + ) -> (); + fn inverse_transform_points( + &mut self, + inPts: core::ffi::c_float, + outPts: core::ffi::c_float, + n: core::ffi::c_int, + ) -> (); + fn inverse_transform_points( + &mut self, + inPts: core::ffi::c_double, + outPts: core::ffi::c_double, + n: core::ffi::c_int, + ) -> (); + fn inverse_transform_points( + &mut self, + inPts: *mut core::ffi::c_void, + outPts: *mut core::ffi::c_void, + ) -> (); + fn multiply_point(&mut self, in_: core::ffi::c_float, out: core::ffi::c_float) -> (); + fn multiply_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); +} +pub trait VtkTransformCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_next_transform(&mut self, cookie: ()) -> *mut core::ffi::c_void; +} +pub trait VtkTransformConcatenation { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> (); + fn concatenate(&mut self, elements: core::ffi::c_double) -> (); + fn set_pre_multiply_flag(&mut self, flag: core::ffi::c_int) -> (); + fn get_pre_multiply_flag(&mut self) -> core::ffi::c_int; + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn inverse(&mut self) -> (); + fn get_inverse_flag(&mut self) -> core::ffi::c_int; + fn identity(&mut self) -> (); + fn deep_copy(&mut self, transform: *mut core::ffi::c_void) -> (); + fn get_number_of_transforms(&mut self) -> core::ffi::c_int; + fn get_number_of_pre_transforms(&mut self) -> core::ffi::c_int; + fn get_number_of_post_transforms(&mut self) -> core::ffi::c_int; + fn get_transform(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_max_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkTransformConcatenationStack { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn pop(&mut self, concat: *mut core::ffi::c_void) -> (); + fn push(&mut self, concat: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, stack: *mut core::ffi::c_void) -> (); +} +pub trait VtkTransformPair { + fn swap_forward_inverse(&mut self) -> (); +} +pub trait VtkWarpTransform: VtkAbstractTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> (); + fn get_inverse_flag(&mut self) -> core::ffi::c_int; + fn set_inverse_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_inverse_tolerance(&mut self) -> core::ffi::c_double; + fn set_inverse_iterations(&mut self, _arg: core::ffi::c_int) -> (); + fn get_inverse_iterations(&mut self) -> core::ffi::c_int; + fn internal_transform_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn internal_transform_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn internal_transform_derivative( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + derivative: core::ffi::c_float, + ) -> (); + fn internal_transform_derivative( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + derivative: core::ffi::c_double, + ) -> (); + fn template_transform_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn template_transform_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn template_transform_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + derivative: core::ffi::c_float, + ) -> (); + fn template_transform_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + derivative: core::ffi::c_double, + ) -> (); + fn template_transform_inverse( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> (); + fn template_transform_inverse( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> (); + fn template_transform_inverse( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + derivative: core::ffi::c_float, + ) -> (); + fn template_transform_inverse( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + derivative: core::ffi::c_double, + ) -> (); +} +impl VtkCylindricalTransform for vtkCylindricalTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylindrical_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylindrical_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylindrical_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylindrical_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylindrical_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylindrical_transform_new_instance(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylindrical_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylindrical_transform_make_transform(self.0) } + } +} +impl VtkGeneralTransform for vtkGeneralTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_new_instance(self.0) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_identity(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_inverse(self.0) } + } + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_translate(self.0, x, y, z) } + } + fn translate(&mut self, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_general_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_translate(self.0, x) } + } + fn translate(&mut self, x: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_general_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_float, + ); + } + unsafe { vtk_general_transform_translate(self.0, x) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_rotate_wxyz(self.0, angle, x, y, z) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + axis: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_rotate_wxyz(self.0, angle, axis) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + axis: core::ffi::c_float, + ); + } + unsafe { vtk_general_transform_rotate_wxyz(self.0, angle, axis) } + } + fn rotate_x(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_general_transform_rotate_x( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_rotate_x(self.0, angle) } + } + fn rotate_y(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_general_transform_rotate_y( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_rotate_y(self.0, angle) } + } + fn rotate_z(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_general_transform_rotate_z( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_rotate_z(self.0, angle) } + } + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_scale( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_scale(self.0, x, y, z) } + } + fn scale(&mut self, s: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_general_transform_scale( + sself: *mut core::ffi::c_void, + s: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_scale(self.0, s) } + } + fn scale(&mut self, s: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_general_transform_scale( + sself: *mut core::ffi::c_void, + s: core::ffi::c_float, + ); + } + unsafe { vtk_general_transform_scale(self.0, s) } + } + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_general_transform_concatenate( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_general_transform_concatenate(self.0, matrix) } + } + fn concatenate(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_general_transform_concatenate( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_concatenate(self.0, elements) } + } + fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_general_transform_concatenate( + sself: *mut core::ffi::c_void, + transform: *mut core::ffi::c_void, + ); + } + unsafe { vtk_general_transform_concatenate(self.0, transform) } + } + fn pre_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_pre_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_pre_multiply(self.0) } + } + fn post_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_post_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_post_multiply(self.0) } + } + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_general_transform_get_number_of_concatenated_transforms( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_general_transform_get_number_of_concatenated_transforms(self.0) } + } + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_get_concatenated_transform( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_get_concatenated_transform(self.0, i) } + } + fn set_input(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_general_transform_set_input( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_general_transform_set_input(self.0, input) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_get_input(self.0) } + } + fn get_inverse_flag(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_general_transform_get_inverse_flag( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_general_transform_get_inverse_flag(self.0) } + } + fn push(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_push(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_push(self.0) } + } + fn pop(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_pop(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_pop(self.0) } + } + fn internal_transform_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_internal_transform_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ); + } + unsafe { vtk_general_transform_internal_transform_point(self.0, in_, out) } + } + fn internal_transform_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_internal_transform_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_internal_transform_point(self.0, in_, out) } + } + fn internal_transform_derivative( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + derivative: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_internal_transform_derivative( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_float, + out: core::ffi::c_float, + derivative: core::ffi::c_float, + ); + } + unsafe { + vtk_general_transform_internal_transform_derivative( + self.0, + in_, + out, + derivative, + ) + } + } + fn internal_transform_derivative( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + derivative: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_internal_transform_derivative( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_double, + out: core::ffi::c_double, + derivative: core::ffi::c_double, + ); + } + unsafe { + vtk_general_transform_internal_transform_derivative( + self.0, + in_, + out, + derivative, + ) + } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_make_transform(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_general_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_general_transform_get_m_time(self.0) } + } +} +impl VtkIdentityTransform for vtkIdentityTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_identity_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_identity_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_identity_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_identity_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_identity_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_identity_transform_new_instance(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_identity_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_identity_transform_inverse(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_identity_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_identity_transform_make_transform(self.0) } + } +} +impl VtkLandmarkTransform for vtkLandmarkTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_new_instance(self.0) } + } + fn set_source_landmarks(&mut self, source: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_source_landmarks( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_landmark_transform_set_source_landmarks(self.0, source) } + } + fn set_target_landmarks(&mut self, target: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_target_landmarks( + sself: *mut core::ffi::c_void, + target: *mut core::ffi::c_void, + ); + } + unsafe { vtk_landmark_transform_set_target_landmarks(self.0, target) } + } + fn get_source_landmarks(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_get_source_landmarks( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_get_source_landmarks(self.0) } + } + fn get_target_landmarks(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_get_target_landmarks( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_get_target_landmarks(self.0) } + } + fn set_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_landmark_transform_set_mode(self.0, _arg) } + } + fn set_mode_to_rigid_body(&mut self) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_mode_to_rigid_body( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_landmark_transform_set_mode_to_rigid_body(self.0) } + } + fn set_mode_to_similarity(&mut self) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_mode_to_similarity( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_landmark_transform_set_mode_to_similarity(self.0) } + } + fn set_mode_to_affine(&mut self) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_mode_to_affine(sself: *mut core::ffi::c_void); + } + unsafe { vtk_landmark_transform_set_mode_to_affine(self.0) } + } + fn get_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_landmark_transform_get_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_landmark_transform_get_mode(self.0) } + } + fn get_mode_as_string(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_landmark_transform_get_mode_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_landmark_transform_get_mode_as_string(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_landmark_transform_inverse(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_landmark_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_landmark_transform_get_m_time(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_make_transform(self.0) } + } +} +impl VtkMatrixToHomogeneousTransform for vtkMatrixToHomogeneousTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_homogeneous_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_homogeneous_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_homogeneous_transform_new_instance(self.0) } + } + fn set_input(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_set_input( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_to_homogeneous_transform_set_input(self.0, p0) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_homogeneous_transform_get_input(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_inverse( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_to_homogeneous_transform_inverse(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_matrix_to_homogeneous_transform_get_m_time(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_homogeneous_transform_make_transform(self.0) } + } +} +impl VtkMatrixToLinearTransform for vtkMatrixToLinearTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_linear_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_linear_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_linear_transform_new_instance(self.0) } + } + fn set_input(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_set_input( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_to_linear_transform_set_input(self.0, p0) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_linear_transform_get_input(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_to_linear_transform_inverse(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_matrix_to_linear_transform_get_m_time(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_linear_transform_make_transform(self.0) } + } +} +impl VtkPerspectiveTransform for vtkPerspectiveTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_new_instance(self.0) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_identity(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_inverse(self.0) } + } + fn adjust_viewport( + &mut self, + oldXMin: core::ffi::c_double, + oldXMax: core::ffi::c_double, + oldYMin: core::ffi::c_double, + oldYMax: core::ffi::c_double, + newXMin: core::ffi::c_double, + newXMax: core::ffi::c_double, + newYMin: core::ffi::c_double, + newYMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_adjust_viewport( + sself: *mut core::ffi::c_void, + oldXMin: core::ffi::c_double, + oldXMax: core::ffi::c_double, + oldYMin: core::ffi::c_double, + oldYMax: core::ffi::c_double, + newXMin: core::ffi::c_double, + newXMax: core::ffi::c_double, + newYMin: core::ffi::c_double, + newYMax: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_adjust_viewport( + self.0, + oldXMin, + oldXMax, + oldYMin, + oldYMax, + newXMin, + newXMax, + newYMin, + newYMax, + ) + } + } + fn adjust_z_buffer( + &mut self, + oldNearZ: core::ffi::c_double, + oldFarZ: core::ffi::c_double, + newNearZ: core::ffi::c_double, + newFarZ: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_adjust_z_buffer( + sself: *mut core::ffi::c_void, + oldNearZ: core::ffi::c_double, + oldFarZ: core::ffi::c_double, + newNearZ: core::ffi::c_double, + newFarZ: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_adjust_z_buffer( + self.0, + oldNearZ, + oldFarZ, + newNearZ, + newFarZ, + ) + } + } + fn ortho( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_ortho( + sself: *mut core::ffi::c_void, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_ortho(self.0, xmin, xmax, ymin, ymax, znear, zfar) + } + } + fn frustum( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_frustum( + sself: *mut core::ffi::c_void, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_frustum( + self.0, + xmin, + xmax, + ymin, + ymax, + znear, + zfar, + ) + } + } + fn perspective( + &mut self, + angle: core::ffi::c_double, + aspect: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_perspective( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + aspect: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_perspective(self.0, angle, aspect, znear, zfar) + } + } + fn shear( + &mut self, + dxdz: core::ffi::c_double, + dydz: core::ffi::c_double, + zplane: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_shear( + sself: *mut core::ffi::c_void, + dxdz: core::ffi::c_double, + dydz: core::ffi::c_double, + zplane: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_shear(self.0, dxdz, dydz, zplane) } + } + fn stereo( + &mut self, + angle: core::ffi::c_double, + focaldistance: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_stereo( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + focaldistance: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_stereo(self.0, angle, focaldistance) } + } + fn setup_camera( + &mut self, + position: core::ffi::c_double, + focalpoint: core::ffi::c_double, + viewup: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_setup_camera( + sself: *mut core::ffi::c_void, + position: core::ffi::c_double, + focalpoint: core::ffi::c_double, + viewup: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_setup_camera(self.0, position, focalpoint, viewup) + } + } + fn setup_camera( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + fp0: core::ffi::c_double, + fp1: core::ffi::c_double, + fp2: core::ffi::c_double, + vup0: core::ffi::c_double, + vup1: core::ffi::c_double, + vup2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_setup_camera( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + fp0: core::ffi::c_double, + fp1: core::ffi::c_double, + fp2: core::ffi::c_double, + vup0: core::ffi::c_double, + vup1: core::ffi::c_double, + vup2: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_setup_camera( + self.0, + p0, + p1, + p2, + fp0, + fp1, + fp2, + vup0, + vup1, + vup2, + ) + } + } + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_translate(self.0, x, y, z) } + } + fn translate(&mut self, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_translate(self.0, x) } + } + fn translate(&mut self, x: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_float, + ); + } + unsafe { vtk_perspective_transform_translate(self.0, x) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_rotate_wxyz(self.0, angle, x, y, z) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + axis: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_rotate_wxyz(self.0, angle, axis) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + axis: core::ffi::c_float, + ); + } + unsafe { vtk_perspective_transform_rotate_wxyz(self.0, angle, axis) } + } + fn rotate_x(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_rotate_x( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_rotate_x(self.0, angle) } + } + fn rotate_y(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_rotate_y( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_rotate_y(self.0, angle) } + } + fn rotate_z(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_rotate_z( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_rotate_z(self.0, angle) } + } + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_scale( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_scale(self.0, x, y, z) } + } + fn scale(&mut self, s: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_scale( + sself: *mut core::ffi::c_void, + s: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_scale(self.0, s) } + } + fn scale(&mut self, s: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_scale( + sself: *mut core::ffi::c_void, + s: core::ffi::c_float, + ); + } + unsafe { vtk_perspective_transform_scale(self.0, s) } + } + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_set_matrix( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_perspective_transform_set_matrix(self.0, matrix) } + } + fn set_matrix(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_set_matrix( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_set_matrix(self.0, elements) } + } + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_concatenate( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_perspective_transform_concatenate(self.0, matrix) } + } + fn concatenate(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_concatenate( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_concatenate(self.0, elements) } + } + fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_concatenate( + sself: *mut core::ffi::c_void, + transform: *mut core::ffi::c_void, + ); + } + unsafe { vtk_perspective_transform_concatenate(self.0, transform) } + } + fn pre_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_pre_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_pre_multiply(self.0) } + } + fn post_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_post_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_post_multiply(self.0) } + } + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_perspective_transform_get_number_of_concatenated_transforms( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_perspective_transform_get_number_of_concatenated_transforms(self.0) + } + } + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_get_concatenated_transform( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_get_concatenated_transform(self.0, i) } + } + fn set_input(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_set_input( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_perspective_transform_set_input(self.0, input) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_get_input(self.0) } + } + fn get_inverse_flag(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_perspective_transform_get_inverse_flag( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_perspective_transform_get_inverse_flag(self.0) } + } + fn push(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_push(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_push(self.0) } + } + fn pop(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_pop(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_pop(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_make_transform(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_perspective_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_perspective_transform_get_m_time(self.0) } + } +} +impl VtkSphericalTransform for vtkSphericalTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spherical_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spherical_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spherical_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spherical_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spherical_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spherical_transform_new_instance(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spherical_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spherical_transform_make_transform(self.0) } + } +} +impl VtkThinPlateSplineTransform for vtkThinPlateSplineTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_new(self.0) } + } + fn get_sigma(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_sigma( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_thin_plate_spline_transform_get_sigma(self.0) } + } + fn set_sigma(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_sigma( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_sigma(self.0, _arg) } + } + fn set_basis(&mut self, basis: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_basis( + sself: *mut core::ffi::c_void, + basis: core::ffi::c_int, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_basis(self.0, basis) } + } + fn get_basis(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_basis( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_thin_plate_spline_transform_get_basis(self.0) } + } + fn set_basis_to_r(&mut self) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_basis_to_r( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_basis_to_r(self.0) } + } + fn set_basis_to_r_2_log_r(&mut self) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(self.0) } + } + fn get_basis_as_string(&mut self) -> *const core::ffi::c_char { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_basis_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + unsafe { vtk_thin_plate_spline_transform_get_basis_as_string(self.0) } + } + fn set_basis_function(&mut self, U: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_basis_function( + sself: *mut core::ffi::c_void, + U: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_basis_function(self.0, U) } + } + fn set_basis_derivative(&mut self, dUdr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_basis_derivative( + sself: *mut core::ffi::c_void, + dUdr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_basis_derivative(self.0, dUdr) } + } + fn set_source_landmarks(&mut self, source: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_source_landmarks( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_source_landmarks(self.0, source) } + } + fn get_source_landmarks(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_source_landmarks( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_get_source_landmarks(self.0) } + } + fn set_target_landmarks(&mut self, target: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_target_landmarks( + sself: *mut core::ffi::c_void, + target: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_target_landmarks(self.0, target) } + } + fn get_target_landmarks(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_target_landmarks( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_get_target_landmarks(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_thin_plate_spline_transform_get_m_time(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_make_transform(self.0) } + } + fn get_regularize_bulk_transform(&mut self) -> bool { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_regularize_bulk_transform( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_thin_plate_spline_transform_get_regularize_bulk_transform(self.0) } + } + fn set_regularize_bulk_transform(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_regularize_bulk_transform( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { + vtk_thin_plate_spline_transform_set_regularize_bulk_transform(self.0, _arg) + } + } + fn regularize_bulk_transform_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_regularize_bulk_transform_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_regularize_bulk_transform_on(self.0) } + } + fn regularize_bulk_transform_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_regularize_bulk_transform_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_regularize_bulk_transform_off(self.0) } + } +} +impl VtkTransform for vtkTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_new_instance(self.0) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_identity(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_inverse(self.0) } + } + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_transform_translate(self.0, x, y, z) } + } + fn translate(&mut self, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ); + } + unsafe { vtk_transform_translate(self.0, x) } + } + fn translate(&mut self, x: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_float, + ); + } + unsafe { vtk_transform_translate(self.0, x) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_transform_rotate_wxyz(self.0, angle, x, y, z) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + axis: core::ffi::c_double, + ); + } + unsafe { vtk_transform_rotate_wxyz(self.0, angle, axis) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + axis: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + axis: core::ffi::c_float, + ); + } + unsafe { vtk_transform_rotate_wxyz(self.0, angle, axis) } + } + fn rotate_x(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_rotate_x( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_transform_rotate_x(self.0, angle) } + } + fn rotate_y(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_rotate_y( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_transform_rotate_y(self.0, angle) } + } + fn rotate_z(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_rotate_z( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_transform_rotate_z(self.0, angle) } + } + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_transform_scale( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_transform_scale(self.0, x, y, z) } + } + fn scale(&mut self, s: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_scale( + sself: *mut core::ffi::c_void, + s: core::ffi::c_double, + ); + } + unsafe { vtk_transform_scale(self.0, s) } + } + fn scale(&mut self, s: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_transform_scale(sself: *mut core::ffi::c_void, s: core::ffi::c_float); + } + unsafe { vtk_transform_scale(self.0, s) } + } + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_set_matrix( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_set_matrix(self.0, matrix) } + } + fn set_matrix(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_set_matrix( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_transform_set_matrix(self.0, elements) } + } + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_concatenate( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_concatenate(self.0, matrix) } + } + fn concatenate(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_concatenate( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_transform_concatenate(self.0, elements) } + } + fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_concatenate( + sself: *mut core::ffi::c_void, + transform: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_concatenate(self.0, transform) } + } + fn pre_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_pre_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_pre_multiply(self.0) } + } + fn post_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_post_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_post_multiply(self.0) } + } + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_transform_get_number_of_concatenated_transforms( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_transform_get_number_of_concatenated_transforms(self.0) } + } + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_get_concatenated_transform( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_get_concatenated_transform(self.0, i) } + } + fn get_orientation(&mut self, orient: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_get_orientation( + sself: *mut core::ffi::c_void, + orient: core::ffi::c_double, + ); + } + unsafe { vtk_transform_get_orientation(self.0, orient) } + } + fn get_orientation(&mut self, orient: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_transform_get_orientation( + sself: *mut core::ffi::c_void, + orient: core::ffi::c_float, + ); + } + unsafe { vtk_transform_get_orientation(self.0, orient) } + } + fn get_orientation(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_transform_get_orientation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_transform_get_orientation(self.0) } + } + fn get_orientation( + &mut self, + orient: core::ffi::c_double, + matrix: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_transform_get_orientation( + sself: *mut core::ffi::c_void, + orient: core::ffi::c_double, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_get_orientation(self.0, orient, matrix) } + } + fn get_orientation_wxyz(&mut self, wxyz: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_get_orientation_wxyz( + sself: *mut core::ffi::c_void, + wxyz: core::ffi::c_double, + ); + } + unsafe { vtk_transform_get_orientation_wxyz(self.0, wxyz) } + } + fn get_orientation_wxyz(&mut self, wxyz: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_transform_get_orientation_wxyz( + sself: *mut core::ffi::c_void, + wxyz: core::ffi::c_float, + ); + } + unsafe { vtk_transform_get_orientation_wxyz(self.0, wxyz) } + } + fn get_orientation_wxyz(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_transform_get_orientation_wxyz( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_transform_get_orientation_wxyz(self.0) } + } + fn get_position(&mut self, pos: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_get_position( + sself: *mut core::ffi::c_void, + pos: core::ffi::c_double, + ); + } + unsafe { vtk_transform_get_position(self.0, pos) } + } + fn get_position(&mut self, pos: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_transform_get_position( + sself: *mut core::ffi::c_void, + pos: core::ffi::c_float, + ); + } + unsafe { vtk_transform_get_position(self.0, pos) } + } + fn get_position(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_transform_get_position( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_transform_get_position(self.0) } + } + fn get_scale(&mut self, scale: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_get_scale( + sself: *mut core::ffi::c_void, + scale: core::ffi::c_double, + ); + } + unsafe { vtk_transform_get_scale(self.0, scale) } + } + fn get_scale(&mut self, scale: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_transform_get_scale( + sself: *mut core::ffi::c_void, + scale: core::ffi::c_float, + ); + } + unsafe { vtk_transform_get_scale(self.0, scale) } + } + fn get_scale(&mut self) -> *mut core::ffi::c_double { + unsafe extern "C" { + fn vtk_transform_get_scale( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_double; + } + unsafe { vtk_transform_get_scale(self.0) } + } + fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_get_inverse( + sself: *mut core::ffi::c_void, + inverse: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_get_inverse(self.0, inverse) } + } + fn get_transpose(&mut self, transpose: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_get_transpose( + sself: *mut core::ffi::c_void, + transpose: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_get_transpose(self.0, transpose) } + } + fn set_input(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_set_input( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_set_input(self.0, input) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_get_input(self.0) } + } + fn get_inverse_flag(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_transform_get_inverse_flag( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_transform_get_inverse_flag(self.0) } + } + fn push(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_push(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_push(self.0) } + } + fn pop(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_pop(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_pop(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_make_transform(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_transform_get_m_time(self.0) } + } + fn multiply_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_transform_multiply_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ); + } + unsafe { vtk_transform_multiply_point(self.0, in_, out) } + } + fn multiply_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_transform_multiply_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ); + } + unsafe { vtk_transform_multiply_point(self.0, in_, out) } + } +} +impl VtkTransform2D for vtkTransform2D { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_2_d_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_2_d_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_2_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_2_d_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_2_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_2_d_new_instance(self.0) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_2_d_identity(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_2_d_inverse(self.0) } + } + fn translate(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_translate(self.0, x, y) } + } + fn translate(&mut self, x: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_translate(self.0, x) } + } + fn translate(&mut self, x: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_float, + ); + } + unsafe { vtk_transform_2_d_translate(self.0, x) } + } + fn rotate(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_rotate( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_rotate(self.0, angle) } + } + fn scale(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_scale( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_scale(self.0, x, y) } + } + fn scale(&mut self, s: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_scale( + sself: *mut core::ffi::c_void, + s: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_scale(self.0, s) } + } + fn scale(&mut self, s: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_scale( + sself: *mut core::ffi::c_void, + s: core::ffi::c_float, + ); + } + unsafe { vtk_transform_2_d_scale(self.0, s) } + } + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_set_matrix( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_2_d_set_matrix(self.0, matrix) } + } + fn set_matrix(&mut self, elements: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_set_matrix( + sself: *mut core::ffi::c_void, + elements: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_set_matrix(self.0, elements) } + } + fn get_matrix(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_2_d_get_matrix( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_2_d_get_matrix(self.0) } + } + fn get_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_get_matrix( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_2_d_get_matrix(self.0, matrix) } + } + fn get_position(&mut self, pos: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_get_position( + sself: *mut core::ffi::c_void, + pos: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_get_position(self.0, pos) } + } + fn get_position(&mut self, pos: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_get_position( + sself: *mut core::ffi::c_void, + pos: core::ffi::c_float, + ); + } + unsafe { vtk_transform_2_d_get_position(self.0, pos) } + } + fn get_scale(&mut self, scale: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_get_scale( + sself: *mut core::ffi::c_void, + scale: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_get_scale(self.0, scale) } + } + fn get_scale(&mut self, pos: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_get_scale( + sself: *mut core::ffi::c_void, + pos: core::ffi::c_float, + ); + } + unsafe { vtk_transform_2_d_get_scale(self.0, pos) } + } + fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_get_inverse( + sself: *mut core::ffi::c_void, + inverse: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_2_d_get_inverse(self.0, inverse) } + } + fn get_transpose(&mut self, transpose: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_get_transpose( + sself: *mut core::ffi::c_void, + transpose: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_2_d_get_transpose(self.0, transpose) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_transform_2_d_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_transform_2_d_get_m_time(self.0) } + } + fn transform_points( + &mut self, + inPts: core::ffi::c_float, + outPts: core::ffi::c_float, + n: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_transform_points( + sself: *mut core::ffi::c_void, + inPts: core::ffi::c_float, + outPts: core::ffi::c_float, + n: core::ffi::c_int, + ); + } + unsafe { vtk_transform_2_d_transform_points(self.0, inPts, outPts, n) } + } + fn transform_points( + &mut self, + inPts: core::ffi::c_double, + outPts: core::ffi::c_double, + n: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_transform_points( + sself: *mut core::ffi::c_void, + inPts: core::ffi::c_double, + outPts: core::ffi::c_double, + n: core::ffi::c_int, + ); + } + unsafe { vtk_transform_2_d_transform_points(self.0, inPts, outPts, n) } + } + fn transform_points( + &mut self, + inPts: *mut core::ffi::c_void, + outPts: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_transform_points( + sself: *mut core::ffi::c_void, + inPts: *mut core::ffi::c_void, + outPts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_2_d_transform_points(self.0, inPts, outPts) } + } + fn inverse_transform_points( + &mut self, + inPts: core::ffi::c_float, + outPts: core::ffi::c_float, + n: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_inverse_transform_points( + sself: *mut core::ffi::c_void, + inPts: core::ffi::c_float, + outPts: core::ffi::c_float, + n: core::ffi::c_int, + ); + } + unsafe { vtk_transform_2_d_inverse_transform_points(self.0, inPts, outPts, n) } + } + fn inverse_transform_points( + &mut self, + inPts: core::ffi::c_double, + outPts: core::ffi::c_double, + n: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_inverse_transform_points( + sself: *mut core::ffi::c_void, + inPts: core::ffi::c_double, + outPts: core::ffi::c_double, + n: core::ffi::c_int, + ); + } + unsafe { vtk_transform_2_d_inverse_transform_points(self.0, inPts, outPts, n) } + } + fn inverse_transform_points( + &mut self, + inPts: *mut core::ffi::c_void, + outPts: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_inverse_transform_points( + sself: *mut core::ffi::c_void, + inPts: *mut core::ffi::c_void, + outPts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_2_d_inverse_transform_points(self.0, inPts, outPts) } + } + fn multiply_point( + &mut self, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_multiply_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_float, + out: core::ffi::c_float, + ); + } + unsafe { vtk_transform_2_d_multiply_point(self.0, in_, out) } + } + fn multiply_point( + &mut self, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_multiply_point( + sself: *mut core::ffi::c_void, + in_: core::ffi::c_double, + out: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_multiply_point(self.0, in_, out) } + } +} +impl VtkTransformCollection for vtkTransformCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_collection_new(self.0) } + } + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_collection_add_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_collection_add_item(self.0, p0) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_collection_get_next_item(self.0) } + } + fn get_next_transform(&mut self, cookie: ()) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_collection_get_next_transform( + sself: *mut core::ffi::c_void, + cookie: (), + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_collection_get_next_transform(self.0, cookie) } + } +} /// cylindrical to rectangular coords and back /// /// From d9cf067e41380ba01f80a088cadbbbbfa6337d7e Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 18:25:59 +0200 Subject: [PATCH 15/30] fix all pointer issues with claude using an iterative approach --- examples/sphere_source.rs | 5 +- vtk-gen/src/code_gen_cpp.rs | 49 +++++++++++++++- vtk-gen/src/code_gen_rust.rs | 43 +++++++------- vtk-gen/src/inheritance_hierarchy.rs | 4 ++ vtk-gen/src/intermediate_representation.rs | 67 +++++++++++++++++++++- vtk-gen/src/main.rs | 42 +++++++++++++- vtk-gen/src/parse_cpp.rs | 17 +++--- vtk-gen/src/parse_wrap_vtk_xml.rs | 11 ++++ vtk-rs-9.1/examples/sphere_source.rs | 37 ++++++++++++ 9 files changed, 239 insertions(+), 36 deletions(-) create mode 100644 vtk-rs-9.1/examples/sphere_source.rs diff --git a/examples/sphere_source.rs b/examples/sphere_source.rs index 1e0d03a..186824d 100644 --- a/examples/sphere_source.rs +++ b/examples/sphere_source.rs @@ -1,11 +1,12 @@ use vtk_rs as vtk; +use vtk_rs::prelude::*; fn main() { - let colors = vtk::NamedColors::new(); + let _colors = vtk::NamedColors::new(); // Create a sphere let mut sphere_source = vtk::SphereSource::new(); - sphere_source.set_center([0.; 3]); + sphere_source.set_center(0., 0., 0.); sphere_source.set_radius(5.0); // Make the surface smooth diff --git a/vtk-gen/src/code_gen_cpp.rs b/vtk-gen/src/code_gen_cpp.rs index 725ba87..3f10285 100644 --- a/vtk-gen/src/code_gen_cpp.rs +++ b/vtk-gen/src/code_gen_cpp.rs @@ -74,6 +74,7 @@ impl FormatCppStr for IRType { c_ulong => Ok("unsigned long"), c_ulonglong => Ok("unsigned long long"), c_char => Ok("char"), + c_signed_char => Ok("signed char"), c_short => Ok("short"), c_int => Ok("int"), c_long => Ok("long"), @@ -88,6 +89,30 @@ impl FormatCppStr for IRType { } } +fn is_numeric_primitive(ty: &IRType) -> bool { + use IRType::*; + // c_char is excluded: char* is a C string, not an array. + // c_signed_char IS included: signed char* is a typed data buffer (e.g. vtkSignedCharArray), + // and char* ↔ signed char* is an error in C++ so we must not emit a pointer to it. + matches!( + ty, + c_signed_char + | c_uchar + | c_short + | c_ushort + | c_int + | c_uint + | c_long + | c_ulong + | c_longlong + | c_ulonglong + | float + | double + | usize + | bool + ) +} + fn ir_type_to_cpp_string(irtype: &IRType) -> Result { use IRType::*; match irtype { @@ -98,6 +123,7 @@ fn ir_type_to_cpp_string(irtype: &IRType) -> Result { c_ulong => Ok("unsigned long".to_string()), c_ulonglong => Ok("unsigned long long".to_string()), c_char => Ok("char".to_string()), + c_signed_char => Ok("signed char".to_string()), c_short => Ok("short".to_string()), c_int => Ok("int".to_string()), c_long => Ok("long".to_string()), @@ -111,7 +137,22 @@ fn ir_type_to_cpp_string(irtype: &IRType) -> Result { String => Ok("const char*".to_string()), other => Ok(format!("const {}", ir_type_to_cpp_string(other)?)), }, - Pointer(inner) => Ok(format!("{}*", ir_type_to_cpp_string(inner)?)), + Pointer(inner) => { + // Strip one layer of Const to check the core element type + let core = match inner.as_ref() { + Const(x) => x.as_ref(), + x => x, + }; + if is_numeric_primitive(core) { + anyhow::bail!("pointer-to-numeric-primitive (array arg) not bridgeable") + } + // Mutable char* is not bridgeable: VTK may expect signed char* (data arrays), + // and C++ rejects implicit conversion between char* and signed char*. + if matches!(inner.as_ref(), c_char) { + anyhow::bail!("mutable char* not bridgeable (may conflict with signed char*)") + } + Ok(format!("{}*", ir_type_to_cpp_string(inner)?)) + } Ref(inner) => Ok(format!("{}&", ir_type_to_cpp_string(inner)?)), _ => anyhow::bail!("C++ type not supported: skipping method"), } @@ -190,6 +231,9 @@ impl IRModule { impl IRStruct { fn method_to_cpp(&self, method: &IRMethod, writer: &mut impl std::io::Write) -> Result<()> { + if matches!(method.return_type, IRType::String) { + anyhow::bail!("std::string return type cannot be bridged to const char*"); + } let ret_str = ir_type_to_cpp_string(&method.return_type)?; let is_void = matches!(method.return_type, IRType::Unit); @@ -221,6 +265,9 @@ impl IRStruct { method: &IRMethod, writer: &mut impl std::io::Write, ) -> Result<()> { + if matches!(method.return_type, IRType::String) { + anyhow::bail!("std::string return type cannot be bridged to const char*"); + } let ret_str = ir_type_to_cpp_string(&method.return_type)?; let mut param_strs: Vec = vec![format!("vtkNew<{}> sself", self.name)]; for (ident, irtype) in &method.args { diff --git a/vtk-gen/src/code_gen_rust.rs b/vtk-gen/src/code_gen_rust.rs index d400a00..f677bd9 100644 --- a/vtk-gen/src/code_gen_rust.rs +++ b/vtk-gen/src/code_gen_rust.rs @@ -65,18 +65,31 @@ fn is_rust_keyword(s: &str) -> bool { fn ir_type_is_supported(irtype: &crate::IRType) -> bool { use crate::IRType::*; match irtype { - FileMode | File => false, - Ref(inner) | Pointer(inner) | Const(inner) | Vec(inner) | LinkedList(inner) => { - ir_type_is_supported(inner) + // Path types (VTK object names) are only bridgeable as opaque pointers. + // Passing VTK objects by value or reference (e.g. `const vtkStdString&`) is not bridgeable. + FileMode | File | Path(_) => false, + Pointer(inner) => { + // Mutable char* (Pointer(c_char)) is not safely bridgeable: it may be a signed + // char data buffer rather than a C string, causing char*/signed char* type errors. + // Only Pointer(Const(c_char)) (= const char*, C string) and VTK object pointers are ok. + if matches!(inner.as_ref(), c_char) { + return false; + } + is_string_type(irtype) || matches!(inner.as_ref(), Path(_)) } + // Heap-allocated collection types cannot cross the FFI boundary safely. + Vec(_) | LinkedList(_) | Map(_, _) => false, + Ref(inner) | Const(inner) => ir_type_is_supported(inner), Array(inner, _) => ir_type_is_supported(inner), - Map(k, v) => ir_type_is_supported(k) && ir_type_is_supported(v), _ => true, } } fn method_is_supported(method: &crate::IRMethod) -> bool { - ir_type_is_supported(&method.return_type) + // std::string return types can't be bridged: the C++ callee returns by value and the + // resulting const char* would dangle immediately. String *parameters* are fine. + !matches!(method.return_type, crate::IRType::String) + && ir_type_is_supported(&method.return_type) && method.args.iter().all(|(_, irtype)| ir_type_is_supported(irtype)) } @@ -100,7 +113,7 @@ fn capitalize_first(s: &str) -> String { fn is_string_type(irtype: &crate::IRType) -> bool { use crate::IRType::*; match irtype { - String => true, + String | c_char => true, Const(inner) | Ref(inner) | Pointer(inner) => is_string_type(inner), _ => false, } @@ -218,6 +231,7 @@ impl ToTokens for crate::IRType { let ty = match self { Unit => quote::quote!(()), c_char => quote!(core::ffi::c_char), + c_signed_char => quote!(core::ffi::c_schar), c_short => quote!(core::ffi::c_short), c_int => quote!(core::ffi::c_int), c_long => quote!(core::ffi::c_long), @@ -303,20 +317,9 @@ impl crate::IRModule { } let trait_ident = quote::format_ident!("{}", capitalize_first(class_name)); - // Supertrait bounds: parents in this same module that also have traits - let parent_bounds: Vec = ir_struct - .parents - .iter() - .filter(|p| { - self.classes - .get(*p) - .map_or(false, |c| !c.exposable_methods.is_empty()) - }) - .map(|p| { - let pident = quote::format_ident!("{}", capitalize_first(p)); - quote::quote!(#pident) - }) - .collect(); + // Supertrait bounds would require implementing every ancestor trait for each + // concrete struct across module boundaries, which the generator doesn't yet support. + let parent_bounds: Vec = vec![]; let method_sigs: Vec = ir_struct .exposable_methods diff --git a/vtk-gen/src/inheritance_hierarchy.rs b/vtk-gen/src/inheritance_hierarchy.rs index 5e157a9..9da2ec4 100644 --- a/vtk-gen/src/inheritance_hierarchy.rs +++ b/vtk-gen/src/inheritance_hierarchy.rs @@ -151,6 +151,10 @@ impl ClassHierarchy { .filter(|x| !parent_methods.contains(&x)) .filter(|x| x.signature.trim().chars().take(8).collect::() != "template") .filter(|x| !x.signature.contains("typename")) + // C-style array parameters (e.g. `double pts[3]`) decay to pointers but WrapVTK + // records no pointer attribute for them. We can't bridge array parameters safely + // without explicit length info, so skip any method whose signature contains `[`. + .filter(|x| !x.signature.contains('[')) .collect(); Ok(unique_methods) diff --git a/vtk-gen/src/intermediate_representation.rs b/vtk-gen/src/intermediate_representation.rs index fb88140..641f480 100644 --- a/vtk-gen/src/intermediate_representation.rs +++ b/vtk-gen/src/intermediate_representation.rs @@ -9,7 +9,10 @@ use crate::parse_wrap_vtk_xml::{Access, Module}; pub enum IRType { /// Type `()` or `void` in C++ Unit, + /// Plain C `char` (used for C strings / VTK_FILEPATH parameters) c_char, + /// Explicitly `signed char` (used for VTK typed-data arrays, e.g. vtkSignedCharArray) + c_signed_char, c_short, c_int, c_long, @@ -44,7 +47,8 @@ impl TryFrom<&CppType> for IRType { use IRType::*; let res = match value { Void => Unit, - SignedChar => c_char, + PlainChar => c_char, + SignedChar => c_signed_char, UnsignedChar => c_uchar, ShortInt => c_short, UnsignedShortInt => c_ushort, @@ -126,7 +130,22 @@ impl IRMethod { Some(crate::Pointer::Ref) => CppType::Ref(Box::new(inner_ty)), Some(crate::Pointer::Star) => CppType::Pointer(Box::new(inner_ty)), Some(crate::Pointer::StarStar) => { - CppType::Pointer(Box::new(CppType::Ref(Box::new(inner_ty)))) + // WrapVTK encodes `const char*` VTK_FILEPATH return types as + // type="const char" pointer="**". Recover the intended single pointer. + match &inner_ty { + CppType::Const(inner) + if matches!(inner.as_ref(), CppType::SignedChar) => + { + CppType::Pointer(Box::new(inner_ty)) + } + _ => anyhow::bail!("double pointer not bridgeable"), + } + } + Some(crate::Pointer::StarStarConst) => { + anyhow::bail!("const double pointer not bridgeable") + } + Some(crate::Pointer::StarStarStar) => { + anyhow::bail!("triple pointer not bridgeable") } None => inner_ty, } @@ -146,7 +165,34 @@ impl IRMethod { }; let name = crate::parse_cpp::Ident::parse(&name)?; let name = IRIdent::from(name); - let cpp_ty = CppType::parse(¶m.r#type)?; + let inner_ty = CppType::parse(¶m.r#type)?; + // WrapVTK stores pointer/reference qualifiers separately from the type string, + // just like it does for return types. + let cpp_ty = match ¶m.pointer { + Some(crate::Pointer::Ref) => CppType::Ref(Box::new(inner_ty)), + Some(crate::Pointer::Star) => CppType::Pointer(Box::new(inner_ty)), + Some(crate::Pointer::StarStar) => { + // WrapVTK encodes `const char*` VTK_FILEPATH params as + // type="const char" pointer="**". Recover the intended single pointer. + // Any other ** (including mutable char** output params) is not bridgeable. + match &inner_ty { + CppType::Const(inner) + if matches!(inner.as_ref(), CppType::SignedChar) => + { + CppType::Pointer(Box::new(inner_ty)) + } + _ => anyhow::bail!("double pointer not bridgeable"), + } + } + Some(crate::Pointer::StarStarConst) => { + anyhow::bail!("const double pointer not bridgeable") + } + Some(crate::Pointer::StarStarStar) => { + anyhow::bail!("triple pointer not bridgeable") + } + None if param.reference => CppType::Ref(Box::new(inner_ty)), + None => inner_ty, + }; Ok((name, IRType::try_from(&cpp_ty)?)) }) .collect::>>()?; @@ -254,6 +300,21 @@ impl IRModule { } } }) + // C doesn't support overloading: drop duplicate binding names, + // keeping only the first overload seen for each name. + .scan(std::collections::HashSet::new(), |seen, m| { + if seen.insert(m.name.clone()) { + Some(Some(m)) + } else { + log::warn!( + "[IR] Skipping overloaded duplicate binding \"{}\" of class \"{}\"", + m.name, + class.name, + ); + Some(None) + } + }) + .flatten() .collect::>(), is_abstract: class.is_abstract, is_template: class.is_template, diff --git a/vtk-gen/src/main.rs b/vtk-gen/src/main.rs index 16d5268..a3b6d4f 100644 --- a/vtk-gen/src/main.rs +++ b/vtk-gen/src/main.rs @@ -158,6 +158,40 @@ fn write_rust_main(modules: &[IRModule], writer: &mut impl std::io::Write) -> Re )); } + // Re-export all constructable classes at crate root, stripping the `vtk` prefix. + // e.g. `vtkSphereSource` → `SphereSource`, `vtkNamedColors` → `NamedColors`. + let mut prelude_uses = quote::quote!(); + for m in modules { + let mod_name = quote::format_ident!("{}", m.name); + for (class_name, class) in &m.classes { + if class.is_constructable() { + let alias_name = if class_name.starts_with("vtk") { + class_name[3..].to_string() + } else { + use convert_case::Casing; + class_name.to_case(convert_case::Case::Pascal) + }; + let class_ident = quote::format_ident!("{}", class_name); + let alias_ident = quote::format_ident!("{}", alias_name); + o1.extend(quote::quote!( + pub use #mod_name::#class_ident as #alias_ident; + )); + } + } + // Collect all pub trait re-exports for the prelude (crate:: prefix required in Rust 2018+) + prelude_uses.extend(quote::quote!( + pub use crate::#mod_name::*; + )); + } + + // Generate a prelude module that re-exports all traits via glob so users can write + // `use vtk_rs::prelude::*;` and call trait methods without explicit imports. + o1.extend(quote::quote!( + pub mod prelude { + #prelude_uses + } + )); + format_quote_and_write(o1, writer)?; Ok(()) } @@ -217,7 +251,6 @@ fn write_build_rs(writer: &mut impl std::io::Write, ir_modules: &[IRModule]) -> // Link to VTK let modules = vec![ "vtksys", - "vtktoken", #(#module_names),* ]; vtk_rs_link::link_cmake_project(modules)?; @@ -244,8 +277,11 @@ fn main() -> Result<()> { pretty_env_logger::init(); let args = Args::parse(); - // Obtain all modules - let modules = get_modules(args.wrap_vtk.join("build/xml/vtkCommon*"))?; + // Obtain all modules — scan both vtkCommon* and vtkFiltersSources + let mut modules = get_modules(args.wrap_vtk.join("build/xml/vtkCommon*"))?; + modules.extend(get_modules(args.wrap_vtk.join("build/xml/vtkFiltersSources"))?); + // Sort modules by name to ensure deterministic output + modules.sort_by(|a, b| a.name.cmp(&b.name)); let class_hierarchy = ClassHierarchy::new(&modules)?; diff --git a/vtk-gen/src/parse_cpp.rs b/vtk-gen/src/parse_cpp.rs index 26c70b9..8aa5bba 100644 --- a/vtk-gen/src/parse_cpp.rs +++ b/vtk-gen/src/parse_cpp.rs @@ -37,6 +37,9 @@ impl Parse for Path { #[derive(Debug, PartialEq)] pub enum CppType { Void, + /// Plain `char` (used for C strings and VTK_FILEPATH) + PlainChar, + /// Explicitly signed `signed char` (used for VTK typed data arrays, e.g. vtkSignedCharArray) SignedChar, UnsignedChar, ShortInt, @@ -226,7 +229,7 @@ impl Parse for CppType { "string" => Ok(CppType::String), "type_info" => Ok(TypeInfo), "size_t" => Ok(SizeT), - "char" => Ok(SignedChar), + "char" => Ok(PlainChar), "ostream" => Ok(Ostream), other => { if other.trim().contains(" ") { @@ -279,7 +282,7 @@ mod test { fn parse_types() -> Result<()> { let t0 = "char"; let cpp_type = CppType::parse(t0)?; - assert_eq!(cpp_type, CppType::SignedChar); + assert_eq!(cpp_type, CppType::PlainChar); let t1 = "unsigned char"; let cpp_type = CppType::parse(t1)?; @@ -338,7 +341,7 @@ mod test { let map1 = "std::map"; parse_map!(map1, CppType::Int, CppType::Float); let map2 = "std::map"; - parse_map!(map2, CppType::LongInt, CppType::SignedChar); + parse_map!(map2, CppType::LongInt, CppType::PlainChar); let map3 = "map"; parse_map!(map3, CppType::UnsignedChar, CppType::Double); @@ -364,7 +367,7 @@ mod test { let list1 = "std::list"; parse_list!(list1, CppType::Float); let list2 = "std::list"; - parse_list!(list2, CppType::SignedChar); + parse_list!(list2, CppType::PlainChar); let list3 = "std::list"; parse_list!(list3, CppType::UnsignedChar); let list4 = "std::list>"; @@ -394,7 +397,7 @@ mod test { let vec2 = "std::vector>"; parse_vec!(vec2, CppType::Vec(_)); let vec3 = "vector"; - parse_vec!(vec3, CppType::SignedChar); + parse_vec!(vec3, CppType::PlainChar); Ok(()) } @@ -448,7 +451,7 @@ mod test { ); let generic1 = "json"; - parse_generic!(generic1, "json", [CppType::Int, CppType::SignedChar]); + parse_generic!(generic1, "json", [CppType::Int, CppType::PlainChar]); let generic2 = "what::the"; parse_generic!( generic2, @@ -484,7 +487,7 @@ mod test { let cpp_type = CppType::parse("&float")?; assert_eq!(cpp_type, CppType::Ref(Box::new(CppType::Float))); let cpp_type = CppType::parse("char*")?; - assert_eq!(cpp_type, CppType::Pointer(Box::new(CppType::SignedChar))); + assert_eq!(cpp_type, CppType::Pointer(Box::new(CppType::PlainChar))); let cpp_type = CppType::parse("unsigned char")?; assert_eq!(cpp_type, CppType::UnsignedChar); diff --git a/vtk-gen/src/parse_wrap_vtk_xml.rs b/vtk-gen/src/parse_wrap_vtk_xml.rs index d6b2263..43cde49 100644 --- a/vtk-gen/src/parse_wrap_vtk_xml.rs +++ b/vtk-gen/src/parse_wrap_vtk_xml.rs @@ -216,6 +216,8 @@ pub struct Parameter { #[serde(default = "Default::default")] #[serde(deserialize_with = "option_one_to_bool")] pub reference: bool, + #[serde(rename = "@pointer")] + pub pointer: Option, } #[derive(Deserialize, PartialEq, Debug, Clone)] @@ -300,6 +302,13 @@ pub enum Pointer { Star, #[serde(rename = "**")] StarStar, + /// `** const` in C++ — const outer pointer, double indirection. + /// Treated the same as `**` for binding purposes. + #[serde(rename = "**const")] + StarStarConst, + /// Triple indirection — not bridgeable, causes the method to be skipped. + #[serde(rename = "***")] + StarStarStar, } #[derive(Deserialize, PartialEq, Debug, Clone)] @@ -550,11 +559,13 @@ mod test_parsing { name: Some("os".into()), r#type: "ostream".into(), reference: true, + pointer: None, }, Parameter { name: Some("indent".into()), r#type: "vtkIndent".into(), reference: false, + pointer: None, } ] ); diff --git a/vtk-rs-9.1/examples/sphere_source.rs b/vtk-rs-9.1/examples/sphere_source.rs new file mode 100644 index 0000000..186824d --- /dev/null +++ b/vtk-rs-9.1/examples/sphere_source.rs @@ -0,0 +1,37 @@ +use vtk_rs as vtk; +use vtk_rs::prelude::*; + +fn main() { + let _colors = vtk::NamedColors::new(); + + // Create a sphere + let mut sphere_source = vtk::SphereSource::new(); + sphere_source.set_center(0., 0., 0.); + sphere_source.set_radius(5.0); + + // Make the surface smooth + sphere_source.set_phi_resolution(100); + sphere_source.set_theta_resolution(100); + + /* let mut mapper = vtk::PolyDataMapper::new(); + mapper.set_input_connection(sphere_source.get_output_port()); + let mut mapper = vtkPolyDataMapper::New(); + mapper.SetInputConnection(sphere_source.GetOutputPort()); + + let mut actor = vtkActor::New(); + actor.SetMapper(&mapper); + actor.GetProperty().SetColor(colors.GetColor3d("Cornsilk")); + + let mut renderer = vtkRenderer::New(); + let mut render_window = vtkRenderWindow::New(); + render_window.SetWindowName("Sphere"); + render_window.AddRenderer(&renderer); + let render_window_interactor = vtkRenderWindowInteractor::New(); + render_window_interactor.SetRenderWindow(&render_window); + + renderer.AddActor(&actor); + renderer.SetBackground(colors.GetColor3d("DarkGreen")); + + render_window.Render(); + render_window_interactor.Start();*/ +} From df6ec6d551769ee685538e8437981fa8a2afd665 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 18:27:36 +0200 Subject: [PATCH 16/30] update CHANGELOG.md --- CHANGELOG.md | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index a22f95d..ae77ba2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,37 @@ ## [0.3.0] - 2026-05-29 +### Added +- `vtkFiltersSources` module is now generated and linked, adding `SphereSource` and 20+ other source classes. +- Re-export all constructable VTK classes at the crate root with the `vtk` prefix stripped (e.g. `vtk_rs::SphereSource`, `vtk_rs::NamedColors`). +- `pub mod prelude` in the generated `lib.rs` that re-exports all module contents via glob, enabling `use vtk_rs::prelude::*` for ergonomic trait method access without explicit trait imports. +- `sphere_source` example in `vtk-rs-9.1/examples/`, runnable via `cargo run --example sphere_source -p vtk-rs`. +- `has_ancestor(class_name, target) -> bool` on `ClassHierarchy` — iterative DFS to walk the full ancestor chain (not just direct parents). Used to correctly detect `vtkObjectBase` ancestry across deep inheritance hierarchies. +- `IRStruct::has_vtk_object_base_ancestor: bool` field, computed via `has_ancestor` rather than checking direct parents only, fixing `is_constructable()` for deeply inherited classes. +- `IRMethod::vtk_name: String` field (PascalCase VTK method name) and `short_name()` helper for generating clean Rust method names. +- `c_signed_char` IR type to distinguish VTK's explicitly-typed `signed char` (used in typed data arrays such as `vtkSignedCharArray`) from plain `char` (used for C strings). `CppType::PlainChar` added to the C++ parser for the same reason. +- Overload deduplication via `.scan()` in `IRModule::new()`: C does not support overloading, so only the first VTK overload seen for each binding name is kept. +- `StarStarConst` (`**const`) and `StarStarStar` (`***`) pointer variants added to the `Pointer` enum in `parse_wrap_vtk_xml`. +- `pointer: Option` field added to `Parameter` in `parse_wrap_vtk_xml` so parameter pointer qualifiers are no longer silently dropped. +- C-style array parameter filter in `get_exposable_methods`: methods whose signature contains `[` are skipped because array extents are not encoded in the WrapVTK XML. +- Comprehensive test suites: `#[cfg(test)] mod inheritance_tests` (5 tests), `mod gen_rust_tests` (20 tests), `mod gen_cpp_tests` (8 tests), `mod tests` in `intermediate_representation` (5 tests). Total: 52 vtk-gen unit tests. + +### Changed +- `is_constructable()` now requires `has_vtk_object_base_ancestor` (full ancestor chain) instead of checking only direct parents for `vtkObjectBase`. +- `method_to_cpp` / `method_to_cpp_header` emit `extern "C"` bindings using `method.vtk_name` for the C++ call site and `method.name` for the symbol name. +- The glob processed by vtk-gen now includes `vtkFiltersSources` in addition to `vtkCommon*`. +- `write_build_rs` in `vtk-gen/src/main.rs` no longer hardcodes `vtktoken` in the link list (VTK 9.1 system packages do not ship `libvtktoken`). + +### Fixed +- **`std::string` return types** (`IRType::String`): bridging `std::string` as `const char*` is illegal (dangling pointer). These methods are now skipped on both the Rust and C++ sides. +- **`const char*` vs `const char* const*`**: `StarStarConst` now always bails instead of incorrectly reducing to a single pointer. +- **Mutable `char**` output parameters**: `StarStar + non-const char` now bails; only `StarStar + const char` (VTK_FILEPATH encoding) is reduced to a single pointer. +- **Mutable `char*` vs `signed char*`**: `Pointer(c_char)` (without `Const`) is now rejected on both Rust and C++ sides — VTK typed-data-array methods use `signed char*`, which is not implicitly convertible from `char*` in C++. +- **`signed char*` data array methods**: Separated `CppType::PlainChar` (`"char"`) from `CppType::SignedChar` (`"signed char"`) so typed-data-array parameters (`const signed char*`) generate the correct C++ type and are rejected at the Rust FFI boundary (not safely bridgeable without element-count information). +- **`Path` types by value/reference** (e.g. `const vtkStdString&`, `vtkColor3ub`): rejected in `ir_type_is_supported`; VTK object types are only bridgeable as opaque pointers. +- **Heap collection types** (`Vec`, `LinkedList`, `Map`): rejected in `ir_type_is_supported` — these types cannot cross the `extern "C"` boundary safely. +- **Cross-module supertrait bounds**: removed from generated trait definitions. Generating `trait VtkFoo: VtkBar` across module boundaries requires the concrete struct to implement all ancestor traits, which the generator does not yet support. +- **`vtktoken` linker error**: removed from the hardcoded link list in `write_build_rs`; `libvtktoken` is a VTK 9.2+ library not present in VTK 9.1 system packages. + ## [0.2.0] - 2025-06-03 ## [0.1.3] - 2025-05-25 From dd075f82e359c126e345a6edf810e2c8e26f060f Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 22:11:48 +0200 Subject: [PATCH 17/30] fix C++ codegen: use raw T* instead of vtkNew in extern "C" wrappers --- CHANGELOG.md | 1 + examples/sphere_source.rs | 2 ++ vtk-gen/src/code_gen_cpp.rs | 20 ++++++++++---------- vtk-gen/src/main.rs | 1 + 4 files changed, 14 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ae77ba2..815c4be 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,7 @@ - `write_build_rs` in `vtk-gen/src/main.rs` no longer hardcodes `vtktoken` in the link list (VTK 9.1 system packages do not ship `libvtktoken`). ### Fixed +- **`vtkNew` ABI mismatch in generated C++ wrappers**: `vtkNew` has a non-trivial destructor, so passing or returning it by value in `extern "C"` functions violates the x86-64 SysV ABI and causes the wrapped VTK object to be destroyed on every method call. Constructor, destructor, get-ptr, and all method wrappers now use raw `T*` (`T::New()` / `sself->Delete()` / `return sself`) instead of `vtkNew`. - **`std::string` return types** (`IRType::String`): bridging `std::string` as `const char*` is illegal (dangling pointer). These methods are now skipped on both the Rust and C++ sides. - **`const char*` vs `const char* const*`**: `StarStarConst` now always bails instead of incorrectly reducing to a single pointer. - **Mutable `char**` output parameters**: `StarStar + non-const char` now bails; only `StarStar + const char` (VTK_FILEPATH encoding) is reduced to a single pointer. diff --git a/examples/sphere_source.rs b/examples/sphere_source.rs index 186824d..bc3193e 100644 --- a/examples/sphere_source.rs +++ b/examples/sphere_source.rs @@ -13,6 +13,8 @@ fn main() { sphere_source.set_phi_resolution(100); sphere_source.set_theta_resolution(100); + println!("sphere source: {sphere_source:?}") + /* let mut mapper = vtk::PolyDataMapper::new(); mapper.set_input_connection(sphere_source.get_output_port()); let mut mapper = vtkPolyDataMapper::New(); diff --git a/vtk-gen/src/code_gen_cpp.rs b/vtk-gen/src/code_gen_cpp.rs index 3f10285..b70d95a 100644 --- a/vtk-gen/src/code_gen_cpp.rs +++ b/vtk-gen/src/code_gen_cpp.rs @@ -237,7 +237,7 @@ impl IRStruct { let ret_str = ir_type_to_cpp_string(&method.return_type)?; let is_void = matches!(method.return_type, IRType::Unit); - let mut param_strs: Vec = vec![format!("vtkNew<{}> sself", self.name)]; + let mut param_strs: Vec = vec![format!("{}* sself", self.name)]; let mut call_args: Vec = vec![]; for (ident, irtype) in &method.args { param_strs.push(format!("{} {}", ir_type_to_cpp_string(irtype)?, ident.0)); @@ -269,7 +269,7 @@ impl IRStruct { anyhow::bail!("std::string return type cannot be bridged to const char*"); } let ret_str = ir_type_to_cpp_string(&method.return_type)?; - let mut param_strs: Vec = vec![format!("vtkNew<{}> sself", self.name)]; + let mut param_strs: Vec = vec![format!("{}* sself", self.name)]; for (ident, irtype) in &method.args { param_strs.push(format!("{} {}", ir_type_to_cpp_string(irtype)?, ident.0)); } @@ -285,17 +285,17 @@ impl IRStruct { fn build_constructor(&self, writer: &mut impl std::io::Write) -> Result<()> { let ty = &self.name; let constructor = self.constructor_binding_name(); - let func1 = cpp!(extern "C" vtkNew<#ty> #constructor() {return vtkNew<#ty>();})?; + let func1 = cpp!(extern "C" #ty* #constructor() {return #ty::New();})?; let destructor = self.destructor_binding_name(); - let func2 = cpp!(extern "C" void #destructor(vtkNew<#ty> sself) { - sself.Reset(); + let func2 = cpp!(extern "C" void #destructor(#ty* sself) { + sself->Delete(); return; })?; let get_ptr = self.get_ptr_binding_name(); - let func3 = cpp!(extern "C" void* #get_ptr(vtkNew<#ty> sself) { - return sself.GetPointer(); + let func3 = cpp!(extern "C" void* #get_ptr(#ty* sself) { + return sself; })?; writeln!(writer, "{func1}")?; @@ -307,13 +307,13 @@ impl IRStruct { fn build_constructor_headers(&self, writer: &mut impl std::io::Write) -> Result<()> { let ty = &self.name; let constructor = self.constructor_binding_name(); - let func1 = cpp!(extern "C" vtkNew<#ty> #constructor();)?; + let func1 = cpp!(extern "C" #ty* #constructor();)?; let destructor = self.destructor_binding_name(); - let func2 = cpp!(extern "C" void #destructor(vtkNew<#ty> sself);)?; + let func2 = cpp!(extern "C" void #destructor(#ty* sself);)?; let get_ptr = self.get_ptr_binding_name(); - let func3 = cpp!(extern "C" void* #get_ptr(vtkNew<#ty> sself);)?; + let func3 = cpp!(extern "C" void* #get_ptr(#ty* sself);)?; writeln!(writer, "{func1}")?; writeln!(writer, "{func2}")?; diff --git a/vtk-gen/src/main.rs b/vtk-gen/src/main.rs index a3b6d4f..e48f7ef 100644 --- a/vtk-gen/src/main.rs +++ b/vtk-gen/src/main.rs @@ -254,6 +254,7 @@ fn write_build_rs(writer: &mut impl std::io::Write, ir_modules: &[IRModule]) -> #(#module_names),* ]; vtk_rs_link::link_cmake_project(modules)?; + println!("cargo:rustc-link-lib=tbb"); Ok(()) } From 3ff98ee119e2c8f1a32189cd2b03a5fc4e867827 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 22:35:30 +0200 Subject: [PATCH 18/30] fix correct c_longlong mapping --- vtk-gen/src/code_gen_rust.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vtk-gen/src/code_gen_rust.rs b/vtk-gen/src/code_gen_rust.rs index f677bd9..a6afa50 100644 --- a/vtk-gen/src/code_gen_rust.rs +++ b/vtk-gen/src/code_gen_rust.rs @@ -235,7 +235,7 @@ impl ToTokens for crate::IRType { c_short => quote!(core::ffi::c_short), c_int => quote!(core::ffi::c_int), c_long => quote!(core::ffi::c_long), - c_longlong => quote!(core::ffi::c_uchar), + c_longlong => quote!(core::ffi::c_longlong), c_uchar => quote!(core::ffi::c_uchar), c_ushort => quote!(core::ffi::c_ushort), c_uint => quote!(core::ffi::c_uint), From be976c3048ff8ff0cd65b3860b68dabfede63fef Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 22:36:50 +0200 Subject: [PATCH 19/30] fix test to work with T* instead of vtkNew --- vtk-gen/src/code_gen_cpp.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vtk-gen/src/code_gen_cpp.rs b/vtk-gen/src/code_gen_cpp.rs index b70d95a..30c3ebd 100644 --- a/vtk-gen/src/code_gen_cpp.rs +++ b/vtk-gen/src/code_gen_cpp.rs @@ -482,7 +482,7 @@ mod gen_cpp_tests { s.method_to_cpp(&m, &mut out).unwrap(); let src = String::from_utf8(out).unwrap(); assert!(src.contains("extern \"C\" void vtk_foo_update")); - assert!(src.contains("vtkNew sself")); + assert!(src.contains("vtkFoo* sself")); assert!(src.contains("sself->Update()")); } From 4e6f99ac3ba757c47eb78ec4d796f3dc0b94e7e3 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 22:39:16 +0200 Subject: [PATCH 20/30] fix generated create/drop test and new() for T* --- vtk-gen/src/code_gen_rust.rs | 31 +++++-------------------------- 1 file changed, 5 insertions(+), 26 deletions(-) diff --git a/vtk-gen/src/code_gen_rust.rs b/vtk-gen/src/code_gen_rust.rs index a6afa50..d7ff311 100644 --- a/vtk-gen/src/code_gen_rust.rs +++ b/vtk-gen/src/code_gen_rust.rs @@ -414,9 +414,8 @@ impl crate::IRModule { }); let constructor = quote::format_ident!("{}", c.constructor_binding_name()); - let constructor_comment = format!(" Creates a new [{name}] wrapped inside `vtkNew`"); + let constructor_comment = format!(" Creates a new [{name}] via `{struct_name}::New()`"); let destructor = quote::format_ident!("{}", c.destructor_binding_name()); - let get_ptr = quote::format_ident!("{}", c.get_ptr_binding_name()); let testname = quote::format_ident!("test_{}_create_drop", c.name); @@ -434,16 +433,7 @@ impl crate::IRModule { unsafe extern "C" { fn #constructor() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *#constructor() }) - } - - // This method is supposed to be used for testing only - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn #get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { #get_ptr( self.0 ) } + Self(unsafe { #constructor() }) } } @@ -464,21 +454,10 @@ impl crate::IRModule { } #[test] - fn #testname () { - // Create a new heap-allocated object behind vtkNew<..> - let obj = #name :: new(); - // Store the internal pointer which now contains the vtkNew<..> pointer - let ptr = obj.0; - // Ensure that the vtkNew<..> pointer and its content are not null - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); - // Manually drop the object, freeing the memory and nulling the pointer + fn #testname() { + let obj = #name::new(); + assert!(!obj.0.is_null()); drop(obj); - // Wrap the previous pointer in new object without explicitly calling - // constructor. This allows us to access its contents with the defined API. - let new_obj = #name(ptr); - // Ensure that the previously created object is null - assert!(unsafe { new_obj._get_ptr().is_null() }); } )); } From fa021a8322f33985d4eaceea8c8cd1c0d67fe0e9 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 22:43:30 +0200 Subject: [PATCH 21/30] fix avoid panic in get_exposable_methods when no parent class --- vtk-gen/src/inheritance_hierarchy.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/vtk-gen/src/inheritance_hierarchy.rs b/vtk-gen/src/inheritance_hierarchy.rs index 9da2ec4..458bca9 100644 --- a/vtk-gen/src/inheritance_hierarchy.rs +++ b/vtk-gen/src/inheritance_hierarchy.rs @@ -140,7 +140,8 @@ impl ClassHierarchy { let parent_methods: Vec<_> = all_parents .into_iter() - .flat_map(|class_name| self.classes[&class_name].methods.public.iter()) + .filter_map(|class_name| self.classes.get(&class_name)) + .flat_map(|c| c.methods.public.iter()) .collect(); let unique_methods: Vec<_> = self.classes[class_name] From a21d10566b3ea07aee8d56ef754d2bb16b2516ae Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 22:47:12 +0200 Subject: [PATCH 22/30] refactor remove dead code in ToTokens for IRModule --- vtk-gen/src/code_gen_rust.rs | 31 +------------------------------ 1 file changed, 1 insertion(+), 30 deletions(-) diff --git a/vtk-gen/src/code_gen_rust.rs b/vtk-gen/src/code_gen_rust.rs index d7ff311..3c42e01 100644 --- a/vtk-gen/src/code_gen_rust.rs +++ b/vtk-gen/src/code_gen_rust.rs @@ -468,43 +468,14 @@ impl crate::IRModule { impl quote::ToTokens for crate::IRModule { fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { - let modname = syn::Ident::new(&self.name, proc_macro2::Span::call_site()); - - // Identify traits as exposable methods of parent classes and provide default - // implementations. let traits = self.identify_traits(); tokens.extend(quote::quote!(#traits)); - // Implement traits for classes exposed in this module. let implement_self = self.implement_own_traits(); tokens.extend(quote::quote!(#implement_self)); - // Implement existing traits from other modules for classes exposed in this module - let bindings = self.create_bindings(); - - let mut output = quote::quote!(); - for class in self.classes.values() { - if class.is_constructable() { - let mut methods = quote::quote!(); - for method in class.exposable_methods.iter().take(2) { - methods.extend(quote::quote!(#method)); - } - let class_name = syn::Ident::new(&class.name, proc_macro2::Span::call_site()); - output.extend(quote::quote!( - impl #class_name { - #methods - } - )); - } - } - tokens.extend(quote::quote!( - // #[allow(non_camel_case_types)] - // pub mod #modname { - // #output - // } - #bindings - )); + tokens.extend(bindings); } } From a2e2102ceb5a2061f5ed639614f5615067457e6c Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 22:50:16 +0200 Subject: [PATCH 23/30] fix remove dead StarStar special-case --- vtk-gen/src/intermediate_representation.rs | 23 ++-------------------- 1 file changed, 2 insertions(+), 21 deletions(-) diff --git a/vtk-gen/src/intermediate_representation.rs b/vtk-gen/src/intermediate_representation.rs index 641f480..1f846d6 100644 --- a/vtk-gen/src/intermediate_representation.rs +++ b/vtk-gen/src/intermediate_representation.rs @@ -130,16 +130,7 @@ impl IRMethod { Some(crate::Pointer::Ref) => CppType::Ref(Box::new(inner_ty)), Some(crate::Pointer::Star) => CppType::Pointer(Box::new(inner_ty)), Some(crate::Pointer::StarStar) => { - // WrapVTK encodes `const char*` VTK_FILEPATH return types as - // type="const char" pointer="**". Recover the intended single pointer. - match &inner_ty { - CppType::Const(inner) - if matches!(inner.as_ref(), CppType::SignedChar) => - { - CppType::Pointer(Box::new(inner_ty)) - } - _ => anyhow::bail!("double pointer not bridgeable"), - } + anyhow::bail!("double pointer not bridgeable") } Some(crate::Pointer::StarStarConst) => { anyhow::bail!("const double pointer not bridgeable") @@ -172,17 +163,7 @@ impl IRMethod { Some(crate::Pointer::Ref) => CppType::Ref(Box::new(inner_ty)), Some(crate::Pointer::Star) => CppType::Pointer(Box::new(inner_ty)), Some(crate::Pointer::StarStar) => { - // WrapVTK encodes `const char*` VTK_FILEPATH params as - // type="const char" pointer="**". Recover the intended single pointer. - // Any other ** (including mutable char** output params) is not bridgeable. - match &inner_ty { - CppType::Const(inner) - if matches!(inner.as_ref(), CppType::SignedChar) => - { - CppType::Pointer(Box::new(inner_ty)) - } - _ => anyhow::bail!("double pointer not bridgeable"), - } + anyhow::bail!("double pointer not bridgeable") } Some(crate::Pointer::StarStarConst) => { anyhow::bail!("const double pointer not bridgeable") From f0a065b7899ceb13b146de92fd3513db448b6155 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 22:53:34 +0200 Subject: [PATCH 24/30] update stale vtkNew comment in is_constructable --- vtk-gen/src/intermediate_representation.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/vtk-gen/src/intermediate_representation.rs b/vtk-gen/src/intermediate_representation.rs index 1f846d6..0ce20ed 100644 --- a/vtk-gen/src/intermediate_representation.rs +++ b/vtk-gen/src/intermediate_representation.rs @@ -223,8 +223,7 @@ impl IRStruct { && !self.is_abstract && !self.is_template && !self.exposable_methods.is_empty() - // This could be lifted in the future when considering objects which can be constructed - // not via vtkNew<..>() + // Only vtkObjectBase subclasses have the New() / Delete() reference-counting API. && self.has_vtk_object_base_ancestor } } From 7f7456461b8338c561a81b1986f66c04910d1c82 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 22:56:42 +0200 Subject: [PATCH 25/30] update CHANGELOG --- CHANGELOG.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 815c4be..56cb505 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -24,14 +24,18 @@ ### Fixed - **`vtkNew` ABI mismatch in generated C++ wrappers**: `vtkNew` has a non-trivial destructor, so passing or returning it by value in `extern "C"` functions violates the x86-64 SysV ABI and causes the wrapped VTK object to be destroyed on every method call. Constructor, destructor, get-ptr, and all method wrappers now use raw `T*` (`T::New()` / `sself->Delete()` / `return sself`) instead of `vtkNew`. - **`std::string` return types** (`IRType::String`): bridging `std::string` as `const char*` is illegal (dangling pointer). These methods are now skipped on both the Rust and C++ sides. -- **`const char*` vs `const char* const*`**: `StarStarConst` now always bails instead of incorrectly reducing to a single pointer. -- **Mutable `char**` output parameters**: `StarStar + non-const char` now bails; only `StarStar + const char` (VTK_FILEPATH encoding) is reduced to a single pointer. +- **`const char*` vs `const char* const*`**: `StarStarConst` and `StarStar` now always bail instead of incorrectly reducing to a single pointer. +- **Mutable `char**` output parameters**: `StarStar` always bails — VTK_FILEPATH uses `pointer="*"` in the actual XML, never `pointer="**"`. The previous special-case for `Const(SignedChar)**` was unreachable dead code and has been removed. - **Mutable `char*` vs `signed char*`**: `Pointer(c_char)` (without `Const`) is now rejected on both Rust and C++ sides — VTK typed-data-array methods use `signed char*`, which is not implicitly convertible from `char*` in C++. - **`signed char*` data array methods**: Separated `CppType::PlainChar` (`"char"`) from `CppType::SignedChar` (`"signed char"`) so typed-data-array parameters (`const signed char*`) generate the correct C++ type and are rejected at the Rust FFI boundary (not safely bridgeable without element-count information). - **`Path` types by value/reference** (e.g. `const vtkStdString&`, `vtkColor3ub`): rejected in `ir_type_is_supported`; VTK object types are only bridgeable as opaque pointers. - **Heap collection types** (`Vec`, `LinkedList`, `Map`): rejected in `ir_type_is_supported` — these types cannot cross the `extern "C"` boundary safely. - **Cross-module supertrait bounds**: removed from generated trait definitions. Generating `trait VtkFoo: VtkBar` across module boundaries requires the concrete struct to implement all ancestor traits, which the generator does not yet support. - **`vtktoken` linker error**: removed from the hardcoded link list in `write_build_rs`; `libvtktoken` is a VTK 9.2+ library not present in VTK 9.1 system packages. +- **`c_longlong` Rust type mapping**: was incorrectly emitting `core::ffi::c_uchar` (copy-paste error); now correctly emits `core::ffi::c_longlong`. +- **Generated `test_vtkXxx_create_drop` was broken**: after the `vtkNew` → `T*` switch, `get_ptr` returns the pointer itself so the post-drop null assertion was wrong and the test accessed freed memory (UB). Simplified to verify creation gives a non-null pointer and `drop` does not panic. +- **Panic in `get_exposable_methods`**: indexing `self.classes[parent]` would panic if a parent class named in an XML `` entry had no corresponding XML file scanned. Changed to a silent skip via `.filter_map(|n| self.classes.get(&n))`. +- **`new()` in generated bindings**: `Self(unsafe { &mut *constructor() })` created a spurious `&mut c_void` reference before coercing back to `*mut c_void`. Simplified to `Self(unsafe { constructor() })`. ## [0.2.0] - 2025-06-03 From adb59d3b55e5548993cf02f8a6cc2626cab9e94a Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 22:58:08 +0200 Subject: [PATCH 26/30] include updated vtk-rs-9.1 --- vtk-rs-9.1/build.rs | 3 +- vtk-rs-9.1/libvtkrs/CMakeLists.txt | 3 + .../libvtkrs/include/vtk_common_color.h | 30 +- .../vtk_common_computational_geometry.h | 468 +- vtk-rs-9.1/libvtkrs/include/vtk_common_core.h | 2081 +- .../libvtkrs/include/vtk_common_data_model.h | 4905 +- .../include/vtk_common_execution_model.h | 679 +- vtk-rs-9.1/libvtkrs/include/vtk_common_math.h | 241 +- vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h | 214 +- .../libvtkrs/include/vtk_common_system.h | 145 +- .../libvtkrs/include/vtk_common_transforms.h | 297 +- .../libvtkrs/include/vtk_filters_sources.h | 839 + vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp | 30 +- .../src/vtk_common_computational_geometry.cpp | 468 +- vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp | 2081 +- .../libvtkrs/src/vtk_common_data_model.cpp | 4905 +- .../src/vtk_common_execution_model.cpp | 679 +- vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp | 241 +- vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp | 214 +- vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp | 145 +- .../libvtkrs/src/vtk_common_transforms.cpp | 297 +- .../libvtkrs/src/vtk_filters_sources.cpp | 842 + vtk-rs-9.1/src/lib.rs | 426 + vtk-rs-9.1/src/vtkCommonColor.rs | 553 +- .../src/vtkCommonComputationalGeometry.rs | 1510 +- vtk-rs-9.1/src/vtkCommonCore.rs | 23028 ++------ vtk-rs-9.1/src/vtkCommonDataModel.rs | 43393 ++-------------- vtk-rs-9.1/src/vtkCommonExecutionModel.rs | 4440 +- vtk-rs-9.1/src/vtkCommonMath.rs | 2332 +- vtk-rs-9.1/src/vtkCommonMisc.rs | 1199 +- vtk-rs-9.1/src/vtkCommonSystem.rs | 366 +- vtk-rs-9.1/src/vtkCommonTransforms.rs | 1578 +- vtk-rs-9.1/src/vtkFiltersSources.rs | 10307 ++++ 33 files changed, 28906 insertions(+), 80033 deletions(-) create mode 100644 vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h create mode 100644 vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp create mode 100644 vtk-rs-9.1/src/vtkFiltersSources.rs diff --git a/vtk-rs-9.1/build.rs b/vtk-rs-9.1/build.rs index 187c983..af9320c 100644 --- a/vtk-rs-9.1/build.rs +++ b/vtk-rs-9.1/build.rs @@ -20,7 +20,6 @@ fn main() -> Result<()> { build_cmake(); let modules = vec![ "vtksys", - "vtktoken", "vtkCommonColor", "vtkCommonComputationalGeometry", "vtkCommonCore", @@ -30,7 +29,9 @@ fn main() -> Result<()> { "vtkCommonMisc", "vtkCommonSystem", "vtkCommonTransforms", + "vtkFiltersSources", ]; vtk_rs_link::link_cmake_project(modules)?; + println!("cargo:rustc-link-lib=tbb"); Ok(()) } diff --git a/vtk-rs-9.1/libvtkrs/CMakeLists.txt b/vtk-rs-9.1/libvtkrs/CMakeLists.txt index 6ccacbc..ab86dd7 100644 --- a/vtk-rs-9.1/libvtkrs/CMakeLists.txt +++ b/vtk-rs-9.1/libvtkrs/CMakeLists.txt @@ -12,6 +12,7 @@ find_package(VTK COMPONENTS CommonMisc CommonSystem CommonTransforms + FiltersSources ) if (NOT VTK_FOUND) @@ -31,6 +32,7 @@ add_library(vtkrs STATIC ${PROJECT_SOURCE_DIR}/include/vtk_common_misc.h ${PROJECT_SOURCE_DIR}/include/vtk_common_system.h ${PROJECT_SOURCE_DIR}/include/vtk_common_transforms.h + ${PROJECT_SOURCE_DIR}/include/vtk_filters_sources.h ) if (VTK094) @@ -49,6 +51,7 @@ target_sources(vtkrs ${PROJECT_SOURCE_DIR}/src/vtk_common_misc.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_system.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_transforms.cpp + ${PROJECT_SOURCE_DIR}/src/vtk_filters_sources.cpp ) set_target_properties(vtkrs PROPERTIES LINKER_LANGUAGE CXX) diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h index b1f0102..bef080d 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h @@ -7,18 +7,18 @@ #include // Declare exported functions -extern "C" vtkNew < vtkColorSeries > vtkColorSeries_new () ; -extern "C" void vtkColorSeries_destructor (vtkNew < vtkColorSeries > sself) ; -extern "C" void * vtkColorSeries_get_ptr (vtkNew < vtkColorSeries > sself) ; -extern "C" void vtk_color_series_set_color_scheme(vtkNew sself, int scheme); -extern "C" int vtk_color_series_get_number_of_color_schemes(vtkNew sself); -extern "C" int vtk_color_series_get_color_scheme(vtkNew sself); -extern "C" int vtk_color_series_get_number_of_colors(vtkNew sself); -extern "C" void vtk_color_series_set_number_of_colors(vtkNew sself, int numColors); -extern "C" void vtk_color_series_remove_color(vtkNew sself, int index); -extern "C" void vtk_color_series_clear_colors(vtkNew sself); -extern "C" vtkNew < vtkNamedColors > vtkNamedColors_new () ; -extern "C" void vtkNamedColors_destructor (vtkNew < vtkNamedColors > sself) ; -extern "C" void * vtkNamedColors_get_ptr (vtkNew < vtkNamedColors > sself) ; -extern "C" int vtk_named_colors_get_number_of_colors(vtkNew sself); -extern "C" void vtk_named_colors_reset_colors(vtkNew sself); +extern "C" vtkColorSeries * vtkColorSeries_new () ; +extern "C" void vtkColorSeries_destructor (vtkColorSeries * sself) ; +extern "C" void * vtkColorSeries_get_ptr (vtkColorSeries * sself) ; +extern "C" void vtk_color_series_set_color_scheme(vtkColorSeries* sself, int scheme); +extern "C" int vtk_color_series_get_number_of_color_schemes(vtkColorSeries* sself); +extern "C" int vtk_color_series_get_color_scheme(vtkColorSeries* sself); +extern "C" int vtk_color_series_get_number_of_colors(vtkColorSeries* sself); +extern "C" void vtk_color_series_set_number_of_colors(vtkColorSeries* sself, int numColors); +extern "C" void vtk_color_series_remove_color(vtkColorSeries* sself, int index); +extern "C" void vtk_color_series_clear_colors(vtkColorSeries* sself); +extern "C" vtkNamedColors * vtkNamedColors_new () ; +extern "C" void vtkNamedColors_destructor (vtkNamedColors * sself) ; +extern "C" void * vtkNamedColors_get_ptr (vtkNamedColors * sself) ; +extern "C" int vtk_named_colors_get_number_of_colors(vtkNamedColors* sself); +extern "C" void vtk_named_colors_reset_colors(vtkNamedColors* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h index 813395c..41a48b6 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h @@ -31,259 +31,215 @@ #include // Declare exported functions -extern "C" vtkNew < vtkCardinalSpline > vtkCardinalSpline_new () ; -extern "C" void vtkCardinalSpline_destructor (vtkNew < vtkCardinalSpline > sself) ; -extern "C" void * vtkCardinalSpline_get_ptr (vtkNew < vtkCardinalSpline > sself) ; -extern "C" void vtk_cardinal_spline_compute(vtkNew sself); -extern "C" double vtk_cardinal_spline_evaluate(vtkNew sself, double t); -extern "C" vtkNew < vtkKochanekSpline > vtkKochanekSpline_new () ; -extern "C" void vtkKochanekSpline_destructor (vtkNew < vtkKochanekSpline > sself) ; -extern "C" void * vtkKochanekSpline_get_ptr (vtkNew < vtkKochanekSpline > sself) ; -extern "C" void vtk_kochanek_spline_compute(vtkNew sself); -extern "C" double vtk_kochanek_spline_evaluate(vtkNew sself, double t); -extern "C" void vtk_kochanek_spline_set_default_bias(vtkNew sself, double _arg); -extern "C" double vtk_kochanek_spline_get_default_bias(vtkNew sself); -extern "C" void vtk_kochanek_spline_set_default_tension(vtkNew sself, double _arg); -extern "C" double vtk_kochanek_spline_get_default_tension(vtkNew sself); -extern "C" void vtk_kochanek_spline_set_default_continuity(vtkNew sself, double _arg); -extern "C" double vtk_kochanek_spline_get_default_continuity(vtkNew sself); -extern "C" vtkNew < vtkParametricBohemianDome > vtkParametricBohemianDome_new () ; -extern "C" void vtkParametricBohemianDome_destructor (vtkNew < vtkParametricBohemianDome > sself) ; -extern "C" void * vtkParametricBohemianDome_get_ptr (vtkNew < vtkParametricBohemianDome > sself) ; -extern "C" double vtk_parametric_bohemian_dome_get_a(vtkNew sself); -extern "C" void vtk_parametric_bohemian_dome_set_a(vtkNew sself, double _arg); -extern "C" double vtk_parametric_bohemian_dome_get_b(vtkNew sself); -extern "C" void vtk_parametric_bohemian_dome_set_b(vtkNew sself, double _arg); -extern "C" double vtk_parametric_bohemian_dome_get_c(vtkNew sself); -extern "C" void vtk_parametric_bohemian_dome_set_c(vtkNew sself, double _arg); -extern "C" int vtk_parametric_bohemian_dome_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_bohemian_dome_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_bohemian_dome_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricBour > vtkParametricBour_new () ; -extern "C" void vtkParametricBour_destructor (vtkNew < vtkParametricBour > sself) ; -extern "C" void * vtkParametricBour_get_ptr (vtkNew < vtkParametricBour > sself) ; -extern "C" int vtk_parametric_bour_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_bour_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_bour_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricBoy > vtkParametricBoy_new () ; -extern "C" void vtkParametricBoy_destructor (vtkNew < vtkParametricBoy > sself) ; -extern "C" void * vtkParametricBoy_get_ptr (vtkNew < vtkParametricBoy > sself) ; -extern "C" int vtk_parametric_boy_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_boy_set_z_scale(vtkNew sself, double _arg); -extern "C" double vtk_parametric_boy_get_z_scale(vtkNew sself); -extern "C" void vtk_parametric_boy_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_boy_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricCatalanMinimal > vtkParametricCatalanMinimal_new () ; -extern "C" void vtkParametricCatalanMinimal_destructor (vtkNew < vtkParametricCatalanMinimal > sself) ; -extern "C" void * vtkParametricCatalanMinimal_get_ptr (vtkNew < vtkParametricCatalanMinimal > sself) ; -extern "C" int vtk_parametric_catalan_minimal_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_catalan_minimal_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_catalan_minimal_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricConicSpiral > vtkParametricConicSpiral_new () ; -extern "C" void vtkParametricConicSpiral_destructor (vtkNew < vtkParametricConicSpiral > sself) ; -extern "C" void * vtkParametricConicSpiral_get_ptr (vtkNew < vtkParametricConicSpiral > sself) ; -extern "C" int vtk_parametric_conic_spiral_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_conic_spiral_set_a(vtkNew sself, double _arg); -extern "C" double vtk_parametric_conic_spiral_get_a(vtkNew sself); -extern "C" void vtk_parametric_conic_spiral_set_b(vtkNew sself, double _arg); -extern "C" double vtk_parametric_conic_spiral_get_b(vtkNew sself); -extern "C" void vtk_parametric_conic_spiral_set_c(vtkNew sself, double _arg); -extern "C" double vtk_parametric_conic_spiral_get_c(vtkNew sself); -extern "C" void vtk_parametric_conic_spiral_set_n(vtkNew sself, double _arg); -extern "C" double vtk_parametric_conic_spiral_get_n(vtkNew sself); -extern "C" void vtk_parametric_conic_spiral_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_conic_spiral_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricCrossCap > vtkParametricCrossCap_new () ; -extern "C" void vtkParametricCrossCap_destructor (vtkNew < vtkParametricCrossCap > sself) ; -extern "C" void * vtkParametricCrossCap_get_ptr (vtkNew < vtkParametricCrossCap > sself) ; -extern "C" int vtk_parametric_cross_cap_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_cross_cap_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_cross_cap_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricDini > vtkParametricDini_new () ; -extern "C" void vtkParametricDini_destructor (vtkNew < vtkParametricDini > sself) ; -extern "C" void * vtkParametricDini_get_ptr (vtkNew < vtkParametricDini > sself) ; -extern "C" int vtk_parametric_dini_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_dini_set_a(vtkNew sself, double _arg); -extern "C" double vtk_parametric_dini_get_a(vtkNew sself); -extern "C" void vtk_parametric_dini_set_b(vtkNew sself, double _arg); -extern "C" double vtk_parametric_dini_get_b(vtkNew sself); -extern "C" void vtk_parametric_dini_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_dini_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricEllipsoid > vtkParametricEllipsoid_new () ; -extern "C" void vtkParametricEllipsoid_destructor (vtkNew < vtkParametricEllipsoid > sself) ; -extern "C" void * vtkParametricEllipsoid_get_ptr (vtkNew < vtkParametricEllipsoid > sself) ; -extern "C" int vtk_parametric_ellipsoid_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_ellipsoid_set_x_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_ellipsoid_get_x_radius(vtkNew sself); -extern "C" void vtk_parametric_ellipsoid_set_y_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_ellipsoid_get_y_radius(vtkNew sself); -extern "C" void vtk_parametric_ellipsoid_set_z_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_ellipsoid_get_z_radius(vtkNew sself); -extern "C" void vtk_parametric_ellipsoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_ellipsoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricEnneper > vtkParametricEnneper_new () ; -extern "C" void vtkParametricEnneper_destructor (vtkNew < vtkParametricEnneper > sself) ; -extern "C" void * vtkParametricEnneper_get_ptr (vtkNew < vtkParametricEnneper > sself) ; -extern "C" int vtk_parametric_enneper_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_enneper_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_enneper_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricFigure8Klein > vtkParametricFigure8Klein_new () ; -extern "C" void vtkParametricFigure8Klein_destructor (vtkNew < vtkParametricFigure8Klein > sself) ; -extern "C" void * vtkParametricFigure8Klein_get_ptr (vtkNew < vtkParametricFigure8Klein > sself) ; -extern "C" void vtk_parametric_figure_8_klein_set_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_figure_8_klein_get_radius(vtkNew sself); -extern "C" int vtk_parametric_figure_8_klein_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_figure_8_klein_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_figure_8_klein_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricHenneberg > vtkParametricHenneberg_new () ; -extern "C" void vtkParametricHenneberg_destructor (vtkNew < vtkParametricHenneberg > sself) ; -extern "C" void * vtkParametricHenneberg_get_ptr (vtkNew < vtkParametricHenneberg > sself) ; -extern "C" int vtk_parametric_henneberg_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_henneberg_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_henneberg_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricKlein > vtkParametricKlein_new () ; -extern "C" void vtkParametricKlein_destructor (vtkNew < vtkParametricKlein > sself) ; -extern "C" void * vtkParametricKlein_get_ptr (vtkNew < vtkParametricKlein > sself) ; -extern "C" int vtk_parametric_klein_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_klein_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_klein_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricKuen > vtkParametricKuen_new () ; -extern "C" void vtkParametricKuen_destructor (vtkNew < vtkParametricKuen > sself) ; -extern "C" void * vtkParametricKuen_get_ptr (vtkNew < vtkParametricKuen > sself) ; -extern "C" int vtk_parametric_kuen_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_kuen_set_delta_v_0(vtkNew sself, double _arg); -extern "C" double vtk_parametric_kuen_get_delta_v_0(vtkNew sself); -extern "C" void vtk_parametric_kuen_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_kuen_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricMobius > vtkParametricMobius_new () ; -extern "C" void vtkParametricMobius_destructor (vtkNew < vtkParametricMobius > sself) ; -extern "C" void * vtkParametricMobius_get_ptr (vtkNew < vtkParametricMobius > sself) ; -extern "C" void vtk_parametric_mobius_set_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_mobius_get_radius(vtkNew sself); -extern "C" int vtk_parametric_mobius_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_mobius_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_mobius_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricPluckerConoid > vtkParametricPluckerConoid_new () ; -extern "C" void vtkParametricPluckerConoid_destructor (vtkNew < vtkParametricPluckerConoid > sself) ; -extern "C" void * vtkParametricPluckerConoid_get_ptr (vtkNew < vtkParametricPluckerConoid > sself) ; -extern "C" int vtk_parametric_plucker_conoid_get_n(vtkNew sself); -extern "C" void vtk_parametric_plucker_conoid_set_n(vtkNew sself, int _arg); -extern "C" int vtk_parametric_plucker_conoid_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_plucker_conoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_plucker_conoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricPseudosphere > vtkParametricPseudosphere_new () ; -extern "C" void vtkParametricPseudosphere_destructor (vtkNew < vtkParametricPseudosphere > sself) ; -extern "C" void * vtkParametricPseudosphere_get_ptr (vtkNew < vtkParametricPseudosphere > sself) ; -extern "C" int vtk_parametric_pseudosphere_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_pseudosphere_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_pseudosphere_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricRandomHills > vtkParametricRandomHills_new () ; -extern "C" void vtkParametricRandomHills_destructor (vtkNew < vtkParametricRandomHills > sself) ; -extern "C" void * vtkParametricRandomHills_get_ptr (vtkNew < vtkParametricRandomHills > sself) ; -extern "C" int vtk_parametric_random_hills_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_random_hills_set_number_of_hills(vtkNew sself, int _arg); -extern "C" int vtk_parametric_random_hills_get_number_of_hills(vtkNew sself); -extern "C" void vtk_parametric_random_hills_set_hill_x_variance(vtkNew sself, double _arg); -extern "C" double vtk_parametric_random_hills_get_hill_x_variance(vtkNew sself); -extern "C" void vtk_parametric_random_hills_set_hill_y_variance(vtkNew sself, double _arg); -extern "C" double vtk_parametric_random_hills_get_hill_y_variance(vtkNew sself); -extern "C" void vtk_parametric_random_hills_set_hill_amplitude(vtkNew sself, double _arg); -extern "C" double vtk_parametric_random_hills_get_hill_amplitude(vtkNew sself); -extern "C" void vtk_parametric_random_hills_set_random_seed(vtkNew sself, int _arg); -extern "C" int vtk_parametric_random_hills_get_random_seed(vtkNew sself); -extern "C" void vtk_parametric_random_hills_set_allow_random_generation(vtkNew sself, int _arg); -extern "C" int vtk_parametric_random_hills_get_allow_random_generation_min_value(vtkNew sself); -extern "C" int vtk_parametric_random_hills_get_allow_random_generation_max_value(vtkNew sself); -extern "C" int vtk_parametric_random_hills_get_allow_random_generation(vtkNew sself); -extern "C" void vtk_parametric_random_hills_allow_random_generation_on(vtkNew sself); -extern "C" void vtk_parametric_random_hills_allow_random_generation_off(vtkNew sself); -extern "C" void vtk_parametric_random_hills_set_x_variance_scale_factor(vtkNew sself, double _arg); -extern "C" double vtk_parametric_random_hills_get_x_variance_scale_factor(vtkNew sself); -extern "C" void vtk_parametric_random_hills_set_y_variance_scale_factor(vtkNew sself, double _arg); -extern "C" double vtk_parametric_random_hills_get_y_variance_scale_factor(vtkNew sself); -extern "C" void vtk_parametric_random_hills_set_amplitude_scale_factor(vtkNew sself, double _arg); -extern "C" double vtk_parametric_random_hills_get_amplitude_scale_factor(vtkNew sself); -extern "C" void vtk_parametric_random_hills_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_random_hills_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricRoman > vtkParametricRoman_new () ; -extern "C" void vtkParametricRoman_destructor (vtkNew < vtkParametricRoman > sself) ; -extern "C" void * vtkParametricRoman_get_ptr (vtkNew < vtkParametricRoman > sself) ; -extern "C" int vtk_parametric_roman_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_roman_set_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_roman_get_radius(vtkNew sself); -extern "C" void vtk_parametric_roman_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_roman_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricSpline > vtkParametricSpline_new () ; -extern "C" void vtkParametricSpline_destructor (vtkNew < vtkParametricSpline > sself) ; -extern "C" void * vtkParametricSpline_get_ptr (vtkNew < vtkParametricSpline > sself) ; -extern "C" int vtk_parametric_spline_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_spline_evaluate(vtkNew sself, double u, double Pt, double Du); -extern "C" double vtk_parametric_spline_evaluate_scalar(vtkNew sself, double u, double Pt, double Du); -extern "C" void vtk_parametric_spline_set_number_of_points(vtkNew sself, long long numPts); -extern "C" void vtk_parametric_spline_set_point(vtkNew sself, long long index, double x, double y, double z); -extern "C" void vtk_parametric_spline_set_closed(vtkNew sself, int _arg); -extern "C" int vtk_parametric_spline_get_closed(vtkNew sself); -extern "C" void vtk_parametric_spline_closed_on(vtkNew sself); -extern "C" void vtk_parametric_spline_closed_off(vtkNew sself); -extern "C" void vtk_parametric_spline_set_parameterize_by_length(vtkNew sself, int _arg); -extern "C" int vtk_parametric_spline_get_parameterize_by_length(vtkNew sself); -extern "C" void vtk_parametric_spline_parameterize_by_length_on(vtkNew sself); -extern "C" void vtk_parametric_spline_parameterize_by_length_off(vtkNew sself); -extern "C" void vtk_parametric_spline_set_left_constraint(vtkNew sself, int _arg); -extern "C" int vtk_parametric_spline_get_left_constraint_min_value(vtkNew sself); -extern "C" int vtk_parametric_spline_get_left_constraint_max_value(vtkNew sself); -extern "C" int vtk_parametric_spline_get_left_constraint(vtkNew sself); -extern "C" void vtk_parametric_spline_set_right_constraint(vtkNew sself, int _arg); -extern "C" int vtk_parametric_spline_get_right_constraint_min_value(vtkNew sself); -extern "C" int vtk_parametric_spline_get_right_constraint_max_value(vtkNew sself); -extern "C" int vtk_parametric_spline_get_right_constraint(vtkNew sself); -extern "C" void vtk_parametric_spline_set_left_value(vtkNew sself, double _arg); -extern "C" double vtk_parametric_spline_get_left_value(vtkNew sself); -extern "C" void vtk_parametric_spline_set_right_value(vtkNew sself, double _arg); -extern "C" double vtk_parametric_spline_get_right_value(vtkNew sself); -extern "C" vtkNew < vtkParametricSuperEllipsoid > vtkParametricSuperEllipsoid_new () ; -extern "C" void vtkParametricSuperEllipsoid_destructor (vtkNew < vtkParametricSuperEllipsoid > sself) ; -extern "C" void * vtkParametricSuperEllipsoid_get_ptr (vtkNew < vtkParametricSuperEllipsoid > sself) ; -extern "C" int vtk_parametric_super_ellipsoid_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_super_ellipsoid_set_x_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_ellipsoid_get_x_radius(vtkNew sself); -extern "C" void vtk_parametric_super_ellipsoid_set_y_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_ellipsoid_get_y_radius(vtkNew sself); -extern "C" void vtk_parametric_super_ellipsoid_set_z_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_ellipsoid_get_z_radius(vtkNew sself); -extern "C" void vtk_parametric_super_ellipsoid_set_n_1(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_ellipsoid_get_n_1(vtkNew sself); -extern "C" void vtk_parametric_super_ellipsoid_set_n_2(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_ellipsoid_get_n_2(vtkNew sself); -extern "C" void vtk_parametric_super_ellipsoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_super_ellipsoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricSuperToroid > vtkParametricSuperToroid_new () ; -extern "C" void vtkParametricSuperToroid_destructor (vtkNew < vtkParametricSuperToroid > sself) ; -extern "C" void * vtkParametricSuperToroid_get_ptr (vtkNew < vtkParametricSuperToroid > sself) ; -extern "C" int vtk_parametric_super_toroid_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_super_toroid_set_ring_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_toroid_get_ring_radius(vtkNew sself); -extern "C" void vtk_parametric_super_toroid_set_cross_section_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_toroid_get_cross_section_radius(vtkNew sself); -extern "C" void vtk_parametric_super_toroid_set_x_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_toroid_get_x_radius(vtkNew sself); -extern "C" void vtk_parametric_super_toroid_set_y_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_toroid_get_y_radius(vtkNew sself); -extern "C" void vtk_parametric_super_toroid_set_z_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_toroid_get_z_radius(vtkNew sself); -extern "C" void vtk_parametric_super_toroid_set_n_1(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_toroid_get_n_1(vtkNew sself); -extern "C" void vtk_parametric_super_toroid_set_n_2(vtkNew sself, double _arg); -extern "C" double vtk_parametric_super_toroid_get_n_2(vtkNew sself); -extern "C" void vtk_parametric_super_toroid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_super_toroid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" vtkNew < vtkParametricTorus > vtkParametricTorus_new () ; -extern "C" void vtkParametricTorus_destructor (vtkNew < vtkParametricTorus > sself) ; -extern "C" void * vtkParametricTorus_get_ptr (vtkNew < vtkParametricTorus > sself) ; -extern "C" void vtk_parametric_torus_set_ring_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_torus_get_ring_radius(vtkNew sself); -extern "C" void vtk_parametric_torus_set_cross_section_radius(vtkNew sself, double _arg); -extern "C" double vtk_parametric_torus_get_cross_section_radius(vtkNew sself); -extern "C" int vtk_parametric_torus_get_dimension(vtkNew sself); -extern "C" void vtk_parametric_torus_evaluate(vtkNew sself, double uvw, double Pt, double Duvw); -extern "C" double vtk_parametric_torus_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw); +extern "C" vtkCardinalSpline * vtkCardinalSpline_new () ; +extern "C" void vtkCardinalSpline_destructor (vtkCardinalSpline * sself) ; +extern "C" void * vtkCardinalSpline_get_ptr (vtkCardinalSpline * sself) ; +extern "C" void vtk_cardinal_spline_compute(vtkCardinalSpline* sself); +extern "C" double vtk_cardinal_spline_evaluate(vtkCardinalSpline* sself, double t); +extern "C" vtkKochanekSpline * vtkKochanekSpline_new () ; +extern "C" void vtkKochanekSpline_destructor (vtkKochanekSpline * sself) ; +extern "C" void * vtkKochanekSpline_get_ptr (vtkKochanekSpline * sself) ; +extern "C" void vtk_kochanek_spline_compute(vtkKochanekSpline* sself); +extern "C" double vtk_kochanek_spline_evaluate(vtkKochanekSpline* sself, double t); +extern "C" void vtk_kochanek_spline_set_default_bias(vtkKochanekSpline* sself, double _arg); +extern "C" double vtk_kochanek_spline_get_default_bias(vtkKochanekSpline* sself); +extern "C" void vtk_kochanek_spline_set_default_tension(vtkKochanekSpline* sself, double _arg); +extern "C" double vtk_kochanek_spline_get_default_tension(vtkKochanekSpline* sself); +extern "C" void vtk_kochanek_spline_set_default_continuity(vtkKochanekSpline* sself, double _arg); +extern "C" double vtk_kochanek_spline_get_default_continuity(vtkKochanekSpline* sself); +extern "C" vtkParametricBohemianDome * vtkParametricBohemianDome_new () ; +extern "C" void vtkParametricBohemianDome_destructor (vtkParametricBohemianDome * sself) ; +extern "C" void * vtkParametricBohemianDome_get_ptr (vtkParametricBohemianDome * sself) ; +extern "C" double vtk_parametric_bohemian_dome_get_a(vtkParametricBohemianDome* sself); +extern "C" void vtk_parametric_bohemian_dome_set_a(vtkParametricBohemianDome* sself, double _arg); +extern "C" double vtk_parametric_bohemian_dome_get_b(vtkParametricBohemianDome* sself); +extern "C" void vtk_parametric_bohemian_dome_set_b(vtkParametricBohemianDome* sself, double _arg); +extern "C" double vtk_parametric_bohemian_dome_get_c(vtkParametricBohemianDome* sself); +extern "C" void vtk_parametric_bohemian_dome_set_c(vtkParametricBohemianDome* sself, double _arg); +extern "C" int vtk_parametric_bohemian_dome_get_dimension(vtkParametricBohemianDome* sself); +extern "C" vtkParametricBour * vtkParametricBour_new () ; +extern "C" void vtkParametricBour_destructor (vtkParametricBour * sself) ; +extern "C" void * vtkParametricBour_get_ptr (vtkParametricBour * sself) ; +extern "C" int vtk_parametric_bour_get_dimension(vtkParametricBour* sself); +extern "C" vtkParametricBoy * vtkParametricBoy_new () ; +extern "C" void vtkParametricBoy_destructor (vtkParametricBoy * sself) ; +extern "C" void * vtkParametricBoy_get_ptr (vtkParametricBoy * sself) ; +extern "C" int vtk_parametric_boy_get_dimension(vtkParametricBoy* sself); +extern "C" void vtk_parametric_boy_set_z_scale(vtkParametricBoy* sself, double _arg); +extern "C" double vtk_parametric_boy_get_z_scale(vtkParametricBoy* sself); +extern "C" vtkParametricCatalanMinimal * vtkParametricCatalanMinimal_new () ; +extern "C" void vtkParametricCatalanMinimal_destructor (vtkParametricCatalanMinimal * sself) ; +extern "C" void * vtkParametricCatalanMinimal_get_ptr (vtkParametricCatalanMinimal * sself) ; +extern "C" int vtk_parametric_catalan_minimal_get_dimension(vtkParametricCatalanMinimal* sself); +extern "C" vtkParametricConicSpiral * vtkParametricConicSpiral_new () ; +extern "C" void vtkParametricConicSpiral_destructor (vtkParametricConicSpiral * sself) ; +extern "C" void * vtkParametricConicSpiral_get_ptr (vtkParametricConicSpiral * sself) ; +extern "C" int vtk_parametric_conic_spiral_get_dimension(vtkParametricConicSpiral* sself); +extern "C" void vtk_parametric_conic_spiral_set_a(vtkParametricConicSpiral* sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_a(vtkParametricConicSpiral* sself); +extern "C" void vtk_parametric_conic_spiral_set_b(vtkParametricConicSpiral* sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_b(vtkParametricConicSpiral* sself); +extern "C" void vtk_parametric_conic_spiral_set_c(vtkParametricConicSpiral* sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_c(vtkParametricConicSpiral* sself); +extern "C" void vtk_parametric_conic_spiral_set_n(vtkParametricConicSpiral* sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_n(vtkParametricConicSpiral* sself); +extern "C" vtkParametricCrossCap * vtkParametricCrossCap_new () ; +extern "C" void vtkParametricCrossCap_destructor (vtkParametricCrossCap * sself) ; +extern "C" void * vtkParametricCrossCap_get_ptr (vtkParametricCrossCap * sself) ; +extern "C" int vtk_parametric_cross_cap_get_dimension(vtkParametricCrossCap* sself); +extern "C" vtkParametricDini * vtkParametricDini_new () ; +extern "C" void vtkParametricDini_destructor (vtkParametricDini * sself) ; +extern "C" void * vtkParametricDini_get_ptr (vtkParametricDini * sself) ; +extern "C" int vtk_parametric_dini_get_dimension(vtkParametricDini* sself); +extern "C" void vtk_parametric_dini_set_a(vtkParametricDini* sself, double _arg); +extern "C" double vtk_parametric_dini_get_a(vtkParametricDini* sself); +extern "C" void vtk_parametric_dini_set_b(vtkParametricDini* sself, double _arg); +extern "C" double vtk_parametric_dini_get_b(vtkParametricDini* sself); +extern "C" vtkParametricEllipsoid * vtkParametricEllipsoid_new () ; +extern "C" void vtkParametricEllipsoid_destructor (vtkParametricEllipsoid * sself) ; +extern "C" void * vtkParametricEllipsoid_get_ptr (vtkParametricEllipsoid * sself) ; +extern "C" int vtk_parametric_ellipsoid_get_dimension(vtkParametricEllipsoid* sself); +extern "C" void vtk_parametric_ellipsoid_set_x_radius(vtkParametricEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_ellipsoid_get_x_radius(vtkParametricEllipsoid* sself); +extern "C" void vtk_parametric_ellipsoid_set_y_radius(vtkParametricEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_ellipsoid_get_y_radius(vtkParametricEllipsoid* sself); +extern "C" void vtk_parametric_ellipsoid_set_z_radius(vtkParametricEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_ellipsoid_get_z_radius(vtkParametricEllipsoid* sself); +extern "C" vtkParametricEnneper * vtkParametricEnneper_new () ; +extern "C" void vtkParametricEnneper_destructor (vtkParametricEnneper * sself) ; +extern "C" void * vtkParametricEnneper_get_ptr (vtkParametricEnneper * sself) ; +extern "C" int vtk_parametric_enneper_get_dimension(vtkParametricEnneper* sself); +extern "C" vtkParametricFigure8Klein * vtkParametricFigure8Klein_new () ; +extern "C" void vtkParametricFigure8Klein_destructor (vtkParametricFigure8Klein * sself) ; +extern "C" void * vtkParametricFigure8Klein_get_ptr (vtkParametricFigure8Klein * sself) ; +extern "C" void vtk_parametric_figure_8_klein_set_radius(vtkParametricFigure8Klein* sself, double _arg); +extern "C" double vtk_parametric_figure_8_klein_get_radius(vtkParametricFigure8Klein* sself); +extern "C" int vtk_parametric_figure_8_klein_get_dimension(vtkParametricFigure8Klein* sself); +extern "C" vtkParametricHenneberg * vtkParametricHenneberg_new () ; +extern "C" void vtkParametricHenneberg_destructor (vtkParametricHenneberg * sself) ; +extern "C" void * vtkParametricHenneberg_get_ptr (vtkParametricHenneberg * sself) ; +extern "C" int vtk_parametric_henneberg_get_dimension(vtkParametricHenneberg* sself); +extern "C" vtkParametricKlein * vtkParametricKlein_new () ; +extern "C" void vtkParametricKlein_destructor (vtkParametricKlein * sself) ; +extern "C" void * vtkParametricKlein_get_ptr (vtkParametricKlein * sself) ; +extern "C" int vtk_parametric_klein_get_dimension(vtkParametricKlein* sself); +extern "C" vtkParametricKuen * vtkParametricKuen_new () ; +extern "C" void vtkParametricKuen_destructor (vtkParametricKuen * sself) ; +extern "C" void * vtkParametricKuen_get_ptr (vtkParametricKuen * sself) ; +extern "C" int vtk_parametric_kuen_get_dimension(vtkParametricKuen* sself); +extern "C" void vtk_parametric_kuen_set_delta_v_0(vtkParametricKuen* sself, double _arg); +extern "C" double vtk_parametric_kuen_get_delta_v_0(vtkParametricKuen* sself); +extern "C" vtkParametricMobius * vtkParametricMobius_new () ; +extern "C" void vtkParametricMobius_destructor (vtkParametricMobius * sself) ; +extern "C" void * vtkParametricMobius_get_ptr (vtkParametricMobius * sself) ; +extern "C" void vtk_parametric_mobius_set_radius(vtkParametricMobius* sself, double _arg); +extern "C" double vtk_parametric_mobius_get_radius(vtkParametricMobius* sself); +extern "C" int vtk_parametric_mobius_get_dimension(vtkParametricMobius* sself); +extern "C" vtkParametricPluckerConoid * vtkParametricPluckerConoid_new () ; +extern "C" void vtkParametricPluckerConoid_destructor (vtkParametricPluckerConoid * sself) ; +extern "C" void * vtkParametricPluckerConoid_get_ptr (vtkParametricPluckerConoid * sself) ; +extern "C" int vtk_parametric_plucker_conoid_get_n(vtkParametricPluckerConoid* sself); +extern "C" void vtk_parametric_plucker_conoid_set_n(vtkParametricPluckerConoid* sself, int _arg); +extern "C" int vtk_parametric_plucker_conoid_get_dimension(vtkParametricPluckerConoid* sself); +extern "C" vtkParametricPseudosphere * vtkParametricPseudosphere_new () ; +extern "C" void vtkParametricPseudosphere_destructor (vtkParametricPseudosphere * sself) ; +extern "C" void * vtkParametricPseudosphere_get_ptr (vtkParametricPseudosphere * sself) ; +extern "C" int vtk_parametric_pseudosphere_get_dimension(vtkParametricPseudosphere* sself); +extern "C" vtkParametricRandomHills * vtkParametricRandomHills_new () ; +extern "C" void vtkParametricRandomHills_destructor (vtkParametricRandomHills * sself) ; +extern "C" void * vtkParametricRandomHills_get_ptr (vtkParametricRandomHills * sself) ; +extern "C" int vtk_parametric_random_hills_get_dimension(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_number_of_hills(vtkParametricRandomHills* sself, int _arg); +extern "C" int vtk_parametric_random_hills_get_number_of_hills(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_hill_x_variance(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_hill_x_variance(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_hill_y_variance(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_hill_y_variance(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_hill_amplitude(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_hill_amplitude(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_random_seed(vtkParametricRandomHills* sself, int _arg); +extern "C" int vtk_parametric_random_hills_get_random_seed(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_allow_random_generation(vtkParametricRandomHills* sself, int _arg); +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_min_value(vtkParametricRandomHills* sself); +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_max_value(vtkParametricRandomHills* sself); +extern "C" int vtk_parametric_random_hills_get_allow_random_generation(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_allow_random_generation_on(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_allow_random_generation_off(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_x_variance_scale_factor(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_x_variance_scale_factor(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_y_variance_scale_factor(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_y_variance_scale_factor(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_amplitude_scale_factor(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_amplitude_scale_factor(vtkParametricRandomHills* sself); +extern "C" vtkParametricRoman * vtkParametricRoman_new () ; +extern "C" void vtkParametricRoman_destructor (vtkParametricRoman * sself) ; +extern "C" void * vtkParametricRoman_get_ptr (vtkParametricRoman * sself) ; +extern "C" int vtk_parametric_roman_get_dimension(vtkParametricRoman* sself); +extern "C" void vtk_parametric_roman_set_radius(vtkParametricRoman* sself, double _arg); +extern "C" double vtk_parametric_roman_get_radius(vtkParametricRoman* sself); +extern "C" vtkParametricSpline * vtkParametricSpline_new () ; +extern "C" void vtkParametricSpline_destructor (vtkParametricSpline * sself) ; +extern "C" void * vtkParametricSpline_get_ptr (vtkParametricSpline * sself) ; +extern "C" int vtk_parametric_spline_get_dimension(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_number_of_points(vtkParametricSpline* sself, long long numPts); +extern "C" void vtk_parametric_spline_set_point(vtkParametricSpline* sself, long long index, double x, double y, double z); +extern "C" void vtk_parametric_spline_set_closed(vtkParametricSpline* sself, int _arg); +extern "C" int vtk_parametric_spline_get_closed(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_closed_on(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_closed_off(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_parameterize_by_length(vtkParametricSpline* sself, int _arg); +extern "C" int vtk_parametric_spline_get_parameterize_by_length(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_parameterize_by_length_on(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_parameterize_by_length_off(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_left_constraint(vtkParametricSpline* sself, int _arg); +extern "C" int vtk_parametric_spline_get_left_constraint_min_value(vtkParametricSpline* sself); +extern "C" int vtk_parametric_spline_get_left_constraint_max_value(vtkParametricSpline* sself); +extern "C" int vtk_parametric_spline_get_left_constraint(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_right_constraint(vtkParametricSpline* sself, int _arg); +extern "C" int vtk_parametric_spline_get_right_constraint_min_value(vtkParametricSpline* sself); +extern "C" int vtk_parametric_spline_get_right_constraint_max_value(vtkParametricSpline* sself); +extern "C" int vtk_parametric_spline_get_right_constraint(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_left_value(vtkParametricSpline* sself, double _arg); +extern "C" double vtk_parametric_spline_get_left_value(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_right_value(vtkParametricSpline* sself, double _arg); +extern "C" double vtk_parametric_spline_get_right_value(vtkParametricSpline* sself); +extern "C" vtkParametricSuperEllipsoid * vtkParametricSuperEllipsoid_new () ; +extern "C" void vtkParametricSuperEllipsoid_destructor (vtkParametricSuperEllipsoid * sself) ; +extern "C" void * vtkParametricSuperEllipsoid_get_ptr (vtkParametricSuperEllipsoid * sself) ; +extern "C" int vtk_parametric_super_ellipsoid_get_dimension(vtkParametricSuperEllipsoid* sself); +extern "C" void vtk_parametric_super_ellipsoid_set_x_radius(vtkParametricSuperEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_x_radius(vtkParametricSuperEllipsoid* sself); +extern "C" void vtk_parametric_super_ellipsoid_set_y_radius(vtkParametricSuperEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_y_radius(vtkParametricSuperEllipsoid* sself); +extern "C" void vtk_parametric_super_ellipsoid_set_z_radius(vtkParametricSuperEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_z_radius(vtkParametricSuperEllipsoid* sself); +extern "C" void vtk_parametric_super_ellipsoid_set_n_1(vtkParametricSuperEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_n_1(vtkParametricSuperEllipsoid* sself); +extern "C" void vtk_parametric_super_ellipsoid_set_n_2(vtkParametricSuperEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_n_2(vtkParametricSuperEllipsoid* sself); +extern "C" vtkParametricSuperToroid * vtkParametricSuperToroid_new () ; +extern "C" void vtkParametricSuperToroid_destructor (vtkParametricSuperToroid * sself) ; +extern "C" void * vtkParametricSuperToroid_get_ptr (vtkParametricSuperToroid * sself) ; +extern "C" int vtk_parametric_super_toroid_get_dimension(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_ring_radius(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_ring_radius(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_cross_section_radius(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_cross_section_radius(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_x_radius(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_x_radius(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_y_radius(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_y_radius(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_z_radius(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_z_radius(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_n_1(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_n_1(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_n_2(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_n_2(vtkParametricSuperToroid* sself); +extern "C" vtkParametricTorus * vtkParametricTorus_new () ; +extern "C" void vtkParametricTorus_destructor (vtkParametricTorus * sself) ; +extern "C" void * vtkParametricTorus_get_ptr (vtkParametricTorus * sself) ; +extern "C" void vtk_parametric_torus_set_ring_radius(vtkParametricTorus* sself, double _arg); +extern "C" double vtk_parametric_torus_get_ring_radius(vtkParametricTorus* sself); +extern "C" void vtk_parametric_torus_set_cross_section_radius(vtkParametricTorus* sself, double _arg); +extern "C" double vtk_parametric_torus_get_cross_section_radius(vtkParametricTorus* sself); +extern "C" int vtk_parametric_torus_get_dimension(vtkParametricTorus* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h index eecd38c..c33c6f6 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h @@ -162,1276 +162,811 @@ #include // Declare exported functions -extern "C" vtkNew < vtkAnimationCue > vtkAnimationCue_new () ; -extern "C" void vtkAnimationCue_destructor (vtkNew < vtkAnimationCue > sself) ; -extern "C" void * vtkAnimationCue_get_ptr (vtkNew < vtkAnimationCue > sself) ; -extern "C" void vtk_animation_cue_set_time_mode(vtkNew sself, int mode); -extern "C" int vtk_animation_cue_get_time_mode(vtkNew sself); -extern "C" void vtk_animation_cue_set_time_mode_to_relative(vtkNew sself); -extern "C" void vtk_animation_cue_set_time_mode_to_normalized(vtkNew sself); -extern "C" void vtk_animation_cue_set_start_time(vtkNew sself, double _arg); -extern "C" double vtk_animation_cue_get_start_time(vtkNew sself); -extern "C" void vtk_animation_cue_set_end_time(vtkNew sself, double _arg); -extern "C" double vtk_animation_cue_get_end_time(vtkNew sself); -extern "C" void vtk_animation_cue_tick(vtkNew sself, double currenttime, double deltatime, double clocktime); -extern "C" void vtk_animation_cue_initialize(vtkNew sself); -extern "C" void vtk_animation_cue_finalize(vtkNew sself); -extern "C" double vtk_animation_cue_get_animation_time(vtkNew sself); -extern "C" double vtk_animation_cue_get_delta_time(vtkNew sself); -extern "C" double vtk_animation_cue_get_clock_time(vtkNew sself); -extern "C" vtkNew < vtkArchiver > vtkArchiver_new () ; -extern "C" void vtkArchiver_destructor (vtkNew < vtkArchiver > sself) ; -extern "C" void * vtkArchiver_get_ptr (vtkNew < vtkArchiver > sself) ; -extern "C" char* vtk_archiver_get_archive_name(vtkNew sself); -extern "C" void vtk_archiver_set_archive_name(vtkNew sself, const char _arg); -extern "C" void vtk_archiver_open_archive(vtkNew sself); -extern "C" void vtk_archiver_close_archive(vtkNew sself); -extern "C" void vtk_archiver_insert_into_archive(vtkNew sself, const char* relativePath, const char data, size_t size); -extern "C" bool vtk_archiver_contains(vtkNew sself, const char* relativePath); -extern "C" vtkNew < vtkBitArray > vtkBitArray_new () ; -extern "C" void vtkBitArray_destructor (vtkNew < vtkBitArray > sself) ; -extern "C" void * vtkBitArray_get_ptr (vtkNew < vtkBitArray > sself) ; -extern "C" int vtk_bit_array_allocate(vtkNew sself, long long sz, long long ext); -extern "C" void vtk_bit_array_initialize(vtkNew sself); -extern "C" int vtk_bit_array_get_data_type(vtkNew sself); -extern "C" int vtk_bit_array_get_data_type_size(vtkNew sself); -extern "C" void vtk_bit_array_set_number_of_tuples(vtkNew sself, long long number); -extern "C" bool vtk_bit_array_set_number_of_values(vtkNew sself, long long number); -extern "C" double* vtk_bit_array_get_tuple(vtkNew sself, long long i); -extern "C" void vtk_bit_array_get_tuple(vtkNew sself, long long i, double tuple); -extern "C" void vtk_bit_array_set_tuple(vtkNew sself, long long i, const float tuple); -extern "C" void vtk_bit_array_set_tuple(vtkNew sself, long long i, const double tuple); -extern "C" void vtk_bit_array_insert_tuple(vtkNew sself, long long i, const float tuple); -extern "C" void vtk_bit_array_insert_tuple(vtkNew sself, long long i, const double tuple); -extern "C" long long vtk_bit_array_insert_next_tuple(vtkNew sself, const float tuple); -extern "C" long long vtk_bit_array_insert_next_tuple(vtkNew sself, const double tuple); -extern "C" void vtk_bit_array_remove_tuple(vtkNew sself, long long id); -extern "C" void vtk_bit_array_set_component(vtkNew sself, long long i, int j, double c); -extern "C" void vtk_bit_array_squeeze(vtkNew sself); -extern "C" int vtk_bit_array_resize(vtkNew sself, long long numTuples); -extern "C" int vtk_bit_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_bit_array_set_value(vtkNew sself, long long id, int value); -extern "C" void vtk_bit_array_insert_value(vtkNew sself, long long id, int i); -extern "C" long long vtk_bit_array_insert_next_value(vtkNew sself, int i); -extern "C" void vtk_bit_array_insert_component(vtkNew sself, long long i, int j, double c); -extern "C" unsigned char* vtk_bit_array_get_pointer(vtkNew sself, long long id); -extern "C" unsigned char* vtk_bit_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" void* vtk_bit_array_write_void_pointer(vtkNew sself, long long id, long long number); -extern "C" void* vtk_bit_array_get_void_pointer(vtkNew sself, long long id); -extern "C" void vtk_bit_array_set_void_array(vtkNew sself, void array, long long size, int save); -extern "C" long long vtk_bit_array_lookup_value(vtkNew sself, int value); -extern "C" void vtk_bit_array_data_changed(vtkNew sself); -extern "C" void vtk_bit_array_clear_lookup(vtkNew sself); -extern "C" vtkNew < vtkBitArrayIterator > vtkBitArrayIterator_new () ; -extern "C" void vtkBitArrayIterator_destructor (vtkNew < vtkBitArrayIterator > sself) ; -extern "C" void * vtkBitArrayIterator_get_ptr (vtkNew < vtkBitArrayIterator > sself) ; -extern "C" int* vtk_bit_array_iterator_get_tuple(vtkNew sself, long long id); -extern "C" int vtk_bit_array_iterator_get_value(vtkNew sself, long long id); -extern "C" long long vtk_bit_array_iterator_get_number_of_tuples(vtkNew sself); -extern "C" long long vtk_bit_array_iterator_get_number_of_values(vtkNew sself); -extern "C" int vtk_bit_array_iterator_get_number_of_components(vtkNew sself); -extern "C" int vtk_bit_array_iterator_get_data_type(vtkNew sself); -extern "C" int vtk_bit_array_iterator_get_data_type_size(vtkNew sself); -extern "C" void vtk_bit_array_iterator_set_value(vtkNew sself, long long id, int value); -extern "C" vtkNew < vtkBoxMuellerRandomSequence > vtkBoxMuellerRandomSequence_new () ; -extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkNew < vtkBoxMuellerRandomSequence > sself) ; -extern "C" void * vtkBoxMuellerRandomSequence_get_ptr (vtkNew < vtkBoxMuellerRandomSequence > sself) ; -extern "C" void vtk_box_mueller_random_sequence_initialize(vtkNew sself, unsigned int seed); -extern "C" double vtk_box_mueller_random_sequence_get_value(vtkNew sself); -extern "C" void vtk_box_mueller_random_sequence_next(vtkNew sself); -extern "C" vtkNew < vtkByteSwap > vtkByteSwap_new () ; -extern "C" void vtkByteSwap_destructor (vtkNew < vtkByteSwap > sself) ; -extern "C" void * vtkByteSwap_get_ptr (vtkNew < vtkByteSwap > sself) ; -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, float p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, float p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, float p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, float p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, double p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, double p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, double p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, double p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, char p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, char p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, char p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, char p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, short p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, short p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, short p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, short p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, int p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, int p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, int p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, int p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, long p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, long p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, long p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, long p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, long long p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, long long p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, long long p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, long long p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, char p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, char p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, char p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, char p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned char p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned char p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned char p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned char p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned short p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned short p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned short p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned short p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned int p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned int p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned int p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned int p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned long p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned long p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned long p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned long p, size_t num); -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned long long p); -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned long long p); -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned long long p, size_t num); -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned long long p, size_t num); -extern "C" void vtk_byte_swap_swap_2_le(vtkNew sself, void p); -extern "C" void vtk_byte_swap_swap_4_le(vtkNew sself, void p); -extern "C" void vtk_byte_swap_swap_8_le(vtkNew sself, void p); -extern "C" void vtk_byte_swap_swap_2_le_range(vtkNew sself, void p, size_t num); -extern "C" void vtk_byte_swap_swap_4_le_range(vtkNew sself, void p, size_t num); -extern "C" void vtk_byte_swap_swap_8_le_range(vtkNew sself, void p, size_t num); -extern "C" void vtk_byte_swap_swap_2_be(vtkNew sself, void p); -extern "C" void vtk_byte_swap_swap_4_be(vtkNew sself, void p); -extern "C" void vtk_byte_swap_swap_8_be(vtkNew sself, void p); -extern "C" void vtk_byte_swap_swap_2_be_range(vtkNew sself, void p, size_t num); -extern "C" void vtk_byte_swap_swap_4_be_range(vtkNew sself, void p, size_t num); -extern "C" void vtk_byte_swap_swap_8_be_range(vtkNew sself, void p, size_t num); -extern "C" void vtk_byte_swap_swap_void_range(vtkNew sself, void buffer, size_t numWords, size_t wordSize); -extern "C" vtkNew < vtkCallbackCommand > vtkCallbackCommand_new () ; -extern "C" void vtkCallbackCommand_destructor (vtkNew < vtkCallbackCommand > sself) ; -extern "C" void * vtkCallbackCommand_get_ptr (vtkNew < vtkCallbackCommand > sself) ; -extern "C" void vtk_callback_command_set_client_data(vtkNew sself, void cd); -extern "C" void* vtk_callback_command_get_client_data(vtkNew sself); -extern "C" void vtk_callback_command_set_abort_flag_on_execute(vtkNew sself, int f); -extern "C" int vtk_callback_command_get_abort_flag_on_execute(vtkNew sself); -extern "C" void vtk_callback_command_abort_flag_on_execute_on(vtkNew sself); -extern "C" void vtk_callback_command_abort_flag_on_execute_off(vtkNew sself); -extern "C" vtkNew < vtkCharArray > vtkCharArray_new () ; -extern "C" void vtkCharArray_destructor (vtkNew < vtkCharArray > sself) ; -extern "C" void * vtkCharArray_get_ptr (vtkNew < vtkCharArray > sself) ; -extern "C" int vtk_char_array_get_data_type(vtkNew sself); -extern "C" void vtk_char_array_get_typed_tuple(vtkNew sself, long long i, char tuple); -extern "C" void vtk_char_array_set_typed_tuple(vtkNew sself, long long i, const char tuple); -extern "C" void vtk_char_array_insert_typed_tuple(vtkNew sself, long long i, const char tuple); -extern "C" long long vtk_char_array_insert_next_typed_tuple(vtkNew sself, const char tuple); -extern "C" char vtk_char_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_char_array_set_value(vtkNew sself, long long id, char value); -extern "C" bool vtk_char_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_char_array_insert_value(vtkNew sself, long long id, char f); -extern "C" long long vtk_char_array_insert_next_value(vtkNew sself, char f); -extern "C" char* vtk_char_array_get_value_range(vtkNew sself, int comp); -extern "C" char* vtk_char_array_get_value_range(vtkNew sself); -extern "C" char* vtk_char_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" char* vtk_char_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_char_array_set_array(vtkNew sself, char array, long long size, int save); -extern "C" void vtk_char_array_set_array(vtkNew sself, char array, long long size, int save, int deleteMethod); -extern "C" char vtk_char_array_get_data_type_value_min(vtkNew sself); -extern "C" char vtk_char_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkCollection > vtkCollection_new () ; -extern "C" void vtkCollection_destructor (vtkNew < vtkCollection > sself) ; -extern "C" void * vtkCollection_get_ptr (vtkNew < vtkCollection > sself) ; -extern "C" void vtk_collection_remove_item(vtkNew sself, int i); -extern "C" void vtk_collection_remove_all_items(vtkNew sself); -extern "C" int vtk_collection_get_number_of_items(vtkNew sself); -extern "C" void vtk_collection_init_traversal(vtkNew sself); -extern "C" void vtk_collection_init_traversal(vtkNew sself, void cookie); -extern "C" vtkNew < vtkCollectionIterator > vtkCollectionIterator_new () ; -extern "C" void vtkCollectionIterator_destructor (vtkNew < vtkCollectionIterator > sself) ; -extern "C" void * vtkCollectionIterator_get_ptr (vtkNew < vtkCollectionIterator > sself) ; -extern "C" void vtk_collection_iterator_init_traversal(vtkNew sself); -extern "C" void vtk_collection_iterator_go_to_first_item(vtkNew sself); -extern "C" void vtk_collection_iterator_go_to_next_item(vtkNew sself); -extern "C" int vtk_collection_iterator_is_done_with_traversal(vtkNew sself); -extern "C" vtkNew < vtkCriticalSection > vtkCriticalSection_new () ; -extern "C" void vtkCriticalSection_destructor (vtkNew < vtkCriticalSection > sself) ; -extern "C" void * vtkCriticalSection_get_ptr (vtkNew < vtkCriticalSection > sself) ; -extern "C" void vtk_critical_section_lock(vtkNew sself); -extern "C" void vtk_critical_section_unlock(vtkNew sself); -extern "C" vtkNew < vtkDataArrayCollection > vtkDataArrayCollection_new () ; -extern "C" void vtkDataArrayCollection_destructor (vtkNew < vtkDataArrayCollection > sself) ; -extern "C" void * vtkDataArrayCollection_get_ptr (vtkNew < vtkDataArrayCollection > sself) ; -extern "C" int vtk_data_array_collection_get_number_of_items(vtkNew sself); -extern "C" vtkNew < vtkDataArrayCollectionIterator > vtkDataArrayCollectionIterator_new () ; -extern "C" void vtkDataArrayCollectionIterator_destructor (vtkNew < vtkDataArrayCollectionIterator > sself) ; -extern "C" void * vtkDataArrayCollectionIterator_get_ptr (vtkNew < vtkDataArrayCollectionIterator > sself) ; -extern "C" vtkNew < vtkDataArraySelection > vtkDataArraySelection_new () ; -extern "C" void vtkDataArraySelection_destructor (vtkNew < vtkDataArraySelection > sself) ; -extern "C" void * vtkDataArraySelection_get_ptr (vtkNew < vtkDataArraySelection > sself) ; -extern "C" void vtk_data_array_selection_enable_array(vtkNew sself, const char name); -extern "C" void vtk_data_array_selection_disable_array(vtkNew sself, const char name); -extern "C" int vtk_data_array_selection_array_is_enabled(vtkNew sself, const char name); -extern "C" int vtk_data_array_selection_array_exists(vtkNew sself, const char name); -extern "C" void vtk_data_array_selection_enable_all_arrays(vtkNew sself); -extern "C" void vtk_data_array_selection_disable_all_arrays(vtkNew sself); -extern "C" int vtk_data_array_selection_get_number_of_arrays(vtkNew sself); -extern "C" int vtk_data_array_selection_get_number_of_arrays_enabled(vtkNew sself); -extern "C" const char* vtk_data_array_selection_get_array_name(vtkNew sself, int index); -extern "C" int vtk_data_array_selection_get_array_index(vtkNew sself, const char name); -extern "C" int vtk_data_array_selection_get_enabled_array_index(vtkNew sself, const char name); -extern "C" int vtk_data_array_selection_get_array_setting(vtkNew sself, int index); -extern "C" int vtk_data_array_selection_get_array_setting(vtkNew sself, const char name); -extern "C" void vtk_data_array_selection_set_array_setting(vtkNew sself, const char name, int setting); -extern "C" void vtk_data_array_selection_remove_all_arrays(vtkNew sself); -extern "C" int vtk_data_array_selection_add_array(vtkNew sself, const char name, bool state); -extern "C" void vtk_data_array_selection_remove_array_by_index(vtkNew sself, int index); -extern "C" void vtk_data_array_selection_remove_array_by_name(vtkNew sself, const char name); -extern "C" void vtk_data_array_selection_set_arrays(vtkNew sself, const char names, int numArrays); -extern "C" void vtk_data_array_selection_set_arrays_with_default(vtkNew sself, const char names, int numArrays, int defaultStatus); -extern "C" void vtk_data_array_selection_set_unknown_array_setting(vtkNew sself, int _arg); -extern "C" int vtk_data_array_selection_get_unknown_array_setting(vtkNew sself); -extern "C" vtkNew < vtkDebugLeaks > vtkDebugLeaks_new () ; -extern "C" void vtkDebugLeaks_destructor (vtkNew < vtkDebugLeaks > sself) ; -extern "C" void * vtkDebugLeaks_get_ptr (vtkNew < vtkDebugLeaks > sself) ; -extern "C" void vtk_debug_leaks_construct_class(vtkNew sself, const char className); -extern "C" void vtk_debug_leaks_destruct_class(vtkNew sself, const char className); -extern "C" int vtk_debug_leaks_print_current_leaks(vtkNew sself); -extern "C" int vtk_debug_leaks_get_exit_error(vtkNew sself); -extern "C" void vtk_debug_leaks_set_exit_error(vtkNew sself, int p0); -extern "C" vtkNew < vtkDoubleArray > vtkDoubleArray_new () ; -extern "C" void vtkDoubleArray_destructor (vtkNew < vtkDoubleArray > sself) ; -extern "C" void * vtkDoubleArray_get_ptr (vtkNew < vtkDoubleArray > sself) ; -extern "C" int vtk_double_array_get_data_type(vtkNew sself); -extern "C" void vtk_double_array_get_typed_tuple(vtkNew sself, long long i, double tuple); -extern "C" void vtk_double_array_set_typed_tuple(vtkNew sself, long long i, const double tuple); -extern "C" void vtk_double_array_insert_typed_tuple(vtkNew sself, long long i, const double tuple); -extern "C" long long vtk_double_array_insert_next_typed_tuple(vtkNew sself, const double tuple); -extern "C" double vtk_double_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_double_array_set_value(vtkNew sself, long long id, double value); -extern "C" bool vtk_double_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_double_array_insert_value(vtkNew sself, long long id, double f); -extern "C" long long vtk_double_array_insert_next_value(vtkNew sself, double f); -extern "C" double* vtk_double_array_get_value_range(vtkNew sself, int comp); -extern "C" double* vtk_double_array_get_value_range(vtkNew sself); -extern "C" double* vtk_double_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" double* vtk_double_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_double_array_set_array(vtkNew sself, double array, long long size, int save); -extern "C" void vtk_double_array_set_array(vtkNew sself, double array, long long size, int save, int deleteMethod); -extern "C" double vtk_double_array_get_data_type_value_min(vtkNew sself); -extern "C" double vtk_double_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkDynamicLoader > vtkDynamicLoader_new () ; -extern "C" void vtkDynamicLoader_destructor (vtkNew < vtkDynamicLoader > sself) ; -extern "C" void * vtkDynamicLoader_get_ptr (vtkNew < vtkDynamicLoader > sself) ; -extern "C" const char* vtk_dynamic_loader_lib_prefix(vtkNew sself); -extern "C" const char* vtk_dynamic_loader_lib_extension(vtkNew sself); -extern "C" const char* vtk_dynamic_loader_last_error(vtkNew sself); -extern "C" vtkNew < vtkEventDataDevice3D > vtkEventDataDevice3D_new () ; -extern "C" void vtkEventDataDevice3D_destructor (vtkNew < vtkEventDataDevice3D > sself) ; -extern "C" void * vtkEventDataDevice3D_get_ptr (vtkNew < vtkEventDataDevice3D > sself) ; -extern "C" void vtk_event_data_device_3_d_get_world_position(vtkNew sself, double v); -extern "C" const double* vtk_event_data_device_3_d_get_world_position(vtkNew sself); -extern "C" void vtk_event_data_device_3_d_set_world_position(vtkNew sself, const double p); -extern "C" void vtk_event_data_device_3_d_get_world_direction(vtkNew sself, double v); -extern "C" const double* vtk_event_data_device_3_d_get_world_direction(vtkNew sself); -extern "C" void vtk_event_data_device_3_d_set_world_direction(vtkNew sself, const double p); -extern "C" void vtk_event_data_device_3_d_get_world_orientation(vtkNew sself, double v); -extern "C" const double* vtk_event_data_device_3_d_get_world_orientation(vtkNew sself); -extern "C" void vtk_event_data_device_3_d_set_world_orientation(vtkNew sself, const double p); -extern "C" void vtk_event_data_device_3_d_get_track_pad_position(vtkNew sself, double v); -extern "C" const double* vtk_event_data_device_3_d_get_track_pad_position(vtkNew sself); -extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkNew sself, const double p); -extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkNew sself, double x, double y); -extern "C" vtkNew < vtkEventDataForDevice > vtkEventDataForDevice_new () ; -extern "C" void vtkEventDataForDevice_destructor (vtkNew < vtkEventDataForDevice > sself) ; -extern "C" void * vtkEventDataForDevice_get_ptr (vtkNew < vtkEventDataForDevice > sself) ; -extern "C" vtkNew < vtkEventForwarderCommand > vtkEventForwarderCommand_new () ; -extern "C" void vtkEventForwarderCommand_destructor (vtkNew < vtkEventForwarderCommand > sself) ; -extern "C" void * vtkEventForwarderCommand_get_ptr (vtkNew < vtkEventForwarderCommand > sself) ; -extern "C" void* vtk_event_forwarder_command_get_target(vtkNew sself); -extern "C" vtkNew < vtkFileOutputWindow > vtkFileOutputWindow_new () ; -extern "C" void vtkFileOutputWindow_destructor (vtkNew < vtkFileOutputWindow > sself) ; -extern "C" void * vtkFileOutputWindow_get_ptr (vtkNew < vtkFileOutputWindow > sself) ; -extern "C" void vtk_file_output_window_display_text(vtkNew sself, const char p0); -extern "C" void vtk_file_output_window_set_file_name(vtkNew sself, const char _arg); -extern "C" char* vtk_file_output_window_get_file_name(vtkNew sself); -extern "C" void vtk_file_output_window_set_flush(vtkNew sself, int _arg); -extern "C" int vtk_file_output_window_get_flush(vtkNew sself); -extern "C" void vtk_file_output_window_flush_on(vtkNew sself); -extern "C" void vtk_file_output_window_flush_off(vtkNew sself); -extern "C" void vtk_file_output_window_set_append(vtkNew sself, int _arg); -extern "C" int vtk_file_output_window_get_append(vtkNew sself); -extern "C" void vtk_file_output_window_append_on(vtkNew sself); -extern "C" void vtk_file_output_window_append_off(vtkNew sself); -extern "C" vtkNew < vtkFloatArray > vtkFloatArray_new () ; -extern "C" void vtkFloatArray_destructor (vtkNew < vtkFloatArray > sself) ; -extern "C" void * vtkFloatArray_get_ptr (vtkNew < vtkFloatArray > sself) ; -extern "C" int vtk_float_array_get_data_type(vtkNew sself); -extern "C" void vtk_float_array_get_typed_tuple(vtkNew sself, long long i, float tuple); -extern "C" void vtk_float_array_set_typed_tuple(vtkNew sself, long long i, const float tuple); -extern "C" void vtk_float_array_insert_typed_tuple(vtkNew sself, long long i, const float tuple); -extern "C" long long vtk_float_array_insert_next_typed_tuple(vtkNew sself, const float tuple); -extern "C" float vtk_float_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_float_array_set_value(vtkNew sself, long long id, float value); -extern "C" bool vtk_float_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_float_array_insert_value(vtkNew sself, long long id, float f); -extern "C" long long vtk_float_array_insert_next_value(vtkNew sself, float f); -extern "C" float* vtk_float_array_get_value_range(vtkNew sself, int comp); -extern "C" float* vtk_float_array_get_value_range(vtkNew sself); -extern "C" float* vtk_float_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" float* vtk_float_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_float_array_set_array(vtkNew sself, float array, long long size, int save); -extern "C" void vtk_float_array_set_array(vtkNew sself, float array, long long size, int save, int deleteMethod); -extern "C" float vtk_float_array_get_data_type_value_min(vtkNew sself); -extern "C" float vtk_float_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkGarbageCollector > vtkGarbageCollector_new () ; -extern "C" void vtkGarbageCollector_destructor (vtkNew < vtkGarbageCollector > sself) ; -extern "C" void * vtkGarbageCollector_get_ptr (vtkNew < vtkGarbageCollector > sself) ; -extern "C" void vtk_garbage_collector_collect(vtkNew sself); -extern "C" void vtk_garbage_collector_deferred_collection_push(vtkNew sself); -extern "C" void vtk_garbage_collector_deferred_collection_pop(vtkNew sself); -extern "C" void vtk_garbage_collector_set_global_debug_flag(vtkNew sself, bool flag); -extern "C" bool vtk_garbage_collector_get_global_debug_flag(vtkNew sself); -extern "C" vtkNew < vtkIdList > vtkIdList_new () ; -extern "C" void vtkIdList_destructor (vtkNew < vtkIdList > sself) ; -extern "C" void * vtkIdList_get_ptr (vtkNew < vtkIdList > sself) ; -extern "C" void vtk_id_list_initialize(vtkNew sself); -extern "C" int vtk_id_list_allocate(vtkNew sself, const long long sz, const int strategy); -extern "C" long long vtk_id_list_get_number_of_ids(vtkNew sself); -extern "C" long long vtk_id_list_get_id(vtkNew sself, const long long i); -extern "C" long long vtk_id_list_find_id_location(vtkNew sself, const long long id); -extern "C" void vtk_id_list_set_number_of_ids(vtkNew sself, const long long number); -extern "C" void vtk_id_list_set_id(vtkNew sself, const long long i, const long long vtkid); -extern "C" void vtk_id_list_insert_id(vtkNew sself, const long long i, const long long vtkid); -extern "C" long long vtk_id_list_insert_next_id(vtkNew sself, const long long vtkid); -extern "C" long long vtk_id_list_insert_unique_id(vtkNew sself, const long long vtkid); -extern "C" void vtk_id_list_sort(vtkNew sself); -extern "C" void vtk_id_list_fill(vtkNew sself, long long value); -extern "C" long long* vtk_id_list_get_pointer(vtkNew sself, const long long i); -extern "C" long long* vtk_id_list_write_pointer(vtkNew sself, const long long i, const long long number); -extern "C" void vtk_id_list_set_array(vtkNew sself, long long array, long long size); -extern "C" void vtk_id_list_reset(vtkNew sself); -extern "C" void vtk_id_list_squeeze(vtkNew sself); -extern "C" void vtk_id_list_delete_id(vtkNew sself, long long vtkid); -extern "C" long long vtk_id_list_is_id(vtkNew sself, long long vtkid); -extern "C" long long* vtk_id_list_resize(vtkNew sself, const long long sz); -extern "C" long long* vtk_id_list_begin(vtkNew sself); -extern "C" long long* vtk_id_list_end(vtkNew sself); -extern "C" const long long* vtk_id_list_begin(vtkNew sself); -extern "C" const long long* vtk_id_list_end(vtkNew sself); -extern "C" vtkNew < vtkIdListCollection > vtkIdListCollection_new () ; -extern "C" void vtkIdListCollection_destructor (vtkNew < vtkIdListCollection > sself) ; -extern "C" void * vtkIdListCollection_get_ptr (vtkNew < vtkIdListCollection > sself) ; -extern "C" int vtk_id_list_collection_get_number_of_items(vtkNew sself); -extern "C" vtkNew < vtkIdTypeArray > vtkIdTypeArray_new () ; -extern "C" void vtkIdTypeArray_destructor (vtkNew < vtkIdTypeArray > sself) ; -extern "C" void * vtkIdTypeArray_get_ptr (vtkNew < vtkIdTypeArray > sself) ; -extern "C" int vtk_id_type_array_get_data_type(vtkNew sself); -extern "C" void vtk_id_type_array_get_typed_tuple(vtkNew sself, long long i, long long tuple); -extern "C" void vtk_id_type_array_set_typed_tuple(vtkNew sself, long long i, const long long tuple); -extern "C" void vtk_id_type_array_insert_typed_tuple(vtkNew sself, long long i, const long long tuple); -extern "C" long long vtk_id_type_array_insert_next_typed_tuple(vtkNew sself, const long long tuple); -extern "C" long long vtk_id_type_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_id_type_array_set_value(vtkNew sself, long long id, long long value); -extern "C" bool vtk_id_type_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_id_type_array_insert_value(vtkNew sself, long long id, long long f); -extern "C" long long vtk_id_type_array_insert_next_value(vtkNew sself, long long f); -extern "C" long long* vtk_id_type_array_get_value_range(vtkNew sself, int comp); -extern "C" long long* vtk_id_type_array_get_value_range(vtkNew sself); -extern "C" long long* vtk_id_type_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" long long* vtk_id_type_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_id_type_array_set_array(vtkNew sself, long long array, long long size, int save); -extern "C" void vtk_id_type_array_set_array(vtkNew sself, long long array, long long size, int save, int deleteMethod); -extern "C" long long vtk_id_type_array_get_data_type_value_min(vtkNew sself); -extern "C" long long vtk_id_type_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkInformation > vtkInformation_new () ; -extern "C" void vtkInformation_destructor (vtkNew < vtkInformation > sself) ; -extern "C" void * vtkInformation_get_ptr (vtkNew < vtkInformation > sself) ; -extern "C" void vtk_information_modified(vtkNew sself); -extern "C" void vtk_information_clear(vtkNew sself); -extern "C" int vtk_information_get_number_of_keys(vtkNew sself); -extern "C" vtkNew < vtkInformationIterator > vtkInformationIterator_new () ; -extern "C" void vtkInformationIterator_destructor (vtkNew < vtkInformationIterator > sself) ; -extern "C" void * vtkInformationIterator_get_ptr (vtkNew < vtkInformationIterator > sself) ; -extern "C" void vtk_information_iterator_init_traversal(vtkNew sself); -extern "C" void vtk_information_iterator_go_to_first_item(vtkNew sself); -extern "C" void vtk_information_iterator_go_to_next_item(vtkNew sself); -extern "C" int vtk_information_iterator_is_done_with_traversal(vtkNew sself); -extern "C" vtkNew < vtkInformationKeyLookup > vtkInformationKeyLookup_new () ; -extern "C" void vtkInformationKeyLookup_destructor (vtkNew < vtkInformationKeyLookup > sself) ; -extern "C" void * vtkInformationKeyLookup_get_ptr (vtkNew < vtkInformationKeyLookup > sself) ; -extern "C" vtkNew < vtkInformationVector > vtkInformationVector_new () ; -extern "C" void vtkInformationVector_destructor (vtkNew < vtkInformationVector > sself) ; -extern "C" void * vtkInformationVector_get_ptr (vtkNew < vtkInformationVector > sself) ; -extern "C" int vtk_information_vector_get_number_of_information_objects(vtkNew sself); -extern "C" void vtk_information_vector_set_number_of_information_objects(vtkNew sself, int n); -extern "C" void vtk_information_vector_remove(vtkNew sself, int idx); -extern "C" vtkNew < vtkIntArray > vtkIntArray_new () ; -extern "C" void vtkIntArray_destructor (vtkNew < vtkIntArray > sself) ; -extern "C" void * vtkIntArray_get_ptr (vtkNew < vtkIntArray > sself) ; -extern "C" int vtk_int_array_get_data_type(vtkNew sself); -extern "C" void vtk_int_array_get_typed_tuple(vtkNew sself, long long i, int tuple); -extern "C" void vtk_int_array_set_typed_tuple(vtkNew sself, long long i, const int tuple); -extern "C" void vtk_int_array_insert_typed_tuple(vtkNew sself, long long i, const int tuple); -extern "C" long long vtk_int_array_insert_next_typed_tuple(vtkNew sself, const int tuple); -extern "C" int vtk_int_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_int_array_set_value(vtkNew sself, long long id, int value); -extern "C" bool vtk_int_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_int_array_insert_value(vtkNew sself, long long id, int f); -extern "C" long long vtk_int_array_insert_next_value(vtkNew sself, int f); -extern "C" int* vtk_int_array_get_value_range(vtkNew sself, int comp); -extern "C" int* vtk_int_array_get_value_range(vtkNew sself); -extern "C" int* vtk_int_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" int* vtk_int_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_int_array_set_array(vtkNew sself, int array, long long size, int save); -extern "C" void vtk_int_array_set_array(vtkNew sself, int array, long long size, int save, int deleteMethod); -extern "C" int vtk_int_array_get_data_type_value_min(vtkNew sself); -extern "C" int vtk_int_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkLongArray > vtkLongArray_new () ; -extern "C" void vtkLongArray_destructor (vtkNew < vtkLongArray > sself) ; -extern "C" void * vtkLongArray_get_ptr (vtkNew < vtkLongArray > sself) ; -extern "C" int vtk_long_array_get_data_type(vtkNew sself); -extern "C" void vtk_long_array_get_typed_tuple(vtkNew sself, long long i, long tuple); -extern "C" void vtk_long_array_set_typed_tuple(vtkNew sself, long long i, const long tuple); -extern "C" void vtk_long_array_insert_typed_tuple(vtkNew sself, long long i, const long tuple); -extern "C" long long vtk_long_array_insert_next_typed_tuple(vtkNew sself, const long tuple); -extern "C" long vtk_long_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_long_array_set_value(vtkNew sself, long long id, long value); -extern "C" bool vtk_long_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_long_array_insert_value(vtkNew sself, long long id, long f); -extern "C" long long vtk_long_array_insert_next_value(vtkNew sself, long f); -extern "C" long* vtk_long_array_get_value_range(vtkNew sself, int comp); -extern "C" long* vtk_long_array_get_value_range(vtkNew sself); -extern "C" long* vtk_long_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" long* vtk_long_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_long_array_set_array(vtkNew sself, long array, long long size, int save); -extern "C" void vtk_long_array_set_array(vtkNew sself, long array, long long size, int save, int deleteMethod); -extern "C" long vtk_long_array_get_data_type_value_min(vtkNew sself); -extern "C" long vtk_long_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkLongLongArray > vtkLongLongArray_new () ; -extern "C" void vtkLongLongArray_destructor (vtkNew < vtkLongLongArray > sself) ; -extern "C" void * vtkLongLongArray_get_ptr (vtkNew < vtkLongLongArray > sself) ; -extern "C" int vtk_long_long_array_get_data_type(vtkNew sself); -extern "C" void vtk_long_long_array_get_typed_tuple(vtkNew sself, long long i, long long tuple); -extern "C" void vtk_long_long_array_set_typed_tuple(vtkNew sself, long long i, const long long tuple); -extern "C" void vtk_long_long_array_insert_typed_tuple(vtkNew sself, long long i, const long long tuple); -extern "C" long long vtk_long_long_array_insert_next_typed_tuple(vtkNew sself, const long long tuple); -extern "C" long long vtk_long_long_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_long_long_array_set_value(vtkNew sself, long long id, long long value); -extern "C" bool vtk_long_long_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_long_long_array_insert_value(vtkNew sself, long long id, long long f); -extern "C" long long vtk_long_long_array_insert_next_value(vtkNew sself, long long f); -extern "C" long long* vtk_long_long_array_get_value_range(vtkNew sself, int comp); -extern "C" long long* vtk_long_long_array_get_value_range(vtkNew sself); -extern "C" long long* vtk_long_long_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" long long* vtk_long_long_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_long_long_array_set_array(vtkNew sself, long long array, long long size, int save); -extern "C" void vtk_long_long_array_set_array(vtkNew sself, long long array, long long size, int save, int deleteMethod); -extern "C" long long vtk_long_long_array_get_data_type_value_min(vtkNew sself); -extern "C" long long vtk_long_long_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkLookupTable > vtkLookupTable_new () ; -extern "C" void vtkLookupTable_destructor (vtkNew < vtkLookupTable > sself) ; -extern "C" void * vtkLookupTable_get_ptr (vtkNew < vtkLookupTable > sself) ; -extern "C" int vtk_lookup_table_is_opaque(vtkNew sself); -extern "C" int vtk_lookup_table_allocate(vtkNew sself, int sz, int ext); -extern "C" void vtk_lookup_table_build(vtkNew sself); -extern "C" void vtk_lookup_table_force_build(vtkNew sself); -extern "C" void vtk_lookup_table_build_special_colors(vtkNew sself); -extern "C" void vtk_lookup_table_set_ramp(vtkNew sself, int _arg); -extern "C" void vtk_lookup_table_set_ramp_to_linear(vtkNew sself); -extern "C" void vtk_lookup_table_set_ramp_to_s_curve(vtkNew sself); -extern "C" void vtk_lookup_table_set_ramp_to_sqrt(vtkNew sself); -extern "C" int vtk_lookup_table_get_ramp(vtkNew sself); -extern "C" void vtk_lookup_table_set_scale(vtkNew sself, int scale); -extern "C" void vtk_lookup_table_set_scale_to_linear(vtkNew sself); -extern "C" void vtk_lookup_table_set_scale_to_log_10(vtkNew sself); -extern "C" int vtk_lookup_table_get_scale(vtkNew sself); -extern "C" void vtk_lookup_table_set_table_range(vtkNew sself, const double r); -extern "C" void vtk_lookup_table_set_table_range(vtkNew sself, double min, double max); -extern "C" double* vtk_lookup_table_get_table_range(vtkNew sself); -extern "C" void vtk_lookup_table_get_table_range(vtkNew sself, double data); -extern "C" void vtk_lookup_table_set_hue_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_lookup_table_set_hue_range(vtkNew sself, const double _arg); -extern "C" double* vtk_lookup_table_get_hue_range(vtkNew sself); -extern "C" void vtk_lookup_table_get_hue_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_lookup_table_get_hue_range(vtkNew sself, double _arg); -extern "C" void vtk_lookup_table_set_saturation_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_lookup_table_set_saturation_range(vtkNew sself, const double _arg); -extern "C" double* vtk_lookup_table_get_saturation_range(vtkNew sself); -extern "C" void vtk_lookup_table_get_saturation_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_lookup_table_get_saturation_range(vtkNew sself, double _arg); -extern "C" void vtk_lookup_table_set_value_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_lookup_table_set_value_range(vtkNew sself, const double _arg); -extern "C" double* vtk_lookup_table_get_value_range(vtkNew sself); -extern "C" void vtk_lookup_table_get_value_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_lookup_table_get_value_range(vtkNew sself, double _arg); -extern "C" void vtk_lookup_table_set_alpha_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_lookup_table_set_alpha_range(vtkNew sself, const double _arg); -extern "C" double* vtk_lookup_table_get_alpha_range(vtkNew sself); -extern "C" void vtk_lookup_table_get_alpha_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_lookup_table_get_alpha_range(vtkNew sself, double _arg); -extern "C" void vtk_lookup_table_set_nan_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); -extern "C" void vtk_lookup_table_set_nan_color(vtkNew sself, const double _arg); -extern "C" double* vtk_lookup_table_get_nan_color(vtkNew sself); -extern "C" void vtk_lookup_table_get_nan_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); -extern "C" void vtk_lookup_table_get_nan_color(vtkNew sself, double _arg); -extern "C" unsigned char* vtk_lookup_table_get_nan_color_as_unsigned_chars(vtkNew sself); -extern "C" void vtk_lookup_table_get_color_as_unsigned_chars(vtkNew sself, const double colorIn, unsigned char colorOut); -extern "C" void vtk_lookup_table_set_below_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); -extern "C" void vtk_lookup_table_set_below_range_color(vtkNew sself, const double _arg); -extern "C" double* vtk_lookup_table_get_below_range_color(vtkNew sself); -extern "C" void vtk_lookup_table_get_below_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); -extern "C" void vtk_lookup_table_get_below_range_color(vtkNew sself, double _arg); -extern "C" void vtk_lookup_table_set_use_below_range_color(vtkNew sself, int _arg); -extern "C" int vtk_lookup_table_get_use_below_range_color(vtkNew sself); -extern "C" void vtk_lookup_table_use_below_range_color_on(vtkNew sself); -extern "C" void vtk_lookup_table_use_below_range_color_off(vtkNew sself); -extern "C" void vtk_lookup_table_set_above_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); -extern "C" void vtk_lookup_table_set_above_range_color(vtkNew sself, const double _arg); -extern "C" double* vtk_lookup_table_get_above_range_color(vtkNew sself); -extern "C" void vtk_lookup_table_get_above_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4); -extern "C" void vtk_lookup_table_get_above_range_color(vtkNew sself, double _arg); -extern "C" void vtk_lookup_table_set_use_above_range_color(vtkNew sself, int _arg); -extern "C" int vtk_lookup_table_get_use_above_range_color(vtkNew sself); -extern "C" void vtk_lookup_table_use_above_range_color_on(vtkNew sself); -extern "C" void vtk_lookup_table_use_above_range_color_off(vtkNew sself); -extern "C" const unsigned char* vtk_lookup_table_map_value(vtkNew sself, double v); -extern "C" void vtk_lookup_table_get_color(vtkNew sself, double v, double rgb); -extern "C" double vtk_lookup_table_get_opacity(vtkNew sself, double v); -extern "C" long long vtk_lookup_table_get_index(vtkNew sself, double v); -extern "C" void vtk_lookup_table_set_number_of_table_values(vtkNew sself, long long number); -extern "C" long long vtk_lookup_table_get_number_of_table_values(vtkNew sself); -extern "C" void vtk_lookup_table_set_table_value(vtkNew sself, long long indx, const double rgba); -extern "C" void vtk_lookup_table_set_table_value(vtkNew sself, long long indx, double r, double g, double b, double a); -extern "C" double* vtk_lookup_table_get_table_value(vtkNew sself, long long indx); -extern "C" void vtk_lookup_table_get_table_value(vtkNew sself, long long indx, double rgba); -extern "C" unsigned char* vtk_lookup_table_get_pointer(vtkNew sself, long long id); -extern "C" unsigned char* vtk_lookup_table_write_pointer(vtkNew sself, long long id, int number); -extern "C" double* vtk_lookup_table_get_range(vtkNew sself); -extern "C" void vtk_lookup_table_get_log_range(vtkNew sself, const double range, double log_range); -extern "C" double vtk_lookup_table_apply_log_scale(vtkNew sself, double v, const double range, const double log_range); -extern "C" void vtk_lookup_table_set_number_of_colors(vtkNew sself, long long _arg); -extern "C" long long vtk_lookup_table_get_number_of_colors_min_value(vtkNew sself); -extern "C" long long vtk_lookup_table_get_number_of_colors_max_value(vtkNew sself); -extern "C" long long vtk_lookup_table_get_number_of_colors(vtkNew sself); -extern "C" void vtk_lookup_table_map_scalars_through_table_2(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat); -extern "C" int vtk_lookup_table_using_log_scale(vtkNew sself); -extern "C" void vtk_lookup_table_get_indexed_color(vtkNew sself, long long idx, double rgba); -extern "C" vtkNew < vtkMath > vtkMath_new () ; -extern "C" void vtkMath_destructor (vtkNew < vtkMath > sself) ; -extern "C" void * vtkMath_get_ptr (vtkNew < vtkMath > sself) ; -extern "C" double vtk_math_pi(vtkNew sself); -extern "C" float vtk_math_radians_from_degrees(vtkNew sself, float degrees); -extern "C" double vtk_math_radians_from_degrees(vtkNew sself, double degrees); -extern "C" float vtk_math_degrees_from_radians(vtkNew sself, float radians); -extern "C" double vtk_math_degrees_from_radians(vtkNew sself, double radians); -extern "C" int vtk_math_round(vtkNew sself, float f); -extern "C" int vtk_math_round(vtkNew sself, double f); -extern "C" int vtk_math_floor(vtkNew sself, double x); -extern "C" int vtk_math_ceil(vtkNew sself, double x); -extern "C" int vtk_math_ceil_log_2(vtkNew sself, unsigned long long x); -extern "C" bool vtk_math_is_power_of_two(vtkNew sself, unsigned long long x); -extern "C" int vtk_math_nearest_power_of_two(vtkNew sself, int x); -extern "C" long long vtk_math_factorial(vtkNew sself, int N); -extern "C" long long vtk_math_binomial(vtkNew sself, int m, int n); -extern "C" int* vtk_math_begin_combination(vtkNew sself, int m, int n); -extern "C" int vtk_math_next_combination(vtkNew sself, int m, int n, int combination); -extern "C" void vtk_math_free_combination(vtkNew sself, int combination); -extern "C" void vtk_math_random_seed(vtkNew sself, int s); -extern "C" int vtk_math_get_seed(vtkNew sself); -extern "C" double vtk_math_random(vtkNew sself); -extern "C" double vtk_math_random(vtkNew sself, double min, double max); -extern "C" double vtk_math_gaussian(vtkNew sself); -extern "C" double vtk_math_gaussian(vtkNew sself, double mean, double std); -extern "C" void vtk_math_assign(vtkNew sself, const double a, double b); -extern "C" void vtk_math_add(vtkNew sself, const float a, const float b, float c); -extern "C" void vtk_math_add(vtkNew sself, const double a, const double b, double c); -extern "C" void vtk_math_subtract(vtkNew sself, const float a, const float b, float c); -extern "C" void vtk_math_subtract(vtkNew sself, const double a, const double b, double c); -extern "C" void vtk_math_multiply_scalar(vtkNew sself, float a, float s); -extern "C" void vtk_math_multiply_scalar_2_d(vtkNew sself, float a, float s); -extern "C" void vtk_math_multiply_scalar(vtkNew sself, double a, double s); -extern "C" void vtk_math_multiply_scalar_2_d(vtkNew sself, double a, double s); -extern "C" float vtk_math_dot(vtkNew sself, const float a, const float b); -extern "C" double vtk_math_dot(vtkNew sself, const double a, const double b); -extern "C" void vtk_math_outer(vtkNew sself, const float a, const float b, float c); -extern "C" void vtk_math_outer(vtkNew sself, const double a, const double b, double c); -extern "C" void vtk_math_cross(vtkNew sself, const float a, const float b, float c); -extern "C" void vtk_math_cross(vtkNew sself, const double a, const double b, double c); -extern "C" float vtk_math_norm(vtkNew sself, const float x, int n); -extern "C" double vtk_math_norm(vtkNew sself, const double x, int n); -extern "C" float vtk_math_norm(vtkNew sself, const float v); -extern "C" double vtk_math_norm(vtkNew sself, const double v); -extern "C" float vtk_math_normalize(vtkNew sself, float v); -extern "C" double vtk_math_normalize(vtkNew sself, double v); -extern "C" void vtk_math_perpendiculars(vtkNew sself, const double v1, double v2, double v3, double theta); -extern "C" void vtk_math_perpendiculars(vtkNew sself, const float v1, float v2, float v3, double theta); -extern "C" bool vtk_math_project_vector(vtkNew sself, const float a, const float b, float projection); -extern "C" bool vtk_math_project_vector(vtkNew sself, const double a, const double b, double projection); -extern "C" bool vtk_math_project_vector_2_d(vtkNew sself, const float a, const float b, float projection); -extern "C" bool vtk_math_project_vector_2_d(vtkNew sself, const double a, const double b, double projection); -extern "C" float vtk_math_distance_2_between_points(vtkNew sself, const float p1, const float p2); -extern "C" double vtk_math_distance_2_between_points(vtkNew sself, const double p1, const double p2); -extern "C" double vtk_math_angle_between_vectors(vtkNew sself, const double v1, const double v2); -extern "C" double vtk_math_signed_angle_between_vectors(vtkNew sself, const double v1, const double v2, const double vn); -extern "C" double vtk_math_gaussian_amplitude(vtkNew sself, const double variance, const double distanceFromMean); -extern "C" double vtk_math_gaussian_amplitude(vtkNew sself, const double mean, const double variance, const double position); -extern "C" double vtk_math_gaussian_weight(vtkNew sself, const double variance, const double distanceFromMean); -extern "C" double vtk_math_gaussian_weight(vtkNew sself, const double mean, const double variance, const double position); -extern "C" float vtk_math_dot_2_d(vtkNew sself, const float x, const float y); -extern "C" double vtk_math_dot_2_d(vtkNew sself, const double x, const double y); -extern "C" void vtk_math_outer_2_d(vtkNew sself, const float x, const float y, float A); -extern "C" void vtk_math_outer_2_d(vtkNew sself, const double x, const double y, double A); -extern "C" float vtk_math_norm_2_d(vtkNew sself, const float x); -extern "C" double vtk_math_norm_2_d(vtkNew sself, const double x); -extern "C" float vtk_math_normalize_2_d(vtkNew sself, float v); -extern "C" double vtk_math_normalize_2_d(vtkNew sself, double v); -extern "C" float vtk_math_determinant_2_x_2(vtkNew sself, const float c1, const float c2); -extern "C" double vtk_math_determinant_2_x_2(vtkNew sself, double a, double b, double c, double d); -extern "C" double vtk_math_determinant_2_x_2(vtkNew sself, const double c1, const double c2); -extern "C" void vtk_math_lu_factor_3_x_3(vtkNew sself, float A, int index); -extern "C" void vtk_math_lu_factor_3_x_3(vtkNew sself, double A, int index); -extern "C" void vtk_math_lu_solve_3_x_3(vtkNew sself, const float A, const int index, float x); -extern "C" void vtk_math_lu_solve_3_x_3(vtkNew sself, const double A, const int index, double x); -extern "C" void vtk_math_linear_solve_3_x_3(vtkNew sself, const float A, const float x, float y); -extern "C" void vtk_math_linear_solve_3_x_3(vtkNew sself, const double A, const double x, double y); -extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const float A, const float v, float u); -extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const double A, const double v, double u); -extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const float A, const float B, float C); -extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const double A, const double B, double C); -extern "C" void vtk_math_multiply_matrix(vtkNew sself, const double A, const double B, unsigned int rowA, unsigned int colA, unsigned int rowB, unsigned int colB, double C); -extern "C" void vtk_math_transpose_3_x_3(vtkNew sself, const float A, float AT); -extern "C" void vtk_math_transpose_3_x_3(vtkNew sself, const double A, double AT); -extern "C" void vtk_math_invert_3_x_3(vtkNew sself, const float A, float AI); -extern "C" void vtk_math_invert_3_x_3(vtkNew sself, const double A, double AI); -extern "C" void vtk_math_identity_3_x_3(vtkNew sself, float A); -extern "C" void vtk_math_identity_3_x_3(vtkNew sself, double A); -extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const float A); -extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const double A); -extern "C" float vtk_math_determinant_3_x_3(vtkNew sself, const float c1, const float c2, const float c3); -extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const double c1, const double c2, const double c3); -extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3); -extern "C" void vtk_math_quaternion_to_matrix_3_x_3(vtkNew sself, const float quat, float A); -extern "C" void vtk_math_quaternion_to_matrix_3_x_3(vtkNew sself, const double quat, double A); -extern "C" void vtk_math_matrix_3_x_3_to_quaternion(vtkNew sself, const float A, float quat); -extern "C" void vtk_math_matrix_3_x_3_to_quaternion(vtkNew sself, const double A, double quat); -extern "C" void vtk_math_multiply_quaternion(vtkNew sself, const float q1, const float q2, float q); -extern "C" void vtk_math_multiply_quaternion(vtkNew sself, const double q1, const double q2, double q); -extern "C" void vtk_math_rotate_vector_by_normalized_quaternion(vtkNew sself, const float v, const float q, float r); -extern "C" void vtk_math_rotate_vector_by_normalized_quaternion(vtkNew sself, const double v, const double q, double r); -extern "C" void vtk_math_rotate_vector_by_wxyz(vtkNew sself, const float v, const float q, float r); -extern "C" void vtk_math_rotate_vector_by_wxyz(vtkNew sself, const double v, const double q, double r); -extern "C" void vtk_math_orthogonalize_3_x_3(vtkNew sself, const float A, float B); -extern "C" void vtk_math_orthogonalize_3_x_3(vtkNew sself, const double A, double B); -extern "C" void vtk_math_diagonalize_3_x_3(vtkNew sself, const float A, float w, float V); -extern "C" void vtk_math_diagonalize_3_x_3(vtkNew sself, const double A, double w, double V); -extern "C" void vtk_math_singular_value_decomposition_3_x_3(vtkNew sself, const float A, float U, float w, float VT); -extern "C" void vtk_math_singular_value_decomposition_3_x_3(vtkNew sself, const double A, double U, double w, double VT); -extern "C" int vtk_math_solve_linear_system_gepp_2_x_2(vtkNew sself, double a00, double a01, double a10, double a11, double b0, double b1, double x0, double x1); -extern "C" int vtk_math_solve_linear_system(vtkNew sself, double A, double x, int size); -extern "C" int vtk_math_invert_matrix(vtkNew sself, double A, double AI, int size); -extern "C" int vtk_math_invert_matrix(vtkNew sself, double A, double AI, int size, int tmp1Size, double tmp2Size); -extern "C" int vtk_math_lu_factor_linear_system(vtkNew sself, double A, int index, int size); -extern "C" int vtk_math_lu_factor_linear_system(vtkNew sself, double A, int index, int size, double tmpSize); -extern "C" void vtk_math_lu_solve_linear_system(vtkNew sself, double A, int index, double x, int size); -extern "C" double vtk_math_estimate_matrix_condition(vtkNew sself, const double A, int size); -extern "C" int vtk_math_jacobi(vtkNew sself, float a, float w, float v); -extern "C" int vtk_math_jacobi(vtkNew sself, double a, double w, double v); -extern "C" int vtk_math_jacobi_n(vtkNew sself, float a, int n, float w, float v); -extern "C" int vtk_math_jacobi_n(vtkNew sself, double a, int n, double w, double v); -extern "C" int vtk_math_solve_homogeneous_least_squares(vtkNew sself, int numberOfSamples, double xt, int xOrder, double mt); -extern "C" int vtk_math_solve_least_squares(vtkNew sself, int numberOfSamples, double xt, int xOrder, double yt, int yOrder, double mt, int checkHomogeneous); -extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, const float rgb, float hsv); -extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, float r, float g, float b, float h, float s, float v); -extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, const double rgb, double hsv); -extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, double r, double g, double b, double h, double s, double v); -extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, const float hsv, float rgb); -extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, float h, float s, float v, float r, float g, float b); -extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, const double hsv, double rgb); -extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, double h, double s, double v, double r, double g, double b); -extern "C" void vtk_math_lab_to_xyz(vtkNew sself, const double lab, double xyz); -extern "C" void vtk_math_lab_to_xyz(vtkNew sself, double L, double a, double b, double x, double y, double z); -extern "C" void vtk_math_xyz_to_lab(vtkNew sself, const double xyz, double lab); -extern "C" void vtk_math_xyz_to_lab(vtkNew sself, double x, double y, double z, double L, double a, double b); -extern "C" void vtk_math_xyz_to_rgb(vtkNew sself, const double xyz, double rgb); -extern "C" void vtk_math_xyz_to_rgb(vtkNew sself, double x, double y, double z, double r, double g, double b); -extern "C" void vtk_math_rgb_to_xyz(vtkNew sself, const double rgb, double xyz); -extern "C" void vtk_math_rgb_to_xyz(vtkNew sself, double r, double g, double b, double x, double y, double z); -extern "C" void vtk_math_rgb_to_lab(vtkNew sself, const double rgb, double lab); -extern "C" void vtk_math_rgb_to_lab(vtkNew sself, double red, double green, double blue, double L, double a, double b); -extern "C" void vtk_math_lab_to_rgb(vtkNew sself, const double lab, double rgb); -extern "C" void vtk_math_lab_to_rgb(vtkNew sself, double L, double a, double b, double red, double green, double blue); -extern "C" void vtk_math_uninitialize_bounds(vtkNew sself, double bounds); -extern "C" int vtk_math_are_bounds_initialized(vtkNew sself, const double bounds); -extern "C" void vtk_math_clamp_value(vtkNew sself, double value, const double range); -extern "C" void vtk_math_clamp_value(vtkNew sself, double value, const double range, double clamped_value); -extern "C" void vtk_math_clamp_values(vtkNew sself, double values, int nb_values, const double range); -extern "C" void vtk_math_clamp_values(vtkNew sself, const double values, int nb_values, const double range, double clamped_values); -extern "C" double vtk_math_clamp_and_normalize_value(vtkNew sself, double value, const double range); -extern "C" int vtk_math_get_scalar_type_fitting_range(vtkNew sself, double range_min, double range_max, double scale, double shift); -extern "C" int vtk_math_extent_is_within_other_extent(vtkNew sself, const int extent1, const int extent2); -extern "C" int vtk_math_bounds_is_within_other_bounds(vtkNew sself, const double bounds1, const double bounds2, const double delta); -extern "C" int vtk_math_point_is_within_bounds(vtkNew sself, const double point, const double bounds, const double delta); -extern "C" int vtk_math_plane_intersects_aabb(vtkNew sself, const double bounds, const double normal, const double point); -extern "C" double vtk_math_solve_3_point_circle(vtkNew sself, const double p1, const double p2, const double p3, double center); -extern "C" double vtk_math_inf(vtkNew sself); -extern "C" double vtk_math_neg_inf(vtkNew sself); -extern "C" double vtk_math_nan(vtkNew sself); -extern "C" int vtk_math_is_inf(vtkNew sself, double x); -extern "C" int vtk_math_is_nan(vtkNew sself, double x); -extern "C" bool vtk_math_is_finite(vtkNew sself, double x); -extern "C" int vtk_math_quadratic_root(vtkNew sself, double a, double b, double c, double min, double max, double u); -extern "C" vtkNew < vtkMersenneTwister > vtkMersenneTwister_new () ; -extern "C" void vtkMersenneTwister_destructor (vtkNew < vtkMersenneTwister > sself) ; -extern "C" void * vtkMersenneTwister_get_ptr (vtkNew < vtkMersenneTwister > sself) ; -extern "C" void vtk_mersenne_twister_initialize(vtkNew sself, unsigned int seed); -extern "C" unsigned int vtk_mersenne_twister_initialize_new_sequence(vtkNew sself, unsigned int seed, int p); -extern "C" void vtk_mersenne_twister_initialize_sequence(vtkNew sself, unsigned int id, unsigned int seed, int p); -extern "C" double vtk_mersenne_twister_get_value(vtkNew sself, unsigned int id); -extern "C" double vtk_mersenne_twister_get_value(vtkNew sself); -extern "C" void vtk_mersenne_twister_next(vtkNew sself, unsigned int id); -extern "C" void vtk_mersenne_twister_next(vtkNew sself); -extern "C" vtkNew < vtkMinimalStandardRandomSequence > vtkMinimalStandardRandomSequence_new () ; -extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkNew < vtkMinimalStandardRandomSequence > sself) ; -extern "C" void * vtkMinimalStandardRandomSequence_get_ptr (vtkNew < vtkMinimalStandardRandomSequence > sself) ; -extern "C" void vtk_minimal_standard_random_sequence_initialize(vtkNew sself, unsigned int seed); -extern "C" void vtk_minimal_standard_random_sequence_set_seed(vtkNew sself, int value); -extern "C" void vtk_minimal_standard_random_sequence_set_seed_only(vtkNew sself, int value); -extern "C" int vtk_minimal_standard_random_sequence_get_seed(vtkNew sself); -extern "C" double vtk_minimal_standard_random_sequence_get_value(vtkNew sself); -extern "C" void vtk_minimal_standard_random_sequence_next(vtkNew sself); -extern "C" double vtk_minimal_standard_random_sequence_get_range_value(vtkNew sself, double rangeMin, double rangeMax); -extern "C" double vtk_minimal_standard_random_sequence_get_next_range_value(vtkNew sself, double rangeMin, double rangeMax); -extern "C" vtkNew < vtkMultiThreader > vtkMultiThreader_new () ; -extern "C" void vtkMultiThreader_destructor (vtkNew < vtkMultiThreader > sself) ; -extern "C" void * vtkMultiThreader_get_ptr (vtkNew < vtkMultiThreader > sself) ; -extern "C" void vtk_multi_threader_set_number_of_threads(vtkNew sself, int _arg); -extern "C" int vtk_multi_threader_get_number_of_threads_min_value(vtkNew sself); -extern "C" int vtk_multi_threader_get_number_of_threads_max_value(vtkNew sself); -extern "C" int vtk_multi_threader_get_number_of_threads(vtkNew sself); -extern "C" int vtk_multi_threader_get_global_static_maximum_number_of_threads(vtkNew sself); -extern "C" void vtk_multi_threader_set_global_maximum_number_of_threads(vtkNew sself, int val); -extern "C" int vtk_multi_threader_get_global_maximum_number_of_threads(vtkNew sself); -extern "C" void vtk_multi_threader_set_global_default_number_of_threads(vtkNew sself, int val); -extern "C" int vtk_multi_threader_get_global_default_number_of_threads(vtkNew sself); -extern "C" void vtk_multi_threader_single_method_execute(vtkNew sself); -extern "C" void vtk_multi_threader_multiple_method_execute(vtkNew sself); -extern "C" void vtk_multi_threader_terminate_thread(vtkNew sself, int threadId); -extern "C" int vtk_multi_threader_is_thread_active(vtkNew sself, int threadId); -extern "C" vtkNew < vtkObject > vtkObject_new () ; -extern "C" void vtkObject_destructor (vtkNew < vtkObject > sself) ; -extern "C" void * vtkObject_get_ptr (vtkNew < vtkObject > sself) ; -extern "C" int vtk_object_is_type_of(vtkNew sself, const char type); -extern "C" int vtk_object_is_a(vtkNew sself, const char type); -extern "C" long long vtk_object_get_number_of_generations_from_base_type(vtkNew sself, const char type); -extern "C" long long vtk_object_get_number_of_generations_from_base(vtkNew sself, const char type); -extern "C" void vtk_object_debug_on(vtkNew sself); -extern "C" void vtk_object_debug_off(vtkNew sself); -extern "C" bool vtk_object_get_debug(vtkNew sself); -extern "C" void vtk_object_set_debug(vtkNew sself, bool debugFlag); -extern "C" void vtk_object_break_on_error(vtkNew sself); -extern "C" void vtk_object_modified(vtkNew sself); -extern "C" unsigned long vtk_object_get_m_time(vtkNew sself); -extern "C" void vtk_object_set_global_warning_display(vtkNew sself, int val); -extern "C" void vtk_object_global_warning_display_on(vtkNew sself); -extern "C" void vtk_object_global_warning_display_off(vtkNew sself); -extern "C" int vtk_object_get_global_warning_display(vtkNew sself); -extern "C" void vtk_object_remove_observer(vtkNew sself, unsigned long tag); -extern "C" void vtk_object_remove_observers(vtkNew sself, unsigned long event); -extern "C" void vtk_object_remove_observers(vtkNew sself, const char event); -extern "C" void vtk_object_remove_all_observers(vtkNew sself); -extern "C" int vtk_object_has_observer(vtkNew sself, unsigned long event); -extern "C" int vtk_object_has_observer(vtkNew sself, const char event); -extern "C" int vtk_object_invoke_event(vtkNew sself, unsigned long event, void callData); -extern "C" int vtk_object_invoke_event(vtkNew sself, const char event, void callData); -extern "C" int vtk_object_invoke_event(vtkNew sself, unsigned long event); -extern "C" int vtk_object_invoke_event(vtkNew sself, const char event); -extern "C" vtkNew < vtkObjectFactoryCollection > vtkObjectFactoryCollection_new () ; -extern "C" void vtkObjectFactoryCollection_destructor (vtkNew < vtkObjectFactoryCollection > sself) ; -extern "C" void * vtkObjectFactoryCollection_get_ptr (vtkNew < vtkObjectFactoryCollection > sself) ; -extern "C" vtkNew < vtkOldStyleCallbackCommand > vtkOldStyleCallbackCommand_new () ; -extern "C" void vtkOldStyleCallbackCommand_destructor (vtkNew < vtkOldStyleCallbackCommand > sself) ; -extern "C" void * vtkOldStyleCallbackCommand_get_ptr (vtkNew < vtkOldStyleCallbackCommand > sself) ; -extern "C" void vtk_old_style_callback_command_set_client_data(vtkNew sself, void cd); -extern "C" vtkNew < vtkOutputWindow > vtkOutputWindow_new () ; -extern "C" void vtkOutputWindow_destructor (vtkNew < vtkOutputWindow > sself) ; -extern "C" void * vtkOutputWindow_get_ptr (vtkNew < vtkOutputWindow > sself) ; -extern "C" void vtk_output_window_display_text(vtkNew sself, const char p0); -extern "C" void vtk_output_window_display_error_text(vtkNew sself, const char p0); -extern "C" void vtk_output_window_display_warning_text(vtkNew sself, const char p0); -extern "C" void vtk_output_window_display_generic_warning_text(vtkNew sself, const char p0); -extern "C" void vtk_output_window_display_debug_text(vtkNew sself, const char p0); -extern "C" void vtk_output_window_prompt_user_on(vtkNew sself); -extern "C" void vtk_output_window_prompt_user_off(vtkNew sself); -extern "C" void vtk_output_window_set_prompt_user(vtkNew sself, bool _arg); -extern "C" void vtk_output_window_set_use_std_error_for_all_messages(vtkNew sself, bool p0); -extern "C" bool vtk_output_window_get_use_std_error_for_all_messages(vtkNew sself); -extern "C" void vtk_output_window_use_std_error_for_all_messages_on(vtkNew sself); -extern "C" void vtk_output_window_use_std_error_for_all_messages_off(vtkNew sself); -extern "C" void vtk_output_window_set_display_mode(vtkNew sself, int _arg); -extern "C" int vtk_output_window_get_display_mode_min_value(vtkNew sself); -extern "C" int vtk_output_window_get_display_mode_max_value(vtkNew sself); -extern "C" int vtk_output_window_get_display_mode(vtkNew sself); -extern "C" void vtk_output_window_set_display_mode_to_default(vtkNew sself); -extern "C" void vtk_output_window_set_display_mode_to_never(vtkNew sself); -extern "C" void vtk_output_window_set_display_mode_to_always(vtkNew sself); -extern "C" void vtk_output_window_set_display_mode_to_always_std_err(vtkNew sself); -extern "C" vtkNew < vtkOverrideInformationCollection > vtkOverrideInformationCollection_new () ; -extern "C" void vtkOverrideInformationCollection_destructor (vtkNew < vtkOverrideInformationCollection > sself) ; -extern "C" void * vtkOverrideInformationCollection_get_ptr (vtkNew < vtkOverrideInformationCollection > sself) ; -extern "C" vtkNew < vtkPoints > vtkPoints_new () ; -extern "C" void vtkPoints_destructor (vtkNew < vtkPoints > sself) ; -extern "C" void * vtkPoints_get_ptr (vtkNew < vtkPoints > sself) ; -extern "C" int vtk_points_allocate(vtkNew sself, long long sz, long long ext); -extern "C" void vtk_points_initialize(vtkNew sself); -extern "C" int vtk_points_get_data_type(vtkNew sself); -extern "C" void vtk_points_set_data_type(vtkNew sself, int dataType); -extern "C" void vtk_points_set_data_type_to_bit(vtkNew sself); -extern "C" void vtk_points_set_data_type_to_char(vtkNew sself); -extern "C" void vtk_points_set_data_type_to_unsigned_char(vtkNew sself); -extern "C" void vtk_points_set_data_type_to_short(vtkNew sself); -extern "C" void vtk_points_set_data_type_to_unsigned_short(vtkNew sself); -extern "C" void vtk_points_set_data_type_to_int(vtkNew sself); -extern "C" void vtk_points_set_data_type_to_unsigned_int(vtkNew sself); -extern "C" void vtk_points_set_data_type_to_long(vtkNew sself); -extern "C" void vtk_points_set_data_type_to_unsigned_long(vtkNew sself); -extern "C" void vtk_points_set_data_type_to_float(vtkNew sself); -extern "C" void vtk_points_set_data_type_to_double(vtkNew sself); -extern "C" void* vtk_points_get_void_pointer(vtkNew sself, const int id); -extern "C" void vtk_points_squeeze(vtkNew sself); -extern "C" void vtk_points_reset(vtkNew sself); -extern "C" unsigned long vtk_points_get_actual_memory_size(vtkNew sself); -extern "C" long long vtk_points_get_number_of_points(vtkNew sself); -extern "C" double* vtk_points_get_point(vtkNew sself, long long id); -extern "C" void vtk_points_get_point(vtkNew sself, long long id, double x); -extern "C" void vtk_points_set_point(vtkNew sself, long long id, const float x); -extern "C" void vtk_points_set_point(vtkNew sself, long long id, const double x); -extern "C" void vtk_points_set_point(vtkNew sself, long long id, double x, double y, double z); -extern "C" void vtk_points_insert_point(vtkNew sself, long long id, const float x); -extern "C" void vtk_points_insert_point(vtkNew sself, long long id, const double x); -extern "C" void vtk_points_insert_point(vtkNew sself, long long id, double x, double y, double z); -extern "C" long long vtk_points_insert_next_point(vtkNew sself, const float x); -extern "C" long long vtk_points_insert_next_point(vtkNew sself, const double x); -extern "C" long long vtk_points_insert_next_point(vtkNew sself, double x, double y, double z); -extern "C" void vtk_points_set_number_of_points(vtkNew sself, long long numPoints); -extern "C" int vtk_points_resize(vtkNew sself, long long numPoints); -extern "C" void vtk_points_compute_bounds(vtkNew sself); -extern "C" double* vtk_points_get_bounds(vtkNew sself); -extern "C" void vtk_points_get_bounds(vtkNew sself, double bounds); -extern "C" unsigned long vtk_points_get_m_time(vtkNew sself); -extern "C" void vtk_points_modified(vtkNew sself); -extern "C" vtkNew < vtkPoints2D > vtkPoints2D_new () ; -extern "C" void vtkPoints2D_destructor (vtkNew < vtkPoints2D > sself) ; -extern "C" void * vtkPoints2D_get_ptr (vtkNew < vtkPoints2D > sself) ; -extern "C" int vtk_points_2_d_allocate(vtkNew sself, long long sz, long long ext); -extern "C" void vtk_points_2_d_initialize(vtkNew sself); -extern "C" int vtk_points_2_d_get_data_type(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type(vtkNew sself, int dataType); -extern "C" void vtk_points_2_d_set_data_type_to_bit(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type_to_char(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type_to_unsigned_char(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type_to_short(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type_to_unsigned_short(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type_to_int(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type_to_unsigned_int(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type_to_long(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type_to_unsigned_long(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type_to_float(vtkNew sself); -extern "C" void vtk_points_2_d_set_data_type_to_double(vtkNew sself); -extern "C" void* vtk_points_2_d_get_void_pointer(vtkNew sself, const int id); -extern "C" void vtk_points_2_d_squeeze(vtkNew sself); -extern "C" void vtk_points_2_d_reset(vtkNew sself); -extern "C" unsigned long vtk_points_2_d_get_actual_memory_size(vtkNew sself); -extern "C" long long vtk_points_2_d_get_number_of_points(vtkNew sself); -extern "C" double* vtk_points_2_d_get_point(vtkNew sself, long long id); -extern "C" void vtk_points_2_d_get_point(vtkNew sself, long long id, double x); -extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, const float x); -extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, const double x); -extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, double x, double y); -extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, const float x); -extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, const double x); -extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, double x, double y); -extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, const float x); -extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, const double x); -extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, double x, double y); -extern "C" void vtk_points_2_d_remove_point(vtkNew sself, long long id); -extern "C" void vtk_points_2_d_set_number_of_points(vtkNew sself, long long numPoints); -extern "C" int vtk_points_2_d_resize(vtkNew sself, long long numPoints); -extern "C" void vtk_points_2_d_compute_bounds(vtkNew sself); -extern "C" double* vtk_points_2_d_get_bounds(vtkNew sself); -extern "C" void vtk_points_2_d_get_bounds(vtkNew sself, double bounds); -extern "C" vtkNew < vtkPriorityQueue > vtkPriorityQueue_new () ; -extern "C" void vtkPriorityQueue_destructor (vtkNew < vtkPriorityQueue > sself) ; -extern "C" void * vtkPriorityQueue_get_ptr (vtkNew < vtkPriorityQueue > sself) ; -extern "C" void vtk_priority_queue_allocate(vtkNew sself, long long sz, long long ext); -extern "C" void vtk_priority_queue_insert(vtkNew sself, double priority, long long id); -extern "C" long long vtk_priority_queue_pop(vtkNew sself, long long location, double priority); -extern "C" long long vtk_priority_queue_pop(vtkNew sself, long long location); -extern "C" long long vtk_priority_queue_peek(vtkNew sself, long long location, double priority); -extern "C" long long vtk_priority_queue_peek(vtkNew sself, long long location); -extern "C" double vtk_priority_queue_delete_id(vtkNew sself, long long id); -extern "C" double vtk_priority_queue_get_priority(vtkNew sself, long long id); -extern "C" long long vtk_priority_queue_get_number_of_items(vtkNew sself); -extern "C" void vtk_priority_queue_reset(vtkNew sself); -extern "C" vtkNew < vtkRandomPool > vtkRandomPool_new () ; -extern "C" void vtkRandomPool_destructor (vtkNew < vtkRandomPool > sself) ; -extern "C" void * vtkRandomPool_get_ptr (vtkNew < vtkRandomPool > sself) ; -extern "C" void vtk_random_pool_set_size(vtkNew sself, long long _arg); -extern "C" long long vtk_random_pool_get_size_min_value(vtkNew sself); -extern "C" long long vtk_random_pool_get_size_max_value(vtkNew sself); -extern "C" long long vtk_random_pool_get_size(vtkNew sself); -extern "C" void vtk_random_pool_set_number_of_components(vtkNew sself, long long _arg); -extern "C" long long vtk_random_pool_get_number_of_components_min_value(vtkNew sself); -extern "C" long long vtk_random_pool_get_number_of_components_max_value(vtkNew sself); -extern "C" long long vtk_random_pool_get_number_of_components(vtkNew sself); -extern "C" long long vtk_random_pool_get_total_size(vtkNew sself); -extern "C" const double* vtk_random_pool_generate_pool(vtkNew sself); -extern "C" const double* vtk_random_pool_get_pool(vtkNew sself); -extern "C" double vtk_random_pool_get_value(vtkNew sself, long long i); -extern "C" double vtk_random_pool_get_value(vtkNew sself, long long i, int compNum); -extern "C" void vtk_random_pool_set_chunk_size(vtkNew sself, long long _arg); -extern "C" long long vtk_random_pool_get_chunk_size_min_value(vtkNew sself); -extern "C" long long vtk_random_pool_get_chunk_size_max_value(vtkNew sself); -extern "C" long long vtk_random_pool_get_chunk_size(vtkNew sself); -extern "C" vtkNew < vtkReferenceCount > vtkReferenceCount_new () ; -extern "C" void vtkReferenceCount_destructor (vtkNew < vtkReferenceCount > sself) ; -extern "C" void * vtkReferenceCount_get_ptr (vtkNew < vtkReferenceCount > sself) ; -extern "C" vtkNew < vtkScalarsToColors > vtkScalarsToColors_new () ; -extern "C" void vtkScalarsToColors_destructor (vtkNew < vtkScalarsToColors > sself) ; -extern "C" void * vtkScalarsToColors_get_ptr (vtkNew < vtkScalarsToColors > sself) ; -extern "C" int vtk_scalars_to_colors_is_opaque(vtkNew sself); -extern "C" void vtk_scalars_to_colors_build(vtkNew sself); -extern "C" double* vtk_scalars_to_colors_get_range(vtkNew sself); -extern "C" void vtk_scalars_to_colors_set_range(vtkNew sself, double min, double max); -extern "C" void vtk_scalars_to_colors_set_range(vtkNew sself, const double rng); -extern "C" const unsigned char* vtk_scalars_to_colors_map_value(vtkNew sself, double v); -extern "C" void vtk_scalars_to_colors_get_color(vtkNew sself, double v, double rgb); -extern "C" double* vtk_scalars_to_colors_get_color(vtkNew sself, double v); -extern "C" double vtk_scalars_to_colors_get_opacity(vtkNew sself, double v); -extern "C" double vtk_scalars_to_colors_get_luminance(vtkNew sself, double x); -extern "C" void vtk_scalars_to_colors_set_alpha(vtkNew sself, double alpha); -extern "C" double vtk_scalars_to_colors_get_alpha(vtkNew sself); -extern "C" void vtk_scalars_to_colors_set_vector_mode(vtkNew sself, int _arg); -extern "C" int vtk_scalars_to_colors_get_vector_mode(vtkNew sself); -extern "C" void vtk_scalars_to_colors_set_vector_mode_to_magnitude(vtkNew sself); -extern "C" void vtk_scalars_to_colors_set_vector_mode_to_component(vtkNew sself); -extern "C" void vtk_scalars_to_colors_set_vector_mode_to_rgb_colors(vtkNew sself); -extern "C" void vtk_scalars_to_colors_set_vector_component(vtkNew sself, int _arg); -extern "C" int vtk_scalars_to_colors_get_vector_component(vtkNew sself); -extern "C" void vtk_scalars_to_colors_set_vector_size(vtkNew sself, int _arg); -extern "C" int vtk_scalars_to_colors_get_vector_size(vtkNew sself); -extern "C" void vtk_scalars_to_colors_map_vectors_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat, int vectorComponent, int vectorSize); -extern "C" void vtk_scalars_to_colors_map_vectors_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat); -extern "C" void vtk_scalars_to_colors_map_scalars_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat); -extern "C" void vtk_scalars_to_colors_map_scalars_through_table_2(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat); -extern "C" int vtk_scalars_to_colors_using_log_scale(vtkNew sself); -extern "C" long long vtk_scalars_to_colors_get_number_of_available_colors(vtkNew sself); -extern "C" long long vtk_scalars_to_colors_get_number_of_annotated_values(vtkNew sself); -extern "C" void vtk_scalars_to_colors_get_indexed_color(vtkNew sself, long long i, double rgba); -extern "C" void vtk_scalars_to_colors_reset_annotations(vtkNew sself); -extern "C" void vtk_scalars_to_colors_set_indexed_lookup(vtkNew sself, int _arg); -extern "C" int vtk_scalars_to_colors_get_indexed_lookup(vtkNew sself); -extern "C" void vtk_scalars_to_colors_indexed_lookup_on(vtkNew sself); -extern "C" void vtk_scalars_to_colors_indexed_lookup_off(vtkNew sself); -extern "C" vtkNew < vtkShortArray > vtkShortArray_new () ; -extern "C" void vtkShortArray_destructor (vtkNew < vtkShortArray > sself) ; -extern "C" void * vtkShortArray_get_ptr (vtkNew < vtkShortArray > sself) ; -extern "C" int vtk_short_array_get_data_type(vtkNew sself); -extern "C" void vtk_short_array_get_typed_tuple(vtkNew sself, long long i, short tuple); -extern "C" void vtk_short_array_set_typed_tuple(vtkNew sself, long long i, const short tuple); -extern "C" void vtk_short_array_insert_typed_tuple(vtkNew sself, long long i, const short tuple); -extern "C" long long vtk_short_array_insert_next_typed_tuple(vtkNew sself, const short tuple); -extern "C" short vtk_short_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_short_array_set_value(vtkNew sself, long long id, short value); -extern "C" bool vtk_short_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_short_array_insert_value(vtkNew sself, long long id, short f); -extern "C" long long vtk_short_array_insert_next_value(vtkNew sself, short f); -extern "C" short* vtk_short_array_get_value_range(vtkNew sself, int comp); -extern "C" short* vtk_short_array_get_value_range(vtkNew sself); -extern "C" short* vtk_short_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" short* vtk_short_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_short_array_set_array(vtkNew sself, short array, long long size, int save); -extern "C" void vtk_short_array_set_array(vtkNew sself, short array, long long size, int save, int deleteMethod); -extern "C" short vtk_short_array_get_data_type_value_min(vtkNew sself); -extern "C" short vtk_short_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkSignedCharArray > vtkSignedCharArray_new () ; -extern "C" void vtkSignedCharArray_destructor (vtkNew < vtkSignedCharArray > sself) ; -extern "C" void * vtkSignedCharArray_get_ptr (vtkNew < vtkSignedCharArray > sself) ; -extern "C" int vtk_signed_char_array_get_data_type(vtkNew sself); -extern "C" void vtk_signed_char_array_get_typed_tuple(vtkNew sself, long long i, char tuple); -extern "C" void vtk_signed_char_array_set_typed_tuple(vtkNew sself, long long i, const char tuple); -extern "C" void vtk_signed_char_array_insert_typed_tuple(vtkNew sself, long long i, const char tuple); -extern "C" long long vtk_signed_char_array_insert_next_typed_tuple(vtkNew sself, const char tuple); -extern "C" char vtk_signed_char_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_signed_char_array_set_value(vtkNew sself, long long id, char value); -extern "C" bool vtk_signed_char_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_signed_char_array_insert_value(vtkNew sself, long long id, char f); -extern "C" long long vtk_signed_char_array_insert_next_value(vtkNew sself, char f); -extern "C" char* vtk_signed_char_array_get_value_range(vtkNew sself, int comp); -extern "C" char* vtk_signed_char_array_get_value_range(vtkNew sself); -extern "C" char* vtk_signed_char_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" char* vtk_signed_char_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_signed_char_array_set_array(vtkNew sself, char array, long long size, int save); -extern "C" void vtk_signed_char_array_set_array(vtkNew sself, char array, long long size, int save, int deleteMethod); -extern "C" char vtk_signed_char_array_get_data_type_value_min(vtkNew sself); -extern "C" char vtk_signed_char_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkSortDataArray > vtkSortDataArray_new () ; -extern "C" void vtkSortDataArray_destructor (vtkNew < vtkSortDataArray > sself) ; -extern "C" void * vtkSortDataArray_get_ptr (vtkNew < vtkSortDataArray > sself) ; -extern "C" long long* vtk_sort_data_array_initialize_sort_indices(vtkNew sself, long long numKeys); -extern "C" void vtk_sort_data_array_generate_sort_indices(vtkNew sself, int dataType, void dataIn, long long numKeys, int numComp, int k, long long idx); -extern "C" vtkNew < vtkStringArray > vtkStringArray_new () ; -extern "C" void vtkStringArray_destructor (vtkNew < vtkStringArray > sself) ; -extern "C" void * vtkStringArray_get_ptr (vtkNew < vtkStringArray > sself) ; -extern "C" int vtk_string_array_get_data_type(vtkNew sself); -extern "C" int vtk_string_array_is_numeric(vtkNew sself); -extern "C" void vtk_string_array_initialize(vtkNew sself); -extern "C" int vtk_string_array_get_data_type_size(vtkNew sself); -extern "C" void vtk_string_array_squeeze(vtkNew sself); -extern "C" int vtk_string_array_resize(vtkNew sself, long long numTuples); -extern "C" int vtk_string_array_allocate(vtkNew sself, long long sz, long long ext); -extern "C" void vtk_string_array_set_value(vtkNew sself, long long id, const char value); -extern "C" void vtk_string_array_set_number_of_tuples(vtkNew sself, long long number); -extern "C" long long vtk_string_array_get_number_of_values(vtkNew sself); -extern "C" int vtk_string_array_get_number_of_element_components(vtkNew sself); -extern "C" int vtk_string_array_get_element_component_size(vtkNew sself); -extern "C" void vtk_string_array_insert_value(vtkNew sself, long long id, const char val); -extern "C" long long vtk_string_array_insert_next_value(vtkNew sself, const char f); -extern "C" void* vtk_string_array_get_void_pointer(vtkNew sself, long long id); -extern "C" void vtk_string_array_set_void_array(vtkNew sself, void array, long long size, int save); -extern "C" unsigned long vtk_string_array_get_actual_memory_size(vtkNew sself); -extern "C" long long vtk_string_array_get_data_size(vtkNew sself); -extern "C" long long vtk_string_array_lookup_value(vtkNew sself, const char value); -extern "C" void vtk_string_array_data_changed(vtkNew sself); -extern "C" void vtk_string_array_data_element_changed(vtkNew sself, long long id); -extern "C" void vtk_string_array_clear_lookup(vtkNew sself); -extern "C" vtkNew < vtkStringOutputWindow > vtkStringOutputWindow_new () ; -extern "C" void vtkStringOutputWindow_destructor (vtkNew < vtkStringOutputWindow > sself) ; -extern "C" void * vtkStringOutputWindow_get_ptr (vtkNew < vtkStringOutputWindow > sself) ; -extern "C" void vtk_string_output_window_display_text(vtkNew sself, const char p0); -extern "C" const char* vtk_string_output_window_get_output(vtkNew sself); -extern "C" vtkNew < vtkTimePointUtility > vtkTimePointUtility_new () ; -extern "C" void vtkTimePointUtility_destructor (vtkNew < vtkTimePointUtility > sself) ; -extern "C" void * vtkTimePointUtility_get_ptr (vtkNew < vtkTimePointUtility > sself) ; -extern "C" unsigned long long vtk_time_point_utility_date_to_time_point(vtkNew sself, int year, int month, int day); -extern "C" unsigned long long vtk_time_point_utility_time_to_time_point(vtkNew sself, int hour, int minute, int second, int millis); -extern "C" unsigned long long vtk_time_point_utility_date_time_to_time_point(vtkNew sself, int year, int month, int day, int hour, int minute, int sec, int millis); -extern "C" void vtk_time_point_utility_get_date(vtkNew sself, unsigned long long time, int year, int month, int day); -extern "C" void vtk_time_point_utility_get_time(vtkNew sself, unsigned long long time, int hour, int minute, int second, int millis); -extern "C" void vtk_time_point_utility_get_date_time(vtkNew sself, unsigned long long time, int year, int month, int day, int hour, int minute, int second, int millis); -extern "C" int vtk_time_point_utility_get_year(vtkNew sself, unsigned long long time); -extern "C" int vtk_time_point_utility_get_month(vtkNew sself, unsigned long long time); -extern "C" int vtk_time_point_utility_get_day(vtkNew sself, unsigned long long time); -extern "C" int vtk_time_point_utility_get_hour(vtkNew sself, unsigned long long time); -extern "C" int vtk_time_point_utility_get_minute(vtkNew sself, unsigned long long time); -extern "C" int vtk_time_point_utility_get_second(vtkNew sself, unsigned long long time); -extern "C" int vtk_time_point_utility_get_millisecond(vtkNew sself, unsigned long long time); -extern "C" unsigned long long vtk_time_point_utility_iso_8601_to_time_point(vtkNew sself, const char str, bool ok); -extern "C" const char* vtk_time_point_utility_time_point_to_iso_8601(vtkNew sself, unsigned long long p0, int format); -extern "C" vtkNew < vtkTypeFloat32Array > vtkTypeFloat32Array_new () ; -extern "C" void vtkTypeFloat32Array_destructor (vtkNew < vtkTypeFloat32Array > sself) ; -extern "C" void * vtkTypeFloat32Array_get_ptr (vtkNew < vtkTypeFloat32Array > sself) ; -extern "C" vtkNew < vtkTypeFloat64Array > vtkTypeFloat64Array_new () ; -extern "C" void vtkTypeFloat64Array_destructor (vtkNew < vtkTypeFloat64Array > sself) ; -extern "C" void * vtkTypeFloat64Array_get_ptr (vtkNew < vtkTypeFloat64Array > sself) ; -extern "C" vtkNew < vtkTypeInt16Array > vtkTypeInt16Array_new () ; -extern "C" void vtkTypeInt16Array_destructor (vtkNew < vtkTypeInt16Array > sself) ; -extern "C" void * vtkTypeInt16Array_get_ptr (vtkNew < vtkTypeInt16Array > sself) ; -extern "C" vtkNew < vtkTypeInt32Array > vtkTypeInt32Array_new () ; -extern "C" void vtkTypeInt32Array_destructor (vtkNew < vtkTypeInt32Array > sself) ; -extern "C" void * vtkTypeInt32Array_get_ptr (vtkNew < vtkTypeInt32Array > sself) ; -extern "C" vtkNew < vtkTypeInt64Array > vtkTypeInt64Array_new () ; -extern "C" void vtkTypeInt64Array_destructor (vtkNew < vtkTypeInt64Array > sself) ; -extern "C" void * vtkTypeInt64Array_get_ptr (vtkNew < vtkTypeInt64Array > sself) ; -extern "C" vtkNew < vtkTypeInt8Array > vtkTypeInt8Array_new () ; -extern "C" void vtkTypeInt8Array_destructor (vtkNew < vtkTypeInt8Array > sself) ; -extern "C" void * vtkTypeInt8Array_get_ptr (vtkNew < vtkTypeInt8Array > sself) ; -extern "C" vtkNew < vtkTypeUInt16Array > vtkTypeUInt16Array_new () ; -extern "C" void vtkTypeUInt16Array_destructor (vtkNew < vtkTypeUInt16Array > sself) ; -extern "C" void * vtkTypeUInt16Array_get_ptr (vtkNew < vtkTypeUInt16Array > sself) ; -extern "C" vtkNew < vtkTypeUInt32Array > vtkTypeUInt32Array_new () ; -extern "C" void vtkTypeUInt32Array_destructor (vtkNew < vtkTypeUInt32Array > sself) ; -extern "C" void * vtkTypeUInt32Array_get_ptr (vtkNew < vtkTypeUInt32Array > sself) ; -extern "C" vtkNew < vtkTypeUInt64Array > vtkTypeUInt64Array_new () ; -extern "C" void vtkTypeUInt64Array_destructor (vtkNew < vtkTypeUInt64Array > sself) ; -extern "C" void * vtkTypeUInt64Array_get_ptr (vtkNew < vtkTypeUInt64Array > sself) ; -extern "C" vtkNew < vtkTypeUInt8Array > vtkTypeUInt8Array_new () ; -extern "C" void vtkTypeUInt8Array_destructor (vtkNew < vtkTypeUInt8Array > sself) ; -extern "C" void * vtkTypeUInt8Array_get_ptr (vtkNew < vtkTypeUInt8Array > sself) ; -extern "C" vtkNew < vtkUnicodeStringArray > vtkUnicodeStringArray_new () ; -extern "C" void vtkUnicodeStringArray_destructor (vtkNew < vtkUnicodeStringArray > sself) ; -extern "C" void * vtkUnicodeStringArray_get_ptr (vtkNew < vtkUnicodeStringArray > sself) ; -extern "C" int vtk_unicode_string_array_allocate(vtkNew sself, long long sz, long long ext); -extern "C" void vtk_unicode_string_array_initialize(vtkNew sself); -extern "C" int vtk_unicode_string_array_get_data_type(vtkNew sself); -extern "C" int vtk_unicode_string_array_get_data_type_size(vtkNew sself); -extern "C" int vtk_unicode_string_array_get_element_component_size(vtkNew sself); -extern "C" void vtk_unicode_string_array_set_number_of_tuples(vtkNew sself, long long number); -extern "C" void* vtk_unicode_string_array_get_void_pointer(vtkNew sself, long long id); -extern "C" void vtk_unicode_string_array_squeeze(vtkNew sself); -extern "C" int vtk_unicode_string_array_resize(vtkNew sself, long long numTuples); -extern "C" void vtk_unicode_string_array_set_void_array(vtkNew sself, void array, long long size, int save); -extern "C" unsigned long vtk_unicode_string_array_get_actual_memory_size(vtkNew sself); -extern "C" int vtk_unicode_string_array_is_numeric(vtkNew sself); -extern "C" void vtk_unicode_string_array_data_changed(vtkNew sself); -extern "C" void vtk_unicode_string_array_clear_lookup(vtkNew sself); -extern "C" void vtk_unicode_string_array_insert_next_utf_8_value(vtkNew sself, const char p0); -extern "C" void vtk_unicode_string_array_set_utf_8_value(vtkNew sself, long long i, const char p1); -extern "C" const char* vtk_unicode_string_array_get_utf_8_value(vtkNew sself, long long i); -extern "C" vtkNew < vtkUnsignedCharArray > vtkUnsignedCharArray_new () ; -extern "C" void vtkUnsignedCharArray_destructor (vtkNew < vtkUnsignedCharArray > sself) ; -extern "C" void * vtkUnsignedCharArray_get_ptr (vtkNew < vtkUnsignedCharArray > sself) ; -extern "C" int vtk_unsigned_char_array_get_data_type(vtkNew sself); -extern "C" void vtk_unsigned_char_array_get_typed_tuple(vtkNew sself, long long i, unsigned char tuple); -extern "C" void vtk_unsigned_char_array_set_typed_tuple(vtkNew sself, long long i, const unsigned char tuple); -extern "C" void vtk_unsigned_char_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned char tuple); -extern "C" long long vtk_unsigned_char_array_insert_next_typed_tuple(vtkNew sself, const unsigned char tuple); -extern "C" unsigned char vtk_unsigned_char_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_unsigned_char_array_set_value(vtkNew sself, long long id, unsigned char value); -extern "C" bool vtk_unsigned_char_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_unsigned_char_array_insert_value(vtkNew sself, long long id, unsigned char f); -extern "C" long long vtk_unsigned_char_array_insert_next_value(vtkNew sself, unsigned char f); -extern "C" unsigned char* vtk_unsigned_char_array_get_value_range(vtkNew sself, int comp); -extern "C" unsigned char* vtk_unsigned_char_array_get_value_range(vtkNew sself); -extern "C" unsigned char* vtk_unsigned_char_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" unsigned char* vtk_unsigned_char_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_unsigned_char_array_set_array(vtkNew sself, unsigned char array, long long size, int save); -extern "C" void vtk_unsigned_char_array_set_array(vtkNew sself, unsigned char array, long long size, int save, int deleteMethod); -extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_min(vtkNew sself); -extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkUnsignedIntArray > vtkUnsignedIntArray_new () ; -extern "C" void vtkUnsignedIntArray_destructor (vtkNew < vtkUnsignedIntArray > sself) ; -extern "C" void * vtkUnsignedIntArray_get_ptr (vtkNew < vtkUnsignedIntArray > sself) ; -extern "C" int vtk_unsigned_int_array_get_data_type(vtkNew sself); -extern "C" void vtk_unsigned_int_array_get_typed_tuple(vtkNew sself, long long i, unsigned int tuple); -extern "C" void vtk_unsigned_int_array_set_typed_tuple(vtkNew sself, long long i, const unsigned int tuple); -extern "C" void vtk_unsigned_int_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned int tuple); -extern "C" long long vtk_unsigned_int_array_insert_next_typed_tuple(vtkNew sself, const unsigned int tuple); -extern "C" unsigned int vtk_unsigned_int_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_unsigned_int_array_set_value(vtkNew sself, long long id, unsigned int value); -extern "C" bool vtk_unsigned_int_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_unsigned_int_array_insert_value(vtkNew sself, long long id, unsigned int f); -extern "C" long long vtk_unsigned_int_array_insert_next_value(vtkNew sself, unsigned int f); -extern "C" unsigned int* vtk_unsigned_int_array_get_value_range(vtkNew sself, int comp); -extern "C" unsigned int* vtk_unsigned_int_array_get_value_range(vtkNew sself); -extern "C" unsigned int* vtk_unsigned_int_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" unsigned int* vtk_unsigned_int_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_unsigned_int_array_set_array(vtkNew sself, unsigned int array, long long size, int save); -extern "C" void vtk_unsigned_int_array_set_array(vtkNew sself, unsigned int array, long long size, int save, int deleteMethod); -extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_min(vtkNew sself); -extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkUnsignedLongArray > vtkUnsignedLongArray_new () ; -extern "C" void vtkUnsignedLongArray_destructor (vtkNew < vtkUnsignedLongArray > sself) ; -extern "C" void * vtkUnsignedLongArray_get_ptr (vtkNew < vtkUnsignedLongArray > sself) ; -extern "C" int vtk_unsigned_long_array_get_data_type(vtkNew sself); -extern "C" void vtk_unsigned_long_array_get_typed_tuple(vtkNew sself, long long i, unsigned long tuple); -extern "C" void vtk_unsigned_long_array_set_typed_tuple(vtkNew sself, long long i, const unsigned long tuple); -extern "C" void vtk_unsigned_long_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned long tuple); -extern "C" long long vtk_unsigned_long_array_insert_next_typed_tuple(vtkNew sself, const unsigned long tuple); -extern "C" unsigned long vtk_unsigned_long_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_unsigned_long_array_set_value(vtkNew sself, long long id, unsigned long value); -extern "C" bool vtk_unsigned_long_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_unsigned_long_array_insert_value(vtkNew sself, long long id, unsigned long f); -extern "C" long long vtk_unsigned_long_array_insert_next_value(vtkNew sself, unsigned long f); -extern "C" unsigned long* vtk_unsigned_long_array_get_value_range(vtkNew sself, int comp); -extern "C" unsigned long* vtk_unsigned_long_array_get_value_range(vtkNew sself); -extern "C" unsigned long* vtk_unsigned_long_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" unsigned long* vtk_unsigned_long_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_unsigned_long_array_set_array(vtkNew sself, unsigned long array, long long size, int save); -extern "C" void vtk_unsigned_long_array_set_array(vtkNew sself, unsigned long array, long long size, int save, int deleteMethod); -extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_min(vtkNew sself); -extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkUnsignedLongLongArray > vtkUnsignedLongLongArray_new () ; -extern "C" void vtkUnsignedLongLongArray_destructor (vtkNew < vtkUnsignedLongLongArray > sself) ; -extern "C" void * vtkUnsignedLongLongArray_get_ptr (vtkNew < vtkUnsignedLongLongArray > sself) ; -extern "C" int vtk_unsigned_long_long_array_get_data_type(vtkNew sself); -extern "C" void vtk_unsigned_long_long_array_get_typed_tuple(vtkNew sself, long long i, unsigned long long tuple); -extern "C" void vtk_unsigned_long_long_array_set_typed_tuple(vtkNew sself, long long i, const unsigned long long tuple); -extern "C" void vtk_unsigned_long_long_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned long long tuple); -extern "C" long long vtk_unsigned_long_long_array_insert_next_typed_tuple(vtkNew sself, const unsigned long long tuple); -extern "C" unsigned long long vtk_unsigned_long_long_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_unsigned_long_long_array_set_value(vtkNew sself, long long id, unsigned long long value); -extern "C" bool vtk_unsigned_long_long_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_unsigned_long_long_array_insert_value(vtkNew sself, long long id, unsigned long long f); -extern "C" long long vtk_unsigned_long_long_array_insert_next_value(vtkNew sself, unsigned long long f); -extern "C" unsigned long long* vtk_unsigned_long_long_array_get_value_range(vtkNew sself, int comp); -extern "C" unsigned long long* vtk_unsigned_long_long_array_get_value_range(vtkNew sself); -extern "C" unsigned long long* vtk_unsigned_long_long_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" unsigned long long* vtk_unsigned_long_long_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_unsigned_long_long_array_set_array(vtkNew sself, unsigned long long array, long long size, int save); -extern "C" void vtk_unsigned_long_long_array_set_array(vtkNew sself, unsigned long long array, long long size, int save, int deleteMethod); -extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_min(vtkNew sself); -extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkUnsignedShortArray > vtkUnsignedShortArray_new () ; -extern "C" void vtkUnsignedShortArray_destructor (vtkNew < vtkUnsignedShortArray > sself) ; -extern "C" void * vtkUnsignedShortArray_get_ptr (vtkNew < vtkUnsignedShortArray > sself) ; -extern "C" int vtk_unsigned_short_array_get_data_type(vtkNew sself); -extern "C" void vtk_unsigned_short_array_get_typed_tuple(vtkNew sself, long long i, unsigned short tuple); -extern "C" void vtk_unsigned_short_array_set_typed_tuple(vtkNew sself, long long i, const unsigned short tuple); -extern "C" void vtk_unsigned_short_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned short tuple); -extern "C" long long vtk_unsigned_short_array_insert_next_typed_tuple(vtkNew sself, const unsigned short tuple); -extern "C" unsigned short vtk_unsigned_short_array_get_value(vtkNew sself, long long id); -extern "C" void vtk_unsigned_short_array_set_value(vtkNew sself, long long id, unsigned short value); -extern "C" bool vtk_unsigned_short_array_set_number_of_values(vtkNew sself, long long number); -extern "C" void vtk_unsigned_short_array_insert_value(vtkNew sself, long long id, unsigned short f); -extern "C" long long vtk_unsigned_short_array_insert_next_value(vtkNew sself, unsigned short f); -extern "C" unsigned short* vtk_unsigned_short_array_get_value_range(vtkNew sself, int comp); -extern "C" unsigned short* vtk_unsigned_short_array_get_value_range(vtkNew sself); -extern "C" unsigned short* vtk_unsigned_short_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" unsigned short* vtk_unsigned_short_array_get_pointer(vtkNew sself, long long id); -extern "C" void vtk_unsigned_short_array_set_array(vtkNew sself, unsigned short array, long long size, int save); -extern "C" void vtk_unsigned_short_array_set_array(vtkNew sself, unsigned short array, long long size, int save, int deleteMethod); -extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_min(vtkNew sself); -extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_max(vtkNew sself); -extern "C" vtkNew < vtkVariantArray > vtkVariantArray_new () ; -extern "C" void vtkVariantArray_destructor (vtkNew < vtkVariantArray > sself) ; -extern "C" void * vtkVariantArray_get_ptr (vtkNew < vtkVariantArray > sself) ; -extern "C" int vtk_variant_array_allocate(vtkNew sself, long long sz, long long ext); -extern "C" void vtk_variant_array_initialize(vtkNew sself); -extern "C" int vtk_variant_array_get_data_type(vtkNew sself); -extern "C" int vtk_variant_array_get_data_type_size(vtkNew sself); -extern "C" int vtk_variant_array_get_element_component_size(vtkNew sself); -extern "C" void vtk_variant_array_set_number_of_tuples(vtkNew sself, long long number); -extern "C" void* vtk_variant_array_get_void_pointer(vtkNew sself, long long id); -extern "C" void vtk_variant_array_squeeze(vtkNew sself); -extern "C" int vtk_variant_array_resize(vtkNew sself, long long numTuples); -extern "C" void vtk_variant_array_set_void_array(vtkNew sself, void arr, long long size, int save); -extern "C" void vtk_variant_array_set_void_array(vtkNew sself, void arr, long long size, int save, int deleteM); -extern "C" unsigned long vtk_variant_array_get_actual_memory_size(vtkNew sself); -extern "C" int vtk_variant_array_is_numeric(vtkNew sself); -extern "C" long long vtk_variant_array_get_number_of_values(vtkNew sself); -extern "C" void vtk_variant_array_data_changed(vtkNew sself); -extern "C" void vtk_variant_array_data_element_changed(vtkNew sself, long long id); -extern "C" void vtk_variant_array_clear_lookup(vtkNew sself); -extern "C" vtkNew < vtkVersion > vtkVersion_new () ; -extern "C" void vtkVersion_destructor (vtkNew < vtkVersion > sself) ; -extern "C" void * vtkVersion_get_ptr (vtkNew < vtkVersion > sself) ; -extern "C" const char* vtk_version_get_vtk_version(vtkNew sself); -extern "C" const char* vtk_version_get_vtk_version_full(vtkNew sself); -extern "C" int vtk_version_get_vtk_major_version(vtkNew sself); -extern "C" int vtk_version_get_vtk_minor_version(vtkNew sself); -extern "C" int vtk_version_get_vtk_build_version(vtkNew sself); -extern "C" const char* vtk_version_get_vtk_source_version(vtkNew sself); -extern "C" vtkNew < vtkVoidArray > vtkVoidArray_new () ; -extern "C" void vtkVoidArray_destructor (vtkNew < vtkVoidArray > sself) ; -extern "C" void * vtkVoidArray_get_ptr (vtkNew < vtkVoidArray > sself) ; -extern "C" int vtk_void_array_allocate(vtkNew sself, long long sz, long long ext); -extern "C" void vtk_void_array_initialize(vtkNew sself); -extern "C" int vtk_void_array_get_data_type(vtkNew sself); -extern "C" int vtk_void_array_get_data_type_size(vtkNew sself); -extern "C" void vtk_void_array_set_number_of_pointers(vtkNew sself, long long number); -extern "C" long long vtk_void_array_get_number_of_pointers(vtkNew sself); -extern "C" void* vtk_void_array_get_void_pointer(vtkNew sself, long long id); -extern "C" void vtk_void_array_set_void_pointer(vtkNew sself, long long id, void ptr); -extern "C" void vtk_void_array_insert_void_pointer(vtkNew sself, long long i, void ptr); -extern "C" long long vtk_void_array_insert_next_void_pointer(vtkNew sself, void tuple); -extern "C" void vtk_void_array_reset(vtkNew sself); -extern "C" void vtk_void_array_squeeze(vtkNew sself); -extern "C" void&* vtk_void_array_get_pointer(vtkNew sself, long long id); -extern "C" void&* vtk_void_array_write_pointer(vtkNew sself, long long id, long long number); -extern "C" vtkNew < vtkWeakReference > vtkWeakReference_new () ; -extern "C" void vtkWeakReference_destructor (vtkNew < vtkWeakReference > sself) ; -extern "C" void * vtkWeakReference_get_ptr (vtkNew < vtkWeakReference > sself) ; -extern "C" vtkNew < vtkXMLFileOutputWindow > vtkXMLFileOutputWindow_new () ; -extern "C" void vtkXMLFileOutputWindow_destructor (vtkNew < vtkXMLFileOutputWindow > sself) ; -extern "C" void * vtkXMLFileOutputWindow_get_ptr (vtkNew < vtkXMLFileOutputWindow > sself) ; -extern "C" void vtk_xml_file_output_window_display_text(vtkNew sself, const char p0); -extern "C" void vtk_xml_file_output_window_display_tag(vtkNew sself, const char p0); +extern "C" vtkAnimationCue * vtkAnimationCue_new () ; +extern "C" void vtkAnimationCue_destructor (vtkAnimationCue * sself) ; +extern "C" void * vtkAnimationCue_get_ptr (vtkAnimationCue * sself) ; +extern "C" void vtk_animation_cue_set_time_mode(vtkAnimationCue* sself, int mode); +extern "C" int vtk_animation_cue_get_time_mode(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_set_time_mode_to_relative(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_set_time_mode_to_normalized(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_set_start_time(vtkAnimationCue* sself, double _arg); +extern "C" double vtk_animation_cue_get_start_time(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_set_end_time(vtkAnimationCue* sself, double _arg); +extern "C" double vtk_animation_cue_get_end_time(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_tick(vtkAnimationCue* sself, double currenttime, double deltatime, double clocktime); +extern "C" void vtk_animation_cue_initialize(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_finalize(vtkAnimationCue* sself); +extern "C" double vtk_animation_cue_get_animation_time(vtkAnimationCue* sself); +extern "C" double vtk_animation_cue_get_delta_time(vtkAnimationCue* sself); +extern "C" double vtk_animation_cue_get_clock_time(vtkAnimationCue* sself); +extern "C" vtkArchiver * vtkArchiver_new () ; +extern "C" void vtkArchiver_destructor (vtkArchiver * sself) ; +extern "C" void * vtkArchiver_get_ptr (vtkArchiver * sself) ; +extern "C" void vtk_archiver_set_archive_name(vtkArchiver* sself, const char* _arg); +extern "C" void vtk_archiver_open_archive(vtkArchiver* sself); +extern "C" void vtk_archiver_close_archive(vtkArchiver* sself); +extern "C" void vtk_archiver_insert_into_archive(vtkArchiver* sself, const char*& relativePath, const char* data, size_t size); +extern "C" bool vtk_archiver_contains(vtkArchiver* sself, const char*& relativePath); +extern "C" vtkBitArray * vtkBitArray_new () ; +extern "C" void vtkBitArray_destructor (vtkBitArray * sself) ; +extern "C" void * vtkBitArray_get_ptr (vtkBitArray * sself) ; +extern "C" int vtk_bit_array_allocate(vtkBitArray* sself, long long sz, long long ext); +extern "C" void vtk_bit_array_initialize(vtkBitArray* sself); +extern "C" int vtk_bit_array_get_data_type(vtkBitArray* sself); +extern "C" int vtk_bit_array_get_data_type_size(vtkBitArray* sself); +extern "C" void vtk_bit_array_set_number_of_tuples(vtkBitArray* sself, long long number); +extern "C" bool vtk_bit_array_set_number_of_values(vtkBitArray* sself, long long number); +extern "C" void vtk_bit_array_remove_tuple(vtkBitArray* sself, long long id); +extern "C" void vtk_bit_array_set_component(vtkBitArray* sself, long long i, int j, double c); +extern "C" void vtk_bit_array_squeeze(vtkBitArray* sself); +extern "C" int vtk_bit_array_resize(vtkBitArray* sself, long long numTuples); +extern "C" int vtk_bit_array_get_value(vtkBitArray* sself, long long id); +extern "C" void vtk_bit_array_set_value(vtkBitArray* sself, long long id, int value); +extern "C" void vtk_bit_array_insert_value(vtkBitArray* sself, long long id, int i); +extern "C" long long vtk_bit_array_insert_next_value(vtkBitArray* sself, int i); +extern "C" void vtk_bit_array_insert_component(vtkBitArray* sself, long long i, int j, double c); +extern "C" void* vtk_bit_array_write_void_pointer(vtkBitArray* sself, long long id, long long number); +extern "C" void* vtk_bit_array_get_void_pointer(vtkBitArray* sself, long long id); +extern "C" void vtk_bit_array_set_void_array(vtkBitArray* sself, void* array, long long size, int save); +extern "C" void vtk_bit_array_data_changed(vtkBitArray* sself); +extern "C" void vtk_bit_array_clear_lookup(vtkBitArray* sself); +extern "C" vtkBitArrayIterator * vtkBitArrayIterator_new () ; +extern "C" void vtkBitArrayIterator_destructor (vtkBitArrayIterator * sself) ; +extern "C" void * vtkBitArrayIterator_get_ptr (vtkBitArrayIterator * sself) ; +extern "C" int vtk_bit_array_iterator_get_value(vtkBitArrayIterator* sself, long long id); +extern "C" long long vtk_bit_array_iterator_get_number_of_tuples(vtkBitArrayIterator* sself); +extern "C" long long vtk_bit_array_iterator_get_number_of_values(vtkBitArrayIterator* sself); +extern "C" int vtk_bit_array_iterator_get_number_of_components(vtkBitArrayIterator* sself); +extern "C" int vtk_bit_array_iterator_get_data_type(vtkBitArrayIterator* sself); +extern "C" int vtk_bit_array_iterator_get_data_type_size(vtkBitArrayIterator* sself); +extern "C" void vtk_bit_array_iterator_set_value(vtkBitArrayIterator* sself, long long id, int value); +extern "C" vtkBoxMuellerRandomSequence * vtkBoxMuellerRandomSequence_new () ; +extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkBoxMuellerRandomSequence * sself) ; +extern "C" void * vtkBoxMuellerRandomSequence_get_ptr (vtkBoxMuellerRandomSequence * sself) ; +extern "C" void vtk_box_mueller_random_sequence_initialize(vtkBoxMuellerRandomSequence* sself, unsigned int seed); +extern "C" double vtk_box_mueller_random_sequence_get_value(vtkBoxMuellerRandomSequence* sself); +extern "C" void vtk_box_mueller_random_sequence_next(vtkBoxMuellerRandomSequence* sself); +extern "C" vtkByteSwap * vtkByteSwap_new () ; +extern "C" void vtkByteSwap_destructor (vtkByteSwap * sself) ; +extern "C" void * vtkByteSwap_get_ptr (vtkByteSwap * sself) ; +extern "C" void vtk_byte_swap_swap_2_le(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_4_le(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_8_le(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_2_le_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_4_le_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_8_le_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_2_be(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_4_be(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_8_be(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_2_be_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_4_be_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_8_be_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_void_range(vtkByteSwap* sself, void* buffer, size_t numWords, size_t wordSize); +extern "C" vtkCallbackCommand * vtkCallbackCommand_new () ; +extern "C" void vtkCallbackCommand_destructor (vtkCallbackCommand * sself) ; +extern "C" void * vtkCallbackCommand_get_ptr (vtkCallbackCommand * sself) ; +extern "C" void vtk_callback_command_set_client_data(vtkCallbackCommand* sself, void* cd); +extern "C" void* vtk_callback_command_get_client_data(vtkCallbackCommand* sself); +extern "C" void vtk_callback_command_set_abort_flag_on_execute(vtkCallbackCommand* sself, int f); +extern "C" int vtk_callback_command_get_abort_flag_on_execute(vtkCallbackCommand* sself); +extern "C" void vtk_callback_command_abort_flag_on_execute_on(vtkCallbackCommand* sself); +extern "C" void vtk_callback_command_abort_flag_on_execute_off(vtkCallbackCommand* sself); +extern "C" vtkCharArray * vtkCharArray_new () ; +extern "C" void vtkCharArray_destructor (vtkCharArray * sself) ; +extern "C" void * vtkCharArray_get_ptr (vtkCharArray * sself) ; +extern "C" int vtk_char_array_get_data_type(vtkCharArray* sself); +extern "C" void vtk_char_array_set_typed_tuple(vtkCharArray* sself, long long i, const char* tuple); +extern "C" void vtk_char_array_insert_typed_tuple(vtkCharArray* sself, long long i, const char* tuple); +extern "C" long long vtk_char_array_insert_next_typed_tuple(vtkCharArray* sself, const char* tuple); +extern "C" char vtk_char_array_get_value(vtkCharArray* sself, long long id); +extern "C" void vtk_char_array_set_value(vtkCharArray* sself, long long id, char value); +extern "C" bool vtk_char_array_set_number_of_values(vtkCharArray* sself, long long number); +extern "C" void vtk_char_array_insert_value(vtkCharArray* sself, long long id, char f); +extern "C" long long vtk_char_array_insert_next_value(vtkCharArray* sself, char f); +extern "C" char vtk_char_array_get_data_type_value_min(vtkCharArray* sself); +extern "C" char vtk_char_array_get_data_type_value_max(vtkCharArray* sself); +extern "C" vtkCollection * vtkCollection_new () ; +extern "C" void vtkCollection_destructor (vtkCollection * sself) ; +extern "C" void * vtkCollection_get_ptr (vtkCollection * sself) ; +extern "C" void vtk_collection_remove_item(vtkCollection* sself, int i); +extern "C" void vtk_collection_remove_all_items(vtkCollection* sself); +extern "C" int vtk_collection_get_number_of_items(vtkCollection* sself); +extern "C" void vtk_collection_init_traversal(vtkCollection* sself); +extern "C" vtkCollectionIterator * vtkCollectionIterator_new () ; +extern "C" void vtkCollectionIterator_destructor (vtkCollectionIterator * sself) ; +extern "C" void * vtkCollectionIterator_get_ptr (vtkCollectionIterator * sself) ; +extern "C" void vtk_collection_iterator_init_traversal(vtkCollectionIterator* sself); +extern "C" void vtk_collection_iterator_go_to_first_item(vtkCollectionIterator* sself); +extern "C" void vtk_collection_iterator_go_to_next_item(vtkCollectionIterator* sself); +extern "C" int vtk_collection_iterator_is_done_with_traversal(vtkCollectionIterator* sself); +extern "C" vtkCriticalSection * vtkCriticalSection_new () ; +extern "C" void vtkCriticalSection_destructor (vtkCriticalSection * sself) ; +extern "C" void * vtkCriticalSection_get_ptr (vtkCriticalSection * sself) ; +extern "C" void vtk_critical_section_lock(vtkCriticalSection* sself); +extern "C" void vtk_critical_section_unlock(vtkCriticalSection* sself); +extern "C" vtkDataArrayCollection * vtkDataArrayCollection_new () ; +extern "C" void vtkDataArrayCollection_destructor (vtkDataArrayCollection * sself) ; +extern "C" void * vtkDataArrayCollection_get_ptr (vtkDataArrayCollection * sself) ; +extern "C" int vtk_data_array_collection_get_number_of_items(vtkDataArrayCollection* sself); +extern "C" vtkDataArrayCollectionIterator * vtkDataArrayCollectionIterator_new () ; +extern "C" void vtkDataArrayCollectionIterator_destructor (vtkDataArrayCollectionIterator * sself) ; +extern "C" void * vtkDataArrayCollectionIterator_get_ptr (vtkDataArrayCollectionIterator * sself) ; +extern "C" vtkDataArraySelection * vtkDataArraySelection_new () ; +extern "C" void vtkDataArraySelection_destructor (vtkDataArraySelection * sself) ; +extern "C" void * vtkDataArraySelection_get_ptr (vtkDataArraySelection * sself) ; +extern "C" void vtk_data_array_selection_enable_array(vtkDataArraySelection* sself, const char* name); +extern "C" void vtk_data_array_selection_disable_array(vtkDataArraySelection* sself, const char* name); +extern "C" int vtk_data_array_selection_array_is_enabled(vtkDataArraySelection* sself, const char* name); +extern "C" int vtk_data_array_selection_array_exists(vtkDataArraySelection* sself, const char* name); +extern "C" void vtk_data_array_selection_enable_all_arrays(vtkDataArraySelection* sself); +extern "C" void vtk_data_array_selection_disable_all_arrays(vtkDataArraySelection* sself); +extern "C" int vtk_data_array_selection_get_number_of_arrays(vtkDataArraySelection* sself); +extern "C" int vtk_data_array_selection_get_number_of_arrays_enabled(vtkDataArraySelection* sself); +extern "C" const char* vtk_data_array_selection_get_array_name(vtkDataArraySelection* sself, int index); +extern "C" int vtk_data_array_selection_get_array_index(vtkDataArraySelection* sself, const char* name); +extern "C" int vtk_data_array_selection_get_enabled_array_index(vtkDataArraySelection* sself, const char* name); +extern "C" int vtk_data_array_selection_get_array_setting(vtkDataArraySelection* sself, int index); +extern "C" void vtk_data_array_selection_set_array_setting(vtkDataArraySelection* sself, const char* name, int setting); +extern "C" void vtk_data_array_selection_remove_all_arrays(vtkDataArraySelection* sself); +extern "C" int vtk_data_array_selection_add_array(vtkDataArraySelection* sself, const char* name, bool state); +extern "C" void vtk_data_array_selection_remove_array_by_index(vtkDataArraySelection* sself, int index); +extern "C" void vtk_data_array_selection_remove_array_by_name(vtkDataArraySelection* sself, const char* name); +extern "C" void vtk_data_array_selection_set_unknown_array_setting(vtkDataArraySelection* sself, int _arg); +extern "C" int vtk_data_array_selection_get_unknown_array_setting(vtkDataArraySelection* sself); +extern "C" vtkDebugLeaks * vtkDebugLeaks_new () ; +extern "C" void vtkDebugLeaks_destructor (vtkDebugLeaks * sself) ; +extern "C" void * vtkDebugLeaks_get_ptr (vtkDebugLeaks * sself) ; +extern "C" int vtk_debug_leaks_print_current_leaks(vtkDebugLeaks* sself); +extern "C" int vtk_debug_leaks_get_exit_error(vtkDebugLeaks* sself); +extern "C" void vtk_debug_leaks_set_exit_error(vtkDebugLeaks* sself, int p0); +extern "C" vtkDoubleArray * vtkDoubleArray_new () ; +extern "C" void vtkDoubleArray_destructor (vtkDoubleArray * sself) ; +extern "C" void * vtkDoubleArray_get_ptr (vtkDoubleArray * sself) ; +extern "C" int vtk_double_array_get_data_type(vtkDoubleArray* sself); +extern "C" double vtk_double_array_get_value(vtkDoubleArray* sself, long long id); +extern "C" void vtk_double_array_set_value(vtkDoubleArray* sself, long long id, double value); +extern "C" bool vtk_double_array_set_number_of_values(vtkDoubleArray* sself, long long number); +extern "C" void vtk_double_array_insert_value(vtkDoubleArray* sself, long long id, double f); +extern "C" long long vtk_double_array_insert_next_value(vtkDoubleArray* sself, double f); +extern "C" double vtk_double_array_get_data_type_value_min(vtkDoubleArray* sself); +extern "C" double vtk_double_array_get_data_type_value_max(vtkDoubleArray* sself); +extern "C" vtkDynamicLoader * vtkDynamicLoader_new () ; +extern "C" void vtkDynamicLoader_destructor (vtkDynamicLoader * sself) ; +extern "C" void * vtkDynamicLoader_get_ptr (vtkDynamicLoader * sself) ; +extern "C" const char* vtk_dynamic_loader_lib_prefix(vtkDynamicLoader* sself); +extern "C" const char* vtk_dynamic_loader_lib_extension(vtkDynamicLoader* sself); +extern "C" const char* vtk_dynamic_loader_last_error(vtkDynamicLoader* sself); +extern "C" vtkEventDataDevice3D * vtkEventDataDevice3D_new () ; +extern "C" void vtkEventDataDevice3D_destructor (vtkEventDataDevice3D * sself) ; +extern "C" void * vtkEventDataDevice3D_get_ptr (vtkEventDataDevice3D * sself) ; +extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkEventDataDevice3D* sself, double x, double y); +extern "C" vtkEventDataForDevice * vtkEventDataForDevice_new () ; +extern "C" void vtkEventDataForDevice_destructor (vtkEventDataForDevice * sself) ; +extern "C" void * vtkEventDataForDevice_get_ptr (vtkEventDataForDevice * sself) ; +extern "C" vtkEventForwarderCommand * vtkEventForwarderCommand_new () ; +extern "C" void vtkEventForwarderCommand_destructor (vtkEventForwarderCommand * sself) ; +extern "C" void * vtkEventForwarderCommand_get_ptr (vtkEventForwarderCommand * sself) ; +extern "C" void* vtk_event_forwarder_command_get_target(vtkEventForwarderCommand* sself); +extern "C" vtkFileOutputWindow * vtkFileOutputWindow_new () ; +extern "C" void vtkFileOutputWindow_destructor (vtkFileOutputWindow * sself) ; +extern "C" void * vtkFileOutputWindow_get_ptr (vtkFileOutputWindow * sself) ; +extern "C" void vtk_file_output_window_display_text(vtkFileOutputWindow* sself, const char* p0); +extern "C" void vtk_file_output_window_set_file_name(vtkFileOutputWindow* sself, const char* _arg); +extern "C" void vtk_file_output_window_set_flush(vtkFileOutputWindow* sself, int _arg); +extern "C" int vtk_file_output_window_get_flush(vtkFileOutputWindow* sself); +extern "C" void vtk_file_output_window_flush_on(vtkFileOutputWindow* sself); +extern "C" void vtk_file_output_window_flush_off(vtkFileOutputWindow* sself); +extern "C" void vtk_file_output_window_set_append(vtkFileOutputWindow* sself, int _arg); +extern "C" int vtk_file_output_window_get_append(vtkFileOutputWindow* sself); +extern "C" void vtk_file_output_window_append_on(vtkFileOutputWindow* sself); +extern "C" void vtk_file_output_window_append_off(vtkFileOutputWindow* sself); +extern "C" vtkFloatArray * vtkFloatArray_new () ; +extern "C" void vtkFloatArray_destructor (vtkFloatArray * sself) ; +extern "C" void * vtkFloatArray_get_ptr (vtkFloatArray * sself) ; +extern "C" int vtk_float_array_get_data_type(vtkFloatArray* sself); +extern "C" float vtk_float_array_get_value(vtkFloatArray* sself, long long id); +extern "C" void vtk_float_array_set_value(vtkFloatArray* sself, long long id, float value); +extern "C" bool vtk_float_array_set_number_of_values(vtkFloatArray* sself, long long number); +extern "C" void vtk_float_array_insert_value(vtkFloatArray* sself, long long id, float f); +extern "C" long long vtk_float_array_insert_next_value(vtkFloatArray* sself, float f); +extern "C" float vtk_float_array_get_data_type_value_min(vtkFloatArray* sself); +extern "C" float vtk_float_array_get_data_type_value_max(vtkFloatArray* sself); +extern "C" vtkGarbageCollector * vtkGarbageCollector_new () ; +extern "C" void vtkGarbageCollector_destructor (vtkGarbageCollector * sself) ; +extern "C" void * vtkGarbageCollector_get_ptr (vtkGarbageCollector * sself) ; +extern "C" void vtk_garbage_collector_collect(vtkGarbageCollector* sself); +extern "C" void vtk_garbage_collector_deferred_collection_push(vtkGarbageCollector* sself); +extern "C" void vtk_garbage_collector_deferred_collection_pop(vtkGarbageCollector* sself); +extern "C" void vtk_garbage_collector_set_global_debug_flag(vtkGarbageCollector* sself, bool flag); +extern "C" bool vtk_garbage_collector_get_global_debug_flag(vtkGarbageCollector* sself); +extern "C" vtkIdList * vtkIdList_new () ; +extern "C" void vtkIdList_destructor (vtkIdList * sself) ; +extern "C" void * vtkIdList_get_ptr (vtkIdList * sself) ; +extern "C" void vtk_id_list_initialize(vtkIdList* sself); +extern "C" int vtk_id_list_allocate(vtkIdList* sself, const long long sz, const int strategy); +extern "C" long long vtk_id_list_get_number_of_ids(vtkIdList* sself); +extern "C" long long vtk_id_list_get_id(vtkIdList* sself, const long long i); +extern "C" long long vtk_id_list_find_id_location(vtkIdList* sself, const long long id); +extern "C" void vtk_id_list_set_number_of_ids(vtkIdList* sself, const long long number); +extern "C" void vtk_id_list_set_id(vtkIdList* sself, const long long i, const long long vtkid); +extern "C" void vtk_id_list_insert_id(vtkIdList* sself, const long long i, const long long vtkid); +extern "C" long long vtk_id_list_insert_next_id(vtkIdList* sself, const long long vtkid); +extern "C" long long vtk_id_list_insert_unique_id(vtkIdList* sself, const long long vtkid); +extern "C" void vtk_id_list_sort(vtkIdList* sself); +extern "C" void vtk_id_list_fill(vtkIdList* sself, long long value); +extern "C" void vtk_id_list_reset(vtkIdList* sself); +extern "C" void vtk_id_list_squeeze(vtkIdList* sself); +extern "C" void vtk_id_list_delete_id(vtkIdList* sself, long long vtkid); +extern "C" long long vtk_id_list_is_id(vtkIdList* sself, long long vtkid); +extern "C" vtkIdListCollection * vtkIdListCollection_new () ; +extern "C" void vtkIdListCollection_destructor (vtkIdListCollection * sself) ; +extern "C" void * vtkIdListCollection_get_ptr (vtkIdListCollection * sself) ; +extern "C" int vtk_id_list_collection_get_number_of_items(vtkIdListCollection* sself); +extern "C" vtkIdTypeArray * vtkIdTypeArray_new () ; +extern "C" void vtkIdTypeArray_destructor (vtkIdTypeArray * sself) ; +extern "C" void * vtkIdTypeArray_get_ptr (vtkIdTypeArray * sself) ; +extern "C" int vtk_id_type_array_get_data_type(vtkIdTypeArray* sself); +extern "C" long long vtk_id_type_array_get_value(vtkIdTypeArray* sself, long long id); +extern "C" void vtk_id_type_array_set_value(vtkIdTypeArray* sself, long long id, long long value); +extern "C" bool vtk_id_type_array_set_number_of_values(vtkIdTypeArray* sself, long long number); +extern "C" void vtk_id_type_array_insert_value(vtkIdTypeArray* sself, long long id, long long f); +extern "C" long long vtk_id_type_array_insert_next_value(vtkIdTypeArray* sself, long long f); +extern "C" long long vtk_id_type_array_get_data_type_value_min(vtkIdTypeArray* sself); +extern "C" long long vtk_id_type_array_get_data_type_value_max(vtkIdTypeArray* sself); +extern "C" vtkInformation * vtkInformation_new () ; +extern "C" void vtkInformation_destructor (vtkInformation * sself) ; +extern "C" void * vtkInformation_get_ptr (vtkInformation * sself) ; +extern "C" void vtk_information_modified(vtkInformation* sself); +extern "C" void vtk_information_clear(vtkInformation* sself); +extern "C" int vtk_information_get_number_of_keys(vtkInformation* sself); +extern "C" vtkInformationIterator * vtkInformationIterator_new () ; +extern "C" void vtkInformationIterator_destructor (vtkInformationIterator * sself) ; +extern "C" void * vtkInformationIterator_get_ptr (vtkInformationIterator * sself) ; +extern "C" void vtk_information_iterator_init_traversal(vtkInformationIterator* sself); +extern "C" void vtk_information_iterator_go_to_first_item(vtkInformationIterator* sself); +extern "C" void vtk_information_iterator_go_to_next_item(vtkInformationIterator* sself); +extern "C" int vtk_information_iterator_is_done_with_traversal(vtkInformationIterator* sself); +extern "C" vtkInformationKeyLookup * vtkInformationKeyLookup_new () ; +extern "C" void vtkInformationKeyLookup_destructor (vtkInformationKeyLookup * sself) ; +extern "C" void * vtkInformationKeyLookup_get_ptr (vtkInformationKeyLookup * sself) ; +extern "C" vtkInformationVector * vtkInformationVector_new () ; +extern "C" void vtkInformationVector_destructor (vtkInformationVector * sself) ; +extern "C" void * vtkInformationVector_get_ptr (vtkInformationVector * sself) ; +extern "C" int vtk_information_vector_get_number_of_information_objects(vtkInformationVector* sself); +extern "C" void vtk_information_vector_set_number_of_information_objects(vtkInformationVector* sself, int n); +extern "C" vtkIntArray * vtkIntArray_new () ; +extern "C" void vtkIntArray_destructor (vtkIntArray * sself) ; +extern "C" void * vtkIntArray_get_ptr (vtkIntArray * sself) ; +extern "C" int vtk_int_array_get_data_type(vtkIntArray* sself); +extern "C" int vtk_int_array_get_value(vtkIntArray* sself, long long id); +extern "C" void vtk_int_array_set_value(vtkIntArray* sself, long long id, int value); +extern "C" bool vtk_int_array_set_number_of_values(vtkIntArray* sself, long long number); +extern "C" void vtk_int_array_insert_value(vtkIntArray* sself, long long id, int f); +extern "C" long long vtk_int_array_insert_next_value(vtkIntArray* sself, int f); +extern "C" int vtk_int_array_get_data_type_value_min(vtkIntArray* sself); +extern "C" int vtk_int_array_get_data_type_value_max(vtkIntArray* sself); +extern "C" vtkLongArray * vtkLongArray_new () ; +extern "C" void vtkLongArray_destructor (vtkLongArray * sself) ; +extern "C" void * vtkLongArray_get_ptr (vtkLongArray * sself) ; +extern "C" int vtk_long_array_get_data_type(vtkLongArray* sself); +extern "C" long vtk_long_array_get_value(vtkLongArray* sself, long long id); +extern "C" void vtk_long_array_set_value(vtkLongArray* sself, long long id, long value); +extern "C" bool vtk_long_array_set_number_of_values(vtkLongArray* sself, long long number); +extern "C" void vtk_long_array_insert_value(vtkLongArray* sself, long long id, long f); +extern "C" long long vtk_long_array_insert_next_value(vtkLongArray* sself, long f); +extern "C" long vtk_long_array_get_data_type_value_min(vtkLongArray* sself); +extern "C" long vtk_long_array_get_data_type_value_max(vtkLongArray* sself); +extern "C" vtkLongLongArray * vtkLongLongArray_new () ; +extern "C" void vtkLongLongArray_destructor (vtkLongLongArray * sself) ; +extern "C" void * vtkLongLongArray_get_ptr (vtkLongLongArray * sself) ; +extern "C" int vtk_long_long_array_get_data_type(vtkLongLongArray* sself); +extern "C" long long vtk_long_long_array_get_value(vtkLongLongArray* sself, long long id); +extern "C" void vtk_long_long_array_set_value(vtkLongLongArray* sself, long long id, long long value); +extern "C" bool vtk_long_long_array_set_number_of_values(vtkLongLongArray* sself, long long number); +extern "C" void vtk_long_long_array_insert_value(vtkLongLongArray* sself, long long id, long long f); +extern "C" long long vtk_long_long_array_insert_next_value(vtkLongLongArray* sself, long long f); +extern "C" long long vtk_long_long_array_get_data_type_value_min(vtkLongLongArray* sself); +extern "C" long long vtk_long_long_array_get_data_type_value_max(vtkLongLongArray* sself); +extern "C" vtkLookupTable * vtkLookupTable_new () ; +extern "C" void vtkLookupTable_destructor (vtkLookupTable * sself) ; +extern "C" void * vtkLookupTable_get_ptr (vtkLookupTable * sself) ; +extern "C" int vtk_lookup_table_is_opaque(vtkLookupTable* sself); +extern "C" int vtk_lookup_table_allocate(vtkLookupTable* sself, int sz, int ext); +extern "C" void vtk_lookup_table_build(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_force_build(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_build_special_colors(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_ramp(vtkLookupTable* sself, int _arg); +extern "C" void vtk_lookup_table_set_ramp_to_linear(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_ramp_to_s_curve(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_ramp_to_sqrt(vtkLookupTable* sself); +extern "C" int vtk_lookup_table_get_ramp(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_scale(vtkLookupTable* sself, int scale); +extern "C" void vtk_lookup_table_set_scale_to_linear(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_scale_to_log_10(vtkLookupTable* sself); +extern "C" int vtk_lookup_table_get_scale(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_table_range(vtkLookupTable* sself, double min, double max); +extern "C" void vtk_lookup_table_set_hue_range(vtkLookupTable* sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_saturation_range(vtkLookupTable* sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_value_range(vtkLookupTable* sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_alpha_range(vtkLookupTable* sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_nan_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_set_below_range_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_set_use_below_range_color(vtkLookupTable* sself, int _arg); +extern "C" int vtk_lookup_table_get_use_below_range_color(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_use_below_range_color_on(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_use_below_range_color_off(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_above_range_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_set_use_above_range_color(vtkLookupTable* sself, int _arg); +extern "C" int vtk_lookup_table_get_use_above_range_color(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_use_above_range_color_on(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_use_above_range_color_off(vtkLookupTable* sself); +extern "C" double vtk_lookup_table_get_opacity(vtkLookupTable* sself, double v); +extern "C" long long vtk_lookup_table_get_index(vtkLookupTable* sself, double v); +extern "C" void vtk_lookup_table_set_number_of_table_values(vtkLookupTable* sself, long long number); +extern "C" long long vtk_lookup_table_get_number_of_table_values(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_table_value(vtkLookupTable* sself, long long indx, double r, double g, double b, double a); +extern "C" void vtk_lookup_table_set_number_of_colors(vtkLookupTable* sself, long long _arg); +extern "C" long long vtk_lookup_table_get_number_of_colors_min_value(vtkLookupTable* sself); +extern "C" long long vtk_lookup_table_get_number_of_colors_max_value(vtkLookupTable* sself); +extern "C" long long vtk_lookup_table_get_number_of_colors(vtkLookupTable* sself); +extern "C" int vtk_lookup_table_using_log_scale(vtkLookupTable* sself); +extern "C" vtkMath * vtkMath_new () ; +extern "C" void vtkMath_destructor (vtkMath * sself) ; +extern "C" void * vtkMath_get_ptr (vtkMath * sself) ; +extern "C" double vtk_math_pi(vtkMath* sself); +extern "C" float vtk_math_radians_from_degrees(vtkMath* sself, float degrees); +extern "C" float vtk_math_degrees_from_radians(vtkMath* sself, float radians); +extern "C" int vtk_math_round(vtkMath* sself, float f); +extern "C" int vtk_math_floor(vtkMath* sself, double x); +extern "C" int vtk_math_ceil(vtkMath* sself, double x); +extern "C" int vtk_math_ceil_log_2(vtkMath* sself, unsigned long long x); +extern "C" bool vtk_math_is_power_of_two(vtkMath* sself, unsigned long long x); +extern "C" int vtk_math_nearest_power_of_two(vtkMath* sself, int x); +extern "C" long long vtk_math_factorial(vtkMath* sself, int N); +extern "C" long long vtk_math_binomial(vtkMath* sself, int m, int n); +extern "C" void vtk_math_random_seed(vtkMath* sself, int s); +extern "C" int vtk_math_get_seed(vtkMath* sself); +extern "C" double vtk_math_random(vtkMath* sself); +extern "C" double vtk_math_gaussian(vtkMath* sself); +extern "C" double vtk_math_gaussian_amplitude(vtkMath* sself, const double variance, const double distanceFromMean); +extern "C" double vtk_math_gaussian_weight(vtkMath* sself, const double variance, const double distanceFromMean); +extern "C" double vtk_math_determinant_2_x_2(vtkMath* sself, double a, double b, double c, double d); +extern "C" double vtk_math_determinant_3_x_3(vtkMath* sself, double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3); +extern "C" int vtk_math_solve_linear_system_gepp_2_x_2(vtkMath* sself, double a00, double a01, double a10, double a11, double b0, double b1, double& x0, double& x1); +extern "C" int vtk_math_get_scalar_type_fitting_range(vtkMath* sself, double range_min, double range_max, double scale, double shift); +extern "C" double vtk_math_inf(vtkMath* sself); +extern "C" double vtk_math_neg_inf(vtkMath* sself); +extern "C" double vtk_math_nan(vtkMath* sself); +extern "C" int vtk_math_is_inf(vtkMath* sself, double x); +extern "C" int vtk_math_is_nan(vtkMath* sself, double x); +extern "C" bool vtk_math_is_finite(vtkMath* sself, double x); +extern "C" vtkMersenneTwister * vtkMersenneTwister_new () ; +extern "C" void vtkMersenneTwister_destructor (vtkMersenneTwister * sself) ; +extern "C" void * vtkMersenneTwister_get_ptr (vtkMersenneTwister * sself) ; +extern "C" void vtk_mersenne_twister_initialize(vtkMersenneTwister* sself, unsigned int seed); +extern "C" unsigned int vtk_mersenne_twister_initialize_new_sequence(vtkMersenneTwister* sself, unsigned int seed, int p); +extern "C" void vtk_mersenne_twister_initialize_sequence(vtkMersenneTwister* sself, unsigned int id, unsigned int seed, int p); +extern "C" double vtk_mersenne_twister_get_value(vtkMersenneTwister* sself, unsigned int id); +extern "C" void vtk_mersenne_twister_next(vtkMersenneTwister* sself, unsigned int id); +extern "C" vtkMinimalStandardRandomSequence * vtkMinimalStandardRandomSequence_new () ; +extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkMinimalStandardRandomSequence * sself) ; +extern "C" void * vtkMinimalStandardRandomSequence_get_ptr (vtkMinimalStandardRandomSequence * sself) ; +extern "C" void vtk_minimal_standard_random_sequence_initialize(vtkMinimalStandardRandomSequence* sself, unsigned int seed); +extern "C" void vtk_minimal_standard_random_sequence_set_seed(vtkMinimalStandardRandomSequence* sself, int value); +extern "C" void vtk_minimal_standard_random_sequence_set_seed_only(vtkMinimalStandardRandomSequence* sself, int value); +extern "C" int vtk_minimal_standard_random_sequence_get_seed(vtkMinimalStandardRandomSequence* sself); +extern "C" double vtk_minimal_standard_random_sequence_get_value(vtkMinimalStandardRandomSequence* sself); +extern "C" void vtk_minimal_standard_random_sequence_next(vtkMinimalStandardRandomSequence* sself); +extern "C" double vtk_minimal_standard_random_sequence_get_range_value(vtkMinimalStandardRandomSequence* sself, double rangeMin, double rangeMax); +extern "C" double vtk_minimal_standard_random_sequence_get_next_range_value(vtkMinimalStandardRandomSequence* sself, double rangeMin, double rangeMax); +extern "C" vtkMultiThreader * vtkMultiThreader_new () ; +extern "C" void vtkMultiThreader_destructor (vtkMultiThreader * sself) ; +extern "C" void * vtkMultiThreader_get_ptr (vtkMultiThreader * sself) ; +extern "C" void vtk_multi_threader_set_number_of_threads(vtkMultiThreader* sself, int _arg); +extern "C" int vtk_multi_threader_get_number_of_threads_min_value(vtkMultiThreader* sself); +extern "C" int vtk_multi_threader_get_number_of_threads_max_value(vtkMultiThreader* sself); +extern "C" int vtk_multi_threader_get_number_of_threads(vtkMultiThreader* sself); +extern "C" int vtk_multi_threader_get_global_static_maximum_number_of_threads(vtkMultiThreader* sself); +extern "C" void vtk_multi_threader_set_global_maximum_number_of_threads(vtkMultiThreader* sself, int val); +extern "C" int vtk_multi_threader_get_global_maximum_number_of_threads(vtkMultiThreader* sself); +extern "C" void vtk_multi_threader_set_global_default_number_of_threads(vtkMultiThreader* sself, int val); +extern "C" int vtk_multi_threader_get_global_default_number_of_threads(vtkMultiThreader* sself); +extern "C" void vtk_multi_threader_single_method_execute(vtkMultiThreader* sself); +extern "C" void vtk_multi_threader_multiple_method_execute(vtkMultiThreader* sself); +extern "C" void vtk_multi_threader_terminate_thread(vtkMultiThreader* sself, int threadId); +extern "C" int vtk_multi_threader_is_thread_active(vtkMultiThreader* sself, int threadId); +extern "C" vtkObject * vtkObject_new () ; +extern "C" void vtkObject_destructor (vtkObject * sself) ; +extern "C" void * vtkObject_get_ptr (vtkObject * sself) ; +extern "C" int vtk_object_is_type_of(vtkObject* sself, const char* type); +extern "C" int vtk_object_is_a(vtkObject* sself, const char* type); +extern "C" long long vtk_object_get_number_of_generations_from_base_type(vtkObject* sself, const char* type); +extern "C" long long vtk_object_get_number_of_generations_from_base(vtkObject* sself, const char* type); +extern "C" void vtk_object_debug_on(vtkObject* sself); +extern "C" void vtk_object_debug_off(vtkObject* sself); +extern "C" bool vtk_object_get_debug(vtkObject* sself); +extern "C" void vtk_object_set_debug(vtkObject* sself, bool debugFlag); +extern "C" void vtk_object_break_on_error(vtkObject* sself); +extern "C" void vtk_object_modified(vtkObject* sself); +extern "C" unsigned long vtk_object_get_m_time(vtkObject* sself); +extern "C" void vtk_object_set_global_warning_display(vtkObject* sself, int val); +extern "C" void vtk_object_global_warning_display_on(vtkObject* sself); +extern "C" void vtk_object_global_warning_display_off(vtkObject* sself); +extern "C" int vtk_object_get_global_warning_display(vtkObject* sself); +extern "C" void vtk_object_remove_all_observers(vtkObject* sself); +extern "C" int vtk_object_invoke_event(vtkObject* sself, unsigned long event, void* callData); +extern "C" vtkObjectFactoryCollection * vtkObjectFactoryCollection_new () ; +extern "C" void vtkObjectFactoryCollection_destructor (vtkObjectFactoryCollection * sself) ; +extern "C" void * vtkObjectFactoryCollection_get_ptr (vtkObjectFactoryCollection * sself) ; +extern "C" vtkOldStyleCallbackCommand * vtkOldStyleCallbackCommand_new () ; +extern "C" void vtkOldStyleCallbackCommand_destructor (vtkOldStyleCallbackCommand * sself) ; +extern "C" void * vtkOldStyleCallbackCommand_get_ptr (vtkOldStyleCallbackCommand * sself) ; +extern "C" void vtk_old_style_callback_command_set_client_data(vtkOldStyleCallbackCommand* sself, void* cd); +extern "C" vtkOutputWindow * vtkOutputWindow_new () ; +extern "C" void vtkOutputWindow_destructor (vtkOutputWindow * sself) ; +extern "C" void * vtkOutputWindow_get_ptr (vtkOutputWindow * sself) ; +extern "C" void vtk_output_window_display_text(vtkOutputWindow* sself, const char* p0); +extern "C" void vtk_output_window_display_error_text(vtkOutputWindow* sself, const char* p0); +extern "C" void vtk_output_window_display_warning_text(vtkOutputWindow* sself, const char* p0); +extern "C" void vtk_output_window_display_generic_warning_text(vtkOutputWindow* sself, const char* p0); +extern "C" void vtk_output_window_display_debug_text(vtkOutputWindow* sself, const char* p0); +extern "C" void vtk_output_window_prompt_user_on(vtkOutputWindow* sself); +extern "C" void vtk_output_window_prompt_user_off(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_prompt_user(vtkOutputWindow* sself, bool _arg); +extern "C" void vtk_output_window_set_use_std_error_for_all_messages(vtkOutputWindow* sself, bool p0); +extern "C" bool vtk_output_window_get_use_std_error_for_all_messages(vtkOutputWindow* sself); +extern "C" void vtk_output_window_use_std_error_for_all_messages_on(vtkOutputWindow* sself); +extern "C" void vtk_output_window_use_std_error_for_all_messages_off(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_display_mode(vtkOutputWindow* sself, int _arg); +extern "C" int vtk_output_window_get_display_mode_min_value(vtkOutputWindow* sself); +extern "C" int vtk_output_window_get_display_mode_max_value(vtkOutputWindow* sself); +extern "C" int vtk_output_window_get_display_mode(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_display_mode_to_default(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_display_mode_to_never(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_display_mode_to_always(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_display_mode_to_always_std_err(vtkOutputWindow* sself); +extern "C" vtkOverrideInformationCollection * vtkOverrideInformationCollection_new () ; +extern "C" void vtkOverrideInformationCollection_destructor (vtkOverrideInformationCollection * sself) ; +extern "C" void * vtkOverrideInformationCollection_get_ptr (vtkOverrideInformationCollection * sself) ; +extern "C" vtkPoints * vtkPoints_new () ; +extern "C" void vtkPoints_destructor (vtkPoints * sself) ; +extern "C" void * vtkPoints_get_ptr (vtkPoints * sself) ; +extern "C" int vtk_points_allocate(vtkPoints* sself, long long sz, long long ext); +extern "C" void vtk_points_initialize(vtkPoints* sself); +extern "C" int vtk_points_get_data_type(vtkPoints* sself); +extern "C" void vtk_points_set_data_type(vtkPoints* sself, int dataType); +extern "C" void vtk_points_set_data_type_to_bit(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_char(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_unsigned_char(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_short(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_unsigned_short(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_int(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_unsigned_int(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_long(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_unsigned_long(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_float(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_double(vtkPoints* sself); +extern "C" void* vtk_points_get_void_pointer(vtkPoints* sself, const int id); +extern "C" void vtk_points_squeeze(vtkPoints* sself); +extern "C" void vtk_points_reset(vtkPoints* sself); +extern "C" unsigned long vtk_points_get_actual_memory_size(vtkPoints* sself); +extern "C" long long vtk_points_get_number_of_points(vtkPoints* sself); +extern "C" void vtk_points_set_point(vtkPoints* sself, long long id, double x, double y, double z); +extern "C" void vtk_points_insert_point(vtkPoints* sself, long long id, double x, double y, double z); +extern "C" long long vtk_points_insert_next_point(vtkPoints* sself, double x, double y, double z); +extern "C" void vtk_points_set_number_of_points(vtkPoints* sself, long long numPoints); +extern "C" int vtk_points_resize(vtkPoints* sself, long long numPoints); +extern "C" void vtk_points_compute_bounds(vtkPoints* sself); +extern "C" unsigned long vtk_points_get_m_time(vtkPoints* sself); +extern "C" void vtk_points_modified(vtkPoints* sself); +extern "C" vtkPoints2D * vtkPoints2D_new () ; +extern "C" void vtkPoints2D_destructor (vtkPoints2D * sself) ; +extern "C" void * vtkPoints2D_get_ptr (vtkPoints2D * sself) ; +extern "C" int vtk_points_2_d_allocate(vtkPoints2D* sself, long long sz, long long ext); +extern "C" void vtk_points_2_d_initialize(vtkPoints2D* sself); +extern "C" int vtk_points_2_d_get_data_type(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type(vtkPoints2D* sself, int dataType); +extern "C" void vtk_points_2_d_set_data_type_to_bit(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_char(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_char(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_short(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_short(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_int(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_int(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_long(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_long(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_float(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_double(vtkPoints2D* sself); +extern "C" void* vtk_points_2_d_get_void_pointer(vtkPoints2D* sself, const int id); +extern "C" void vtk_points_2_d_squeeze(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_reset(vtkPoints2D* sself); +extern "C" unsigned long vtk_points_2_d_get_actual_memory_size(vtkPoints2D* sself); +extern "C" long long vtk_points_2_d_get_number_of_points(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_point(vtkPoints2D* sself, long long id, double x, double y); +extern "C" void vtk_points_2_d_insert_point(vtkPoints2D* sself, long long id, double x, double y); +extern "C" long long vtk_points_2_d_insert_next_point(vtkPoints2D* sself, double x, double y); +extern "C" void vtk_points_2_d_remove_point(vtkPoints2D* sself, long long id); +extern "C" void vtk_points_2_d_set_number_of_points(vtkPoints2D* sself, long long numPoints); +extern "C" int vtk_points_2_d_resize(vtkPoints2D* sself, long long numPoints); +extern "C" void vtk_points_2_d_compute_bounds(vtkPoints2D* sself); +extern "C" vtkPriorityQueue * vtkPriorityQueue_new () ; +extern "C" void vtkPriorityQueue_destructor (vtkPriorityQueue * sself) ; +extern "C" void * vtkPriorityQueue_get_ptr (vtkPriorityQueue * sself) ; +extern "C" void vtk_priority_queue_allocate(vtkPriorityQueue* sself, long long sz, long long ext); +extern "C" void vtk_priority_queue_insert(vtkPriorityQueue* sself, double priority, long long id); +extern "C" long long vtk_priority_queue_pop(vtkPriorityQueue* sself, long long location, double& priority); +extern "C" long long vtk_priority_queue_peek(vtkPriorityQueue* sself, long long location, double& priority); +extern "C" double vtk_priority_queue_delete_id(vtkPriorityQueue* sself, long long id); +extern "C" double vtk_priority_queue_get_priority(vtkPriorityQueue* sself, long long id); +extern "C" long long vtk_priority_queue_get_number_of_items(vtkPriorityQueue* sself); +extern "C" void vtk_priority_queue_reset(vtkPriorityQueue* sself); +extern "C" vtkRandomPool * vtkRandomPool_new () ; +extern "C" void vtkRandomPool_destructor (vtkRandomPool * sself) ; +extern "C" void * vtkRandomPool_get_ptr (vtkRandomPool * sself) ; +extern "C" void vtk_random_pool_set_size(vtkRandomPool* sself, long long _arg); +extern "C" long long vtk_random_pool_get_size_min_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_size_max_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_size(vtkRandomPool* sself); +extern "C" void vtk_random_pool_set_number_of_components(vtkRandomPool* sself, long long _arg); +extern "C" long long vtk_random_pool_get_number_of_components_min_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_number_of_components_max_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_number_of_components(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_total_size(vtkRandomPool* sself); +extern "C" double vtk_random_pool_get_value(vtkRandomPool* sself, long long i); +extern "C" void vtk_random_pool_set_chunk_size(vtkRandomPool* sself, long long _arg); +extern "C" long long vtk_random_pool_get_chunk_size_min_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_chunk_size_max_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_chunk_size(vtkRandomPool* sself); +extern "C" vtkReferenceCount * vtkReferenceCount_new () ; +extern "C" void vtkReferenceCount_destructor (vtkReferenceCount * sself) ; +extern "C" void * vtkReferenceCount_get_ptr (vtkReferenceCount * sself) ; +extern "C" vtkScalarsToColors * vtkScalarsToColors_new () ; +extern "C" void vtkScalarsToColors_destructor (vtkScalarsToColors * sself) ; +extern "C" void * vtkScalarsToColors_get_ptr (vtkScalarsToColors * sself) ; +extern "C" int vtk_scalars_to_colors_is_opaque(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_build(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_range(vtkScalarsToColors* sself, double min, double max); +extern "C" double vtk_scalars_to_colors_get_opacity(vtkScalarsToColors* sself, double v); +extern "C" double vtk_scalars_to_colors_get_luminance(vtkScalarsToColors* sself, double x); +extern "C" void vtk_scalars_to_colors_set_alpha(vtkScalarsToColors* sself, double alpha); +extern "C" double vtk_scalars_to_colors_get_alpha(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode(vtkScalarsToColors* sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_vector_mode(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_magnitude(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_component(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_rgb_colors(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_component(vtkScalarsToColors* sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_vector_component(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_size(vtkScalarsToColors* sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_vector_size(vtkScalarsToColors* sself); +extern "C" int vtk_scalars_to_colors_using_log_scale(vtkScalarsToColors* sself); +extern "C" long long vtk_scalars_to_colors_get_number_of_available_colors(vtkScalarsToColors* sself); +extern "C" long long vtk_scalars_to_colors_get_number_of_annotated_values(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_reset_annotations(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_indexed_lookup(vtkScalarsToColors* sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_indexed_lookup(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_indexed_lookup_on(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_indexed_lookup_off(vtkScalarsToColors* sself); +extern "C" vtkShortArray * vtkShortArray_new () ; +extern "C" void vtkShortArray_destructor (vtkShortArray * sself) ; +extern "C" void * vtkShortArray_get_ptr (vtkShortArray * sself) ; +extern "C" int vtk_short_array_get_data_type(vtkShortArray* sself); +extern "C" short vtk_short_array_get_value(vtkShortArray* sself, long long id); +extern "C" void vtk_short_array_set_value(vtkShortArray* sself, long long id, short value); +extern "C" bool vtk_short_array_set_number_of_values(vtkShortArray* sself, long long number); +extern "C" void vtk_short_array_insert_value(vtkShortArray* sself, long long id, short f); +extern "C" long long vtk_short_array_insert_next_value(vtkShortArray* sself, short f); +extern "C" short vtk_short_array_get_data_type_value_min(vtkShortArray* sself); +extern "C" short vtk_short_array_get_data_type_value_max(vtkShortArray* sself); +extern "C" vtkSignedCharArray * vtkSignedCharArray_new () ; +extern "C" void vtkSignedCharArray_destructor (vtkSignedCharArray * sself) ; +extern "C" void * vtkSignedCharArray_get_ptr (vtkSignedCharArray * sself) ; +extern "C" int vtk_signed_char_array_get_data_type(vtkSignedCharArray* sself); +extern "C" signed char vtk_signed_char_array_get_value(vtkSignedCharArray* sself, long long id); +extern "C" void vtk_signed_char_array_set_value(vtkSignedCharArray* sself, long long id, signed char value); +extern "C" bool vtk_signed_char_array_set_number_of_values(vtkSignedCharArray* sself, long long number); +extern "C" void vtk_signed_char_array_insert_value(vtkSignedCharArray* sself, long long id, signed char f); +extern "C" long long vtk_signed_char_array_insert_next_value(vtkSignedCharArray* sself, signed char f); +extern "C" signed char vtk_signed_char_array_get_data_type_value_min(vtkSignedCharArray* sself); +extern "C" signed char vtk_signed_char_array_get_data_type_value_max(vtkSignedCharArray* sself); +extern "C" vtkSortDataArray * vtkSortDataArray_new () ; +extern "C" void vtkSortDataArray_destructor (vtkSortDataArray * sself) ; +extern "C" void * vtkSortDataArray_get_ptr (vtkSortDataArray * sself) ; +extern "C" vtkStringArray * vtkStringArray_new () ; +extern "C" void vtkStringArray_destructor (vtkStringArray * sself) ; +extern "C" void * vtkStringArray_get_ptr (vtkStringArray * sself) ; +extern "C" int vtk_string_array_get_data_type(vtkStringArray* sself); +extern "C" int vtk_string_array_is_numeric(vtkStringArray* sself); +extern "C" void vtk_string_array_initialize(vtkStringArray* sself); +extern "C" int vtk_string_array_get_data_type_size(vtkStringArray* sself); +extern "C" void vtk_string_array_squeeze(vtkStringArray* sself); +extern "C" int vtk_string_array_resize(vtkStringArray* sself, long long numTuples); +extern "C" int vtk_string_array_allocate(vtkStringArray* sself, long long sz, long long ext); +extern "C" void vtk_string_array_set_number_of_tuples(vtkStringArray* sself, long long number); +extern "C" long long vtk_string_array_get_number_of_values(vtkStringArray* sself); +extern "C" int vtk_string_array_get_number_of_element_components(vtkStringArray* sself); +extern "C" int vtk_string_array_get_element_component_size(vtkStringArray* sself); +extern "C" void* vtk_string_array_get_void_pointer(vtkStringArray* sself, long long id); +extern "C" void vtk_string_array_set_void_array(vtkStringArray* sself, void* array, long long size, int save); +extern "C" unsigned long vtk_string_array_get_actual_memory_size(vtkStringArray* sself); +extern "C" long long vtk_string_array_get_data_size(vtkStringArray* sself); +extern "C" void vtk_string_array_data_changed(vtkStringArray* sself); +extern "C" void vtk_string_array_data_element_changed(vtkStringArray* sself, long long id); +extern "C" void vtk_string_array_clear_lookup(vtkStringArray* sself); +extern "C" vtkStringOutputWindow * vtkStringOutputWindow_new () ; +extern "C" void vtkStringOutputWindow_destructor (vtkStringOutputWindow * sself) ; +extern "C" void * vtkStringOutputWindow_get_ptr (vtkStringOutputWindow * sself) ; +extern "C" void vtk_string_output_window_display_text(vtkStringOutputWindow* sself, const char* p0); +extern "C" vtkTimePointUtility * vtkTimePointUtility_new () ; +extern "C" void vtkTimePointUtility_destructor (vtkTimePointUtility * sself) ; +extern "C" void * vtkTimePointUtility_get_ptr (vtkTimePointUtility * sself) ; +extern "C" unsigned long long vtk_time_point_utility_date_to_time_point(vtkTimePointUtility* sself, int year, int month, int day); +extern "C" unsigned long long vtk_time_point_utility_time_to_time_point(vtkTimePointUtility* sself, int hour, int minute, int second, int millis); +extern "C" unsigned long long vtk_time_point_utility_date_time_to_time_point(vtkTimePointUtility* sself, int year, int month, int day, int hour, int minute, int sec, int millis); +extern "C" void vtk_time_point_utility_get_date(vtkTimePointUtility* sself, unsigned long long time, int& year, int& month, int& day); +extern "C" void vtk_time_point_utility_get_time(vtkTimePointUtility* sself, unsigned long long time, int& hour, int& minute, int& second, int& millis); +extern "C" void vtk_time_point_utility_get_date_time(vtkTimePointUtility* sself, unsigned long long time, int& year, int& month, int& day, int& hour, int& minute, int& second, int& millis); +extern "C" int vtk_time_point_utility_get_year(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_month(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_day(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_hour(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_minute(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_second(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_millisecond(vtkTimePointUtility* sself, unsigned long long time); +extern "C" const char* vtk_time_point_utility_time_point_to_iso_8601(vtkTimePointUtility* sself, unsigned long long p0, int format); +extern "C" vtkTypeFloat32Array * vtkTypeFloat32Array_new () ; +extern "C" void vtkTypeFloat32Array_destructor (vtkTypeFloat32Array * sself) ; +extern "C" void * vtkTypeFloat32Array_get_ptr (vtkTypeFloat32Array * sself) ; +extern "C" vtkTypeFloat64Array * vtkTypeFloat64Array_new () ; +extern "C" void vtkTypeFloat64Array_destructor (vtkTypeFloat64Array * sself) ; +extern "C" void * vtkTypeFloat64Array_get_ptr (vtkTypeFloat64Array * sself) ; +extern "C" vtkTypeInt16Array * vtkTypeInt16Array_new () ; +extern "C" void vtkTypeInt16Array_destructor (vtkTypeInt16Array * sself) ; +extern "C" void * vtkTypeInt16Array_get_ptr (vtkTypeInt16Array * sself) ; +extern "C" vtkTypeInt32Array * vtkTypeInt32Array_new () ; +extern "C" void vtkTypeInt32Array_destructor (vtkTypeInt32Array * sself) ; +extern "C" void * vtkTypeInt32Array_get_ptr (vtkTypeInt32Array * sself) ; +extern "C" vtkTypeInt64Array * vtkTypeInt64Array_new () ; +extern "C" void vtkTypeInt64Array_destructor (vtkTypeInt64Array * sself) ; +extern "C" void * vtkTypeInt64Array_get_ptr (vtkTypeInt64Array * sself) ; +extern "C" vtkTypeInt8Array * vtkTypeInt8Array_new () ; +extern "C" void vtkTypeInt8Array_destructor (vtkTypeInt8Array * sself) ; +extern "C" void * vtkTypeInt8Array_get_ptr (vtkTypeInt8Array * sself) ; +extern "C" vtkTypeUInt16Array * vtkTypeUInt16Array_new () ; +extern "C" void vtkTypeUInt16Array_destructor (vtkTypeUInt16Array * sself) ; +extern "C" void * vtkTypeUInt16Array_get_ptr (vtkTypeUInt16Array * sself) ; +extern "C" vtkTypeUInt32Array * vtkTypeUInt32Array_new () ; +extern "C" void vtkTypeUInt32Array_destructor (vtkTypeUInt32Array * sself) ; +extern "C" void * vtkTypeUInt32Array_get_ptr (vtkTypeUInt32Array * sself) ; +extern "C" vtkTypeUInt64Array * vtkTypeUInt64Array_new () ; +extern "C" void vtkTypeUInt64Array_destructor (vtkTypeUInt64Array * sself) ; +extern "C" void * vtkTypeUInt64Array_get_ptr (vtkTypeUInt64Array * sself) ; +extern "C" vtkTypeUInt8Array * vtkTypeUInt8Array_new () ; +extern "C" void vtkTypeUInt8Array_destructor (vtkTypeUInt8Array * sself) ; +extern "C" void * vtkTypeUInt8Array_get_ptr (vtkTypeUInt8Array * sself) ; +extern "C" vtkUnicodeStringArray * vtkUnicodeStringArray_new () ; +extern "C" void vtkUnicodeStringArray_destructor (vtkUnicodeStringArray * sself) ; +extern "C" void * vtkUnicodeStringArray_get_ptr (vtkUnicodeStringArray * sself) ; +extern "C" int vtk_unicode_string_array_allocate(vtkUnicodeStringArray* sself, long long sz, long long ext); +extern "C" void vtk_unicode_string_array_initialize(vtkUnicodeStringArray* sself); +extern "C" int vtk_unicode_string_array_get_data_type(vtkUnicodeStringArray* sself); +extern "C" int vtk_unicode_string_array_get_data_type_size(vtkUnicodeStringArray* sself); +extern "C" int vtk_unicode_string_array_get_element_component_size(vtkUnicodeStringArray* sself); +extern "C" void vtk_unicode_string_array_set_number_of_tuples(vtkUnicodeStringArray* sself, long long number); +extern "C" void* vtk_unicode_string_array_get_void_pointer(vtkUnicodeStringArray* sself, long long id); +extern "C" void vtk_unicode_string_array_squeeze(vtkUnicodeStringArray* sself); +extern "C" int vtk_unicode_string_array_resize(vtkUnicodeStringArray* sself, long long numTuples); +extern "C" void vtk_unicode_string_array_set_void_array(vtkUnicodeStringArray* sself, void* array, long long size, int save); +extern "C" unsigned long vtk_unicode_string_array_get_actual_memory_size(vtkUnicodeStringArray* sself); +extern "C" int vtk_unicode_string_array_is_numeric(vtkUnicodeStringArray* sself); +extern "C" void vtk_unicode_string_array_data_changed(vtkUnicodeStringArray* sself); +extern "C" void vtk_unicode_string_array_clear_lookup(vtkUnicodeStringArray* sself); +extern "C" void vtk_unicode_string_array_insert_next_utf_8_value(vtkUnicodeStringArray* sself, const char* p0); +extern "C" void vtk_unicode_string_array_set_utf_8_value(vtkUnicodeStringArray* sself, long long i, const char* p1); +extern "C" const char* vtk_unicode_string_array_get_utf_8_value(vtkUnicodeStringArray* sself, long long i); +extern "C" vtkUnsignedCharArray * vtkUnsignedCharArray_new () ; +extern "C" void vtkUnsignedCharArray_destructor (vtkUnsignedCharArray * sself) ; +extern "C" void * vtkUnsignedCharArray_get_ptr (vtkUnsignedCharArray * sself) ; +extern "C" int vtk_unsigned_char_array_get_data_type(vtkUnsignedCharArray* sself); +extern "C" unsigned char vtk_unsigned_char_array_get_value(vtkUnsignedCharArray* sself, long long id); +extern "C" void vtk_unsigned_char_array_set_value(vtkUnsignedCharArray* sself, long long id, unsigned char value); +extern "C" bool vtk_unsigned_char_array_set_number_of_values(vtkUnsignedCharArray* sself, long long number); +extern "C" void vtk_unsigned_char_array_insert_value(vtkUnsignedCharArray* sself, long long id, unsigned char f); +extern "C" long long vtk_unsigned_char_array_insert_next_value(vtkUnsignedCharArray* sself, unsigned char f); +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_min(vtkUnsignedCharArray* sself); +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_max(vtkUnsignedCharArray* sself); +extern "C" vtkUnsignedIntArray * vtkUnsignedIntArray_new () ; +extern "C" void vtkUnsignedIntArray_destructor (vtkUnsignedIntArray * sself) ; +extern "C" void * vtkUnsignedIntArray_get_ptr (vtkUnsignedIntArray * sself) ; +extern "C" int vtk_unsigned_int_array_get_data_type(vtkUnsignedIntArray* sself); +extern "C" unsigned int vtk_unsigned_int_array_get_value(vtkUnsignedIntArray* sself, long long id); +extern "C" void vtk_unsigned_int_array_set_value(vtkUnsignedIntArray* sself, long long id, unsigned int value); +extern "C" bool vtk_unsigned_int_array_set_number_of_values(vtkUnsignedIntArray* sself, long long number); +extern "C" void vtk_unsigned_int_array_insert_value(vtkUnsignedIntArray* sself, long long id, unsigned int f); +extern "C" long long vtk_unsigned_int_array_insert_next_value(vtkUnsignedIntArray* sself, unsigned int f); +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_min(vtkUnsignedIntArray* sself); +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_max(vtkUnsignedIntArray* sself); +extern "C" vtkUnsignedLongArray * vtkUnsignedLongArray_new () ; +extern "C" void vtkUnsignedLongArray_destructor (vtkUnsignedLongArray * sself) ; +extern "C" void * vtkUnsignedLongArray_get_ptr (vtkUnsignedLongArray * sself) ; +extern "C" int vtk_unsigned_long_array_get_data_type(vtkUnsignedLongArray* sself); +extern "C" unsigned long vtk_unsigned_long_array_get_value(vtkUnsignedLongArray* sself, long long id); +extern "C" void vtk_unsigned_long_array_set_value(vtkUnsignedLongArray* sself, long long id, unsigned long value); +extern "C" bool vtk_unsigned_long_array_set_number_of_values(vtkUnsignedLongArray* sself, long long number); +extern "C" void vtk_unsigned_long_array_insert_value(vtkUnsignedLongArray* sself, long long id, unsigned long f); +extern "C" long long vtk_unsigned_long_array_insert_next_value(vtkUnsignedLongArray* sself, unsigned long f); +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_min(vtkUnsignedLongArray* sself); +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_max(vtkUnsignedLongArray* sself); +extern "C" vtkUnsignedLongLongArray * vtkUnsignedLongLongArray_new () ; +extern "C" void vtkUnsignedLongLongArray_destructor (vtkUnsignedLongLongArray * sself) ; +extern "C" void * vtkUnsignedLongLongArray_get_ptr (vtkUnsignedLongLongArray * sself) ; +extern "C" int vtk_unsigned_long_long_array_get_data_type(vtkUnsignedLongLongArray* sself); +extern "C" unsigned long long vtk_unsigned_long_long_array_get_value(vtkUnsignedLongLongArray* sself, long long id); +extern "C" void vtk_unsigned_long_long_array_set_value(vtkUnsignedLongLongArray* sself, long long id, unsigned long long value); +extern "C" bool vtk_unsigned_long_long_array_set_number_of_values(vtkUnsignedLongLongArray* sself, long long number); +extern "C" void vtk_unsigned_long_long_array_insert_value(vtkUnsignedLongLongArray* sself, long long id, unsigned long long f); +extern "C" long long vtk_unsigned_long_long_array_insert_next_value(vtkUnsignedLongLongArray* sself, unsigned long long f); +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_min(vtkUnsignedLongLongArray* sself); +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_max(vtkUnsignedLongLongArray* sself); +extern "C" vtkUnsignedShortArray * vtkUnsignedShortArray_new () ; +extern "C" void vtkUnsignedShortArray_destructor (vtkUnsignedShortArray * sself) ; +extern "C" void * vtkUnsignedShortArray_get_ptr (vtkUnsignedShortArray * sself) ; +extern "C" int vtk_unsigned_short_array_get_data_type(vtkUnsignedShortArray* sself); +extern "C" unsigned short vtk_unsigned_short_array_get_value(vtkUnsignedShortArray* sself, long long id); +extern "C" void vtk_unsigned_short_array_set_value(vtkUnsignedShortArray* sself, long long id, unsigned short value); +extern "C" bool vtk_unsigned_short_array_set_number_of_values(vtkUnsignedShortArray* sself, long long number); +extern "C" void vtk_unsigned_short_array_insert_value(vtkUnsignedShortArray* sself, long long id, unsigned short f); +extern "C" long long vtk_unsigned_short_array_insert_next_value(vtkUnsignedShortArray* sself, unsigned short f); +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_min(vtkUnsignedShortArray* sself); +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_max(vtkUnsignedShortArray* sself); +extern "C" vtkVariantArray * vtkVariantArray_new () ; +extern "C" void vtkVariantArray_destructor (vtkVariantArray * sself) ; +extern "C" void * vtkVariantArray_get_ptr (vtkVariantArray * sself) ; +extern "C" int vtk_variant_array_allocate(vtkVariantArray* sself, long long sz, long long ext); +extern "C" void vtk_variant_array_initialize(vtkVariantArray* sself); +extern "C" int vtk_variant_array_get_data_type(vtkVariantArray* sself); +extern "C" int vtk_variant_array_get_data_type_size(vtkVariantArray* sself); +extern "C" int vtk_variant_array_get_element_component_size(vtkVariantArray* sself); +extern "C" void vtk_variant_array_set_number_of_tuples(vtkVariantArray* sself, long long number); +extern "C" void* vtk_variant_array_get_void_pointer(vtkVariantArray* sself, long long id); +extern "C" void vtk_variant_array_squeeze(vtkVariantArray* sself); +extern "C" int vtk_variant_array_resize(vtkVariantArray* sself, long long numTuples); +extern "C" void vtk_variant_array_set_void_array(vtkVariantArray* sself, void* arr, long long size, int save); +extern "C" unsigned long vtk_variant_array_get_actual_memory_size(vtkVariantArray* sself); +extern "C" int vtk_variant_array_is_numeric(vtkVariantArray* sself); +extern "C" long long vtk_variant_array_get_number_of_values(vtkVariantArray* sself); +extern "C" void vtk_variant_array_data_changed(vtkVariantArray* sself); +extern "C" void vtk_variant_array_data_element_changed(vtkVariantArray* sself, long long id); +extern "C" void vtk_variant_array_clear_lookup(vtkVariantArray* sself); +extern "C" vtkVersion * vtkVersion_new () ; +extern "C" void vtkVersion_destructor (vtkVersion * sself) ; +extern "C" void * vtkVersion_get_ptr (vtkVersion * sself) ; +extern "C" const char* vtk_version_get_vtk_version(vtkVersion* sself); +extern "C" const char* vtk_version_get_vtk_version_full(vtkVersion* sself); +extern "C" int vtk_version_get_vtk_major_version(vtkVersion* sself); +extern "C" int vtk_version_get_vtk_minor_version(vtkVersion* sself); +extern "C" int vtk_version_get_vtk_build_version(vtkVersion* sself); +extern "C" const char* vtk_version_get_vtk_source_version(vtkVersion* sself); +extern "C" vtkVoidArray * vtkVoidArray_new () ; +extern "C" void vtkVoidArray_destructor (vtkVoidArray * sself) ; +extern "C" void * vtkVoidArray_get_ptr (vtkVoidArray * sself) ; +extern "C" int vtk_void_array_allocate(vtkVoidArray* sself, long long sz, long long ext); +extern "C" void vtk_void_array_initialize(vtkVoidArray* sself); +extern "C" int vtk_void_array_get_data_type(vtkVoidArray* sself); +extern "C" int vtk_void_array_get_data_type_size(vtkVoidArray* sself); +extern "C" void vtk_void_array_set_number_of_pointers(vtkVoidArray* sself, long long number); +extern "C" long long vtk_void_array_get_number_of_pointers(vtkVoidArray* sself); +extern "C" void* vtk_void_array_get_void_pointer(vtkVoidArray* sself, long long id); +extern "C" void vtk_void_array_set_void_pointer(vtkVoidArray* sself, long long id, void* ptr); +extern "C" void vtk_void_array_insert_void_pointer(vtkVoidArray* sself, long long i, void* ptr); +extern "C" long long vtk_void_array_insert_next_void_pointer(vtkVoidArray* sself, void* tuple); +extern "C" void vtk_void_array_reset(vtkVoidArray* sself); +extern "C" void vtk_void_array_squeeze(vtkVoidArray* sself); +extern "C" vtkWeakReference * vtkWeakReference_new () ; +extern "C" void vtkWeakReference_destructor (vtkWeakReference * sself) ; +extern "C" void * vtkWeakReference_get_ptr (vtkWeakReference * sself) ; +extern "C" vtkXMLFileOutputWindow * vtkXMLFileOutputWindow_new () ; +extern "C" void vtkXMLFileOutputWindow_destructor (vtkXMLFileOutputWindow * sself) ; +extern "C" void * vtkXMLFileOutputWindow_get_ptr (vtkXMLFileOutputWindow * sself) ; +extern "C" void vtk_xml_file_output_window_display_text(vtkXMLFileOutputWindow* sself, const char* p0); +extern "C" void vtk_xml_file_output_window_display_tag(vtkXMLFileOutputWindow* sself, const char* p0); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h index 4cf9ada..712326b 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h @@ -279,3022 +279,1889 @@ #include // Declare exported functions -extern "C" vtkNew < vtkAMRDataInternals > vtkAMRDataInternals_new () ; -extern "C" void vtkAMRDataInternals_destructor (vtkNew < vtkAMRDataInternals > sself) ; -extern "C" void * vtkAMRDataInternals_get_ptr (vtkNew < vtkAMRDataInternals > sself) ; -extern "C" void vtk_amr_data_internals_initialize(vtkNew sself); -extern "C" bool vtk_amr_data_internals_empty(vtkNew sself); -extern "C" unsigned int vtk_amr_data_internals_get_number_of_blocks(vtkNew sself); -extern "C" vtkNew < vtkAdjacentVertexIterator > vtkAdjacentVertexIterator_new () ; -extern "C" void vtkAdjacentVertexIterator_destructor (vtkNew < vtkAdjacentVertexIterator > sself) ; -extern "C" void * vtkAdjacentVertexIterator_get_ptr (vtkNew < vtkAdjacentVertexIterator > sself) ; -extern "C" long long vtk_adjacent_vertex_iterator_get_vertex(vtkNew sself); -extern "C" long long vtk_adjacent_vertex_iterator_next(vtkNew sself); -extern "C" bool vtk_adjacent_vertex_iterator_has_next(vtkNew sself); -extern "C" vtkNew < vtkAnimationScene > vtkAnimationScene_new () ; -extern "C" void vtkAnimationScene_destructor (vtkNew < vtkAnimationScene > sself) ; -extern "C" void * vtkAnimationScene_get_ptr (vtkNew < vtkAnimationScene > sself) ; -extern "C" void vtk_animation_scene_set_play_mode(vtkNew sself, int _arg); -extern "C" void vtk_animation_scene_set_mode_to_sequence(vtkNew sself); -extern "C" void vtk_animation_scene_set_mode_to_real_time(vtkNew sself); -extern "C" int vtk_animation_scene_get_play_mode(vtkNew sself); -extern "C" void vtk_animation_scene_set_frame_rate(vtkNew sself, double _arg); -extern "C" double vtk_animation_scene_get_frame_rate(vtkNew sself); -extern "C" void vtk_animation_scene_remove_all_cues(vtkNew sself); -extern "C" int vtk_animation_scene_get_number_of_cues(vtkNew sself); -extern "C" void vtk_animation_scene_play(vtkNew sself); -extern "C" void vtk_animation_scene_stop(vtkNew sself); -extern "C" void vtk_animation_scene_set_loop(vtkNew sself, int _arg); -extern "C" int vtk_animation_scene_get_loop(vtkNew sself); -extern "C" void vtk_animation_scene_set_animation_time(vtkNew sself, double time); -extern "C" void vtk_animation_scene_set_time_mode(vtkNew sself, int mode); -extern "C" int vtk_animation_scene_is_in_play(vtkNew sself); -extern "C" vtkNew < vtkAnnotation > vtkAnnotation_new () ; -extern "C" void vtkAnnotation_destructor (vtkNew < vtkAnnotation > sself) ; -extern "C" void * vtkAnnotation_get_ptr (vtkNew < vtkAnnotation > sself) ; -extern "C" int vtk_annotation_get_data_object_type(vtkNew sself); -extern "C" void vtk_annotation_initialize(vtkNew sself); -extern "C" unsigned long vtk_annotation_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkAnnotationLayers > vtkAnnotationLayers_new () ; -extern "C" void vtkAnnotationLayers_destructor (vtkNew < vtkAnnotationLayers > sself) ; -extern "C" void * vtkAnnotationLayers_get_ptr (vtkNew < vtkAnnotationLayers > sself) ; -extern "C" int vtk_annotation_layers_get_data_object_type(vtkNew sself); -extern "C" unsigned int vtk_annotation_layers_get_number_of_annotations(vtkNew sself); -extern "C" void vtk_annotation_layers_initialize(vtkNew sself); -extern "C" unsigned long vtk_annotation_layers_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkArrayData > vtkArrayData_new () ; -extern "C" void vtkArrayData_destructor (vtkNew < vtkArrayData > sself) ; -extern "C" void * vtkArrayData_get_ptr (vtkNew < vtkArrayData > sself) ; -extern "C" void vtk_array_data_clear_arrays(vtkNew sself); -extern "C" long long vtk_array_data_get_number_of_arrays(vtkNew sself); -extern "C" int vtk_array_data_get_data_object_type(vtkNew sself); -extern "C" vtkNew < vtkAttributesErrorMetric > vtkAttributesErrorMetric_new () ; -extern "C" void vtkAttributesErrorMetric_destructor (vtkNew < vtkAttributesErrorMetric > sself) ; -extern "C" void * vtkAttributesErrorMetric_get_ptr (vtkNew < vtkAttributesErrorMetric > sself) ; -extern "C" double vtk_attributes_error_metric_get_absolute_attribute_tolerance(vtkNew sself); -extern "C" void vtk_attributes_error_metric_set_absolute_attribute_tolerance(vtkNew sself, double value); -extern "C" double vtk_attributes_error_metric_get_attribute_tolerance(vtkNew sself); -extern "C" void vtk_attributes_error_metric_set_attribute_tolerance(vtkNew sself, double value); -extern "C" int vtk_attributes_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); -extern "C" double vtk_attributes_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); -extern "C" vtkNew < vtkBSPCuts > vtkBSPCuts_new () ; -extern "C" void vtkBSPCuts_destructor (vtkNew < vtkBSPCuts > sself) ; -extern "C" void * vtkBSPCuts_get_ptr (vtkNew < vtkBSPCuts > sself) ; -extern "C" int vtk_bsp_cuts_get_data_object_type(vtkNew sself); -extern "C" void vtk_bsp_cuts_create_cuts(vtkNew sself, double bounds, int ncuts, int dim, double coord, int lower, int upper, double lowerDataCoord, double upperDataCoord, int npoints); -extern "C" int vtk_bsp_cuts_get_number_of_cuts(vtkNew sself); -extern "C" int vtk_bsp_cuts_get_arrays(vtkNew sself, int len, int dim, double coord, int lower, int upper, double lowerDataCoord, double upperDataCoord, int npoints); -extern "C" void vtk_bsp_cuts_print_tree(vtkNew sself); -extern "C" void vtk_bsp_cuts_print_arrays(vtkNew sself); -extern "C" vtkNew < vtkBSPIntersections > vtkBSPIntersections_new () ; -extern "C" void vtkBSPIntersections_destructor (vtkNew < vtkBSPIntersections > sself) ; -extern "C" void * vtkBSPIntersections_get_ptr (vtkNew < vtkBSPIntersections > sself) ; -extern "C" int vtk_bsp_intersections_get_bounds(vtkNew sself, double bounds); -extern "C" int vtk_bsp_intersections_get_number_of_regions(vtkNew sself); -extern "C" int vtk_bsp_intersections_get_region_bounds(vtkNew sself, int regionID, double bounds); -extern "C" int vtk_bsp_intersections_get_region_data_bounds(vtkNew sself, int regionID, double bounds); -extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int regionId, double x); -extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int regionId, double x0, double x1, double y0, double y1, double z0, double z1); -extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int ids, int len, double x); -extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int ids, int len, double x0, double x1, double y0, double y1, double z0, double z1); -extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkNew sself, int regionId, double x, double y, double z, double rSquared); -extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkNew sself, int ids, int len, double x, double y, double z, double rSquared); -extern "C" int vtk_bsp_intersections_get_compute_intersections_using_data_bounds(vtkNew sself); -extern "C" void vtk_bsp_intersections_set_compute_intersections_using_data_bounds(vtkNew sself, int c); -extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_on(vtkNew sself); -extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_off(vtkNew sself); -extern "C" vtkNew < vtkBezierCurve > vtkBezierCurve_new () ; -extern "C" void vtkBezierCurve_destructor (vtkNew < vtkBezierCurve > sself) ; -extern "C" void * vtkBezierCurve_get_ptr (vtkNew < vtkBezierCurve > sself) ; -extern "C" int vtk_bezier_curve_get_cell_type(vtkNew sself); -extern "C" void vtk_bezier_curve_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); -extern "C" void vtk_bezier_curve_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkBezierHexahedron > vtkBezierHexahedron_new () ; -extern "C" void vtkBezierHexahedron_destructor (vtkNew < vtkBezierHexahedron > sself) ; -extern "C" void * vtkBezierHexahedron_get_ptr (vtkNew < vtkBezierHexahedron > sself) ; -extern "C" int vtk_bezier_hexahedron_get_cell_type(vtkNew sself); -extern "C" void vtk_bezier_hexahedron_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); -extern "C" void vtk_bezier_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkBezierInterpolation > vtkBezierInterpolation_new () ; -extern "C" void vtkBezierInterpolation_destructor (vtkNew < vtkBezierInterpolation > sself) ; -extern "C" void * vtkBezierInterpolation_get_ptr (vtkNew < vtkBezierInterpolation > sself) ; -extern "C" void vtk_bezier_interpolation_de_casteljau_simplex(vtkNew sself, const int dim, const int deg, const double pcoords, double weights); -extern "C" void vtk_bezier_interpolation_de_casteljau_simplex(vtkNew sself, const int dim, const int deg, const double pcoords, double weights); -extern "C" void vtk_bezier_interpolation_de_casteljau_simplex_deriv(vtkNew sself, const int dim, const int deg, const double pcoords, double weights); -extern "C" void vtk_bezier_interpolation_de_casteljau_simplex_deriv(vtkNew sself, const int dim, const int deg, const double pcoords, double weights); -extern "C" void vtk_bezier_interpolation_evaluate_shape_functions(vtkNew sself, int order, double pcoord, double shape); -extern "C" void vtk_bezier_interpolation_evaluate_shape_and_gradient(vtkNew sself, int order, double pcoord, double shape, double grad); -extern "C" int vtk_bezier_interpolation_tensor_1_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); -extern "C" int vtk_bezier_interpolation_tensor_1_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); -extern "C" int vtk_bezier_interpolation_tensor_2_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); -extern "C" int vtk_bezier_interpolation_tensor_2_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); -extern "C" int vtk_bezier_interpolation_tensor_3_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); -extern "C" int vtk_bezier_interpolation_tensor_3_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); -extern "C" void vtk_bezier_interpolation_wedge_shape_functions(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double shape); -extern "C" void vtk_bezier_interpolation_wedge_shape_derivatives(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double derivs); -extern "C" void vtk_bezier_interpolation_wedge_evaluate(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double fieldVals, int fieldDim, double fieldAtPCoords); -extern "C" vtkNew < vtkBezierQuadrilateral > vtkBezierQuadrilateral_new () ; -extern "C" void vtkBezierQuadrilateral_destructor (vtkNew < vtkBezierQuadrilateral > sself) ; -extern "C" void * vtkBezierQuadrilateral_get_ptr (vtkNew < vtkBezierQuadrilateral > sself) ; -extern "C" int vtk_bezier_quadrilateral_get_cell_type(vtkNew sself); -extern "C" void vtk_bezier_quadrilateral_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); -extern "C" void vtk_bezier_quadrilateral_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkBezierTetra > vtkBezierTetra_new () ; -extern "C" void vtkBezierTetra_destructor (vtkNew < vtkBezierTetra > sself) ; -extern "C" void * vtkBezierTetra_get_ptr (vtkNew < vtkBezierTetra > sself) ; -extern "C" int vtk_bezier_tetra_get_cell_type(vtkNew sself); -extern "C" void vtk_bezier_tetra_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); -extern "C" void vtk_bezier_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkBezierTriangle > vtkBezierTriangle_new () ; -extern "C" void vtkBezierTriangle_destructor (vtkNew < vtkBezierTriangle > sself) ; -extern "C" void * vtkBezierTriangle_get_ptr (vtkNew < vtkBezierTriangle > sself) ; -extern "C" int vtk_bezier_triangle_get_cell_type(vtkNew sself); -extern "C" void vtk_bezier_triangle_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); -extern "C" void vtk_bezier_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkBezierWedge > vtkBezierWedge_new () ; -extern "C" void vtkBezierWedge_destructor (vtkNew < vtkBezierWedge > sself) ; -extern "C" void * vtkBezierWedge_get_ptr (vtkNew < vtkBezierWedge > sself) ; -extern "C" int vtk_bezier_wedge_get_cell_type(vtkNew sself); -extern "C" void vtk_bezier_wedge_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights); -extern "C" void vtk_bezier_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkBiQuadraticQuad > vtkBiQuadraticQuad_new () ; -extern "C" void vtkBiQuadraticQuad_destructor (vtkNew < vtkBiQuadraticQuad > sself) ; -extern "C" void * vtkBiQuadraticQuad_get_ptr (vtkNew < vtkBiQuadraticQuad > sself) ; -extern "C" int vtk_bi_quadratic_quad_get_cell_type(vtkNew sself); -extern "C" int vtk_bi_quadratic_quad_get_cell_dimension(vtkNew sself); -extern "C" int vtk_bi_quadratic_quad_get_number_of_edges(vtkNew sself); -extern "C" int vtk_bi_quadratic_quad_get_number_of_faces(vtkNew sself); -extern "C" int vtk_bi_quadratic_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_bi_quadratic_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_bi_quadratic_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_bi_quadratic_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_bi_quadratic_quad_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_bi_quadratic_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_bi_quadratic_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" vtkNew < vtkBiQuadraticQuadraticHexahedron > vtkBiQuadraticQuadraticHexahedron_new () ; -extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) ; -extern "C" void * vtkBiQuadraticQuadraticHexahedron_get_ptr (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) ; -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(vtkNew sself); -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(vtkNew sself); -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(vtkNew sself); -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(vtkNew sself); -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_bi_quadratic_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_bi_quadratic_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId); -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkBiQuadraticQuadraticWedge > vtkBiQuadraticQuadraticWedge_new () ; -extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkNew < vtkBiQuadraticQuadraticWedge > sself) ; -extern "C" void * vtkBiQuadraticQuadraticWedge_get_ptr (vtkNew < vtkBiQuadraticQuadraticWedge > sself) ; -extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_type(vtkNew sself); -extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(vtkNew sself); -extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(vtkNew sself); -extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(vtkNew sself); -extern "C" int vtk_bi_quadratic_quadratic_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_bi_quadratic_quadratic_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_bi_quadratic_quadratic_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_bi_quadratic_quadratic_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_bi_quadratic_quadratic_wedge_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_bi_quadratic_quadratic_wedge_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_bi_quadratic_quadratic_wedge_get_face_array(vtkNew sself, long long faceId); -extern "C" void vtk_bi_quadratic_quadratic_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkBiQuadraticTriangle > vtkBiQuadraticTriangle_new () ; -extern "C" void vtkBiQuadraticTriangle_destructor (vtkNew < vtkBiQuadraticTriangle > sself) ; -extern "C" void * vtkBiQuadraticTriangle_get_ptr (vtkNew < vtkBiQuadraticTriangle > sself) ; -extern "C" int vtk_bi_quadratic_triangle_get_cell_type(vtkNew sself); -extern "C" int vtk_bi_quadratic_triangle_get_cell_dimension(vtkNew sself); -extern "C" int vtk_bi_quadratic_triangle_get_number_of_edges(vtkNew sself); -extern "C" int vtk_bi_quadratic_triangle_get_number_of_faces(vtkNew sself); -extern "C" int vtk_bi_quadratic_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_bi_quadratic_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_bi_quadratic_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_bi_quadratic_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_bi_quadratic_triangle_get_parametric_center(vtkNew sself, double pcoords); -extern "C" double vtk_bi_quadratic_triangle_get_parametric_distance(vtkNew sself, const double pcoords); -extern "C" void vtk_bi_quadratic_triangle_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_bi_quadratic_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_bi_quadratic_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_bi_quadratic_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" vtkNew < vtkBox > vtkBox_new () ; -extern "C" void vtkBox_destructor (vtkNew < vtkBox > sself) ; -extern "C" void * vtkBox_get_ptr (vtkNew < vtkBox > sself) ; -extern "C" double vtk_box_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_box_evaluate_gradient(vtkNew sself, double x, double n); -extern "C" void vtk_box_set_x_min(vtkNew sself, double p); -extern "C" void vtk_box_set_x_min(vtkNew sself, double x, double y, double z); -extern "C" void vtk_box_get_x_min(vtkNew sself, double p); -extern "C" void vtk_box_get_x_min(vtkNew sself, double x, double y, double z); -extern "C" void vtk_box_set_x_max(vtkNew sself, double p); -extern "C" void vtk_box_set_x_max(vtkNew sself, double x, double y, double z); -extern "C" void vtk_box_get_x_max(vtkNew sself, double p); -extern "C" void vtk_box_get_x_max(vtkNew sself, double x, double y, double z); -extern "C" void vtk_box_set_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); -extern "C" void vtk_box_set_bounds(vtkNew sself, const double bounds); -extern "C" void vtk_box_get_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); -extern "C" void vtk_box_get_bounds(vtkNew sself, double bounds); -extern "C" double* vtk_box_get_bounds(vtkNew sself); -extern "C" void vtk_box_add_bounds(vtkNew sself, const double bounds); -extern "C" char vtk_box_intersect_box(vtkNew sself, const double bounds, const double origin, const double dir, double coord, double t, const double tolerance); -extern "C" int vtk_box_intersect_with_line(vtkNew sself, const double bounds, const double p1, const double p2, double t1, double t2, double x1, double x2, int plane1, int plane2); -extern "C" bool vtk_box_intersect_with_infinite_line(vtkNew sself, const double bounds, const double p1, const double p2, double t1, double t2, double x1, double x2, int plane1, int plane2); -extern "C" int vtk_box_intersect_with_plane(vtkNew sself, double bounds, double origin, double normal); -extern "C" int vtk_box_intersect_with_plane(vtkNew sself, double bounds, double origin, double normal, double xout); -extern "C" int vtk_box_is_box_in_frustum(vtkNew sself, double planes, double bounds); -extern "C" vtkNew < vtkCellArray > vtkCellArray_new () ; -extern "C" void vtkCellArray_destructor (vtkNew < vtkCellArray > sself) ; -extern "C" void * vtkCellArray_get_ptr (vtkNew < vtkCellArray > sself) ; -extern "C" int vtk_cell_array_allocate(vtkNew sself, long long sz, long long ext); -extern "C" bool vtk_cell_array_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize); -extern "C" bool vtk_cell_array_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize); -extern "C" bool vtk_cell_array_resize_exact(vtkNew sself, long long numCells, long long connectivitySize); -extern "C" void vtk_cell_array_initialize(vtkNew sself); -extern "C" void vtk_cell_array_reset(vtkNew sself); -extern "C" void vtk_cell_array_squeeze(vtkNew sself); -extern "C" bool vtk_cell_array_is_valid(vtkNew sself); -extern "C" long long vtk_cell_array_get_number_of_cells(vtkNew sself); -extern "C" long long vtk_cell_array_get_number_of_offsets(vtkNew sself); -extern "C" long long vtk_cell_array_get_number_of_connectivity_ids(vtkNew sself); -extern "C" bool vtk_cell_array_is_storage_64_bit(vtkNew sself); -extern "C" bool vtk_cell_array_is_storage_shareable(vtkNew sself); -extern "C" void vtk_cell_array_use_32_bit_storage(vtkNew sself); -extern "C" void vtk_cell_array_use_64_bit_storage(vtkNew sself); -extern "C" void vtk_cell_array_use_default_storage(vtkNew sself); -extern "C" bool vtk_cell_array_can_convert_to_32_bit_storage(vtkNew sself); -extern "C" bool vtk_cell_array_can_convert_to_64_bit_storage(vtkNew sself); -extern "C" bool vtk_cell_array_can_convert_to_default_storage(vtkNew sself); -extern "C" bool vtk_cell_array_convert_to_32_bit_storage(vtkNew sself); -extern "C" bool vtk_cell_array_convert_to_64_bit_storage(vtkNew sself); -extern "C" bool vtk_cell_array_convert_to_default_storage(vtkNew sself); -extern "C" bool vtk_cell_array_convert_to_smallest_storage(vtkNew sself); -extern "C" long long vtk_cell_array_is_homogeneous(vtkNew sself); -extern "C" void vtk_cell_array_init_traversal(vtkNew sself); -extern "C" int vtk_cell_array_get_next_cell(vtkNew sself, long long npts, const long long pts); -extern "C" void vtk_cell_array_get_cell_at_id(vtkNew sself, long long cellId, long long cellSize, const long long cellPoints); -extern "C" long long vtk_cell_array_get_cell_size(vtkNew sself, const long long cellId); -extern "C" long long vtk_cell_array_insert_next_cell(vtkNew sself, long long npts, const long long pts); -extern "C" long long vtk_cell_array_insert_next_cell(vtkNew sself, int npts); -extern "C" void vtk_cell_array_insert_cell_point(vtkNew sself, long long id); -extern "C" void vtk_cell_array_update_cell_count(vtkNew sself, int npts); -extern "C" long long vtk_cell_array_get_traversal_cell_id(vtkNew sself); -extern "C" void vtk_cell_array_set_traversal_cell_id(vtkNew sself, long long cellId); -extern "C" void vtk_cell_array_reverse_cell_at_id(vtkNew sself, long long cellId); -extern "C" void vtk_cell_array_replace_cell_at_id(vtkNew sself, long long cellId, long long cellSize, const long long cellPoints); -extern "C" int vtk_cell_array_get_max_cell_size(vtkNew sself); -extern "C" void vtk_cell_array_import_legacy_format(vtkNew sself, const long long data, long long len); -extern "C" void vtk_cell_array_append_legacy_format(vtkNew sself, const long long data, long long len, long long ptOffset); -extern "C" unsigned long vtk_cell_array_get_actual_memory_size(vtkNew sself); -extern "C" void vtk_cell_array_set_number_of_cells(vtkNew sself, long long p0); -extern "C" long long vtk_cell_array_estimate_size(vtkNew sself, long long numCells, int maxPtsPerCell); -extern "C" long long vtk_cell_array_get_size(vtkNew sself); -extern "C" long long vtk_cell_array_get_number_of_connectivity_entries(vtkNew sself); -extern "C" void vtk_cell_array_get_cell(vtkNew sself, long long loc, long long npts, const long long pts); -extern "C" long long vtk_cell_array_get_insert_location(vtkNew sself, int npts); -extern "C" long long vtk_cell_array_get_traversal_location(vtkNew sself); -extern "C" long long vtk_cell_array_get_traversal_location(vtkNew sself, long long npts); -extern "C" void vtk_cell_array_set_traversal_location(vtkNew sself, long long loc); -extern "C" void vtk_cell_array_reverse_cell(vtkNew sself, long long loc); -extern "C" void vtk_cell_array_replace_cell(vtkNew sself, long long loc, int npts, const long long pts); -extern "C" vtkNew < vtkCellArrayIterator > vtkCellArrayIterator_new () ; -extern "C" void vtkCellArrayIterator_destructor (vtkNew < vtkCellArrayIterator > sself) ; -extern "C" void * vtkCellArrayIterator_get_ptr (vtkNew < vtkCellArrayIterator > sself) ; -extern "C" void vtk_cell_array_iterator_go_to_cell(vtkNew sself, long long cellId); -extern "C" void vtk_cell_array_iterator_get_cell_at_id(vtkNew sself, long long cellId, long long numCellPts, const long long cellPts); -extern "C" void vtk_cell_array_iterator_go_to_first_cell(vtkNew sself); -extern "C" void vtk_cell_array_iterator_go_to_next_cell(vtkNew sself); -extern "C" bool vtk_cell_array_iterator_is_done_with_traversal(vtkNew sself); -extern "C" long long vtk_cell_array_iterator_get_current_cell_id(vtkNew sself); -extern "C" void vtk_cell_array_iterator_get_current_cell(vtkNew sself, long long cellSize, const long long cellPoints); -extern "C" void vtk_cell_array_iterator_replace_current_cell(vtkNew sself, long long npts, const long long pts); -extern "C" void vtk_cell_array_iterator_reverse_current_cell(vtkNew sself); -extern "C" vtkNew < vtkCellData > vtkCellData_new () ; -extern "C" void vtkCellData_destructor (vtkNew < vtkCellData > sself) ; -extern "C" void * vtkCellData_get_ptr (vtkNew < vtkCellData > sself) ; -extern "C" vtkNew < vtkCellLinks > vtkCellLinks_new () ; -extern "C" void vtkCellLinks_destructor (vtkNew < vtkCellLinks > sself) ; -extern "C" void * vtkCellLinks_get_ptr (vtkNew < vtkCellLinks > sself) ; -extern "C" void vtk_cell_links_allocate(vtkNew sself, long long numLinks, long long ext); -extern "C" void vtk_cell_links_initialize(vtkNew sself); -extern "C" long long vtk_cell_links_get_ncells(vtkNew sself, long long ptId); -extern "C" long long* vtk_cell_links_get_cells(vtkNew sself, long long ptId); -extern "C" void vtk_cell_links_select_cells(vtkNew sself, long long minMaxDegree, unsigned char cellSelection); -extern "C" long long vtk_cell_links_insert_next_point(vtkNew sself, int numLinks); -extern "C" void vtk_cell_links_insert_next_cell_reference(vtkNew sself, long long ptId, long long cellId); -extern "C" void vtk_cell_links_delete_point(vtkNew sself, long long ptId); -extern "C" void vtk_cell_links_remove_cell_reference(vtkNew sself, long long cellId, long long ptId); -extern "C" void vtk_cell_links_add_cell_reference(vtkNew sself, long long cellId, long long ptId); -extern "C" void vtk_cell_links_resize_cell_list(vtkNew sself, long long ptId, int size); -extern "C" void vtk_cell_links_squeeze(vtkNew sself); -extern "C" void vtk_cell_links_reset(vtkNew sself); -extern "C" unsigned long vtk_cell_links_get_actual_memory_size(vtkNew sself); -extern "C" vtkNew < vtkCellLocator > vtkCellLocator_new () ; -extern "C" void vtkCellLocator_destructor (vtkNew < vtkCellLocator > sself) ; -extern "C" void * vtkCellLocator_get_ptr (vtkNew < vtkCellLocator > sself) ; -extern "C" void vtk_cell_locator_set_number_of_cells_per_bucket(vtkNew sself, int N); -extern "C" int vtk_cell_locator_get_number_of_cells_per_bucket(vtkNew sself); -extern "C" int vtk_cell_locator_get_number_of_buckets(vtkNew sself); -extern "C" void vtk_cell_locator_free_search_structure(vtkNew sself); -extern "C" void vtk_cell_locator_build_locator(vtkNew sself); -extern "C" void vtk_cell_locator_build_locator_if_needed(vtkNew sself); -extern "C" void vtk_cell_locator_force_build_locator(vtkNew sself); -extern "C" void vtk_cell_locator_build_locator_internal(vtkNew sself); -extern "C" vtkNew < vtkCellLocatorStrategy > vtkCellLocatorStrategy_new () ; -extern "C" void vtkCellLocatorStrategy_destructor (vtkNew < vtkCellLocatorStrategy > sself) ; -extern "C" void * vtkCellLocatorStrategy_get_ptr (vtkNew < vtkCellLocatorStrategy > sself) ; -extern "C" vtkNew < vtkCellTypes > vtkCellTypes_new () ; -extern "C" void vtkCellTypes_destructor (vtkNew < vtkCellTypes > sself) ; -extern "C" void * vtkCellTypes_get_ptr (vtkNew < vtkCellTypes > sself) ; -extern "C" int vtk_cell_types_allocate(vtkNew sself, long long sz, long long ext); -extern "C" void vtk_cell_types_insert_cell(vtkNew sself, long long id, unsigned char type, long long loc); -extern "C" long long vtk_cell_types_insert_next_cell(vtkNew sself, unsigned char type, long long loc); -extern "C" long long vtk_cell_types_get_cell_location(vtkNew sself, long long cellId); -extern "C" void vtk_cell_types_delete_cell(vtkNew sself, long long cellId); -extern "C" long long vtk_cell_types_get_number_of_types(vtkNew sself); -extern "C" int vtk_cell_types_is_type(vtkNew sself, unsigned char type); -extern "C" long long vtk_cell_types_insert_next_type(vtkNew sself, unsigned char type); -extern "C" unsigned char vtk_cell_types_get_cell_type(vtkNew sself, long long cellId); -extern "C" void vtk_cell_types_squeeze(vtkNew sself); -extern "C" void vtk_cell_types_reset(vtkNew sself); -extern "C" unsigned long vtk_cell_types_get_actual_memory_size(vtkNew sself); -extern "C" const char* vtk_cell_types_get_class_name_from_type_id(vtkNew sself, int typeId); -extern "C" int vtk_cell_types_get_type_id_from_class_name(vtkNew sself, const char classname); -extern "C" int vtk_cell_types_is_linear(vtkNew sself, unsigned char type); -extern "C" vtkNew < vtkClosestNPointsStrategy > vtkClosestNPointsStrategy_new () ; -extern "C" void vtkClosestNPointsStrategy_destructor (vtkNew < vtkClosestNPointsStrategy > sself) ; -extern "C" void * vtkClosestNPointsStrategy_get_ptr (vtkNew < vtkClosestNPointsStrategy > sself) ; -extern "C" void vtk_closest_n_points_strategy_set_closest_n_points(vtkNew sself, int _arg); -extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_min_value(vtkNew sself); -extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_max_value(vtkNew sself); -extern "C" int vtk_closest_n_points_strategy_get_closest_n_points(vtkNew sself); -extern "C" vtkNew < vtkClosestPointStrategy > vtkClosestPointStrategy_new () ; -extern "C" void vtkClosestPointStrategy_destructor (vtkNew < vtkClosestPointStrategy > sself) ; -extern "C" void * vtkClosestPointStrategy_get_ptr (vtkNew < vtkClosestPointStrategy > sself) ; -extern "C" vtkNew < vtkCone > vtkCone_new () ; -extern "C" void vtkCone_destructor (vtkNew < vtkCone > sself) ; -extern "C" void * vtkCone_get_ptr (vtkNew < vtkCone > sself) ; -extern "C" double vtk_cone_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_cone_evaluate_gradient(vtkNew sself, double x, double g); -extern "C" void vtk_cone_set_angle(vtkNew sself, double _arg); -extern "C" double vtk_cone_get_angle_min_value(vtkNew sself); -extern "C" double vtk_cone_get_angle_max_value(vtkNew sself); -extern "C" double vtk_cone_get_angle(vtkNew sself); -extern "C" vtkNew < vtkConvexPointSet > vtkConvexPointSet_new () ; -extern "C" void vtkConvexPointSet_destructor (vtkNew < vtkConvexPointSet > sself) ; -extern "C" void * vtkConvexPointSet_get_ptr (vtkNew < vtkConvexPointSet > sself) ; -extern "C" int vtk_convex_point_set_has_fixed_topology(vtkNew sself); -extern "C" void vtk_convex_point_set_get_edge_points(vtkNew sself, long long edgeId, const long long pts); -extern "C" void vtk_convex_point_set_get_edge_points(vtkNew sself, int edgeId, int pts); -extern "C" long long vtk_convex_point_set_get_face_points(vtkNew sself, long long faceId, const long long pts); -extern "C" void vtk_convex_point_set_get_face_points(vtkNew sself, int faceId, int pts); -extern "C" void vtk_convex_point_set_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); -extern "C" long long vtk_convex_point_set_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); -extern "C" long long vtk_convex_point_set_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); -extern "C" long long vtk_convex_point_set_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); -extern "C" long long vtk_convex_point_set_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); -extern "C" bool vtk_convex_point_set_get_centroid(vtkNew sself, double centroid); -extern "C" double* vtk_convex_point_set_get_parametric_coords(vtkNew sself); -extern "C" int vtk_convex_point_set_get_cell_type(vtkNew sself); -extern "C" int vtk_convex_point_set_requires_initialization(vtkNew sself); -extern "C" int vtk_convex_point_set_get_number_of_edges(vtkNew sself); -extern "C" int vtk_convex_point_set_get_number_of_faces(vtkNew sself); -extern "C" int vtk_convex_point_set_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_convex_point_set_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_convex_point_set_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_convex_point_set_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_convex_point_set_get_parametric_center(vtkNew sself, double pcoords); -extern "C" int vtk_convex_point_set_is_primary_cell(vtkNew sself); -extern "C" void vtk_convex_point_set_interpolate_functions(vtkNew sself, const double pcoords, double sf); -extern "C" vtkNew < vtkCubicLine > vtkCubicLine_new () ; -extern "C" void vtkCubicLine_destructor (vtkNew < vtkCubicLine > sself) ; -extern "C" void * vtkCubicLine_get_ptr (vtkNew < vtkCubicLine > sself) ; -extern "C" int vtk_cubic_line_get_cell_type(vtkNew sself); -extern "C" int vtk_cubic_line_get_cell_dimension(vtkNew sself); -extern "C" int vtk_cubic_line_get_number_of_edges(vtkNew sself); -extern "C" int vtk_cubic_line_get_number_of_faces(vtkNew sself); -extern "C" int vtk_cubic_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_cubic_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_cubic_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" double vtk_cubic_line_get_parametric_distance(vtkNew sself, const double pcoords); -extern "C" int vtk_cubic_line_get_parametric_center(vtkNew sself, double pcoords); -extern "C" int vtk_cubic_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_cubic_line_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_cubic_line_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_cubic_line_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_cubic_line_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" vtkNew < vtkCylinder > vtkCylinder_new () ; -extern "C" void vtkCylinder_destructor (vtkNew < vtkCylinder > sself) ; -extern "C" void * vtkCylinder_get_ptr (vtkNew < vtkCylinder > sself) ; -extern "C" double vtk_cylinder_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_cylinder_evaluate_gradient(vtkNew sself, double x, double g); -extern "C" void vtk_cylinder_set_radius(vtkNew sself, double _arg); -extern "C" double vtk_cylinder_get_radius(vtkNew sself); -extern "C" void vtk_cylinder_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_cylinder_set_center(vtkNew sself, const double _arg); -extern "C" double* vtk_cylinder_get_center(vtkNew sself); -extern "C" void vtk_cylinder_get_center(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_cylinder_get_center(vtkNew sself, double _arg); -extern "C" void vtk_cylinder_set_axis(vtkNew sself, double ax, double ay, double az); -extern "C" void vtk_cylinder_set_axis(vtkNew sself, double a); -extern "C" double* vtk_cylinder_get_axis(vtkNew sself); -extern "C" void vtk_cylinder_get_axis(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_cylinder_get_axis(vtkNew sself, double _arg); -extern "C" vtkNew < vtkDataAssembly > vtkDataAssembly_new () ; -extern "C" void vtkDataAssembly_destructor (vtkNew < vtkDataAssembly > sself) ; -extern "C" void * vtkDataAssembly_get_ptr (vtkNew < vtkDataAssembly > sself) ; -extern "C" void vtk_data_assembly_initialize(vtkNew sself); -extern "C" bool vtk_data_assembly_initialize_from_xml(vtkNew sself, const char xmlcontents); -extern "C" int vtk_data_assembly_get_root_node(vtkNew sself); -extern "C" void vtk_data_assembly_set_root_node_name(vtkNew sself, const char name); -extern "C" const char* vtk_data_assembly_get_root_node_name(vtkNew sself); -extern "C" int vtk_data_assembly_add_node(vtkNew sself, const char name, int parent); -extern "C" bool vtk_data_assembly_remove_node(vtkNew sself, int id); -extern "C" void vtk_data_assembly_set_node_name(vtkNew sself, int id, const char name); -extern "C" const char* vtk_data_assembly_get_node_name(vtkNew sself, int id); -extern "C" const char* vtk_data_assembly_get_node_path(vtkNew sself, int id); -extern "C" int vtk_data_assembly_get_first_node_by_path(vtkNew sself, const char path); -extern "C" bool vtk_data_assembly_add_data_set_index(vtkNew sself, int id, unsigned int dataset_index); -extern "C" bool vtk_data_assembly_add_data_set_index_range(vtkNew sself, int id, unsigned int index_start, int count); -extern "C" bool vtk_data_assembly_remove_data_set_index(vtkNew sself, int id, unsigned int dataset_index); -extern "C" bool vtk_data_assembly_remove_all_data_set_indices(vtkNew sself, int id, bool traverse_subtree); -extern "C" int vtk_data_assembly_find_first_node_with_name(vtkNew sself, const char name, int traversal_order); -extern "C" int vtk_data_assembly_get_number_of_children(vtkNew sself, int parent); -extern "C" int vtk_data_assembly_get_child(vtkNew sself, int parent, int index); -extern "C" int vtk_data_assembly_get_child_index(vtkNew sself, int parent, int child); -extern "C" int vtk_data_assembly_get_parent(vtkNew sself, int id); -extern "C" bool vtk_data_assembly_has_attribute(vtkNew sself, int id, const char name); -extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, const char value); -extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, int value); -extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, unsigned int value); -extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, long long value); -extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, const char value); -extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, int value); -extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, unsigned int value); -extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, long long value); -extern "C" const char* vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, const char default_value); -extern "C" int vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, int default_value); -extern "C" unsigned int vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, unsigned int default_value); -extern "C" long long vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, long long default_value); -extern "C" bool vtk_data_assembly_is_node_name_valid(vtkNew sself, const char name); -extern "C" const char* vtk_data_assembly_make_valid_node_name(vtkNew sself, const char name); -extern "C" bool vtk_data_assembly_is_node_name_reserved(vtkNew sself, const char name); -extern "C" vtkNew < vtkDataAssemblyUtilities > vtkDataAssemblyUtilities_new () ; -extern "C" void vtkDataAssemblyUtilities_destructor (vtkNew < vtkDataAssemblyUtilities > sself) ; -extern "C" void * vtkDataAssemblyUtilities_get_ptr (vtkNew < vtkDataAssemblyUtilities > sself) ; -extern "C" const char* vtk_data_assembly_utilities_hierarchy_name(vtkNew sself); -extern "C" vtkNew < vtkDataObject > vtkDataObject_new () ; -extern "C" void vtkDataObject_destructor (vtkNew < vtkDataObject > sself) ; -extern "C" void * vtkDataObject_get_ptr (vtkNew < vtkDataObject > sself) ; -extern "C" unsigned long vtk_data_object_get_m_time(vtkNew sself); -extern "C" void vtk_data_object_initialize(vtkNew sself); -extern "C" void vtk_data_object_release_data(vtkNew sself); -extern "C" int vtk_data_object_get_data_released(vtkNew sself); -extern "C" void vtk_data_object_set_global_release_data_flag(vtkNew sself, int val); -extern "C" void vtk_data_object_global_release_data_flag_on(vtkNew sself); -extern "C" void vtk_data_object_global_release_data_flag_off(vtkNew sself); -extern "C" int vtk_data_object_get_global_release_data_flag(vtkNew sself); -extern "C" int vtk_data_object_get_data_object_type(vtkNew sself); -extern "C" unsigned long vtk_data_object_get_update_time(vtkNew sself); -extern "C" unsigned long vtk_data_object_get_actual_memory_size(vtkNew sself); -extern "C" void vtk_data_object_data_has_been_generated(vtkNew sself); -extern "C" void vtk_data_object_prepare_for_new_data(vtkNew sself); -extern "C" int vtk_data_object_get_extent_type(vtkNew sself); -extern "C" void vtk_data_object_crop(vtkNew sself, const int updateExtent); -extern "C" long long vtk_data_object_get_number_of_elements(vtkNew sself, int type); -extern "C" const char* vtk_data_object_get_association_type_as_string(vtkNew sself, int associationType); -extern "C" int vtk_data_object_get_association_type_from_string(vtkNew sself, const char associationName); -extern "C" vtkNew < vtkDataObjectCollection > vtkDataObjectCollection_new () ; -extern "C" void vtkDataObjectCollection_destructor (vtkNew < vtkDataObjectCollection > sself) ; -extern "C" void * vtkDataObjectCollection_get_ptr (vtkNew < vtkDataObjectCollection > sself) ; -extern "C" int vtk_data_object_collection_get_number_of_items(vtkNew sself); -extern "C" vtkNew < vtkDataObjectTreeIterator > vtkDataObjectTreeIterator_new () ; -extern "C" void vtkDataObjectTreeIterator_destructor (vtkNew < vtkDataObjectTreeIterator > sself) ; -extern "C" void * vtkDataObjectTreeIterator_get_ptr (vtkNew < vtkDataObjectTreeIterator > sself) ; -extern "C" void vtk_data_object_tree_iterator_go_to_first_item(vtkNew sself); -extern "C" void vtk_data_object_tree_iterator_go_to_next_item(vtkNew sself); -extern "C" int vtk_data_object_tree_iterator_is_done_with_traversal(vtkNew sself); -extern "C" int vtk_data_object_tree_iterator_has_current_meta_data(vtkNew sself); -extern "C" unsigned int vtk_data_object_tree_iterator_get_current_flat_index(vtkNew sself); -extern "C" void vtk_data_object_tree_iterator_set_visit_only_leaves(vtkNew sself, int _arg); -extern "C" int vtk_data_object_tree_iterator_get_visit_only_leaves(vtkNew sself); -extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_on(vtkNew sself); -extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_off(vtkNew sself); -extern "C" void vtk_data_object_tree_iterator_set_traverse_sub_tree(vtkNew sself, int _arg); -extern "C" int vtk_data_object_tree_iterator_get_traverse_sub_tree(vtkNew sself); -extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_on(vtkNew sself); -extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_off(vtkNew sself); -extern "C" vtkNew < vtkDataObjectTypes > vtkDataObjectTypes_new () ; -extern "C" void vtkDataObjectTypes_destructor (vtkNew < vtkDataObjectTypes > sself) ; -extern "C" void * vtkDataObjectTypes_get_ptr (vtkNew < vtkDataObjectTypes > sself) ; -extern "C" const char* vtk_data_object_types_get_class_name_from_type_id(vtkNew sself, int typeId); -extern "C" int vtk_data_object_types_get_type_id_from_class_name(vtkNew sself, const char classname); -extern "C" bool vtk_data_object_types_type_id_is_a(vtkNew sself, int typeId, int targetTypeId); -extern "C" int vtk_data_object_types_get_common_base_type_id(vtkNew sself, int typeA, int typeB); -extern "C" vtkNew < vtkDataSetAttributes > vtkDataSetAttributes_new () ; -extern "C" void vtkDataSetAttributes_destructor (vtkNew < vtkDataSetAttributes > sself) ; -extern "C" void * vtkDataSetAttributes_get_ptr (vtkNew < vtkDataSetAttributes > sself) ; -extern "C" void vtk_data_set_attributes_initialize(vtkNew sself); -extern "C" void vtk_data_set_attributes_update(vtkNew sself); -extern "C" const char* vtk_data_set_attributes_ghost_array_name(vtkNew sself); -extern "C" int vtk_data_set_attributes_set_active_scalars(vtkNew sself, const char name); -extern "C" int vtk_data_set_attributes_set_active_vectors(vtkNew sself, const char name); -extern "C" int vtk_data_set_attributes_set_active_normals(vtkNew sself, const char name); -extern "C" int vtk_data_set_attributes_set_active_tangents(vtkNew sself, const char name); -extern "C" int vtk_data_set_attributes_set_active_t_coords(vtkNew sself, const char name); -extern "C" int vtk_data_set_attributes_set_active_tensors(vtkNew sself, const char name); -extern "C" int vtk_data_set_attributes_set_active_global_ids(vtkNew sself, const char name); -extern "C" int vtk_data_set_attributes_set_active_pedigree_ids(vtkNew sself, const char name); -extern "C" int vtk_data_set_attributes_set_active_rational_weights(vtkNew sself, const char name); -extern "C" int vtk_data_set_attributes_set_active_higher_order_degrees(vtkNew sself, const char name); -extern "C" int vtk_data_set_attributes_set_active_attribute(vtkNew sself, const char name, int attributeType); -extern "C" int vtk_data_set_attributes_set_active_attribute(vtkNew sself, int index, int attributeType); -extern "C" void vtk_data_set_attributes_get_attribute_indices(vtkNew sself, int indexArray); -extern "C" int vtk_data_set_attributes_is_array_an_attribute(vtkNew sself, int idx); -extern "C" const char* vtk_data_set_attributes_get_attribute_type_as_string(vtkNew sself, int attributeType); -extern "C" const char* vtk_data_set_attributes_get_long_attribute_type_as_string(vtkNew sself, int attributeType); -extern "C" void vtk_data_set_attributes_set_copy_attribute(vtkNew sself, int index, int value, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_attribute(vtkNew sself, int index, int ctype); -extern "C" void vtk_data_set_attributes_set_copy_scalars(vtkNew sself, int i, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_scalars(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_scalars_on(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_scalars_off(vtkNew sself); -extern "C" void vtk_data_set_attributes_set_copy_vectors(vtkNew sself, int i, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_vectors(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_vectors_on(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_vectors_off(vtkNew sself); -extern "C" void vtk_data_set_attributes_set_copy_normals(vtkNew sself, int i, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_normals(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_normals_on(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_normals_off(vtkNew sself); -extern "C" void vtk_data_set_attributes_set_copy_tangents(vtkNew sself, int i, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_tangents(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_tangents_on(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_tangents_off(vtkNew sself); -extern "C" void vtk_data_set_attributes_set_copy_t_coords(vtkNew sself, int i, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_t_coords(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_t_coords_on(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_t_coords_off(vtkNew sself); -extern "C" void vtk_data_set_attributes_set_copy_tensors(vtkNew sself, int i, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_tensors(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_tensors_on(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_tensors_off(vtkNew sself); -extern "C" void vtk_data_set_attributes_set_copy_global_ids(vtkNew sself, int i, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_global_ids(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_global_ids_on(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_global_ids_off(vtkNew sself); -extern "C" void vtk_data_set_attributes_set_copy_pedigree_ids(vtkNew sself, int i, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_pedigree_ids(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_pedigree_ids_on(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_pedigree_ids_off(vtkNew sself); -extern "C" void vtk_data_set_attributes_set_copy_rational_weights(vtkNew sself, int i, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_rational_weights(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_rational_weights_on(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_rational_weights_off(vtkNew sself); -extern "C" void vtk_data_set_attributes_set_copy_higher_order_degrees(vtkNew sself, int i, int ctype); -extern "C" int vtk_data_set_attributes_get_copy_higher_order_degrees(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_on(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_off(vtkNew sself); -extern "C" void vtk_data_set_attributes_copy_all_on(vtkNew sself, int ctype); -extern "C" void vtk_data_set_attributes_copy_all_off(vtkNew sself, int ctype); -extern "C" vtkNew < vtkDataSetCellIterator > vtkDataSetCellIterator_new () ; -extern "C" void vtkDataSetCellIterator_destructor (vtkNew < vtkDataSetCellIterator > sself) ; -extern "C" void * vtkDataSetCellIterator_get_ptr (vtkNew < vtkDataSetCellIterator > sself) ; -extern "C" bool vtk_data_set_cell_iterator_is_done_with_traversal(vtkNew sself); -extern "C" long long vtk_data_set_cell_iterator_get_cell_id(vtkNew sself); -extern "C" vtkNew < vtkDataSetCollection > vtkDataSetCollection_new () ; -extern "C" void vtkDataSetCollection_destructor (vtkNew < vtkDataSetCollection > sself) ; -extern "C" void * vtkDataSetCollection_get_ptr (vtkNew < vtkDataSetCollection > sself) ; -extern "C" int vtk_data_set_collection_get_number_of_items(vtkNew sself); -extern "C" vtkNew < vtkDirectedAcyclicGraph > vtkDirectedAcyclicGraph_new () ; -extern "C" void vtkDirectedAcyclicGraph_destructor (vtkNew < vtkDirectedAcyclicGraph > sself) ; -extern "C" void * vtkDirectedAcyclicGraph_get_ptr (vtkNew < vtkDirectedAcyclicGraph > sself) ; -extern "C" vtkNew < vtkDirectedGraph > vtkDirectedGraph_new () ; -extern "C" void vtkDirectedGraph_destructor (vtkNew < vtkDirectedGraph > sself) ; -extern "C" void * vtkDirectedGraph_get_ptr (vtkNew < vtkDirectedGraph > sself) ; -extern "C" vtkNew < vtkEdgeListIterator > vtkEdgeListIterator_new () ; -extern "C" void vtkEdgeListIterator_destructor (vtkNew < vtkEdgeListIterator > sself) ; -extern "C" void * vtkEdgeListIterator_get_ptr (vtkNew < vtkEdgeListIterator > sself) ; -extern "C" bool vtk_edge_list_iterator_has_next(vtkNew sself); -extern "C" vtkNew < vtkEdgeTable > vtkEdgeTable_new () ; -extern "C" void vtkEdgeTable_destructor (vtkNew < vtkEdgeTable > sself) ; -extern "C" void * vtkEdgeTable_get_ptr (vtkNew < vtkEdgeTable > sself) ; -extern "C" void vtk_edge_table_initialize(vtkNew sself); -extern "C" int vtk_edge_table_init_edge_insertion(vtkNew sself, long long numPoints, int storeAttributes); -extern "C" long long vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2); -extern "C" void vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2, long long attributeId); -extern "C" void vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2, void ptr); -extern "C" long long vtk_edge_table_is_edge(vtkNew sself, long long p1, long long p2); -extern "C" void vtk_edge_table_is_edge(vtkNew sself, long long p1, long long p2, void ptr); -extern "C" int vtk_edge_table_insert_unique_point(vtkNew sself, long long p1, long long p2, double x, long long ptId); -extern "C" long long vtk_edge_table_get_number_of_edges(vtkNew sself); -extern "C" void vtk_edge_table_init_traversal(vtkNew sself); -extern "C" long long vtk_edge_table_get_next_edge(vtkNew sself, long long p1, long long p2); -extern "C" int vtk_edge_table_get_next_edge(vtkNew sself, long long p1, long long p2, void ptr); -extern "C" void vtk_edge_table_reset(vtkNew sself); -extern "C" vtkNew < vtkEmptyCell > vtkEmptyCell_new () ; -extern "C" void vtkEmptyCell_destructor (vtkNew < vtkEmptyCell > sself) ; -extern "C" void * vtkEmptyCell_get_ptr (vtkNew < vtkEmptyCell > sself) ; -extern "C" int vtk_empty_cell_get_cell_type(vtkNew sself); -extern "C" int vtk_empty_cell_get_cell_dimension(vtkNew sself); -extern "C" int vtk_empty_cell_get_number_of_edges(vtkNew sself); -extern "C" int vtk_empty_cell_get_number_of_faces(vtkNew sself); -extern "C" int vtk_empty_cell_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_empty_cell_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_empty_cell_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_empty_cell_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" vtkNew < vtkExplicitStructuredGrid > vtkExplicitStructuredGrid_new () ; -extern "C" void vtkExplicitStructuredGrid_destructor (vtkNew < vtkExplicitStructuredGrid > sself) ; -extern "C" void * vtkExplicitStructuredGrid_get_ptr (vtkNew < vtkExplicitStructuredGrid > sself) ; -extern "C" int vtk_explicit_structured_grid_get_data_object_type(vtkNew sself); -extern "C" void vtk_explicit_structured_grid_initialize(vtkNew sself); -extern "C" int vtk_explicit_structured_grid_get_cell_type(vtkNew sself, long long cellId); -extern "C" int vtk_explicit_structured_grid_get_data_dimension(vtkNew sself); -extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkNew sself, int i, int j, int k); -extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkNew sself, int dim); -extern "C" void vtk_explicit_structured_grid_get_dimensions(vtkNew sself, int dim); -extern "C" void vtk_explicit_structured_grid_get_cell_dims(vtkNew sself, int cellDims); -extern "C" int vtk_explicit_structured_grid_get_extent_type(vtkNew sself); -extern "C" void vtk_explicit_structured_grid_set_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1); -extern "C" void vtk_explicit_structured_grid_set_extent(vtkNew sself, int extent); -extern "C" int* vtk_explicit_structured_grid_get_extent(vtkNew sself); -extern "C" void vtk_explicit_structured_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_explicit_structured_grid_get_extent(vtkNew sself, int _arg); -extern "C" void vtk_explicit_structured_grid_build_links(vtkNew sself); -extern "C" long long* vtk_explicit_structured_grid_get_cell_points(vtkNew sself, long long cellId); -extern "C" void vtk_explicit_structured_grid_get_cell_points(vtkNew sself, long long cellId, long long npts, long long pts); -extern "C" void vtk_explicit_structured_grid_get_cell_neighbors(vtkNew sself, long long cellId, long long neighbors, int wholeExtent); -extern "C" void vtk_explicit_structured_grid_compute_cell_structured_coords(vtkNew sself, long long cellId, int i, int j, int k, bool adjustForExtent); -extern "C" long long vtk_explicit_structured_grid_compute_cell_id(vtkNew sself, int i, int j, int k, bool adjustForExtent); -extern "C" void vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(vtkNew sself); -extern "C" void vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name(vtkNew sself, const char _arg); -extern "C" char* vtk_explicit_structured_grid_get_faces_connectivity_flags_array_name(vtkNew sself); -extern "C" void vtk_explicit_structured_grid_blank_cell(vtkNew sself, long long cellId); -extern "C" void vtk_explicit_structured_grid_un_blank_cell(vtkNew sself, long long cellId); -extern "C" bool vtk_explicit_structured_grid_has_any_blank_cells(vtkNew sself); -extern "C" unsigned char vtk_explicit_structured_grid_is_cell_visible(vtkNew sself, long long cellId); -extern "C" unsigned char vtk_explicit_structured_grid_is_cell_ghost(vtkNew sself, long long cellId); -extern "C" bool vtk_explicit_structured_grid_has_any_ghost_cells(vtkNew sself); -extern "C" void vtk_explicit_structured_grid_crop(vtkNew sself, const int updateExtent); -extern "C" unsigned long vtk_explicit_structured_grid_get_actual_memory_size(vtkNew sself); -extern "C" void vtk_explicit_structured_grid_check_and_reorder_faces(vtkNew sself); -extern "C" vtkNew < vtkExtractStructuredGridHelper > vtkExtractStructuredGridHelper_new () ; -extern "C" void vtkExtractStructuredGridHelper_destructor (vtkNew < vtkExtractStructuredGridHelper > sself) ; -extern "C" void * vtkExtractStructuredGridHelper_get_ptr (vtkNew < vtkExtractStructuredGridHelper > sself) ; -extern "C" int* vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself); -extern "C" void vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself, int _arg); -extern "C" void vtk_extract_structured_grid_helper_initialize(vtkNew sself, int voi, int wholeExt, int sampleRate, bool includeBoundary); -extern "C" bool vtk_extract_structured_grid_helper_is_valid(vtkNew sself); -extern "C" int vtk_extract_structured_grid_helper_get_size(vtkNew sself, const int dim); -extern "C" int vtk_extract_structured_grid_helper_get_mapped_index(vtkNew sself, int dim, int outIdx); -extern "C" int vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value(vtkNew sself, int dim, int outExtVal); -extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value(vtkNew sself, int dim, int outExtVal); -extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index(vtkNew sself, int dim, int outIdx); -extern "C" void vtk_extract_structured_grid_helper_compute_begin_and_end(vtkNew sself, int inExt, int voi, int begin, int end); -extern "C" void vtk_extract_structured_grid_helper_get_partitioned_voi(vtkNew sself, const int globalVOI, const int partitionedExtent, const int sampleRate, bool includeBoundary, int partitionedVOI); -extern "C" void vtk_extract_structured_grid_helper_get_partitioned_output_extent(vtkNew sself, const int globalVOI, const int partitionedVOI, const int outputWholeExtent, const int sampleRate, bool includeBoundary, int partitionedOutputExtent); -extern "C" vtkNew < vtkFieldData > vtkFieldData_new () ; -extern "C" void vtkFieldData_destructor (vtkNew < vtkFieldData > sself) ; -extern "C" void * vtkFieldData_get_ptr (vtkNew < vtkFieldData > sself) ; -extern "C" void vtk_field_data_initialize(vtkNew sself); -extern "C" int vtk_field_data_allocate(vtkNew sself, long long sz, long long ext); -extern "C" void vtk_field_data_allocate_arrays(vtkNew sself, int num); -extern "C" int vtk_field_data_get_number_of_arrays(vtkNew sself); -extern "C" void vtk_field_data_null_data(vtkNew sself, long long id); -extern "C" void vtk_field_data_remove_array(vtkNew sself, const char name); -extern "C" void vtk_field_data_remove_array(vtkNew sself, int index); -extern "C" int vtk_field_data_has_array(vtkNew sself, const char name); -extern "C" const char* vtk_field_data_get_array_name(vtkNew sself, int i); -extern "C" void vtk_field_data_copy_field_on(vtkNew sself, const char name); -extern "C" void vtk_field_data_copy_field_off(vtkNew sself, const char name); -extern "C" void vtk_field_data_copy_all_on(vtkNew sself, int unused); -extern "C" void vtk_field_data_copy_all_off(vtkNew sself, int unused); -extern "C" void vtk_field_data_squeeze(vtkNew sself); -extern "C" void vtk_field_data_reset(vtkNew sself); -extern "C" unsigned long vtk_field_data_get_actual_memory_size(vtkNew sself); -extern "C" unsigned long vtk_field_data_get_m_time(vtkNew sself); -extern "C" int vtk_field_data_get_array_containing_component(vtkNew sself, int i, int arrayComp); -extern "C" int vtk_field_data_get_number_of_components(vtkNew sself); -extern "C" long long vtk_field_data_get_number_of_tuples(vtkNew sself); -extern "C" void vtk_field_data_set_number_of_tuples(vtkNew sself, const long long number); -extern "C" vtkNew < vtkGenericAttributeCollection > vtkGenericAttributeCollection_new () ; -extern "C" void vtkGenericAttributeCollection_destructor (vtkNew < vtkGenericAttributeCollection > sself) ; -extern "C" void * vtkGenericAttributeCollection_get_ptr (vtkNew < vtkGenericAttributeCollection > sself) ; -extern "C" int vtk_generic_attribute_collection_get_number_of_attributes(vtkNew sself); -extern "C" int vtk_generic_attribute_collection_get_number_of_components(vtkNew sself); -extern "C" int vtk_generic_attribute_collection_get_number_of_point_centered_components(vtkNew sself); -extern "C" int vtk_generic_attribute_collection_get_max_number_of_components(vtkNew sself); -extern "C" unsigned long vtk_generic_attribute_collection_get_actual_memory_size(vtkNew sself); -extern "C" int vtk_generic_attribute_collection_is_empty(vtkNew sself); -extern "C" int vtk_generic_attribute_collection_find_attribute(vtkNew sself, const char name); -extern "C" int vtk_generic_attribute_collection_get_attribute_index(vtkNew sself, int i); -extern "C" void vtk_generic_attribute_collection_remove_attribute(vtkNew sself, int i); -extern "C" void vtk_generic_attribute_collection_reset(vtkNew sself); -extern "C" unsigned long vtk_generic_attribute_collection_get_m_time(vtkNew sself); -extern "C" int vtk_generic_attribute_collection_get_active_attribute(vtkNew sself); -extern "C" int vtk_generic_attribute_collection_get_active_component(vtkNew sself); -extern "C" void vtk_generic_attribute_collection_set_active_attribute(vtkNew sself, int attribute, int component); -extern "C" int vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate(vtkNew sself); -extern "C" int* vtk_generic_attribute_collection_get_attributes_to_interpolate(vtkNew sself); -extern "C" int vtk_generic_attribute_collection_has_attribute(vtkNew sself, int size, int attributes, int attribute); -extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate(vtkNew sself, int size, int attributes); -extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(vtkNew sself); -extern "C" vtkNew < vtkGenericCell > vtkGenericCell_new () ; -extern "C" void vtkGenericCell_destructor (vtkNew < vtkGenericCell > sself) ; -extern "C" void * vtkGenericCell_get_ptr (vtkNew < vtkGenericCell > sself) ; -extern "C" int vtk_generic_cell_get_cell_type(vtkNew sself); -extern "C" int vtk_generic_cell_get_cell_dimension(vtkNew sself); -extern "C" int vtk_generic_cell_get_number_of_edges(vtkNew sself); -extern "C" int vtk_generic_cell_get_number_of_faces(vtkNew sself); -extern "C" int vtk_generic_cell_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_generic_cell_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_generic_cell_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_generic_cell_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" void vtk_generic_cell_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_generic_cell_set_cell_type(vtkNew sself, int cellType); -extern "C" void vtk_generic_cell_set_cell_type_to_empty_cell(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_vertex(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_poly_vertex(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_line(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_poly_line(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_triangle(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_triangle_strip(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_polygon(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_pixel(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quad(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_tetra(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_voxel(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_hexahedron(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_wedge(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_pyramid(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_pentagonal_prism(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_hexagonal_prism(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_polyhedron(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_convex_point_set(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_edge(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_cubic_line(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_triangle(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_quad(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_polygon(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_tetra(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_hexahedron(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_wedge(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_pyramid(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_quad(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quad(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_triangle(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_tetra(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_curve(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_hexahedron(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_wedge(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_triangle(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_tetra(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_curve(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_quadrilateral(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_hexahedron(vtkNew sself); -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_wedge(vtkNew sself); -extern "C" vtkNew < vtkGenericEdgeTable > vtkGenericEdgeTable_new () ; -extern "C" void vtkGenericEdgeTable_destructor (vtkNew < vtkGenericEdgeTable > sself) ; -extern "C" void * vtkGenericEdgeTable_get_ptr (vtkNew < vtkGenericEdgeTable > sself) ; -extern "C" void vtk_generic_edge_table_insert_edge(vtkNew sself, long long e1, long long e2, long long cellId, int ref, long long ptId); -extern "C" void vtk_generic_edge_table_insert_edge(vtkNew sself, long long e1, long long e2, long long cellId, int ref); -extern "C" int vtk_generic_edge_table_remove_edge(vtkNew sself, long long e1, long long e2); -extern "C" int vtk_generic_edge_table_check_edge(vtkNew sself, long long e1, long long e2, long long ptId); -extern "C" int vtk_generic_edge_table_increment_edge_reference_count(vtkNew sself, long long e1, long long e2, long long cellId); -extern "C" int vtk_generic_edge_table_check_edge_reference_count(vtkNew sself, long long e1, long long e2); -extern "C" void vtk_generic_edge_table_initialize(vtkNew sself, long long start); -extern "C" int vtk_generic_edge_table_get_number_of_components(vtkNew sself); -extern "C" void vtk_generic_edge_table_set_number_of_components(vtkNew sself, int count); -extern "C" int vtk_generic_edge_table_check_point(vtkNew sself, long long ptId); -extern "C" int vtk_generic_edge_table_check_point(vtkNew sself, long long ptId, double point, double scalar); -extern "C" void vtk_generic_edge_table_insert_point(vtkNew sself, long long ptId, double point); -extern "C" void vtk_generic_edge_table_insert_point_and_scalar(vtkNew sself, long long ptId, double pt, double s); -extern "C" void vtk_generic_edge_table_remove_point(vtkNew sself, long long ptId); -extern "C" void vtk_generic_edge_table_increment_point_reference_count(vtkNew sself, long long ptId); -extern "C" void vtk_generic_edge_table_dump_table(vtkNew sself); -extern "C" void vtk_generic_edge_table_load_factor(vtkNew sself); -extern "C" vtkNew < vtkGenericInterpolatedVelocityField > vtkGenericInterpolatedVelocityField_new () ; -extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkNew < vtkGenericInterpolatedVelocityField > sself) ; -extern "C" void * vtkGenericInterpolatedVelocityField_get_ptr (vtkNew < vtkGenericInterpolatedVelocityField > sself) ; -extern "C" int vtk_generic_interpolated_velocity_field_function_values(vtkNew sself, double x, double f); -extern "C" void vtk_generic_interpolated_velocity_field_clear_last_cell(vtkNew sself); -extern "C" int vtk_generic_interpolated_velocity_field_get_last_local_coordinates(vtkNew sself, double pcoords); -extern "C" int vtk_generic_interpolated_velocity_field_get_caching(vtkNew sself); -extern "C" void vtk_generic_interpolated_velocity_field_set_caching(vtkNew sself, int _arg); -extern "C" void vtk_generic_interpolated_velocity_field_caching_on(vtkNew sself); -extern "C" void vtk_generic_interpolated_velocity_field_caching_off(vtkNew sself); -extern "C" int vtk_generic_interpolated_velocity_field_get_cache_hit(vtkNew sself); -extern "C" int vtk_generic_interpolated_velocity_field_get_cache_miss(vtkNew sself); -extern "C" char* vtk_generic_interpolated_velocity_field_get_vectors_selection(vtkNew sself); -extern "C" void vtk_generic_interpolated_velocity_field_select_vectors(vtkNew sself, const char fieldName); -extern "C" vtkNew < vtkGeometricErrorMetric > vtkGeometricErrorMetric_new () ; -extern "C" void vtkGeometricErrorMetric_destructor (vtkNew < vtkGeometricErrorMetric > sself) ; -extern "C" void * vtkGeometricErrorMetric_get_ptr (vtkNew < vtkGeometricErrorMetric > sself) ; -extern "C" double vtk_geometric_error_metric_get_absolute_geometric_tolerance(vtkNew sself); -extern "C" void vtk_geometric_error_metric_set_absolute_geometric_tolerance(vtkNew sself, double value); -extern "C" int vtk_geometric_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); -extern "C" double vtk_geometric_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); -extern "C" int vtk_geometric_error_metric_get_relative(vtkNew sself); -extern "C" vtkNew < vtkGraphEdge > vtkGraphEdge_new () ; -extern "C" void vtkGraphEdge_destructor (vtkNew < vtkGraphEdge > sself) ; -extern "C" void * vtkGraphEdge_get_ptr (vtkNew < vtkGraphEdge > sself) ; -extern "C" void vtk_graph_edge_set_source(vtkNew sself, long long _arg); -extern "C" long long vtk_graph_edge_get_source(vtkNew sself); -extern "C" void vtk_graph_edge_set_target(vtkNew sself, long long _arg); -extern "C" long long vtk_graph_edge_get_target(vtkNew sself); -extern "C" void vtk_graph_edge_set_id(vtkNew sself, long long _arg); -extern "C" long long vtk_graph_edge_get_id(vtkNew sself); -extern "C" vtkNew < vtkGraphInternals > vtkGraphInternals_new () ; -extern "C" void vtkGraphInternals_destructor (vtkNew < vtkGraphInternals > sself) ; -extern "C" void * vtkGraphInternals_get_ptr (vtkNew < vtkGraphInternals > sself) ; -extern "C" vtkNew < vtkHexagonalPrism > vtkHexagonalPrism_new () ; -extern "C" void vtkHexagonalPrism_destructor (vtkNew < vtkHexagonalPrism > sself) ; -extern "C" void * vtkHexagonalPrism_get_ptr (vtkNew < vtkHexagonalPrism > sself) ; -extern "C" void vtk_hexagonal_prism_get_edge_points(vtkNew sself, long long edgeId, const long long pts); -extern "C" void vtk_hexagonal_prism_get_edge_points(vtkNew sself, int edgeId, int pts); -extern "C" long long vtk_hexagonal_prism_get_face_points(vtkNew sself, long long faceId, const long long pts); -extern "C" void vtk_hexagonal_prism_get_face_points(vtkNew sself, int faceId, int pts); -extern "C" void vtk_hexagonal_prism_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); -extern "C" long long vtk_hexagonal_prism_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); -extern "C" long long vtk_hexagonal_prism_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); -extern "C" long long vtk_hexagonal_prism_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); -extern "C" long long vtk_hexagonal_prism_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); -extern "C" bool vtk_hexagonal_prism_get_centroid(vtkNew sself, double centroid); -extern "C" int vtk_hexagonal_prism_get_cell_type(vtkNew sself); -extern "C" int vtk_hexagonal_prism_get_number_of_edges(vtkNew sself); -extern "C" int vtk_hexagonal_prism_get_number_of_faces(vtkNew sself); -extern "C" int vtk_hexagonal_prism_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_hexagonal_prism_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_hexagonal_prism_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_hexagonal_prism_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_hexagonal_prism_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_hexagonal_prism_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_hexagonal_prism_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_hexagonal_prism_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_hexagonal_prism_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_hexagonal_prism_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_hexagonal_prism_get_face_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_hexagonal_prism_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_hexagonal_prism_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_hexagonal_prism_get_point_to_incident_edges_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_hexagonal_prism_get_point_to_incident_faces_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_hexagonal_prism_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); -extern "C" void vtk_hexagonal_prism_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkHexahedron > vtkHexahedron_new () ; -extern "C" void vtkHexahedron_destructor (vtkNew < vtkHexahedron > sself) ; -extern "C" void * vtkHexahedron_get_ptr (vtkNew < vtkHexahedron > sself) ; -extern "C" void vtk_hexahedron_get_edge_points(vtkNew sself, long long edgeId, const long long pts); -extern "C" void vtk_hexahedron_get_edge_points(vtkNew sself, int edgeId, int pts); -extern "C" long long vtk_hexahedron_get_face_points(vtkNew sself, long long faceId, const long long pts); -extern "C" void vtk_hexahedron_get_face_points(vtkNew sself, int faceId, int pts); -extern "C" void vtk_hexahedron_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); -extern "C" long long vtk_hexahedron_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); -extern "C" long long vtk_hexahedron_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); -extern "C" long long vtk_hexahedron_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); -extern "C" long long vtk_hexahedron_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); -extern "C" bool vtk_hexahedron_get_centroid(vtkNew sself, double centroid); -extern "C" int vtk_hexahedron_get_cell_type(vtkNew sself); -extern "C" int vtk_hexahedron_get_number_of_edges(vtkNew sself); -extern "C" int vtk_hexahedron_get_number_of_faces(vtkNew sself); -extern "C" int vtk_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int* vtk_hexahedron_get_triangle_cases(vtkNew sself, int caseId); -extern "C" void vtk_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_hexahedron_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_hexahedron_get_face_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_hexahedron_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_hexahedron_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_hexahedron_get_point_to_incident_edges_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_hexahedron_get_point_to_incident_faces_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_hexahedron_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); -extern "C" void vtk_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkHierarchicalBoxDataIterator > vtkHierarchicalBoxDataIterator_new () ; -extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkNew < vtkHierarchicalBoxDataIterator > sself) ; -extern "C" void * vtkHierarchicalBoxDataIterator_get_ptr (vtkNew < vtkHierarchicalBoxDataIterator > sself) ; -extern "C" vtkNew < vtkHierarchicalBoxDataSet > vtkHierarchicalBoxDataSet_new () ; -extern "C" void vtkHierarchicalBoxDataSet_destructor (vtkNew < vtkHierarchicalBoxDataSet > sself) ; -extern "C" void * vtkHierarchicalBoxDataSet_get_ptr (vtkNew < vtkHierarchicalBoxDataSet > sself) ; -extern "C" vtkNew < vtkHyperTreeGrid > vtkHyperTreeGrid_new () ; -extern "C" void vtkHyperTreeGrid_destructor (vtkNew < vtkHyperTreeGrid > sself) ; -extern "C" void * vtkHyperTreeGrid_get_ptr (vtkNew < vtkHyperTreeGrid > sself) ; -extern "C" void vtk_hyper_tree_grid_set_mode_squeeze(vtkNew sself, const char _arg); -extern "C" char* vtk_hyper_tree_grid_get_mode_squeeze(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_squeeze(vtkNew sself); -extern "C" int vtk_hyper_tree_grid_get_data_object_type(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, const unsigned int dims); -extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, const int dims); -extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, unsigned int i, unsigned int j, unsigned int k); -extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, int i, int j, int k); -extern "C" const unsigned int* vtk_hyper_tree_grid_get_dimensions(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_get_dimensions(vtkNew sself, int dim); -extern "C" void vtk_hyper_tree_grid_get_dimensions(vtkNew sself, unsigned int dim); -extern "C" void vtk_hyper_tree_grid_set_extent(vtkNew sself, const int extent); -extern "C" void vtk_hyper_tree_grid_set_extent(vtkNew sself, int x1, int x2, int y1, int y2, int z1, int z2); -extern "C" int* vtk_hyper_tree_grid_get_extent(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_hyper_tree_grid_get_extent(vtkNew sself, int _arg); -extern "C" const unsigned int* vtk_hyper_tree_grid_get_cell_dims(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_get_cell_dims(vtkNew sself, int cellDims); -extern "C" void vtk_hyper_tree_grid_get_cell_dims(vtkNew sself, unsigned int cellDims); -extern "C" unsigned int vtk_hyper_tree_grid_get_dimension(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_get_1_d_axis(vtkNew sself, unsigned int axis); -extern "C" void vtk_hyper_tree_grid_get_2_d_axes(vtkNew sself, unsigned int axis1, unsigned int axis2); -extern "C" const unsigned int* vtk_hyper_tree_grid_get_axes(vtkNew sself); -extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_children(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_set_transposed_root_indexing(vtkNew sself, bool _arg); -extern "C" bool vtk_hyper_tree_grid_get_transposed_root_indexing(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_kji(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_ijk(vtkNew sself); -extern "C" unsigned int vtk_hyper_tree_grid_get_orientation(vtkNew sself); -extern "C" bool vtk_hyper_tree_grid_get_freeze_state(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_set_branch_factor(vtkNew sself, unsigned int p0); -extern "C" unsigned int vtk_hyper_tree_grid_get_branch_factor(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_get_max_number_of_trees(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_get_number_of_vertices(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_get_number_of_non_empty_trees(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_get_number_of_leaves(vtkNew sself); -extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkNew sself, long long p0); -extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_set_fixed_coordinates(vtkNew sself, unsigned int axis, double value); -extern "C" bool vtk_hyper_tree_grid_has_mask(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_set_has_interface(vtkNew sself, bool _arg); -extern "C" bool vtk_hyper_tree_grid_get_has_interface(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_has_interface_on(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_has_interface_off(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_set_interface_normals_name(vtkNew sself, const char _arg); -extern "C" char* vtk_hyper_tree_grid_get_interface_normals_name(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_set_interface_intercepts_name(vtkNew sself, const char _arg); -extern "C" char* vtk_hyper_tree_grid_get_interface_intercepts_name(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_set_depth_limiter(vtkNew sself, unsigned int _arg); -extern "C" unsigned int vtk_hyper_tree_grid_get_depth_limiter(vtkNew sself); -extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_x(vtkNew sself, double value); -extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_y(vtkNew sself, double value); -extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_z(vtkNew sself, double value); -extern "C" void vtk_hyper_tree_grid_initialize(vtkNew sself); -extern "C" int vtk_hyper_tree_grid_get_extent_type(vtkNew sself); -extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size_bytes(vtkNew sself); -extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size(vtkNew sself); -extern "C" unsigned int vtk_hyper_tree_grid_get_child_mask(vtkNew sself, unsigned int p0); -extern "C" void vtk_hyper_tree_grid_get_index_from_level_zero_coordinates(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3); -extern "C" long long vtk_hyper_tree_grid_get_shifted_level_zero_index(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3); -extern "C" void vtk_hyper_tree_grid_get_level_zero_coordinates_from_index(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3); -extern "C" void vtk_hyper_tree_grid_get_level_zero_origin_and_size_from_index(vtkNew sself, long long p0, double p1, double p2); -extern "C" void vtk_hyper_tree_grid_get_level_zero_origin_from_index(vtkNew sself, long long p0, double p1); -extern "C" long long vtk_hyper_tree_grid_get_global_node_index_max(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_initialize_local_index_node(vtkNew sself); -extern "C" bool vtk_hyper_tree_grid_has_any_ghost_cells(vtkNew sself); -extern "C" double* vtk_hyper_tree_grid_get_bounds(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_get_bounds(vtkNew sself, double bounds); -extern "C" double* vtk_hyper_tree_grid_get_center(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_get_center(vtkNew sself, double center); -extern "C" long long vtk_hyper_tree_grid_get_number_of_elements(vtkNew sself, int type); -extern "C" vtkNew < vtkHyperTreeGridNonOrientedCursor > vtkHyperTreeGridNonOrientedCursor_new () ; -extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) ; -extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_has_tree(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(vtkNew sself); -extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_dimension(vtkNew sself); -extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(vtkNew sself, long long index); -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local(vtkNew sself, long long index); -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_mask(vtkNew sself, bool state); -extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_masked(vtkNew sself); -extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_leaf(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf(vtkNew sself); -extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_root(vtkNew sself); -extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_cursor_get_level(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_child(vtkNew sself, unsigned char ichild); -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_root(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_parent(vtkNew sself); -extern "C" vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > vtkHyperTreeGridNonOrientedGeometryCursor_new () ; -extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) ; -extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index(vtkNew sself); -extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension(vtkNew sself); -extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start(vtkNew sself, long long index); -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local(vtkNew sself, long long index); -extern "C" double* vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_origin(vtkNew sself); -extern "C" double* vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_size(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_bounds(vtkNew sself, double bounds); -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_point(vtkNew sself, double point); -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask(vtkNew sself, bool state); -extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked(vtkNew sself); -extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf(vtkNew sself); -extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root(vtkNew sself); -extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child(vtkNew sself, unsigned char ichild); -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(vtkNew sself); -extern "C" vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > vtkHyperTreeGridNonOrientedMooreSuperCursor_new () ; -extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) ; -extern "C" vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new () ; -extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursorLight_destructor (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > sself) ; -extern "C" vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new () ; -extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > sself) ; -extern "C" vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new () ; -extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_destructor (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > sself) ; -extern "C" vtkNew < vtkHyperTreeGridOrientedCursor > vtkHyperTreeGridOrientedCursor_new () ; -extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkNew < vtkHyperTreeGridOrientedCursor > sself) ; -extern "C" void * vtkHyperTreeGridOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedCursor > sself) ; -extern "C" bool vtk_hyper_tree_grid_oriented_cursor_has_tree(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(vtkNew sself); -extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_dimension(vtkNew sself); -extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(vtkNew sself, long long index); -extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local(vtkNew sself, long long index); -extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_mask(vtkNew sself, bool state); -extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_masked(vtkNew sself); -extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_leaf(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf(vtkNew sself); -extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_root(vtkNew sself); -extern "C" unsigned int vtk_hyper_tree_grid_oriented_cursor_get_level(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_oriented_cursor_to_child(vtkNew sself, unsigned char ichild); -extern "C" vtkNew < vtkHyperTreeGridOrientedGeometryCursor > vtkHyperTreeGridOrientedGeometryCursor_new () ; -extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) ; -extern "C" void * vtkHyperTreeGridOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) ; -extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(vtkNew sself); -extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(vtkNew sself); -extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension(vtkNew sself); -extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start(vtkNew sself, long long index); -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local(vtkNew sself, long long index); -extern "C" double* vtk_hyper_tree_grid_oriented_geometry_cursor_get_origin(vtkNew sself); -extern "C" double* vtk_hyper_tree_grid_oriented_geometry_cursor_get_size(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_get_bounds(vtkNew sself, double bounds); -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_get_point(vtkNew sself, double point); -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask(vtkNew sself, bool state); -extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked(vtkNew sself); -extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf(vtkNew sself); -extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_root(vtkNew sself); -extern "C" unsigned int vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(vtkNew sself); -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(vtkNew sself, unsigned char ichild); -extern "C" vtkNew < vtkImageData > vtkImageData_new () ; -extern "C" void vtkImageData_destructor (vtkNew < vtkImageData > sself) ; -extern "C" void * vtkImageData_get_ptr (vtkNew < vtkImageData > sself) ; -extern "C" int vtk_image_data_get_data_object_type(vtkNew sself); -extern "C" long long vtk_image_data_get_number_of_cells(vtkNew sself); -extern "C" long long vtk_image_data_get_number_of_points(vtkNew sself); -extern "C" double* vtk_image_data_get_point(vtkNew sself, long long ptId); -extern "C" long long vtk_image_data_find_point(vtkNew sself, double x, double y, double z); -extern "C" long long vtk_image_data_find_point(vtkNew sself, double x); -extern "C" int vtk_image_data_get_cell_type(vtkNew sself, long long cellId); -extern "C" int vtk_image_data_get_max_cell_size(vtkNew sself); -extern "C" void vtk_image_data_initialize(vtkNew sself); -extern "C" unsigned char vtk_image_data_is_point_visible(vtkNew sself, long long ptId); -extern "C" unsigned char vtk_image_data_is_cell_visible(vtkNew sself, long long cellId); -extern "C" bool vtk_image_data_has_any_blank_points(vtkNew sself); -extern "C" bool vtk_image_data_has_any_blank_cells(vtkNew sself); -extern "C" void vtk_image_data_get_cell_dims(vtkNew sself, int cellDims); -extern "C" void vtk_image_data_set_dimensions(vtkNew sself, int i, int j, int k); -extern "C" void vtk_image_data_set_dimensions(vtkNew sself, const int dims); -extern "C" int* vtk_image_data_get_dimensions(vtkNew sself); -extern "C" void vtk_image_data_get_dimensions(vtkNew sself, int dims); -extern "C" void vtk_image_data_get_dimensions(vtkNew sself, long long dims); -extern "C" int vtk_image_data_compute_structured_coordinates(vtkNew sself, const double x, int ijk, double pcoords); -extern "C" int vtk_image_data_get_data_dimension(vtkNew sself); -extern "C" long long vtk_image_data_compute_point_id(vtkNew sself, int ijk); -extern "C" long long vtk_image_data_compute_cell_id(vtkNew sself, int ijk); -extern "C" void vtk_image_data_set_axis_update_extent(vtkNew sself, int axis, int min, int max, const int updateExtent, int axisUpdateExtent); -extern "C" void vtk_image_data_get_axis_update_extent(vtkNew sself, int axis, int min, int max, const int updateExtent); -extern "C" void vtk_image_data_set_extent(vtkNew sself, int extent); -extern "C" void vtk_image_data_set_extent(vtkNew sself, int x1, int x2, int y1, int y2, int z1, int z2); -extern "C" int* vtk_image_data_get_extent(vtkNew sself); -extern "C" void vtk_image_data_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_image_data_get_extent(vtkNew sself, int _arg); -extern "C" double vtk_image_data_get_scalar_type_min(vtkNew sself); -extern "C" double vtk_image_data_get_scalar_type_max(vtkNew sself); -extern "C" int vtk_image_data_get_scalar_size(vtkNew sself); -extern "C" long long* vtk_image_data_get_increments(vtkNew sself); -extern "C" void vtk_image_data_get_increments(vtkNew sself, long long incX, long long incY, long long incZ); -extern "C" void vtk_image_data_get_increments(vtkNew sself, long long inc); -extern "C" void vtk_image_data_get_continuous_increments(vtkNew sself, int extent, long long incX, long long incY, long long incZ); -extern "C" void* vtk_image_data_get_scalar_pointer_for_extent(vtkNew sself, int extent); -extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself, int coordinates); -extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself, int x, int y, int z); -extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself); -extern "C" long long vtk_image_data_get_scalar_index_for_extent(vtkNew sself, int extent); -extern "C" long long vtk_image_data_get_scalar_index(vtkNew sself, int coordinates); -extern "C" long long vtk_image_data_get_scalar_index(vtkNew sself, int x, int y, int z); -extern "C" float vtk_image_data_get_scalar_component_as_float(vtkNew sself, int x, int y, int z, int component); -extern "C" void vtk_image_data_set_scalar_component_from_float(vtkNew sself, int x, int y, int z, int component, float v); -extern "C" double vtk_image_data_get_scalar_component_as_double(vtkNew sself, int x, int y, int z, int component); -extern "C" void vtk_image_data_set_scalar_component_from_double(vtkNew sself, int x, int y, int z, int component, double v); -extern "C" void vtk_image_data_allocate_scalars(vtkNew sself, int dataType, int numComponents); -extern "C" void vtk_image_data_crop(vtkNew sself, const int updateExtent); -extern "C" double* vtk_image_data_get_spacing(vtkNew sself); -extern "C" void vtk_image_data_get_spacing(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_image_data_get_spacing(vtkNew sself, double _arg); -extern "C" void vtk_image_data_set_spacing(vtkNew sself, double i, double j, double k); -extern "C" void vtk_image_data_set_spacing(vtkNew sself, const double ijk); -extern "C" double* vtk_image_data_get_origin(vtkNew sself); -extern "C" void vtk_image_data_get_origin(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_image_data_get_origin(vtkNew sself, double _arg); -extern "C" void vtk_image_data_set_origin(vtkNew sself, double i, double j, double k); -extern "C" void vtk_image_data_set_origin(vtkNew sself, const double ijk); -extern "C" void vtk_image_data_set_direction_matrix(vtkNew sself, const double elements); -extern "C" void vtk_image_data_set_direction_matrix(vtkNew sself, double e00, double e01, double e02, double e10, double e11, double e12, double e20, double e21, double e22); -extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, double i, double j, double k, double xyz); -extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, const double ijk, double xyz); -extern "C" void vtk_image_data_transform_index_to_physical_point(vtkNew sself, int i, int j, int k, double xyz); -extern "C" void vtk_image_data_transform_index_to_physical_point(vtkNew sself, const int ijk, double xyz); -extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, double i, double j, double k, const double origin, const double spacing, const double direction, double xyz); -extern "C" void vtk_image_data_transform_physical_point_to_continuous_index(vtkNew sself, double x, double y, double z, double ijk); -extern "C" void vtk_image_data_transform_physical_point_to_continuous_index(vtkNew sself, const double xyz, double ijk); -extern "C" void vtk_image_data_compute_index_to_physical_matrix(vtkNew sself, const double origin, const double spacing, const double direction, double result); -extern "C" void vtk_image_data_transform_physical_normal_to_continuous_index(vtkNew sself, const double xyz, double ijk); -extern "C" void vtk_image_data_transform_physical_plane_to_continuous_index(vtkNew sself, const double pplane, double iplane); -extern "C" int vtk_image_data_get_scalar_type(vtkNew sself); -extern "C" const char* vtk_image_data_get_scalar_type_as_string(vtkNew sself); -extern "C" int vtk_image_data_get_number_of_scalar_components(vtkNew sself); -extern "C" void vtk_image_data_prepare_for_new_data(vtkNew sself); -extern "C" void vtk_image_data_compute_internal_extent(vtkNew sself, int intExt, int tgtExt, int bnds); -extern "C" int vtk_image_data_get_extent_type(vtkNew sself); -extern "C" vtkNew < vtkImageTransform > vtkImageTransform_new () ; -extern "C" void vtkImageTransform_destructor (vtkNew < vtkImageTransform > sself) ; -extern "C" void * vtkImageTransform_get_ptr (vtkNew < vtkImageTransform > sself) ; -extern "C" vtkNew < vtkImplicitBoolean > vtkImplicitBoolean_new () ; -extern "C" void vtkImplicitBoolean_destructor (vtkNew < vtkImplicitBoolean > sself) ; -extern "C" void * vtkImplicitBoolean_get_ptr (vtkNew < vtkImplicitBoolean > sself) ; -extern "C" double vtk_implicit_boolean_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_implicit_boolean_evaluate_gradient(vtkNew sself, double x, double g); -extern "C" unsigned long vtk_implicit_boolean_get_m_time(vtkNew sself); -extern "C" void vtk_implicit_boolean_set_operation_type(vtkNew sself, int _arg); -extern "C" int vtk_implicit_boolean_get_operation_type_min_value(vtkNew sself); -extern "C" int vtk_implicit_boolean_get_operation_type_max_value(vtkNew sself); -extern "C" int vtk_implicit_boolean_get_operation_type(vtkNew sself); -extern "C" void vtk_implicit_boolean_set_operation_type_to_union(vtkNew sself); -extern "C" void vtk_implicit_boolean_set_operation_type_to_intersection(vtkNew sself); -extern "C" void vtk_implicit_boolean_set_operation_type_to_difference(vtkNew sself); -extern "C" void vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(vtkNew sself); -extern "C" const char* vtk_implicit_boolean_get_operation_type_as_string(vtkNew sself); -extern "C" vtkNew < vtkImplicitDataSet > vtkImplicitDataSet_new () ; -extern "C" void vtkImplicitDataSet_destructor (vtkNew < vtkImplicitDataSet > sself) ; -extern "C" void * vtkImplicitDataSet_get_ptr (vtkNew < vtkImplicitDataSet > sself) ; -extern "C" unsigned long vtk_implicit_data_set_get_m_time(vtkNew sself); -extern "C" double vtk_implicit_data_set_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_implicit_data_set_evaluate_gradient(vtkNew sself, double x, double n); -extern "C" void vtk_implicit_data_set_set_out_value(vtkNew sself, double _arg); -extern "C" double vtk_implicit_data_set_get_out_value(vtkNew sself); -extern "C" void vtk_implicit_data_set_set_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_implicit_data_set_set_out_gradient(vtkNew sself, const double _arg); -extern "C" double* vtk_implicit_data_set_get_out_gradient(vtkNew sself); -extern "C" void vtk_implicit_data_set_get_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_implicit_data_set_get_out_gradient(vtkNew sself, double _arg); -extern "C" vtkNew < vtkImplicitFunctionCollection > vtkImplicitFunctionCollection_new () ; -extern "C" void vtkImplicitFunctionCollection_destructor (vtkNew < vtkImplicitFunctionCollection > sself) ; -extern "C" void * vtkImplicitFunctionCollection_get_ptr (vtkNew < vtkImplicitFunctionCollection > sself) ; -extern "C" vtkNew < vtkImplicitHalo > vtkImplicitHalo_new () ; -extern "C" void vtkImplicitHalo_destructor (vtkNew < vtkImplicitHalo > sself) ; -extern "C" void * vtkImplicitHalo_get_ptr (vtkNew < vtkImplicitHalo > sself) ; -extern "C" double vtk_implicit_halo_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_implicit_halo_evaluate_gradient(vtkNew sself, double x, double g); -extern "C" void vtk_implicit_halo_set_radius(vtkNew sself, double _arg); -extern "C" double vtk_implicit_halo_get_radius(vtkNew sself); -extern "C" void vtk_implicit_halo_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_implicit_halo_set_center(vtkNew sself, const double _arg); -extern "C" double* vtk_implicit_halo_get_center(vtkNew sself); -extern "C" void vtk_implicit_halo_get_center(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_implicit_halo_get_center(vtkNew sself, double _arg); -extern "C" void vtk_implicit_halo_set_fade_out(vtkNew sself, double _arg); -extern "C" double vtk_implicit_halo_get_fade_out(vtkNew sself); -extern "C" vtkNew < vtkImplicitSelectionLoop > vtkImplicitSelectionLoop_new () ; -extern "C" void vtkImplicitSelectionLoop_destructor (vtkNew < vtkImplicitSelectionLoop > sself) ; -extern "C" void * vtkImplicitSelectionLoop_get_ptr (vtkNew < vtkImplicitSelectionLoop > sself) ; -extern "C" double vtk_implicit_selection_loop_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_implicit_selection_loop_evaluate_gradient(vtkNew sself, double x, double n); -extern "C" void vtk_implicit_selection_loop_set_automatic_normal_generation(vtkNew sself, int _arg); -extern "C" int vtk_implicit_selection_loop_get_automatic_normal_generation(vtkNew sself); -extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_on(vtkNew sself); -extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_off(vtkNew sself); -extern "C" void vtk_implicit_selection_loop_set_normal(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_implicit_selection_loop_set_normal(vtkNew sself, const double _arg); -extern "C" double* vtk_implicit_selection_loop_get_normal(vtkNew sself); -extern "C" void vtk_implicit_selection_loop_get_normal(vtkNew sself, double data); -extern "C" unsigned long vtk_implicit_selection_loop_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkImplicitSum > vtkImplicitSum_new () ; -extern "C" void vtkImplicitSum_destructor (vtkNew < vtkImplicitSum > sself) ; -extern "C" void * vtkImplicitSum_get_ptr (vtkNew < vtkImplicitSum > sself) ; -extern "C" double vtk_implicit_sum_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_implicit_sum_evaluate_gradient(vtkNew sself, double x, double g); -extern "C" unsigned long vtk_implicit_sum_get_m_time(vtkNew sself); -extern "C" void vtk_implicit_sum_remove_all_functions(vtkNew sself); -extern "C" void vtk_implicit_sum_set_normalize_by_weight(vtkNew sself, int _arg); -extern "C" int vtk_implicit_sum_get_normalize_by_weight(vtkNew sself); -extern "C" void vtk_implicit_sum_normalize_by_weight_on(vtkNew sself); -extern "C" void vtk_implicit_sum_normalize_by_weight_off(vtkNew sself); -extern "C" vtkNew < vtkImplicitVolume > vtkImplicitVolume_new () ; -extern "C" void vtkImplicitVolume_destructor (vtkNew < vtkImplicitVolume > sself) ; -extern "C" void * vtkImplicitVolume_get_ptr (vtkNew < vtkImplicitVolume > sself) ; -extern "C" unsigned long vtk_implicit_volume_get_m_time(vtkNew sself); -extern "C" double vtk_implicit_volume_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_implicit_volume_evaluate_gradient(vtkNew sself, double x, double n); -extern "C" void vtk_implicit_volume_set_out_value(vtkNew sself, double _arg); -extern "C" double vtk_implicit_volume_get_out_value(vtkNew sself); -extern "C" void vtk_implicit_volume_set_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_implicit_volume_set_out_gradient(vtkNew sself, const double _arg); -extern "C" double* vtk_implicit_volume_get_out_gradient(vtkNew sself); -extern "C" void vtk_implicit_volume_get_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_implicit_volume_get_out_gradient(vtkNew sself, double _arg); -extern "C" vtkNew < vtkImplicitWindowFunction > vtkImplicitWindowFunction_new () ; -extern "C" void vtkImplicitWindowFunction_destructor (vtkNew < vtkImplicitWindowFunction > sself) ; -extern "C" void * vtkImplicitWindowFunction_get_ptr (vtkNew < vtkImplicitWindowFunction > sself) ; -extern "C" double vtk_implicit_window_function_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_implicit_window_function_evaluate_gradient(vtkNew sself, double x, double n); -extern "C" void vtk_implicit_window_function_set_window_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_implicit_window_function_set_window_range(vtkNew sself, const double _arg); -extern "C" double* vtk_implicit_window_function_get_window_range(vtkNew sself); -extern "C" void vtk_implicit_window_function_get_window_range(vtkNew sself, double data); -extern "C" void vtk_implicit_window_function_set_window_values(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_implicit_window_function_set_window_values(vtkNew sself, const double _arg); -extern "C" double* vtk_implicit_window_function_get_window_values(vtkNew sself); -extern "C" void vtk_implicit_window_function_get_window_values(vtkNew sself, double data); -extern "C" unsigned long vtk_implicit_window_function_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkInEdgeIterator > vtkInEdgeIterator_new () ; -extern "C" void vtkInEdgeIterator_destructor (vtkNew < vtkInEdgeIterator > sself) ; -extern "C" void * vtkInEdgeIterator_get_ptr (vtkNew < vtkInEdgeIterator > sself) ; -extern "C" long long vtk_in_edge_iterator_get_vertex(vtkNew sself); -extern "C" bool vtk_in_edge_iterator_has_next(vtkNew sself); -extern "C" vtkNew < vtkIncrementalOctreeNode > vtkIncrementalOctreeNode_new () ; -extern "C" void vtkIncrementalOctreeNode_destructor (vtkNew < vtkIncrementalOctreeNode > sself) ; -extern "C" void * vtkIncrementalOctreeNode_get_ptr (vtkNew < vtkIncrementalOctreeNode > sself) ; -extern "C" int vtk_incremental_octree_node_get_number_of_points(vtkNew sself); -extern "C" void vtk_incremental_octree_node_delete_child_nodes(vtkNew sself); -extern "C" void vtk_incremental_octree_node_set_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2); -extern "C" void vtk_incremental_octree_node_get_bounds(vtkNew sself, double bounds); -extern "C" double* vtk_incremental_octree_node_get_min_bounds(vtkNew sself); -extern "C" void vtk_incremental_octree_node_get_min_bounds(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_incremental_octree_node_get_min_bounds(vtkNew sself, double _arg); -extern "C" double* vtk_incremental_octree_node_get_max_bounds(vtkNew sself); -extern "C" void vtk_incremental_octree_node_get_max_bounds(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_incremental_octree_node_get_max_bounds(vtkNew sself, double _arg); -extern "C" double* vtk_incremental_octree_node_get_min_data_bounds(vtkNew sself); -extern "C" double* vtk_incremental_octree_node_get_max_data_bounds(vtkNew sself); -extern "C" int vtk_incremental_octree_node_is_leaf(vtkNew sself); -extern "C" int vtk_incremental_octree_node_get_child_index(vtkNew sself, const double point); -extern "C" int vtk_incremental_octree_node_contains_point(vtkNew sself, const double pnt); -extern "C" int vtk_incremental_octree_node_contains_point_by_data(vtkNew sself, const double pnt); -extern "C" int vtk_incremental_octree_node_get_number_of_levels(vtkNew sself); -extern "C" int vtk_incremental_octree_node_get_id(vtkNew sself); -extern "C" vtkNew < vtkIncrementalOctreePointLocator > vtkIncrementalOctreePointLocator_new () ; -extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkNew < vtkIncrementalOctreePointLocator > sself) ; -extern "C" void * vtkIncrementalOctreePointLocator_get_ptr (vtkNew < vtkIncrementalOctreePointLocator > sself) ; -extern "C" void vtk_incremental_octree_point_locator_set_max_points_per_leaf(vtkNew sself, int _arg); -extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value(vtkNew sself); -extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value(vtkNew sself); -extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf(vtkNew sself); -extern "C" void vtk_incremental_octree_point_locator_set_build_cubic_octree(vtkNew sself, int _arg); -extern "C" int vtk_incremental_octree_point_locator_get_build_cubic_octree(vtkNew sself); -extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_on(vtkNew sself); -extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_off(vtkNew sself); -extern "C" void vtk_incremental_octree_point_locator_initialize(vtkNew sself); -extern "C" void vtk_incremental_octree_point_locator_free_search_structure(vtkNew sself); -extern "C" void vtk_incremental_octree_point_locator_get_bounds(vtkNew sself, double bounds); -extern "C" double* vtk_incremental_octree_point_locator_get_bounds(vtkNew sself); -extern "C" int vtk_incremental_octree_point_locator_get_number_of_points(vtkNew sself); -extern "C" int vtk_incremental_octree_point_locator_get_number_of_nodes(vtkNew sself); -extern "C" long long vtk_incremental_octree_point_locator_find_closest_inserted_point(vtkNew sself, const double x); -extern "C" void vtk_incremental_octree_point_locator_build_locator(vtkNew sself); -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, const double x); -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z); -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, const double x, double miniDist2); -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z, double miniDist2); -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point_within_squared_radius(vtkNew sself, double radius2, const double x, double dist2); -extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkNew sself, const double x); -extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkNew sself, double x, double y, double z); -extern "C" int vtk_incremental_octree_point_locator_insert_unique_point(vtkNew sself, const double point, long long pntId); -extern "C" void vtk_incremental_octree_point_locator_insert_point(vtkNew sself, long long ptId, const double x); -extern "C" long long vtk_incremental_octree_point_locator_insert_next_point(vtkNew sself, const double x); -extern "C" void vtk_incremental_octree_point_locator_insert_point_without_checking(vtkNew sself, const double point, long long pntId, int insert); -extern "C" int vtk_incremental_octree_point_locator_get_number_of_levels(vtkNew sself); -extern "C" vtkNew < vtkIterativeClosestPointTransform > vtkIterativeClosestPointTransform_new () ; -extern "C" void vtkIterativeClosestPointTransform_destructor (vtkNew < vtkIterativeClosestPointTransform > sself) ; -extern "C" void * vtkIterativeClosestPointTransform_get_ptr (vtkNew < vtkIterativeClosestPointTransform > sself) ; -extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_iterations(vtkNew sself, int _arg); -extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_iterations(vtkNew sself); -extern "C" int vtk_iterative_closest_point_transform_get_number_of_iterations(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_set_check_mean_distance(vtkNew sself, int _arg); -extern "C" int vtk_iterative_closest_point_transform_get_check_mean_distance(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_on(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_off(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode(vtkNew sself, int _arg); -extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value(vtkNew sself); -extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value(vtkNew sself); -extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value(vtkNew sself); -extern "C" const char* vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_set_maximum_mean_distance(vtkNew sself, double _arg); -extern "C" double vtk_iterative_closest_point_transform_get_maximum_mean_distance(vtkNew sself); -extern "C" double vtk_iterative_closest_point_transform_get_mean_distance(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks(vtkNew sself, int _arg); -extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_set_start_by_matching_centroids(vtkNew sself, int _arg); -extern "C" int vtk_iterative_closest_point_transform_get_start_by_matching_centroids(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_on(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_off(vtkNew sself); -extern "C" void vtk_iterative_closest_point_transform_inverse(vtkNew sself); -extern "C" vtkNew < vtkKdNode > vtkKdNode_new () ; -extern "C" void vtkKdNode_destructor (vtkNew < vtkKdNode > sself) ; -extern "C" void * vtkKdNode_get_ptr (vtkNew < vtkKdNode > sself) ; -extern "C" void vtk_kd_node_set_dim(vtkNew sself, int _arg); -extern "C" int vtk_kd_node_get_dim(vtkNew sself); -extern "C" double vtk_kd_node_get_division_position(vtkNew sself); -extern "C" void vtk_kd_node_set_number_of_points(vtkNew sself, int _arg); -extern "C" int vtk_kd_node_get_number_of_points(vtkNew sself); -extern "C" void vtk_kd_node_set_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2); -extern "C" void vtk_kd_node_set_bounds(vtkNew sself, const double b); -extern "C" void vtk_kd_node_get_bounds(vtkNew sself, double b); -extern "C" void vtk_kd_node_set_data_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2); -extern "C" void vtk_kd_node_get_data_bounds(vtkNew sself, double b); -extern "C" void vtk_kd_node_set_data_bounds(vtkNew sself, float v); -extern "C" double* vtk_kd_node_get_min_bounds(vtkNew sself); -extern "C" double* vtk_kd_node_get_max_bounds(vtkNew sself); -extern "C" void vtk_kd_node_set_min_bounds(vtkNew sself, const double mb); -extern "C" void vtk_kd_node_set_max_bounds(vtkNew sself, const double mb); -extern "C" double* vtk_kd_node_get_min_data_bounds(vtkNew sself); -extern "C" double* vtk_kd_node_get_max_data_bounds(vtkNew sself); -extern "C" void vtk_kd_node_set_min_data_bounds(vtkNew sself, const double mb); -extern "C" void vtk_kd_node_set_max_data_bounds(vtkNew sself, const double mb); -extern "C" void vtk_kd_node_set_id(vtkNew sself, int _arg); -extern "C" int vtk_kd_node_get_id(vtkNew sself); -extern "C" int vtk_kd_node_get_min_id(vtkNew sself); -extern "C" int vtk_kd_node_get_max_id(vtkNew sself); -extern "C" void vtk_kd_node_set_min_id(vtkNew sself, int _arg); -extern "C" void vtk_kd_node_set_max_id(vtkNew sself, int _arg); -extern "C" void vtk_kd_node_delete_child_nodes(vtkNew sself); -extern "C" int vtk_kd_node_intersects_box(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds); -extern "C" int vtk_kd_node_intersects_sphere_2(vtkNew sself, double x, double y, double z, double rSquared, int useDataBounds); -extern "C" int vtk_kd_node_contains_box(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds); -extern "C" int vtk_kd_node_contains_point(vtkNew sself, double x, double y, double z, int useDataBounds); -extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkNew sself, double x, double y, double z, int useDataBounds); -extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkNew sself, double x, double y, double z, double boundaryPt, int useDataBounds); -extern "C" double vtk_kd_node_get_distance_2_to_inner_boundary(vtkNew sself, double x, double y, double z); -extern "C" void vtk_kd_node_print_node(vtkNew sself, int depth); -extern "C" void vtk_kd_node_print_verbose_node(vtkNew sself, int depth); -extern "C" vtkNew < vtkKdTree > vtkKdTree_new () ; -extern "C" void vtkKdTree_destructor (vtkNew < vtkKdTree > sself) ; -extern "C" void * vtkKdTree_get_ptr (vtkNew < vtkKdTree > sself) ; -extern "C" void vtk_kd_tree_timing_on(vtkNew sself); -extern "C" void vtk_kd_tree_timing_off(vtkNew sself); -extern "C" void vtk_kd_tree_set_timing(vtkNew sself, int _arg); -extern "C" int vtk_kd_tree_get_timing(vtkNew sself); -extern "C" void vtk_kd_tree_set_min_cells(vtkNew sself, int _arg); -extern "C" int vtk_kd_tree_get_min_cells(vtkNew sself); -extern "C" int vtk_kd_tree_get_number_of_regions_or_less(vtkNew sself); -extern "C" void vtk_kd_tree_set_number_of_regions_or_less(vtkNew sself, int _arg); -extern "C" int vtk_kd_tree_get_number_of_regions_or_more(vtkNew sself); -extern "C" void vtk_kd_tree_set_number_of_regions_or_more(vtkNew sself, int _arg); -extern "C" double vtk_kd_tree_get_fudge_factor(vtkNew sself); -extern "C" void vtk_kd_tree_set_fudge_factor(vtkNew sself, double _arg); -extern "C" void vtk_kd_tree_omit_x_partitioning(vtkNew sself); -extern "C" void vtk_kd_tree_omit_y_partitioning(vtkNew sself); -extern "C" void vtk_kd_tree_omit_z_partitioning(vtkNew sself); -extern "C" void vtk_kd_tree_omit_xy_partitioning(vtkNew sself); -extern "C" void vtk_kd_tree_omit_yz_partitioning(vtkNew sself); -extern "C" void vtk_kd_tree_omit_zx_partitioning(vtkNew sself); -extern "C" void vtk_kd_tree_omit_no_partitioning(vtkNew sself); -extern "C" void vtk_kd_tree_remove_data_set(vtkNew sself, int index); -extern "C" void vtk_kd_tree_remove_all_data_sets(vtkNew sself); -extern "C" int vtk_kd_tree_get_number_of_data_sets(vtkNew sself); -extern "C" void vtk_kd_tree_get_bounds(vtkNew sself, double bounds); -extern "C" void vtk_kd_tree_set_new_bounds(vtkNew sself, double bounds); -extern "C" int vtk_kd_tree_get_number_of_regions(vtkNew sself); -extern "C" void vtk_kd_tree_get_region_bounds(vtkNew sself, int regionID, double bounds); -extern "C" void vtk_kd_tree_get_region_data_bounds(vtkNew sself, int regionID, double bounds); -extern "C" void vtk_kd_tree_print_tree(vtkNew sself); -extern "C" void vtk_kd_tree_print_verbose_tree(vtkNew sself); -extern "C" void vtk_kd_tree_print_region(vtkNew sself, int id); -extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself, int dataSetIndex, int regionReqList, int reqListSize); -extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself, int regionReqList, int listSize); -extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself); -extern "C" void vtk_kd_tree_set_include_region_boundary_cells(vtkNew sself, int _arg); -extern "C" int vtk_kd_tree_get_include_region_boundary_cells(vtkNew sself); -extern "C" void vtk_kd_tree_include_region_boundary_cells_on(vtkNew sself); -extern "C" void vtk_kd_tree_include_region_boundary_cells_off(vtkNew sself); -extern "C" void vtk_kd_tree_delete_cell_lists(vtkNew sself); -extern "C" int vtk_kd_tree_get_region_containing_cell(vtkNew sself, int set, long long cellID); -extern "C" int vtk_kd_tree_get_region_containing_cell(vtkNew sself, long long cellID); -extern "C" int* vtk_kd_tree_all_get_region_containing_cell(vtkNew sself); -extern "C" int vtk_kd_tree_get_region_containing_point(vtkNew sself, double x, double y, double z); -extern "C" void vtk_kd_tree_build_locator(vtkNew sself); -extern "C" long long vtk_kd_tree_find_point(vtkNew sself, double x); -extern "C" long long vtk_kd_tree_find_point(vtkNew sself, double x, double y, double z); -extern "C" long long vtk_kd_tree_find_closest_point(vtkNew sself, double x, double dist2); -extern "C" long long vtk_kd_tree_find_closest_point(vtkNew sself, double x, double y, double z, double dist2); -extern "C" long long vtk_kd_tree_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); -extern "C" long long vtk_kd_tree_find_closest_point_in_region(vtkNew sself, int regionId, double x, double dist2); -extern "C" long long vtk_kd_tree_find_closest_point_in_region(vtkNew sself, int regionId, double x, double y, double z, double dist2); -extern "C" void vtk_kd_tree_free_search_structure(vtkNew sself); -extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_on(vtkNew sself); -extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_off(vtkNew sself); -extern "C" void vtk_kd_tree_set_generate_representation_using_data_bounds(vtkNew sself, int _arg); -extern "C" int vtk_kd_tree_get_generate_representation_using_data_bounds(vtkNew sself); -extern "C" int vtk_kd_tree_new_geometry(vtkNew sself); -extern "C" void vtk_kd_tree_invalidate_geometry(vtkNew sself); -extern "C" vtkNew < vtkKdTreePointLocator > vtkKdTreePointLocator_new () ; -extern "C" void vtkKdTreePointLocator_destructor (vtkNew < vtkKdTreePointLocator > sself) ; -extern "C" void * vtkKdTreePointLocator_get_ptr (vtkNew < vtkKdTreePointLocator > sself) ; -extern "C" long long vtk_kd_tree_point_locator_find_closest_point(vtkNew sself, const double x); -extern "C" long long vtk_kd_tree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); -extern "C" void vtk_kd_tree_point_locator_free_search_structure(vtkNew sself); -extern "C" void vtk_kd_tree_point_locator_build_locator(vtkNew sself); -extern "C" vtkNew < vtkLagrangeCurve > vtkLagrangeCurve_new () ; -extern "C" void vtkLagrangeCurve_destructor (vtkNew < vtkLagrangeCurve > sself) ; -extern "C" void * vtkLagrangeCurve_get_ptr (vtkNew < vtkLagrangeCurve > sself) ; -extern "C" int vtk_lagrange_curve_get_cell_type(vtkNew sself); -extern "C" void vtk_lagrange_curve_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkLagrangeHexahedron > vtkLagrangeHexahedron_new () ; -extern "C" void vtkLagrangeHexahedron_destructor (vtkNew < vtkLagrangeHexahedron > sself) ; -extern "C" void * vtkLagrangeHexahedron_get_ptr (vtkNew < vtkLagrangeHexahedron > sself) ; -extern "C" int vtk_lagrange_hexahedron_get_cell_type(vtkNew sself); -extern "C" void vtk_lagrange_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkLagrangeInterpolation > vtkLagrangeInterpolation_new () ; -extern "C" void vtkLagrangeInterpolation_destructor (vtkNew < vtkLagrangeInterpolation > sself) ; -extern "C" void * vtkLagrangeInterpolation_get_ptr (vtkNew < vtkLagrangeInterpolation > sself) ; -extern "C" void vtk_lagrange_interpolation_evaluate_shape_functions(vtkNew sself, const int order, const double pcoord, double shape); -extern "C" void vtk_lagrange_interpolation_evaluate_shape_and_gradient(vtkNew sself, const int order, const double pcoord, double shape, double grad); -extern "C" int vtk_lagrange_interpolation_tensor_1_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); -extern "C" int vtk_lagrange_interpolation_tensor_1_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); -extern "C" int vtk_lagrange_interpolation_tensor_2_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); -extern "C" int vtk_lagrange_interpolation_tensor_2_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); -extern "C" int vtk_lagrange_interpolation_tensor_3_shape_functions(vtkNew sself, const int order, const double pcoords, double shape); -extern "C" int vtk_lagrange_interpolation_tensor_3_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs); -extern "C" void vtk_lagrange_interpolation_wedge_shape_functions(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double shape); -extern "C" void vtk_lagrange_interpolation_wedge_shape_derivatives(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double derivs); -extern "C" void vtk_lagrange_interpolation_wedge_evaluate(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double fieldVals, int fieldDim, double fieldAtPCoords); -extern "C" vtkNew < vtkLagrangeQuadrilateral > vtkLagrangeQuadrilateral_new () ; -extern "C" void vtkLagrangeQuadrilateral_destructor (vtkNew < vtkLagrangeQuadrilateral > sself) ; -extern "C" void * vtkLagrangeQuadrilateral_get_ptr (vtkNew < vtkLagrangeQuadrilateral > sself) ; -extern "C" int vtk_lagrange_quadrilateral_get_cell_type(vtkNew sself); -extern "C" void vtk_lagrange_quadrilateral_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkLagrangeTetra > vtkLagrangeTetra_new () ; -extern "C" void vtkLagrangeTetra_destructor (vtkNew < vtkLagrangeTetra > sself) ; -extern "C" void * vtkLagrangeTetra_get_ptr (vtkNew < vtkLagrangeTetra > sself) ; -extern "C" int vtk_lagrange_tetra_get_cell_type(vtkNew sself); -extern "C" void vtk_lagrange_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkLagrangeTriangle > vtkLagrangeTriangle_new () ; -extern "C" void vtkLagrangeTriangle_destructor (vtkNew < vtkLagrangeTriangle > sself) ; -extern "C" void * vtkLagrangeTriangle_get_ptr (vtkNew < vtkLagrangeTriangle > sself) ; -extern "C" int vtk_lagrange_triangle_get_cell_type(vtkNew sself); -extern "C" void vtk_lagrange_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkLagrangeWedge > vtkLagrangeWedge_new () ; -extern "C" void vtkLagrangeWedge_destructor (vtkNew < vtkLagrangeWedge > sself) ; -extern "C" void * vtkLagrangeWedge_get_ptr (vtkNew < vtkLagrangeWedge > sself) ; -extern "C" int vtk_lagrange_wedge_get_cell_type(vtkNew sself); -extern "C" void vtk_lagrange_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" vtkNew < vtkLine > vtkLine_new () ; -extern "C" void vtkLine_destructor (vtkNew < vtkLine > sself) ; -extern "C" void * vtkLine_get_ptr (vtkNew < vtkLine > sself) ; -extern "C" int vtk_line_get_cell_type(vtkNew sself); -extern "C" int vtk_line_get_cell_dimension(vtkNew sself); -extern "C" int vtk_line_get_number_of_edges(vtkNew sself); -extern "C" int vtk_line_get_number_of_faces(vtkNew sself); -extern "C" int vtk_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_line_inflate(vtkNew sself, double dist); -extern "C" int vtk_line_get_parametric_center(vtkNew sself, double pcoords); -extern "C" int vtk_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_line_intersection(vtkNew sself, const double p1, const double p2, const double x1, const double x2, double u, double v, const double tolerance, int toleranceType); -extern "C" int vtk_line_intersection_3_d(vtkNew sself, double p1, double p2, double x1, double x2, double u, double v, const double tolerance); -extern "C" double vtk_line_distance_to_line(vtkNew sself, const double x, const double p1, const double p2, double t, double closestPoint); -extern "C" double vtk_line_distance_to_line(vtkNew sself, const double x, const double p1, const double p2); -extern "C" double vtk_line_distance_between_lines(vtkNew sself, double l0, double l1, double m0, double m1, double closestPt1, double closestPt2, double t1, double t2); -extern "C" double vtk_line_distance_between_line_segments(vtkNew sself, double l0, double l1, double m0, double m1, double closestPt1, double closestPt2, double t1, double t2); -extern "C" void vtk_line_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_line_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_line_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_line_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" vtkNew < vtkMeanValueCoordinatesInterpolator > vtkMeanValueCoordinatesInterpolator_new () ; -extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) ; -extern "C" void * vtkMeanValueCoordinatesInterpolator_get_ptr (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) ; -extern "C" vtkNew < vtkMergePoints > vtkMergePoints_new () ; -extern "C" void vtkMergePoints_destructor (vtkNew < vtkMergePoints > sself) ; -extern "C" void * vtkMergePoints_get_ptr (vtkNew < vtkMergePoints > sself) ; -extern "C" long long vtk_merge_points_is_inserted_point(vtkNew sself, const double x); -extern "C" int vtk_merge_points_insert_unique_point(vtkNew sself, const double x, long long ptId); -extern "C" vtkNew < vtkMolecule > vtkMolecule_new () ; -extern "C" void vtkMolecule_destructor (vtkNew < vtkMolecule > sself) ; -extern "C" void * vtkMolecule_get_ptr (vtkNew < vtkMolecule > sself) ; -extern "C" long long vtk_molecule_get_number_of_atoms(vtkNew sself); -extern "C" long long vtk_molecule_get_number_of_bonds(vtkNew sself); -extern "C" unsigned short vtk_molecule_get_atom_atomic_number(vtkNew sself, long long atomId); -extern "C" void vtk_molecule_set_atom_atomic_number(vtkNew sself, long long atomId, unsigned short atomicNum); -extern "C" void vtk_molecule_set_atom_position(vtkNew sself, long long atomId, double x, double y, double z); -extern "C" void vtk_molecule_set_atom_position(vtkNew sself, long long atomId, double pos); -extern "C" void vtk_molecule_get_atom_position(vtkNew sself, long long atomId, float pos); -extern "C" void vtk_molecule_get_atom_position(vtkNew sself, long long atomId, double pos); -extern "C" void vtk_molecule_set_bond_order(vtkNew sself, long long bondId, unsigned short order); -extern "C" unsigned short vtk_molecule_get_bond_order(vtkNew sself, long long bondId); -extern "C" double vtk_molecule_get_bond_length(vtkNew sself, long long bondId); -extern "C" bool vtk_molecule_has_lattice(vtkNew sself); -extern "C" void vtk_molecule_clear_lattice(vtkNew sself); -extern "C" void vtk_molecule_allocate_atom_ghost_array(vtkNew sself); -extern "C" void vtk_molecule_allocate_bond_ghost_array(vtkNew sself); -extern "C" long long vtk_molecule_get_bond_id(vtkNew sself, long long a, long long b); -extern "C" void vtk_molecule_set_atomic_number_array_name(vtkNew sself, const char _arg); -extern "C" char* vtk_molecule_get_atomic_number_array_name(vtkNew sself); -extern "C" void vtk_molecule_set_bond_orders_array_name(vtkNew sself, const char _arg); -extern "C" char* vtk_molecule_get_bond_orders_array_name(vtkNew sself); -extern "C" vtkNew < vtkMultiBlockDataSet > vtkMultiBlockDataSet_new () ; -extern "C" void vtkMultiBlockDataSet_destructor (vtkNew < vtkMultiBlockDataSet > sself) ; -extern "C" void * vtkMultiBlockDataSet_get_ptr (vtkNew < vtkMultiBlockDataSet > sself) ; -extern "C" void vtk_multi_block_data_set_set_number_of_blocks(vtkNew sself, unsigned int numBlocks); -extern "C" unsigned int vtk_multi_block_data_set_get_number_of_blocks(vtkNew sself); -extern "C" void vtk_multi_block_data_set_remove_block(vtkNew sself, unsigned int blockno); -extern "C" int vtk_multi_block_data_set_has_meta_data(vtkNew sself, unsigned int blockno); -extern "C" vtkNew < vtkMultiPieceDataSet > vtkMultiPieceDataSet_new () ; -extern "C" void vtkMultiPieceDataSet_destructor (vtkNew < vtkMultiPieceDataSet > sself) ; -extern "C" void * vtkMultiPieceDataSet_get_ptr (vtkNew < vtkMultiPieceDataSet > sself) ; -extern "C" void vtk_multi_piece_data_set_set_number_of_pieces(vtkNew sself, unsigned int numpieces); -extern "C" unsigned int vtk_multi_piece_data_set_get_number_of_pieces(vtkNew sself); -extern "C" vtkNew < vtkMutableDirectedGraph > vtkMutableDirectedGraph_new () ; -extern "C" void vtkMutableDirectedGraph_destructor (vtkNew < vtkMutableDirectedGraph > sself) ; -extern "C" void * vtkMutableDirectedGraph_get_ptr (vtkNew < vtkMutableDirectedGraph > sself) ; -extern "C" long long vtk_mutable_directed_graph_set_number_of_vertices(vtkNew sself, long long numVerts); -extern "C" long long vtk_mutable_directed_graph_add_vertex(vtkNew sself); -extern "C" void vtk_mutable_directed_graph_lazy_add_vertex(vtkNew sself); -extern "C" long long vtk_mutable_directed_graph_add_child(vtkNew sself, long long parent); -extern "C" void vtk_mutable_directed_graph_remove_vertex(vtkNew sself, long long v); -extern "C" void vtk_mutable_directed_graph_remove_edge(vtkNew sself, long long e); -extern "C" vtkNew < vtkMutableUndirectedGraph > vtkMutableUndirectedGraph_new () ; -extern "C" void vtkMutableUndirectedGraph_destructor (vtkNew < vtkMutableUndirectedGraph > sself) ; -extern "C" void * vtkMutableUndirectedGraph_get_ptr (vtkNew < vtkMutableUndirectedGraph > sself) ; -extern "C" long long vtk_mutable_undirected_graph_set_number_of_vertices(vtkNew sself, long long numVerts); -extern "C" long long vtk_mutable_undirected_graph_add_vertex(vtkNew sself); -extern "C" void vtk_mutable_undirected_graph_lazy_add_vertex(vtkNew sself); -extern "C" void vtk_mutable_undirected_graph_lazy_add_edge(vtkNew sself, long long u, long long v); -extern "C" void vtk_mutable_undirected_graph_remove_vertex(vtkNew sself, long long v); -extern "C" void vtk_mutable_undirected_graph_remove_edge(vtkNew sself, long long e); -extern "C" vtkNew < vtkNonMergingPointLocator > vtkNonMergingPointLocator_new () ; -extern "C" void vtkNonMergingPointLocator_destructor (vtkNew < vtkNonMergingPointLocator > sself) ; -extern "C" void * vtkNonMergingPointLocator_get_ptr (vtkNew < vtkNonMergingPointLocator > sself) ; -extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNew sself, const double p0); -extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNew sself, double p0, double p1, double p2); -extern "C" int vtk_non_merging_point_locator_insert_unique_point(vtkNew sself, const double x, long long ptId); -extern "C" vtkNew < vtkNonOverlappingAMR > vtkNonOverlappingAMR_new () ; -extern "C" void vtkNonOverlappingAMR_destructor (vtkNew < vtkNonOverlappingAMR > sself) ; -extern "C" void * vtkNonOverlappingAMR_get_ptr (vtkNew < vtkNonOverlappingAMR > sself) ; -extern "C" int vtk_non_overlapping_amr_get_data_object_type(vtkNew sself); -extern "C" vtkNew < vtkOctreePointLocator > vtkOctreePointLocator_new () ; -extern "C" void vtkOctreePointLocator_destructor (vtkNew < vtkOctreePointLocator > sself) ; -extern "C" void * vtkOctreePointLocator_get_ptr (vtkNew < vtkOctreePointLocator > sself) ; -extern "C" void vtk_octree_point_locator_set_maximum_points_per_region(vtkNew sself, int _arg); -extern "C" int vtk_octree_point_locator_get_maximum_points_per_region(vtkNew sself); -extern "C" void vtk_octree_point_locator_set_create_cubic_octants(vtkNew sself, int _arg); -extern "C" int vtk_octree_point_locator_get_create_cubic_octants(vtkNew sself); -extern "C" double vtk_octree_point_locator_get_fudge_factor(vtkNew sself); -extern "C" void vtk_octree_point_locator_set_fudge_factor(vtkNew sself, double _arg); -extern "C" double* vtk_octree_point_locator_get_bounds(vtkNew sself); -extern "C" void vtk_octree_point_locator_get_bounds(vtkNew sself, double bounds); -extern "C" int vtk_octree_point_locator_get_number_of_leaf_nodes(vtkNew sself); -extern "C" void vtk_octree_point_locator_get_region_bounds(vtkNew sself, int regionID, double bounds); -extern "C" void vtk_octree_point_locator_get_region_data_bounds(vtkNew sself, int leafNodeID, double bounds); -extern "C" int vtk_octree_point_locator_get_region_containing_point(vtkNew sself, double x, double y, double z); -extern "C" void vtk_octree_point_locator_build_locator(vtkNew sself); -extern "C" long long vtk_octree_point_locator_find_closest_point(vtkNew sself, const double x); -extern "C" long long vtk_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z, double dist2); -extern "C" long long vtk_octree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); -extern "C" long long vtk_octree_point_locator_find_closest_point_in_region(vtkNew sself, int regionId, double x, double dist2); -extern "C" long long vtk_octree_point_locator_find_closest_point_in_region(vtkNew sself, int regionId, double x, double y, double z, double dist2); -extern "C" void vtk_octree_point_locator_free_search_structure(vtkNew sself); -extern "C" vtkNew < vtkOctreePointLocatorNode > vtkOctreePointLocatorNode_new () ; -extern "C" void vtkOctreePointLocatorNode_destructor (vtkNew < vtkOctreePointLocatorNode > sself) ; -extern "C" void * vtkOctreePointLocatorNode_get_ptr (vtkNew < vtkOctreePointLocatorNode > sself) ; -extern "C" void vtk_octree_point_locator_node_set_number_of_points(vtkNew sself, int numberOfPoints); -extern "C" int vtk_octree_point_locator_node_get_number_of_points(vtkNew sself); -extern "C" void vtk_octree_point_locator_node_set_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); -extern "C" void vtk_octree_point_locator_node_set_bounds(vtkNew sself, const double b); -extern "C" void vtk_octree_point_locator_node_get_bounds(vtkNew sself, double b); -extern "C" void vtk_octree_point_locator_node_set_data_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); -extern "C" void vtk_octree_point_locator_node_get_data_bounds(vtkNew sself, double b); -extern "C" double* vtk_octree_point_locator_node_get_min_bounds(vtkNew sself); -extern "C" double* vtk_octree_point_locator_node_get_max_bounds(vtkNew sself); -extern "C" void vtk_octree_point_locator_node_set_min_bounds(vtkNew sself, double minBounds); -extern "C" void vtk_octree_point_locator_node_set_max_bounds(vtkNew sself, double maxBounds); -extern "C" double* vtk_octree_point_locator_node_get_min_data_bounds(vtkNew sself); -extern "C" double* vtk_octree_point_locator_node_get_max_data_bounds(vtkNew sself); -extern "C" void vtk_octree_point_locator_node_set_min_data_bounds(vtkNew sself, double minDataBounds); -extern "C" void vtk_octree_point_locator_node_set_max_data_bounds(vtkNew sself, double maxDataBounds); -extern "C" int vtk_octree_point_locator_node_get_id(vtkNew sself); -extern "C" int vtk_octree_point_locator_node_get_min_id(vtkNew sself); -extern "C" void vtk_octree_point_locator_node_create_child_nodes(vtkNew sself); -extern "C" void vtk_octree_point_locator_node_delete_child_nodes(vtkNew sself); -extern "C" int vtk_octree_point_locator_node_contains_point(vtkNew sself, double x, double y, double z, int useDataBounds); -extern "C" int vtk_octree_point_locator_node_get_sub_octant_index(vtkNew sself, double point, int CheckContainment); -extern "C" vtkNew < vtkOrderedTriangulator > vtkOrderedTriangulator_new () ; -extern "C" void vtkOrderedTriangulator_destructor (vtkNew < vtkOrderedTriangulator > sself) ; -extern "C" void * vtkOrderedTriangulator_get_ptr (vtkNew < vtkOrderedTriangulator > sself) ; -extern "C" void vtk_ordered_triangulator_init_triangulation(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts); -extern "C" void vtk_ordered_triangulator_init_triangulation(vtkNew sself, double bounds, int numPts); -extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, double x, double p, int type); -extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, long long sortid, double x, double p, int type); -extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, long long sortid, long long sortid2, double x, double p, int type); -extern "C" void vtk_ordered_triangulator_triangulate(vtkNew sself); -extern "C" void vtk_ordered_triangulator_template_triangulate(vtkNew sself, int cellType, int numPts, int numEdges); -extern "C" void vtk_ordered_triangulator_update_point_type(vtkNew sself, long long internalId, int type); -extern "C" double* vtk_ordered_triangulator_get_point_position(vtkNew sself, long long internalId); -extern "C" double* vtk_ordered_triangulator_get_point_location(vtkNew sself, long long internalId); -extern "C" long long vtk_ordered_triangulator_get_point_id(vtkNew sself, long long internalId); -extern "C" int vtk_ordered_triangulator_get_number_of_points(vtkNew sself); -extern "C" void vtk_ordered_triangulator_set_use_templates(vtkNew sself, int _arg); -extern "C" int vtk_ordered_triangulator_get_use_templates(vtkNew sself); -extern "C" void vtk_ordered_triangulator_use_templates_on(vtkNew sself); -extern "C" void vtk_ordered_triangulator_use_templates_off(vtkNew sself); -extern "C" void vtk_ordered_triangulator_set_pre_sorted(vtkNew sself, int _arg); -extern "C" int vtk_ordered_triangulator_get_pre_sorted(vtkNew sself); -extern "C" void vtk_ordered_triangulator_pre_sorted_on(vtkNew sself); -extern "C" void vtk_ordered_triangulator_pre_sorted_off(vtkNew sself); -extern "C" void vtk_ordered_triangulator_set_use_two_sort_ids(vtkNew sself, int _arg); -extern "C" int vtk_ordered_triangulator_get_use_two_sort_ids(vtkNew sself); -extern "C" void vtk_ordered_triangulator_use_two_sort_ids_on(vtkNew sself); -extern "C" void vtk_ordered_triangulator_use_two_sort_ids_off(vtkNew sself); -extern "C" void vtk_ordered_triangulator_init_tetra_traversal(vtkNew sself); -extern "C" vtkNew < vtkOutEdgeIterator > vtkOutEdgeIterator_new () ; -extern "C" void vtkOutEdgeIterator_destructor (vtkNew < vtkOutEdgeIterator > sself) ; -extern "C" void * vtkOutEdgeIterator_get_ptr (vtkNew < vtkOutEdgeIterator > sself) ; -extern "C" long long vtk_out_edge_iterator_get_vertex(vtkNew sself); -extern "C" bool vtk_out_edge_iterator_has_next(vtkNew sself); -extern "C" vtkNew < vtkOverlappingAMR > vtkOverlappingAMR_new () ; -extern "C" void vtkOverlappingAMR_destructor (vtkNew < vtkOverlappingAMR > sself) ; -extern "C" void * vtkOverlappingAMR_get_ptr (vtkNew < vtkOverlappingAMR > sself) ; -extern "C" void vtk_overlapping_amr_set_origin(vtkNew sself, const double origin); -extern "C" double* vtk_overlapping_amr_get_origin(vtkNew sself); -extern "C" void vtk_overlapping_amr_set_spacing(vtkNew sself, unsigned int level, const double spacing); -extern "C" void vtk_overlapping_amr_get_spacing(vtkNew sself, unsigned int level, double spacing); -extern "C" void vtk_overlapping_amr_get_bounds(vtkNew sself, unsigned int level, unsigned int id, double bb); -extern "C" void vtk_overlapping_amr_get_origin(vtkNew sself, unsigned int level, unsigned int id, double origin); -extern "C" void vtk_overlapping_amr_set_refinement_ratio(vtkNew sself, unsigned int level, int refRatio); -extern "C" int vtk_overlapping_amr_get_refinement_ratio(vtkNew sself, unsigned int level); -extern "C" void vtk_overlapping_amr_set_amr_block_source_index(vtkNew sself, unsigned int level, unsigned int id, int sourceId); -extern "C" int vtk_overlapping_amr_get_amr_block_source_index(vtkNew sself, unsigned int level, unsigned int id); -extern "C" bool vtk_overlapping_amr_has_children_information(vtkNew sself); -extern "C" void vtk_overlapping_amr_generate_parent_child_information(vtkNew sself); -extern "C" unsigned int* vtk_overlapping_amr_get_parents(vtkNew sself, unsigned int level, unsigned int index, unsigned int numParents); -extern "C" unsigned int* vtk_overlapping_amr_get_children(vtkNew sself, unsigned int level, unsigned int index, unsigned int numChildren); -extern "C" void vtk_overlapping_amr_print_parent_child_info(vtkNew sself, unsigned int level, unsigned int index); -extern "C" void vtk_overlapping_amr_get_bounds(vtkNew sself, double b); -extern "C" bool vtk_overlapping_amr_find_grid(vtkNew sself, double q, unsigned int level, unsigned int gridId); -extern "C" void vtk_overlapping_amr_audit(vtkNew sself); -extern "C" vtkNew < vtkPartitionedDataSet > vtkPartitionedDataSet_new () ; -extern "C" void vtkPartitionedDataSet_destructor (vtkNew < vtkPartitionedDataSet > sself) ; -extern "C" void * vtkPartitionedDataSet_get_ptr (vtkNew < vtkPartitionedDataSet > sself) ; -extern "C" void vtk_partitioned_data_set_set_number_of_partitions(vtkNew sself, unsigned int numPartitions); -extern "C" unsigned int vtk_partitioned_data_set_get_number_of_partitions(vtkNew sself); -extern "C" int vtk_partitioned_data_set_has_meta_data(vtkNew sself, unsigned int idx); -extern "C" void vtk_partitioned_data_set_remove_null_partitions(vtkNew sself); -extern "C" vtkNew < vtkPartitionedDataSetCollection > vtkPartitionedDataSetCollection_new () ; -extern "C" void vtkPartitionedDataSetCollection_destructor (vtkNew < vtkPartitionedDataSetCollection > sself) ; -extern "C" void * vtkPartitionedDataSetCollection_get_ptr (vtkNew < vtkPartitionedDataSetCollection > sself) ; -extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets(vtkNew sself, unsigned int numDataSets); -extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets(vtkNew sself); -extern "C" void vtk_partitioned_data_set_collection_remove_partitioned_data_set(vtkNew sself, unsigned int idx); -extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitions(vtkNew sself, unsigned int idx); -extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitions(vtkNew sself, unsigned int idx, unsigned int numPartitions); -extern "C" int vtk_partitioned_data_set_collection_has_meta_data(vtkNew sself, unsigned int idx); -extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkNew sself, unsigned int idx); -extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkNew sself, unsigned int idx, unsigned int partition); -extern "C" unsigned long vtk_partitioned_data_set_collection_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkPath > vtkPath_new () ; -extern "C" void vtkPath_destructor (vtkNew < vtkPath > sself) ; -extern "C" void * vtkPath_get_ptr (vtkNew < vtkPath > sself) ; -extern "C" int vtk_path_get_data_object_type(vtkNew sself); -extern "C" void vtk_path_insert_next_point(vtkNew sself, float pts, int code); -extern "C" void vtk_path_insert_next_point(vtkNew sself, double pts, int code); -extern "C" void vtk_path_insert_next_point(vtkNew sself, double x, double y, double z, int code); -extern "C" long long vtk_path_get_number_of_cells(vtkNew sself); -extern "C" int vtk_path_get_max_cell_size(vtkNew sself); -extern "C" void vtk_path_allocate(vtkNew sself, long long size, int extSize); -extern "C" void vtk_path_reset(vtkNew sself); -extern "C" vtkNew < vtkPentagonalPrism > vtkPentagonalPrism_new () ; -extern "C" void vtkPentagonalPrism_destructor (vtkNew < vtkPentagonalPrism > sself) ; -extern "C" void * vtkPentagonalPrism_get_ptr (vtkNew < vtkPentagonalPrism > sself) ; -extern "C" void vtk_pentagonal_prism_get_edge_points(vtkNew sself, long long edgeId, const long long pts); -extern "C" void vtk_pentagonal_prism_get_edge_points(vtkNew sself, int edgeId, int pts); -extern "C" long long vtk_pentagonal_prism_get_face_points(vtkNew sself, long long faceId, const long long pts); -extern "C" void vtk_pentagonal_prism_get_face_points(vtkNew sself, int faceId, int pts); -extern "C" void vtk_pentagonal_prism_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); -extern "C" long long vtk_pentagonal_prism_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); -extern "C" long long vtk_pentagonal_prism_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); -extern "C" long long vtk_pentagonal_prism_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); -extern "C" long long vtk_pentagonal_prism_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); -extern "C" bool vtk_pentagonal_prism_get_centroid(vtkNew sself, double centroid); -extern "C" int vtk_pentagonal_prism_get_cell_type(vtkNew sself); -extern "C" int vtk_pentagonal_prism_get_number_of_edges(vtkNew sself); -extern "C" int vtk_pentagonal_prism_get_number_of_faces(vtkNew sself); -extern "C" int vtk_pentagonal_prism_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_pentagonal_prism_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_pentagonal_prism_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_pentagonal_prism_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_pentagonal_prism_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_pentagonal_prism_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_pentagonal_prism_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_pentagonal_prism_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_pentagonal_prism_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_pentagonal_prism_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_pentagonal_prism_get_face_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_pentagonal_prism_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_pentagonal_prism_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_pentagonal_prism_get_point_to_incident_edges_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_pentagonal_prism_get_point_to_incident_faces_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_pentagonal_prism_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); -extern "C" void vtk_pentagonal_prism_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkPerlinNoise > vtkPerlinNoise_new () ; -extern "C" void vtkPerlinNoise_destructor (vtkNew < vtkPerlinNoise > sself) ; -extern "C" void * vtkPerlinNoise_get_ptr (vtkNew < vtkPerlinNoise > sself) ; -extern "C" double vtk_perlin_noise_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_perlin_noise_evaluate_gradient(vtkNew sself, double x, double n); -extern "C" void vtk_perlin_noise_set_frequency(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_perlin_noise_set_frequency(vtkNew sself, const double _arg); -extern "C" double* vtk_perlin_noise_get_frequency(vtkNew sself); -extern "C" void vtk_perlin_noise_get_frequency(vtkNew sself, double data); -extern "C" void vtk_perlin_noise_set_phase(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_perlin_noise_set_phase(vtkNew sself, const double _arg); -extern "C" double* vtk_perlin_noise_get_phase(vtkNew sself); -extern "C" void vtk_perlin_noise_get_phase(vtkNew sself, double data); -extern "C" void vtk_perlin_noise_set_amplitude(vtkNew sself, double _arg); -extern "C" double vtk_perlin_noise_get_amplitude(vtkNew sself); -extern "C" vtkNew < vtkPiecewiseFunction > vtkPiecewiseFunction_new () ; -extern "C" void vtkPiecewiseFunction_destructor (vtkNew < vtkPiecewiseFunction > sself) ; -extern "C" void * vtkPiecewiseFunction_get_ptr (vtkNew < vtkPiecewiseFunction > sself) ; -extern "C" int vtk_piecewise_function_get_data_object_type(vtkNew sself); -extern "C" int vtk_piecewise_function_get_size(vtkNew sself); -extern "C" int vtk_piecewise_function_add_point(vtkNew sself, double x, double y); -extern "C" int vtk_piecewise_function_add_point(vtkNew sself, double x, double y, double midpoint, double sharpness); -extern "C" bool vtk_piecewise_function_remove_point_by_index(vtkNew sself, size_t id); -extern "C" int vtk_piecewise_function_remove_point(vtkNew sself, double x); -extern "C" int vtk_piecewise_function_remove_point(vtkNew sself, double x, double y); -extern "C" void vtk_piecewise_function_remove_all_points(vtkNew sself); -extern "C" void vtk_piecewise_function_add_segment(vtkNew sself, double x1, double y1, double x2, double y2); -extern "C" double vtk_piecewise_function_get_value(vtkNew sself, double x); -extern "C" int vtk_piecewise_function_get_node_value(vtkNew sself, int index, double val); -extern "C" int vtk_piecewise_function_set_node_value(vtkNew sself, int index, double val); -extern "C" double* vtk_piecewise_function_get_data_pointer(vtkNew sself); -extern "C" void vtk_piecewise_function_fill_from_data_pointer(vtkNew sself, int p0, double p1); -extern "C" double* vtk_piecewise_function_get_range(vtkNew sself); -extern "C" void vtk_piecewise_function_get_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_piecewise_function_get_range(vtkNew sself, double _arg); -extern "C" int vtk_piecewise_function_adjust_range(vtkNew sself, double range); -extern "C" void vtk_piecewise_function_get_table(vtkNew sself, double x1, double x2, int size, float table, int stride, int logIncrements); -extern "C" void vtk_piecewise_function_get_table(vtkNew sself, double x1, double x2, int size, double table, int stride, int logIncrements); -extern "C" void vtk_piecewise_function_build_function_from_table(vtkNew sself, double x1, double x2, int size, double table, int stride); -extern "C" void vtk_piecewise_function_set_clamping(vtkNew sself, int _arg); -extern "C" int vtk_piecewise_function_get_clamping(vtkNew sself); -extern "C" void vtk_piecewise_function_clamping_on(vtkNew sself); -extern "C" void vtk_piecewise_function_clamping_off(vtkNew sself); -extern "C" void vtk_piecewise_function_set_use_log_scale(vtkNew sself, bool _arg); -extern "C" bool vtk_piecewise_function_get_use_log_scale(vtkNew sself); -extern "C" void vtk_piecewise_function_use_log_scale_on(vtkNew sself); -extern "C" void vtk_piecewise_function_use_log_scale_off(vtkNew sself); -extern "C" const char* vtk_piecewise_function_get_type(vtkNew sself); -extern "C" double vtk_piecewise_function_get_first_non_zero_value(vtkNew sself); -extern "C" void vtk_piecewise_function_initialize(vtkNew sself); -extern "C" void vtk_piecewise_function_set_allow_duplicate_scalars(vtkNew sself, int _arg); -extern "C" int vtk_piecewise_function_get_allow_duplicate_scalars(vtkNew sself); -extern "C" void vtk_piecewise_function_allow_duplicate_scalars_on(vtkNew sself); -extern "C" void vtk_piecewise_function_allow_duplicate_scalars_off(vtkNew sself); -extern "C" int vtk_piecewise_function_estimate_min_number_of_samples(vtkNew sself, const double x1, const double x2); -extern "C" vtkNew < vtkPixel > vtkPixel_new () ; -extern "C" void vtkPixel_destructor (vtkNew < vtkPixel > sself) ; -extern "C" void * vtkPixel_get_ptr (vtkNew < vtkPixel > sself) ; -extern "C" int vtk_pixel_get_cell_type(vtkNew sself); -extern "C" int vtk_pixel_get_cell_dimension(vtkNew sself); -extern "C" int vtk_pixel_get_number_of_edges(vtkNew sself); -extern "C" int vtk_pixel_get_number_of_faces(vtkNew sself); -extern "C" int vtk_pixel_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_pixel_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_pixel_inflate(vtkNew sself, double dist); -extern "C" double vtk_pixel_compute_bounding_sphere(vtkNew sself, double center); -extern "C" int vtk_pixel_get_parametric_center(vtkNew sself, double pcoords); -extern "C" int vtk_pixel_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_pixel_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" void vtk_pixel_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_pixel_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_pixel_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_pixel_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" int vtk_pixel_compute_normal(vtkNew sself, double n); -extern "C" vtkNew < vtkPlane > vtkPlane_new () ; -extern "C" void vtkPlane_destructor (vtkNew < vtkPlane > sself) ; -extern "C" void * vtkPlane_get_ptr (vtkNew < vtkPlane > sself) ; -extern "C" double vtk_plane_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_plane_evaluate_gradient(vtkNew sself, double x, double g); -extern "C" void vtk_plane_set_normal(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_plane_set_normal(vtkNew sself, const double _arg); -extern "C" double* vtk_plane_get_normal(vtkNew sself); -extern "C" void vtk_plane_get_normal(vtkNew sself, double data); -extern "C" void vtk_plane_set_origin(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_plane_set_origin(vtkNew sself, const double _arg); -extern "C" double* vtk_plane_get_origin(vtkNew sself); -extern "C" void vtk_plane_get_origin(vtkNew sself, double data); -extern "C" void vtk_plane_push(vtkNew sself, double distance); -extern "C" void vtk_plane_project_point(vtkNew sself, const double x, const double origin, const double normal, double xproj); -extern "C" void vtk_plane_project_point(vtkNew sself, const double x, double xproj); -extern "C" void vtk_plane_project_vector(vtkNew sself, const double v, const double origin, const double normal, double vproj); -extern "C" void vtk_plane_project_vector(vtkNew sself, const double v, double vproj); -extern "C" void vtk_plane_generalized_project_point(vtkNew sself, const double x, const double origin, const double normal, double xproj); -extern "C" void vtk_plane_generalized_project_point(vtkNew sself, const double x, double xproj); -extern "C" double vtk_plane_evaluate(vtkNew sself, double normal, double origin, double x); -extern "C" double vtk_plane_distance_to_plane(vtkNew sself, double x, double n, double p0); -extern "C" double vtk_plane_distance_to_plane(vtkNew sself, double x); -extern "C" int vtk_plane_intersect_with_line(vtkNew sself, const double p1, const double p2, double n, double p0, double t, double x); -extern "C" int vtk_plane_intersect_with_line(vtkNew sself, const double p1, const double p2, double t, double x); -extern "C" int vtk_plane_intersect_with_finite_plane(vtkNew sself, double n, double o, double pOrigin, double px, double py, double x0, double x1); -extern "C" int vtk_plane_intersect_with_finite_plane(vtkNew sself, double pOrigin, double px, double py, double x0, double x1); -extern "C" vtkNew < vtkPlaneCollection > vtkPlaneCollection_new () ; -extern "C" void vtkPlaneCollection_destructor (vtkNew < vtkPlaneCollection > sself) ; -extern "C" void * vtkPlaneCollection_get_ptr (vtkNew < vtkPlaneCollection > sself) ; -extern "C" int vtk_plane_collection_get_number_of_items(vtkNew sself); -extern "C" vtkNew < vtkPlanes > vtkPlanes_new () ; -extern "C" void vtkPlanes_destructor (vtkNew < vtkPlanes > sself) ; -extern "C" void * vtkPlanes_get_ptr (vtkNew < vtkPlanes > sself) ; -extern "C" double vtk_planes_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_planes_evaluate_gradient(vtkNew sself, double x, double n); -extern "C" void vtk_planes_set_frustum_planes(vtkNew sself, double planes); -extern "C" void vtk_planes_set_bounds(vtkNew sself, const double bounds); -extern "C" void vtk_planes_set_bounds(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax); -extern "C" int vtk_planes_get_number_of_planes(vtkNew sself); -extern "C" vtkNew < vtkPlanesIntersection > vtkPlanesIntersection_new () ; -extern "C" void vtkPlanesIntersection_destructor (vtkNew < vtkPlanesIntersection > sself) ; -extern "C" void * vtkPlanesIntersection_get_ptr (vtkNew < vtkPlanesIntersection > sself) ; -extern "C" void vtk_planes_intersection_set_region_vertices(vtkNew sself, double v, int nvertices); -extern "C" int vtk_planes_intersection_get_number_of_region_vertices(vtkNew sself); -extern "C" int vtk_planes_intersection_get_num_region_vertices(vtkNew sself); -extern "C" int vtk_planes_intersection_get_region_vertices(vtkNew sself, double v, int nvertices); -extern "C" vtkNew < vtkPointData > vtkPointData_new () ; -extern "C" void vtkPointData_destructor (vtkNew < vtkPointData > sself) ; -extern "C" void * vtkPointData_get_ptr (vtkNew < vtkPointData > sself) ; -extern "C" void vtk_point_data_null_point(vtkNew sself, long long ptId); -extern "C" vtkNew < vtkPointLocator > vtkPointLocator_new () ; -extern "C" void vtkPointLocator_destructor (vtkNew < vtkPointLocator > sself) ; -extern "C" void * vtkPointLocator_get_ptr (vtkNew < vtkPointLocator > sself) ; -extern "C" void vtk_point_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3); -extern "C" void vtk_point_locator_set_divisions(vtkNew sself, const int _arg); -extern "C" int* vtk_point_locator_get_divisions(vtkNew sself); -extern "C" void vtk_point_locator_get_divisions(vtkNew sself, int data); -extern "C" void vtk_point_locator_set_number_of_points_per_bucket(vtkNew sself, int _arg); -extern "C" int vtk_point_locator_get_number_of_points_per_bucket_min_value(vtkNew sself); -extern "C" int vtk_point_locator_get_number_of_points_per_bucket_max_value(vtkNew sself); -extern "C" int vtk_point_locator_get_number_of_points_per_bucket(vtkNew sself); -extern "C" long long vtk_point_locator_find_closest_point(vtkNew sself, const double x); -extern "C" long long vtk_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); -extern "C" long long vtk_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2); -extern "C" void vtk_point_locator_insert_point(vtkNew sself, long long ptId, const double x); -extern "C" long long vtk_point_locator_insert_next_point(vtkNew sself, const double x); -extern "C" long long vtk_point_locator_is_inserted_point(vtkNew sself, double x, double y, double z); -extern "C" long long vtk_point_locator_is_inserted_point(vtkNew sself, const double x); -extern "C" int vtk_point_locator_insert_unique_point(vtkNew sself, const double x, long long ptId); -extern "C" long long vtk_point_locator_find_closest_inserted_point(vtkNew sself, const double x); -extern "C" void vtk_point_locator_initialize(vtkNew sself); -extern "C" void vtk_point_locator_free_search_structure(vtkNew sself); -extern "C" void vtk_point_locator_build_locator(vtkNew sself); -extern "C" vtkNew < vtkPointSet > vtkPointSet_new () ; -extern "C" void vtkPointSet_destructor (vtkNew < vtkPointSet > sself) ; -extern "C" void * vtkPointSet_get_ptr (vtkNew < vtkPointSet > sself) ; -extern "C" void vtk_point_set_set_editable(vtkNew sself, bool _arg); -extern "C" bool vtk_point_set_get_editable(vtkNew sself); -extern "C" void vtk_point_set_editable_on(vtkNew sself); -extern "C" void vtk_point_set_editable_off(vtkNew sself); -extern "C" void vtk_point_set_initialize(vtkNew sself); -extern "C" long long vtk_point_set_get_number_of_points(vtkNew sself); -extern "C" void vtk_point_set_get_point(vtkNew sself, long long ptId, double x); -extern "C" long long vtk_point_set_find_point(vtkNew sself, double x); -extern "C" long long vtk_point_set_get_number_of_cells(vtkNew sself); -extern "C" int vtk_point_set_get_max_cell_size(vtkNew sself); -extern "C" int vtk_point_set_get_cell_type(vtkNew sself, long long p0); -extern "C" double* vtk_point_set_get_point(vtkNew sself, long long ptId); -extern "C" void vtk_point_set_build_point_locator(vtkNew sself); -extern "C" void vtk_point_set_build_locator(vtkNew sself); -extern "C" void vtk_point_set_build_cell_locator(vtkNew sself); -extern "C" unsigned long vtk_point_set_get_m_time(vtkNew sself); -extern "C" void vtk_point_set_compute_bounds(vtkNew sself); -extern "C" void vtk_point_set_squeeze(vtkNew sself); -extern "C" vtkNew < vtkPointSetCellIterator > vtkPointSetCellIterator_new () ; -extern "C" void vtkPointSetCellIterator_destructor (vtkNew < vtkPointSetCellIterator > sself) ; -extern "C" void * vtkPointSetCellIterator_get_ptr (vtkNew < vtkPointSetCellIterator > sself) ; -extern "C" bool vtk_point_set_cell_iterator_is_done_with_traversal(vtkNew sself); -extern "C" long long vtk_point_set_cell_iterator_get_cell_id(vtkNew sself); -extern "C" vtkNew < vtkPointsProjectedHull > vtkPointsProjectedHull_new () ; -extern "C" void vtkPointsProjectedHull_destructor (vtkNew < vtkPointsProjectedHull > sself) ; -extern "C" void * vtkPointsProjectedHull_get_ptr (vtkNew < vtkPointsProjectedHull > sself) ; -extern "C" int vtk_points_projected_hull_rectangle_intersection_x(vtkNew sself, float ymin, float ymax, float zmin, float zmax); -extern "C" int vtk_points_projected_hull_rectangle_intersection_x(vtkNew sself, double ymin, double ymax, double zmin, double zmax); -extern "C" int vtk_points_projected_hull_rectangle_intersection_y(vtkNew sself, float zmin, float zmax, float xmin, float xmax); -extern "C" int vtk_points_projected_hull_rectangle_intersection_y(vtkNew sself, double zmin, double zmax, double xmin, double xmax); -extern "C" int vtk_points_projected_hull_rectangle_intersection_z(vtkNew sself, float xmin, float xmax, float ymin, float ymax); -extern "C" int vtk_points_projected_hull_rectangle_intersection_z(vtkNew sself, double xmin, double xmax, double ymin, double ymax); -extern "C" int vtk_points_projected_hull_get_ccw_hull_x(vtkNew sself, float pts, int len); -extern "C" int vtk_points_projected_hull_get_ccw_hull_x(vtkNew sself, double pts, int len); -extern "C" int vtk_points_projected_hull_get_ccw_hull_y(vtkNew sself, float pts, int len); -extern "C" int vtk_points_projected_hull_get_ccw_hull_y(vtkNew sself, double pts, int len); -extern "C" int vtk_points_projected_hull_get_ccw_hull_z(vtkNew sself, float pts, int len); -extern "C" int vtk_points_projected_hull_get_ccw_hull_z(vtkNew sself, double pts, int len); -extern "C" int vtk_points_projected_hull_get_size_ccw_hull_x(vtkNew sself); -extern "C" int vtk_points_projected_hull_get_size_ccw_hull_y(vtkNew sself); -extern "C" int vtk_points_projected_hull_get_size_ccw_hull_z(vtkNew sself); -extern "C" void vtk_points_projected_hull_update(vtkNew sself); -extern "C" vtkNew < vtkPolyData > vtkPolyData_new () ; -extern "C" void vtkPolyData_destructor (vtkNew < vtkPolyData > sself) ; -extern "C" void * vtkPolyData_get_ptr (vtkNew < vtkPolyData > sself) ; -extern "C" int vtk_poly_data_get_data_object_type(vtkNew sself); -extern "C" long long vtk_poly_data_get_number_of_cells(vtkNew sself); -extern "C" int vtk_poly_data_get_cell_type(vtkNew sself, long long cellId); -extern "C" void vtk_poly_data_compute_cells_bounds(vtkNew sself); -extern "C" void vtk_poly_data_get_cells_bounds(vtkNew sself, double bounds); -extern "C" void vtk_poly_data_squeeze(vtkNew sself); -extern "C" int vtk_poly_data_get_max_cell_size(vtkNew sself); -extern "C" long long vtk_poly_data_get_cell_id_relative_to_cell_array(vtkNew sself, long long cellId); -extern "C" long long vtk_poly_data_get_number_of_verts(vtkNew sself); -extern "C" long long vtk_poly_data_get_number_of_lines(vtkNew sself); -extern "C" long long vtk_poly_data_get_number_of_polys(vtkNew sself); -extern "C" long long vtk_poly_data_get_number_of_strips(vtkNew sself); -extern "C" bool vtk_poly_data_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize); -extern "C" bool vtk_poly_data_allocate_estimate(vtkNew sself, long long numVerts, long long maxVertSize, long long numLines, long long maxLineSize, long long numPolys, long long maxPolySize, long long numStrips, long long maxStripSize); -extern "C" bool vtk_poly_data_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize); -extern "C" bool vtk_poly_data_allocate_exact(vtkNew sself, long long numVerts, long long vertConnSize, long long numLines, long long lineConnSize, long long numPolys, long long polyConnSize, long long numStrips, long long stripConnSize); -extern "C" void vtk_poly_data_allocate(vtkNew sself, long long numCells, int extSize); -extern "C" long long vtk_poly_data_insert_next_cell(vtkNew sself, int type, int npts, const long long pts); -extern "C" void vtk_poly_data_reset(vtkNew sself); -extern "C" void vtk_poly_data_build_cells(vtkNew sself); -extern "C" bool vtk_poly_data_need_to_build_cells(vtkNew sself); -extern "C" void vtk_poly_data_build_links(vtkNew sself, int initialSize); -extern "C" void vtk_poly_data_delete_cells(vtkNew sself); -extern "C" void vtk_poly_data_delete_links(vtkNew sself); -extern "C" void vtk_poly_data_get_point_cells(vtkNew sself, long long ptId, long long ncells, long long cells); -extern "C" void vtk_poly_data_get_point_cells(vtkNew sself, long long ptId, unsigned short ncells, long long cells); -extern "C" unsigned char vtk_poly_data_get_cell_points(vtkNew sself, long long cellId, long long npts, const long long pts); -extern "C" int vtk_poly_data_is_triangle(vtkNew sself, int v1, int v2, int v3); -extern "C" int vtk_poly_data_is_edge(vtkNew sself, long long p1, long long p2); -extern "C" int vtk_poly_data_is_point_used_by_cell(vtkNew sself, long long ptId, long long cellId); -extern "C" void vtk_poly_data_replace_cell(vtkNew sself, long long cellId, int npts, const long long pts); -extern "C" void vtk_poly_data_replace_cell_point(vtkNew sself, long long cellId, long long oldPtId, long long newPtId); -extern "C" void vtk_poly_data_reverse_cell(vtkNew sself, long long cellId); -extern "C" void vtk_poly_data_delete_point(vtkNew sself, long long ptId); -extern "C" void vtk_poly_data_delete_cell(vtkNew sself, long long cellId); -extern "C" void vtk_poly_data_remove_deleted_cells(vtkNew sself); -extern "C" long long vtk_poly_data_insert_next_linked_point(vtkNew sself, int numLinks); -extern "C" long long vtk_poly_data_insert_next_linked_point(vtkNew sself, double x, int numLinks); -extern "C" long long vtk_poly_data_insert_next_linked_cell(vtkNew sself, int type, int npts, const long long pts); -extern "C" void vtk_poly_data_replace_linked_cell(vtkNew sself, long long cellId, int npts, const long long pts); -extern "C" void vtk_poly_data_remove_cell_reference(vtkNew sself, long long cellId); -extern "C" void vtk_poly_data_add_cell_reference(vtkNew sself, long long cellId); -extern "C" void vtk_poly_data_remove_reference_to_cell(vtkNew sself, long long ptId, long long cellId); -extern "C" void vtk_poly_data_add_reference_to_cell(vtkNew sself, long long ptId, long long cellId); -extern "C" void vtk_poly_data_resize_cell_list(vtkNew sself, long long ptId, int size); -extern "C" void vtk_poly_data_initialize(vtkNew sself); -extern "C" int vtk_poly_data_get_piece(vtkNew sself); -extern "C" int vtk_poly_data_get_number_of_pieces(vtkNew sself); -extern "C" int vtk_poly_data_get_ghost_level(vtkNew sself); -extern "C" void vtk_poly_data_remove_ghost_cells(vtkNew sself); -extern "C" int vtk_poly_data_get_scalar_field_critical_index(vtkNew sself, long long pointId, int fieldId); -extern "C" int vtk_poly_data_get_scalar_field_critical_index(vtkNew sself, long long pointId, const char fieldName); -extern "C" unsigned long vtk_poly_data_get_mesh_m_time(vtkNew sself); -extern "C" unsigned long vtk_poly_data_get_m_time(vtkNew sself); -extern "C" unsigned char vtk_poly_data_get_cell(vtkNew sself, long long cellId, const long long pts); -extern "C" vtkNew < vtkPolyDataCollection > vtkPolyDataCollection_new () ; -extern "C" void vtkPolyDataCollection_destructor (vtkNew < vtkPolyDataCollection > sself) ; -extern "C" void * vtkPolyDataCollection_get_ptr (vtkNew < vtkPolyDataCollection > sself) ; -extern "C" vtkNew < vtkPolyLine > vtkPolyLine_new () ; -extern "C" void vtkPolyLine_destructor (vtkNew < vtkPolyLine > sself) ; -extern "C" void * vtkPolyLine_get_ptr (vtkNew < vtkPolyLine > sself) ; -extern "C" int vtk_poly_line_get_cell_type(vtkNew sself); -extern "C" int vtk_poly_line_get_cell_dimension(vtkNew sself); -extern "C" int vtk_poly_line_get_number_of_edges(vtkNew sself); -extern "C" int vtk_poly_line_get_number_of_faces(vtkNew sself); -extern "C" int vtk_poly_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_poly_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_poly_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_poly_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_poly_line_get_parametric_center(vtkNew sself, double pcoords); -extern "C" vtkNew < vtkPolyPlane > vtkPolyPlane_new () ; -extern "C" void vtkPolyPlane_destructor (vtkNew < vtkPolyPlane > sself) ; -extern "C" void * vtkPolyPlane_get_ptr (vtkNew < vtkPolyPlane > sself) ; -extern "C" double vtk_poly_plane_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_poly_plane_evaluate_gradient(vtkNew sself, double x, double g); -extern "C" unsigned long vtk_poly_plane_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkPolyVertex > vtkPolyVertex_new () ; -extern "C" void vtkPolyVertex_destructor (vtkNew < vtkPolyVertex > sself) ; -extern "C" void * vtkPolyVertex_get_ptr (vtkNew < vtkPolyVertex > sself) ; -extern "C" int vtk_poly_vertex_get_cell_type(vtkNew sself); -extern "C" int vtk_poly_vertex_get_cell_dimension(vtkNew sself); -extern "C" int vtk_poly_vertex_get_number_of_edges(vtkNew sself); -extern "C" int vtk_poly_vertex_get_number_of_faces(vtkNew sself); -extern "C" int vtk_poly_vertex_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_poly_vertex_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_poly_vertex_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_poly_vertex_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_poly_vertex_get_parametric_center(vtkNew sself, double pcoords); -extern "C" vtkNew < vtkPolygon > vtkPolygon_new () ; -extern "C" void vtkPolygon_destructor (vtkNew < vtkPolygon > sself) ; -extern "C" void * vtkPolygon_get_ptr (vtkNew < vtkPolygon > sself) ; -extern "C" int vtk_polygon_get_cell_type(vtkNew sself); -extern "C" int vtk_polygon_get_cell_dimension(vtkNew sself); -extern "C" int vtk_polygon_get_number_of_edges(vtkNew sself); -extern "C" int vtk_polygon_get_number_of_faces(vtkNew sself); -extern "C" int vtk_polygon_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_polygon_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_polygon_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_polygon_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" double vtk_polygon_compute_area(vtkNew sself); -extern "C" void vtk_polygon_interpolate_functions(vtkNew sself, const double x, double sf); -extern "C" void vtk_polygon_compute_normal(vtkNew sself, int numPts, double pts, double n); -extern "C" bool vtk_polygon_is_convex(vtkNew sself); -extern "C" int vtk_polygon_parameterize_polygon(vtkNew sself, double p0, double p10, double l10, double p20, double l20, double n); -extern "C" int vtk_polygon_point_in_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double n); -extern "C" double vtk_polygon_distance_to_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double closest); -extern "C" int vtk_polygon_intersect_polygon_with_polygon(vtkNew sself, int npts, double pts, double bounds, int npts2, double pts2, double bounds2, double tol, double x); -extern "C" bool vtk_polygon_get_use_mvc_interpolation(vtkNew sself); -extern "C" void vtk_polygon_set_use_mvc_interpolation(vtkNew sself, bool _arg); -extern "C" void vtk_polygon_set_tolerance(vtkNew sself, double _arg); -extern "C" double vtk_polygon_get_tolerance_min_value(vtkNew sself); -extern "C" double vtk_polygon_get_tolerance_max_value(vtkNew sself); -extern "C" double vtk_polygon_get_tolerance(vtkNew sself); -extern "C" int vtk_polygon_ear_cut_triangulation(vtkNew sself, int measure); -extern "C" int vtk_polygon_unbiased_ear_cut_triangulation(vtkNew sself, int seed, int measure); -extern "C" vtkNew < vtkPolyhedron > vtkPolyhedron_new () ; -extern "C" void vtkPolyhedron_destructor (vtkNew < vtkPolyhedron > sself) ; -extern "C" void * vtkPolyhedron_get_ptr (vtkNew < vtkPolyhedron > sself) ; -extern "C" void vtk_polyhedron_get_edge_points(vtkNew sself, long long edgeId, const long long pts); -extern "C" void vtk_polyhedron_get_edge_points(vtkNew sself, int edgeId, int pts); -extern "C" long long vtk_polyhedron_get_face_points(vtkNew sself, long long faceId, const long long pts); -extern "C" void vtk_polyhedron_get_face_points(vtkNew sself, int faceId, int pts); -extern "C" void vtk_polyhedron_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); -extern "C" long long vtk_polyhedron_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); -extern "C" long long vtk_polyhedron_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); -extern "C" long long vtk_polyhedron_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); -extern "C" long long vtk_polyhedron_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); -extern "C" bool vtk_polyhedron_get_centroid(vtkNew sself, double centroid); -extern "C" double* vtk_polyhedron_get_parametric_coords(vtkNew sself); -extern "C" int vtk_polyhedron_get_cell_type(vtkNew sself); -extern "C" int vtk_polyhedron_requires_initialization(vtkNew sself); -extern "C" int vtk_polyhedron_get_number_of_edges(vtkNew sself); -extern "C" int vtk_polyhedron_get_number_of_faces(vtkNew sself); -extern "C" int vtk_polyhedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_polyhedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_polyhedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_polyhedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_polyhedron_get_parametric_center(vtkNew sself, double pcoords); -extern "C" int vtk_polyhedron_is_primary_cell(vtkNew sself); -extern "C" void vtk_polyhedron_interpolate_functions(vtkNew sself, const double x, double sf); -extern "C" void vtk_polyhedron_interpolate_derivs(vtkNew sself, const double x, double derivs); -extern "C" int vtk_polyhedron_requires_explicit_face_representation(vtkNew sself); -extern "C" int vtk_polyhedron_is_inside(vtkNew sself, const double x, double tolerance); -extern "C" bool vtk_polyhedron_is_convex(vtkNew sself); -extern "C" vtkNew < vtkPyramid > vtkPyramid_new () ; -extern "C" void vtkPyramid_destructor (vtkNew < vtkPyramid > sself) ; -extern "C" void * vtkPyramid_get_ptr (vtkNew < vtkPyramid > sself) ; -extern "C" void vtk_pyramid_get_edge_points(vtkNew sself, long long edgeId, const long long pts); -extern "C" void vtk_pyramid_get_edge_points(vtkNew sself, int edgeId, int pts); -extern "C" long long vtk_pyramid_get_face_points(vtkNew sself, long long faceId, const long long pts); -extern "C" void vtk_pyramid_get_face_points(vtkNew sself, int faceId, int pts); -extern "C" void vtk_pyramid_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); -extern "C" long long vtk_pyramid_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); -extern "C" long long vtk_pyramid_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); -extern "C" long long vtk_pyramid_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); -extern "C" long long vtk_pyramid_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); -extern "C" bool vtk_pyramid_get_centroid(vtkNew sself, double centroid); -extern "C" int vtk_pyramid_get_cell_type(vtkNew sself); -extern "C" int vtk_pyramid_get_number_of_edges(vtkNew sself); -extern "C" int vtk_pyramid_get_number_of_faces(vtkNew sself); -extern "C" int vtk_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int* vtk_pyramid_get_triangle_cases(vtkNew sself, int caseId); -extern "C" int vtk_pyramid_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" int vtk_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" const long long* vtk_pyramid_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_pyramid_get_face_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_pyramid_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_pyramid_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_pyramid_get_point_to_incident_edges_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_pyramid_get_point_to_incident_faces_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_pyramid_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); -extern "C" vtkNew < vtkQuad > vtkQuad_new () ; -extern "C" void vtkQuad_destructor (vtkNew < vtkQuad > sself) ; -extern "C" void * vtkQuad_get_ptr (vtkNew < vtkQuad > sself) ; -extern "C" int vtk_quad_get_cell_type(vtkNew sself); -extern "C" int vtk_quad_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quad_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quad_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_quad_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_quad_interpolation_functions(vtkNew sself, const double pcoords, double sf); -extern "C" void vtk_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_quad_interpolate_functions(vtkNew sself, const double pcoords, double sf); -extern "C" void vtk_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_quad_get_edge_array(vtkNew sself, long long edgeId); -extern "C" vtkNew < vtkQuadraticEdge > vtkQuadraticEdge_new () ; -extern "C" void vtkQuadraticEdge_destructor (vtkNew < vtkQuadraticEdge > sself) ; -extern "C" void * vtkQuadraticEdge_get_ptr (vtkNew < vtkQuadraticEdge > sself) ; -extern "C" int vtk_quadratic_edge_get_cell_type(vtkNew sself); -extern "C" int vtk_quadratic_edge_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quadratic_edge_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quadratic_edge_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quadratic_edge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quadratic_edge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_quadratic_edge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_quadratic_edge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_quadratic_edge_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_quadratic_edge_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_edge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_quadratic_edge_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_edge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" vtkNew < vtkQuadraticHexahedron > vtkQuadraticHexahedron_new () ; -extern "C" void vtkQuadraticHexahedron_destructor (vtkNew < vtkQuadraticHexahedron > sself) ; -extern "C" void * vtkQuadraticHexahedron_get_ptr (vtkNew < vtkQuadraticHexahedron > sself) ; -extern "C" int vtk_quadratic_hexahedron_get_cell_type(vtkNew sself); -extern "C" int vtk_quadratic_hexahedron_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quadratic_hexahedron_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quadratic_hexahedron_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId); -extern "C" void vtk_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkQuadraticLinearQuad > vtkQuadraticLinearQuad_new () ; -extern "C" void vtkQuadraticLinearQuad_destructor (vtkNew < vtkQuadraticLinearQuad > sself) ; -extern "C" void * vtkQuadraticLinearQuad_get_ptr (vtkNew < vtkQuadraticLinearQuad > sself) ; -extern "C" int vtk_quadratic_linear_quad_get_cell_type(vtkNew sself); -extern "C" int vtk_quadratic_linear_quad_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quadratic_linear_quad_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quadratic_linear_quad_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quadratic_linear_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quadratic_linear_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_quadratic_linear_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_quadratic_linear_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_quadratic_linear_quad_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_quadratic_linear_quad_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_linear_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_quadratic_linear_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_linear_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" int* vtk_quadratic_linear_quad_get_edge_array(vtkNew sself, long long edgeId); -extern "C" vtkNew < vtkQuadraticLinearWedge > vtkQuadraticLinearWedge_new () ; -extern "C" void vtkQuadraticLinearWedge_destructor (vtkNew < vtkQuadraticLinearWedge > sself) ; -extern "C" void * vtkQuadraticLinearWedge_get_ptr (vtkNew < vtkQuadraticLinearWedge > sself) ; -extern "C" int vtk_quadratic_linear_wedge_get_cell_type(vtkNew sself); -extern "C" int vtk_quadratic_linear_wedge_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quadratic_linear_wedge_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quadratic_linear_wedge_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quadratic_linear_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quadratic_linear_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_quadratic_linear_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_quadratic_linear_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_quadratic_linear_wedge_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_quadratic_linear_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_linear_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_quadratic_linear_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_linear_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_quadratic_linear_wedge_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_quadratic_linear_wedge_get_face_array(vtkNew sself, long long faceId); -extern "C" void vtk_quadratic_linear_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkQuadraticPolygon > vtkQuadraticPolygon_new () ; -extern "C" void vtkQuadraticPolygon_destructor (vtkNew < vtkQuadraticPolygon > sself) ; -extern "C" void * vtkQuadraticPolygon_get_ptr (vtkNew < vtkQuadraticPolygon > sself) ; -extern "C" int vtk_quadratic_polygon_get_cell_type(vtkNew sself); -extern "C" int vtk_quadratic_polygon_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quadratic_polygon_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quadratic_polygon_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quadratic_polygon_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quadratic_polygon_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_quadratic_polygon_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_quadratic_polygon_interpolate_functions(vtkNew sself, const double x, double weights); -extern "C" int vtk_quadratic_polygon_parameterize_polygon(vtkNew sself, double p0, double p10, double l10, double p20, double l20, double n); -extern "C" int vtk_quadratic_polygon_point_in_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double n); -extern "C" double vtk_quadratic_polygon_distance_to_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double closest); -extern "C" int vtk_quadratic_polygon_intersect_polygon_with_polygon(vtkNew sself, int npts, double pts, double bounds, int npts2, double pts2, double bounds2, double tol, double x); -extern "C" void vtk_quadratic_polygon_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" bool vtk_quadratic_polygon_get_use_mvc_interpolation(vtkNew sself); -extern "C" void vtk_quadratic_polygon_set_use_mvc_interpolation(vtkNew sself, bool _arg); -extern "C" vtkNew < vtkQuadraticPyramid > vtkQuadraticPyramid_new () ; -extern "C" void vtkQuadraticPyramid_destructor (vtkNew < vtkQuadraticPyramid > sself) ; -extern "C" void * vtkQuadraticPyramid_get_ptr (vtkNew < vtkQuadraticPyramid > sself) ; -extern "C" int vtk_quadratic_pyramid_get_cell_type(vtkNew sself); -extern "C" int vtk_quadratic_pyramid_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quadratic_pyramid_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quadratic_pyramid_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quadratic_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quadratic_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_quadratic_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_quadratic_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_quadratic_pyramid_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_quadratic_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_quadratic_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_quadratic_pyramid_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_quadratic_pyramid_get_face_array(vtkNew sself, long long faceId); -extern "C" void vtk_quadratic_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkQuadraticQuad > vtkQuadraticQuad_new () ; -extern "C" void vtkQuadraticQuad_destructor (vtkNew < vtkQuadraticQuad > sself) ; -extern "C" void * vtkQuadraticQuad_get_ptr (vtkNew < vtkQuadraticQuad > sself) ; -extern "C" int vtk_quadratic_quad_get_cell_type(vtkNew sself); -extern "C" int vtk_quadratic_quad_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quadratic_quad_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quadratic_quad_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quadratic_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quadratic_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_quadratic_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_quadratic_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_quadratic_quad_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_quadratic_quad_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_quadratic_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" vtkNew < vtkQuadraticTetra > vtkQuadraticTetra_new () ; -extern "C" void vtkQuadraticTetra_destructor (vtkNew < vtkQuadraticTetra > sself) ; -extern "C" void * vtkQuadraticTetra_get_ptr (vtkNew < vtkQuadraticTetra > sself) ; -extern "C" int vtk_quadratic_tetra_get_cell_type(vtkNew sself); -extern "C" int vtk_quadratic_tetra_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quadratic_tetra_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quadratic_tetra_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quadratic_tetra_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quadratic_tetra_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_quadratic_tetra_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_quadratic_tetra_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_quadratic_tetra_get_parametric_center(vtkNew sself, double pcoords); -extern "C" double vtk_quadratic_tetra_get_parametric_distance(vtkNew sself, const double pcoords); -extern "C" void vtk_quadratic_tetra_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_tetra_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_quadratic_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_tetra_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_quadratic_tetra_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_quadratic_tetra_get_face_array(vtkNew sself, long long faceId); -extern "C" void vtk_quadratic_tetra_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkQuadraticTriangle > vtkQuadraticTriangle_new () ; -extern "C" void vtkQuadraticTriangle_destructor (vtkNew < vtkQuadraticTriangle > sself) ; -extern "C" void * vtkQuadraticTriangle_get_ptr (vtkNew < vtkQuadraticTriangle > sself) ; -extern "C" int vtk_quadratic_triangle_get_cell_type(vtkNew sself); -extern "C" int vtk_quadratic_triangle_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quadratic_triangle_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quadratic_triangle_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quadratic_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quadratic_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_quadratic_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_quadratic_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_quadratic_triangle_get_parametric_center(vtkNew sself, double pcoords); -extern "C" double vtk_quadratic_triangle_get_parametric_distance(vtkNew sself, const double pcoords); -extern "C" void vtk_quadratic_triangle_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_quadratic_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" vtkNew < vtkQuadraticWedge > vtkQuadraticWedge_new () ; -extern "C" void vtkQuadraticWedge_destructor (vtkNew < vtkQuadraticWedge > sself) ; -extern "C" void * vtkQuadraticWedge_get_ptr (vtkNew < vtkQuadraticWedge > sself) ; -extern "C" int vtk_quadratic_wedge_get_cell_type(vtkNew sself); -extern "C" int vtk_quadratic_wedge_get_cell_dimension(vtkNew sself); -extern "C" int vtk_quadratic_wedge_get_number_of_edges(vtkNew sself); -extern "C" int vtk_quadratic_wedge_get_number_of_faces(vtkNew sself); -extern "C" int vtk_quadratic_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_quadratic_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_quadratic_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_quadratic_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_quadratic_wedge_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_quadratic_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_quadratic_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_quadratic_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_quadratic_wedge_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_quadratic_wedge_get_face_array(vtkNew sself, long long faceId); -extern "C" void vtk_quadratic_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkQuadratureSchemeDefinition > vtkQuadratureSchemeDefinition_new () ; -extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkNew < vtkQuadratureSchemeDefinition > sself) ; -extern "C" void * vtkQuadratureSchemeDefinition_get_ptr (vtkNew < vtkQuadratureSchemeDefinition > sself) ; -extern "C" void vtk_quadrature_scheme_definition_clear(vtkNew sself); -extern "C" void vtk_quadrature_scheme_definition_initialize(vtkNew sself, int cellType, int numberOfNodes, int numberOfQuadraturePoints, double shapeFunctionWeights); -extern "C" void vtk_quadrature_scheme_definition_initialize(vtkNew sself, int cellType, int numberOfNodes, int numberOfQuadraturePoints, double shapeFunctionWeights, double quadratureWeights); -extern "C" int vtk_quadrature_scheme_definition_get_cell_type(vtkNew sself); -extern "C" int vtk_quadrature_scheme_definition_get_quadrature_key(vtkNew sself); -extern "C" int vtk_quadrature_scheme_definition_get_number_of_nodes(vtkNew sself); -extern "C" int vtk_quadrature_scheme_definition_get_number_of_quadrature_points(vtkNew sself); -extern "C" const double* vtk_quadrature_scheme_definition_get_shape_function_weights(vtkNew sself); -extern "C" const double* vtk_quadrature_scheme_definition_get_shape_function_weights(vtkNew sself, int quadraturePointId); -extern "C" const double* vtk_quadrature_scheme_definition_get_quadrature_weights(vtkNew sself); -extern "C" vtkNew < vtkQuadric > vtkQuadric_new () ; -extern "C" void vtkQuadric_destructor (vtkNew < vtkQuadric > sself) ; -extern "C" void * vtkQuadric_get_ptr (vtkNew < vtkQuadric > sself) ; -extern "C" double vtk_quadric_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_quadric_evaluate_gradient(vtkNew sself, double x, double g); -extern "C" void vtk_quadric_set_coefficients(vtkNew sself, double a); -extern "C" void vtk_quadric_set_coefficients(vtkNew sself, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9); -extern "C" double* vtk_quadric_get_coefficients(vtkNew sself); -extern "C" void vtk_quadric_get_coefficients(vtkNew sself, double data); -extern "C" vtkNew < vtkRectilinearGrid > vtkRectilinearGrid_new () ; -extern "C" void vtkRectilinearGrid_destructor (vtkNew < vtkRectilinearGrid > sself) ; -extern "C" void * vtkRectilinearGrid_get_ptr (vtkNew < vtkRectilinearGrid > sself) ; -extern "C" int vtk_rectilinear_grid_get_data_object_type(vtkNew sself); -extern "C" void vtk_rectilinear_grid_initialize(vtkNew sself); -extern "C" long long vtk_rectilinear_grid_get_number_of_cells(vtkNew sself); -extern "C" long long vtk_rectilinear_grid_get_number_of_points(vtkNew sself); -extern "C" double* vtk_rectilinear_grid_get_point(vtkNew sself, long long ptId); -extern "C" long long vtk_rectilinear_grid_find_point(vtkNew sself, double x); -extern "C" int vtk_rectilinear_grid_get_cell_type(vtkNew sself, long long cellId); -extern "C" int vtk_rectilinear_grid_get_max_cell_size(vtkNew sself); -extern "C" unsigned char vtk_rectilinear_grid_is_point_visible(vtkNew sself, long long ptId); -extern "C" unsigned char vtk_rectilinear_grid_is_cell_visible(vtkNew sself, long long cellId); -extern "C" bool vtk_rectilinear_grid_has_any_blank_points(vtkNew sself); -extern "C" bool vtk_rectilinear_grid_has_any_blank_cells(vtkNew sself); -extern "C" void vtk_rectilinear_grid_get_cell_dims(vtkNew sself, int cellDims); -extern "C" void vtk_rectilinear_grid_set_dimensions(vtkNew sself, int i, int j, int k); -extern "C" void vtk_rectilinear_grid_set_dimensions(vtkNew sself, const int dim); -extern "C" int* vtk_rectilinear_grid_get_dimensions(vtkNew sself); -extern "C" void vtk_rectilinear_grid_get_dimensions(vtkNew sself, int data); -extern "C" int vtk_rectilinear_grid_get_data_dimension(vtkNew sself); -extern "C" int vtk_rectilinear_grid_compute_structured_coordinates(vtkNew sself, double x, int ijk, double pcoords); -extern "C" long long vtk_rectilinear_grid_compute_point_id(vtkNew sself, int ijk); -extern "C" long long vtk_rectilinear_grid_compute_cell_id(vtkNew sself, int ijk); -extern "C" void vtk_rectilinear_grid_get_point(vtkNew sself, const int i, const int j, const int k, double p); -extern "C" void vtk_rectilinear_grid_set_extent(vtkNew sself, int extent); -extern "C" void vtk_rectilinear_grid_set_extent(vtkNew sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax); -extern "C" int* vtk_rectilinear_grid_get_extent(vtkNew sself); -extern "C" void vtk_rectilinear_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_rectilinear_grid_get_extent(vtkNew sself, int _arg); -extern "C" int vtk_rectilinear_grid_get_extent_type(vtkNew sself); -extern "C" void vtk_rectilinear_grid_crop(vtkNew sself, const int updateExtent); -extern "C" int vtk_rectilinear_grid_get_scalar_type(vtkNew sself); -extern "C" const char* vtk_rectilinear_grid_get_scalar_type_as_string(vtkNew sself); -extern "C" int vtk_rectilinear_grid_get_number_of_scalar_components(vtkNew sself); -extern "C" vtkNew < vtkReebGraph > vtkReebGraph_new () ; -extern "C" void vtkReebGraph_destructor (vtkNew < vtkReebGraph > sself) ; -extern "C" void * vtkReebGraph_get_ptr (vtkNew < vtkReebGraph > sself) ; -extern "C" int vtk_reeb_graph_stream_triangle(vtkNew sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2); -extern "C" int vtk_reeb_graph_stream_tetrahedron(vtkNew sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2, long long vertex3Id, double scalar3); -extern "C" void vtk_reeb_graph_close_stream(vtkNew sself); -extern "C" vtkNew < vtkReebGraphSimplificationMetric > vtkReebGraphSimplificationMetric_new () ; -extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkNew < vtkReebGraphSimplificationMetric > sself) ; -extern "C" void * vtkReebGraphSimplificationMetric_get_ptr (vtkNew < vtkReebGraphSimplificationMetric > sself) ; -extern "C" void vtk_reeb_graph_simplification_metric_set_lower_bound(vtkNew sself, double _arg); -extern "C" double vtk_reeb_graph_simplification_metric_get_lower_bound(vtkNew sself); -extern "C" void vtk_reeb_graph_simplification_metric_set_upper_bound(vtkNew sself, double _arg); -extern "C" double vtk_reeb_graph_simplification_metric_get_upper_bound(vtkNew sself); -extern "C" vtkNew < vtkSelection > vtkSelection_new () ; -extern "C" void vtkSelection_destructor (vtkNew < vtkSelection > sself) ; -extern "C" void * vtkSelection_get_ptr (vtkNew < vtkSelection > sself) ; -extern "C" int vtk_selection_get_data_object_type(vtkNew sself); -extern "C" unsigned int vtk_selection_get_number_of_nodes(vtkNew sself); -extern "C" const char* vtk_selection_get_node_name_at_index(vtkNew sself, unsigned int idx); -extern "C" void vtk_selection_remove_node(vtkNew sself, unsigned int idx); -extern "C" void vtk_selection_remove_node(vtkNew sself, const char* name); -extern "C" void vtk_selection_remove_all_nodes(vtkNew sself); -extern "C" void vtk_selection_set_expression(vtkNew sself, const char* _arg); -extern "C" const char* vtk_selection_get_expression(vtkNew sself); -extern "C" unsigned long vtk_selection_get_m_time(vtkNew sself); -extern "C" void vtk_selection_dump(vtkNew sself); -extern "C" vtkNew < vtkSelectionNode > vtkSelectionNode_new () ; -extern "C" void vtkSelectionNode_destructor (vtkNew < vtkSelectionNode > sself) ; -extern "C" void * vtkSelectionNode_get_ptr (vtkNew < vtkSelectionNode > sself) ; -extern "C" void vtk_selection_node_initialize(vtkNew sself); -extern "C" unsigned long vtk_selection_node_get_m_time(vtkNew sself); -extern "C" void vtk_selection_node_set_content_type(vtkNew sself, int type); -extern "C" int vtk_selection_node_get_content_type(vtkNew sself); -extern "C" const char* vtk_selection_node_get_content_type_as_string(vtkNew sself, int type); -extern "C" void vtk_selection_node_set_field_type(vtkNew sself, int type); -extern "C" int vtk_selection_node_get_field_type(vtkNew sself); -extern "C" const char* vtk_selection_node_get_field_type_as_string(vtkNew sself, int type); -extern "C" int vtk_selection_node_get_field_type_from_string(vtkNew sself, const char type); -extern "C" int vtk_selection_node_convert_selection_field_to_attribute_type(vtkNew sself, int val); -extern "C" int vtk_selection_node_convert_attribute_type_to_selection_field(vtkNew sself, int val); -extern "C" void vtk_selection_node_set_query_string(vtkNew sself, const char _arg); -extern "C" char* vtk_selection_node_get_query_string(vtkNew sself); -extern "C" vtkNew < vtkSimpleCellTessellator > vtkSimpleCellTessellator_new () ; -extern "C" void vtkSimpleCellTessellator_destructor (vtkNew < vtkSimpleCellTessellator > sself) ; -extern "C" void * vtkSimpleCellTessellator_get_ptr (vtkNew < vtkSimpleCellTessellator > sself) ; -extern "C" void vtk_simple_cell_tessellator_reset(vtkNew sself); -extern "C" int vtk_simple_cell_tessellator_get_fixed_subdivisions(vtkNew sself); -extern "C" int vtk_simple_cell_tessellator_get_max_subdivision_level(vtkNew sself); -extern "C" int vtk_simple_cell_tessellator_get_max_adaptive_subdivisions(vtkNew sself); -extern "C" void vtk_simple_cell_tessellator_set_fixed_subdivisions(vtkNew sself, int level); -extern "C" void vtk_simple_cell_tessellator_set_max_subdivision_level(vtkNew sself, int level); -extern "C" void vtk_simple_cell_tessellator_set_subdivision_levels(vtkNew sself, int fixed, int maxLevel); -extern "C" vtkNew < vtkSmoothErrorMetric > vtkSmoothErrorMetric_new () ; -extern "C" void vtkSmoothErrorMetric_destructor (vtkNew < vtkSmoothErrorMetric > sself) ; -extern "C" void * vtkSmoothErrorMetric_get_ptr (vtkNew < vtkSmoothErrorMetric > sself) ; -extern "C" double vtk_smooth_error_metric_get_angle_tolerance(vtkNew sself); -extern "C" void vtk_smooth_error_metric_set_angle_tolerance(vtkNew sself, double value); -extern "C" int vtk_smooth_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); -extern "C" double vtk_smooth_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha); -extern "C" vtkNew < vtkSortFieldData > vtkSortFieldData_new () ; -extern "C" void vtkSortFieldData_destructor (vtkNew < vtkSortFieldData > sself) ; -extern "C" void * vtkSortFieldData_get_ptr (vtkNew < vtkSortFieldData > sself) ; -extern "C" vtkNew < vtkSphere > vtkSphere_new () ; -extern "C" void vtkSphere_destructor (vtkNew < vtkSphere > sself) ; -extern "C" void * vtkSphere_get_ptr (vtkNew < vtkSphere > sself) ; -extern "C" double vtk_sphere_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_sphere_evaluate_gradient(vtkNew sself, double x, double n); -extern "C" void vtk_sphere_set_radius(vtkNew sself, double _arg); -extern "C" double vtk_sphere_get_radius(vtkNew sself); -extern "C" void vtk_sphere_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_sphere_set_center(vtkNew sself, const double _arg); -extern "C" double* vtk_sphere_get_center(vtkNew sself); -extern "C" void vtk_sphere_get_center(vtkNew sself, double data); -extern "C" double vtk_sphere_evaluate(vtkNew sself, double center, double R, double x); -extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, float pts, long long numPts, float sphere, long long hints); -extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, double pts, long long numPts, double sphere, long long hints); -extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, float spheres, long long numSpheres, float sphere, long long hints); -extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, double spheres, long long numSpheres, double sphere, long long hints); -extern "C" vtkNew < vtkSpheres > vtkSpheres_new () ; -extern "C" void vtkSpheres_destructor (vtkNew < vtkSpheres > sself) ; -extern "C" void * vtkSpheres_get_ptr (vtkNew < vtkSpheres > sself) ; -extern "C" double vtk_spheres_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_spheres_evaluate_gradient(vtkNew sself, double x, double n); -extern "C" int vtk_spheres_get_number_of_spheres(vtkNew sself); -extern "C" vtkNew < vtkStaticCellLinks > vtkStaticCellLinks_new () ; -extern "C" void vtkStaticCellLinks_destructor (vtkNew < vtkStaticCellLinks > sself) ; -extern "C" void * vtkStaticCellLinks_get_ptr (vtkNew < vtkStaticCellLinks > sself) ; -extern "C" long long vtk_static_cell_links_get_number_of_cells(vtkNew sself, long long ptId); -extern "C" long long vtk_static_cell_links_get_ncells(vtkNew sself, long long ptId); -extern "C" long long* vtk_static_cell_links_get_cells(vtkNew sself, long long ptId); -extern "C" void vtk_static_cell_links_select_cells(vtkNew sself, long long minMaxDegree, unsigned char cellSelection); -extern "C" void vtk_static_cell_links_initialize(vtkNew sself); -extern "C" void vtk_static_cell_links_squeeze(vtkNew sself); -extern "C" void vtk_static_cell_links_reset(vtkNew sself); -extern "C" unsigned long vtk_static_cell_links_get_actual_memory_size(vtkNew sself); -extern "C" vtkNew < vtkStaticCellLocator > vtkStaticCellLocator_new () ; -extern "C" void vtkStaticCellLocator_destructor (vtkNew < vtkStaticCellLocator > sself) ; -extern "C" void * vtkStaticCellLocator_get_ptr (vtkNew < vtkStaticCellLocator > sself) ; -extern "C" void vtk_static_cell_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3); -extern "C" void vtk_static_cell_locator_set_divisions(vtkNew sself, const int _arg); -extern "C" int* vtk_static_cell_locator_get_divisions(vtkNew sself); -extern "C" void vtk_static_cell_locator_get_divisions(vtkNew sself, int data); -extern "C" long long vtk_static_cell_locator_find_cell(vtkNew sself, double x); -extern "C" int vtk_static_cell_locator_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_static_cell_locator_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId, long long cellId); -extern "C" void vtk_static_cell_locator_free_search_structure(vtkNew sself); -extern "C" void vtk_static_cell_locator_build_locator(vtkNew sself); -extern "C" void vtk_static_cell_locator_set_max_number_of_buckets(vtkNew sself, long long _arg); -extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_min_value(vtkNew sself); -extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_max_value(vtkNew sself); -extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets(vtkNew sself); -extern "C" bool vtk_static_cell_locator_get_large_ids(vtkNew sself); -extern "C" void vtk_static_cell_locator_set_use_diagonal_length_tolerance(vtkNew sself, bool _arg); -extern "C" bool vtk_static_cell_locator_get_use_diagonal_length_tolerance(vtkNew sself); -extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_on(vtkNew sself); -extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_off(vtkNew sself); -extern "C" vtkNew < vtkStaticPointLocator > vtkStaticPointLocator_new () ; -extern "C" void vtkStaticPointLocator_destructor (vtkNew < vtkStaticPointLocator > sself) ; -extern "C" void * vtkStaticPointLocator_get_ptr (vtkNew < vtkStaticPointLocator > sself) ; -extern "C" void vtk_static_point_locator_set_number_of_points_per_bucket(vtkNew sself, int _arg); -extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_min_value(vtkNew sself); -extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_max_value(vtkNew sself); -extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket(vtkNew sself); -extern "C" void vtk_static_point_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3); -extern "C" void vtk_static_point_locator_set_divisions(vtkNew sself, const int _arg); -extern "C" int* vtk_static_point_locator_get_divisions(vtkNew sself); -extern "C" void vtk_static_point_locator_get_divisions(vtkNew sself, int data); -extern "C" long long vtk_static_point_locator_find_closest_point(vtkNew sself, const double x); -extern "C" long long vtk_static_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); -extern "C" long long vtk_static_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2); -extern "C" int vtk_static_point_locator_intersect_with_line(vtkNew sself, double a0, double a1, double tol, double t, double lineX, double ptX, long long ptId); -extern "C" void vtk_static_point_locator_merge_points(vtkNew sself, double tol, long long mergeMap); -extern "C" void vtk_static_point_locator_initialize(vtkNew sself); -extern "C" void vtk_static_point_locator_free_search_structure(vtkNew sself); -extern "C" void vtk_static_point_locator_build_locator(vtkNew sself); -extern "C" void vtk_static_point_locator_build_locator(vtkNew sself, const double inBounds); -extern "C" long long vtk_static_point_locator_get_number_of_points_in_bucket(vtkNew sself, long long bNum); -extern "C" void vtk_static_point_locator_set_max_number_of_buckets(vtkNew sself, long long _arg); -extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_min_value(vtkNew sself); -extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_max_value(vtkNew sself); -extern "C" long long vtk_static_point_locator_get_max_number_of_buckets(vtkNew sself); -extern "C" bool vtk_static_point_locator_get_large_ids(vtkNew sself); -extern "C" double* vtk_static_point_locator_get_spacing(vtkNew sself); -extern "C" void vtk_static_point_locator_get_spacing(vtkNew sself, double spacing); -extern "C" vtkNew < vtkStaticPointLocator2D > vtkStaticPointLocator2D_new () ; -extern "C" void vtkStaticPointLocator2D_destructor (vtkNew < vtkStaticPointLocator2D > sself) ; -extern "C" void * vtkStaticPointLocator2D_get_ptr (vtkNew < vtkStaticPointLocator2D > sself) ; -extern "C" void vtk_static_point_locator_2_d_set_number_of_points_per_bucket(vtkNew sself, int _arg); -extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value(vtkNew sself); -extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value(vtkNew sself); -extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket(vtkNew sself); -extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkNew sself, int _arg1, int _arg2); -extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkNew sself, const int _arg); -extern "C" int* vtk_static_point_locator_2_d_get_divisions(vtkNew sself); -extern "C" void vtk_static_point_locator_2_d_get_divisions(vtkNew sself, int data); -extern "C" long long vtk_static_point_locator_2_d_find_closest_point(vtkNew sself, const double x); -extern "C" long long vtk_static_point_locator_2_d_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2); -extern "C" long long vtk_static_point_locator_2_d_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2); -extern "C" int vtk_static_point_locator_2_d_intersect_with_line(vtkNew sself, double a0, double a1, double tol, double t, double lineX, double ptX, long long ptId); -extern "C" void vtk_static_point_locator_2_d_merge_points(vtkNew sself, double tol, long long mergeMap); -extern "C" void vtk_static_point_locator_2_d_initialize(vtkNew sself); -extern "C" void vtk_static_point_locator_2_d_free_search_structure(vtkNew sself); -extern "C" void vtk_static_point_locator_2_d_build_locator(vtkNew sself); -extern "C" long long vtk_static_point_locator_2_d_get_number_of_points_in_bucket(vtkNew sself, long long bNum); -extern "C" void vtk_static_point_locator_2_d_set_max_number_of_buckets(vtkNew sself, long long _arg); -extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(vtkNew sself); -extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(vtkNew sself); -extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets(vtkNew sself); -extern "C" bool vtk_static_point_locator_2_d_get_large_ids(vtkNew sself); -extern "C" void vtk_static_point_locator_2_d_get_bounds(vtkNew sself, double bounds); -extern "C" double* vtk_static_point_locator_2_d_get_spacing(vtkNew sself); -extern "C" void vtk_static_point_locator_2_d_get_spacing(vtkNew sself, double spacing); -extern "C" void vtk_static_point_locator_2_d_get_bucket_indices(vtkNew sself, const double x, int ij); -extern "C" long long vtk_static_point_locator_2_d_get_bucket_index(vtkNew sself, const double x); -extern "C" vtkNew < vtkStructuredExtent > vtkStructuredExtent_new () ; -extern "C" void vtkStructuredExtent_destructor (vtkNew < vtkStructuredExtent > sself) ; -extern "C" void * vtkStructuredExtent_get_ptr (vtkNew < vtkStructuredExtent > sself) ; -extern "C" void vtk_structured_extent_clamp(vtkNew sself, int ext, const int wholeExt); -extern "C" bool vtk_structured_extent_strictly_smaller(vtkNew sself, const int ext, const int wholeExt); -extern "C" bool vtk_structured_extent_smaller(vtkNew sself, const int ext, const int wholeExt); -extern "C" void vtk_structured_extent_grow(vtkNew sself, int ext, int count); -extern "C" void vtk_structured_extent_grow(vtkNew sself, int ext, int count, int wholeExt); -extern "C" void vtk_structured_extent_transform(vtkNew sself, int ext, int wholeExt); -extern "C" void vtk_structured_extent_get_dimensions(vtkNew sself, const int ext, int dims); -extern "C" vtkNew < vtkStructuredGrid > vtkStructuredGrid_new () ; -extern "C" void vtkStructuredGrid_destructor (vtkNew < vtkStructuredGrid > sself) ; -extern "C" void * vtkStructuredGrid_get_ptr (vtkNew < vtkStructuredGrid > sself) ; -extern "C" int vtk_structured_grid_get_data_object_type(vtkNew sself); -extern "C" long long vtk_structured_grid_get_number_of_points(vtkNew sself); -extern "C" void vtk_structured_grid_get_point(vtkNew sself, long long ptId, double p); -extern "C" int vtk_structured_grid_get_cell_type(vtkNew sself, long long cellId); -extern "C" void vtk_structured_grid_set_dimensions(vtkNew sself, int i, int j, int k); -extern "C" void vtk_structured_grid_set_dimensions(vtkNew sself, const int dim); -extern "C" int* vtk_structured_grid_get_dimensions(vtkNew sself); -extern "C" void vtk_structured_grid_get_dimensions(vtkNew sself, int dim); -extern "C" int vtk_structured_grid_get_data_dimension(vtkNew sself); -extern "C" void vtk_structured_grid_set_extent(vtkNew sself, int extent); -extern "C" void vtk_structured_grid_set_extent(vtkNew sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax); -extern "C" int* vtk_structured_grid_get_extent(vtkNew sself); -extern "C" void vtk_structured_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_structured_grid_get_extent(vtkNew sself, int _arg); -extern "C" int vtk_structured_grid_get_extent_type(vtkNew sself); -extern "C" void vtk_structured_grid_blank_point(vtkNew sself, long long ptId); -extern "C" void vtk_structured_grid_un_blank_point(vtkNew sself, long long ptId); -extern "C" void vtk_structured_grid_blank_cell(vtkNew sself, long long ptId); -extern "C" void vtk_structured_grid_un_blank_cell(vtkNew sself, long long ptId); -extern "C" unsigned char vtk_structured_grid_is_point_visible(vtkNew sself, long long ptId); -extern "C" unsigned char vtk_structured_grid_is_cell_visible(vtkNew sself, long long cellId); -extern "C" bool vtk_structured_grid_has_any_blank_points(vtkNew sself); -extern "C" bool vtk_structured_grid_has_any_blank_cells(vtkNew sself); -extern "C" void vtk_structured_grid_get_cell_dims(vtkNew sself, int cellDims); -extern "C" void vtk_structured_grid_crop(vtkNew sself, const int updateExtent); -extern "C" void vtk_structured_grid_get_point(vtkNew sself, int i, int j, int k, double p, bool adjustForExtent); -extern "C" vtkNew < vtkStructuredPoints > vtkStructuredPoints_new () ; -extern "C" void vtkStructuredPoints_destructor (vtkNew < vtkStructuredPoints > sself) ; -extern "C" void * vtkStructuredPoints_get_ptr (vtkNew < vtkStructuredPoints > sself) ; -extern "C" int vtk_structured_points_get_data_object_type(vtkNew sself); -extern "C" vtkNew < vtkStructuredPointsCollection > vtkStructuredPointsCollection_new () ; -extern "C" void vtkStructuredPointsCollection_destructor (vtkNew < vtkStructuredPointsCollection > sself) ; -extern "C" void * vtkStructuredPointsCollection_get_ptr (vtkNew < vtkStructuredPointsCollection > sself) ; -extern "C" vtkNew < vtkSuperquadric > vtkSuperquadric_new () ; -extern "C" void vtkSuperquadric_destructor (vtkNew < vtkSuperquadric > sself) ; -extern "C" void * vtkSuperquadric_get_ptr (vtkNew < vtkSuperquadric > sself) ; -extern "C" double vtk_superquadric_evaluate_function(vtkNew sself, double x); -extern "C" void vtk_superquadric_evaluate_gradient(vtkNew sself, double x, double g); -extern "C" void vtk_superquadric_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_superquadric_set_center(vtkNew sself, const double _arg); -extern "C" double* vtk_superquadric_get_center(vtkNew sself); -extern "C" void vtk_superquadric_get_center(vtkNew sself, double data); -extern "C" void vtk_superquadric_set_scale(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_superquadric_set_scale(vtkNew sself, const double _arg); -extern "C" double* vtk_superquadric_get_scale(vtkNew sself); -extern "C" void vtk_superquadric_get_scale(vtkNew sself, double data); -extern "C" double vtk_superquadric_get_thickness(vtkNew sself); -extern "C" void vtk_superquadric_set_thickness(vtkNew sself, double _arg); -extern "C" double vtk_superquadric_get_thickness_min_value(vtkNew sself); -extern "C" double vtk_superquadric_get_thickness_max_value(vtkNew sself); -extern "C" double vtk_superquadric_get_phi_roundness(vtkNew sself); -extern "C" void vtk_superquadric_set_phi_roundness(vtkNew sself, double e); -extern "C" double vtk_superquadric_get_theta_roundness(vtkNew sself); -extern "C" void vtk_superquadric_set_theta_roundness(vtkNew sself, double e); -extern "C" void vtk_superquadric_set_size(vtkNew sself, double _arg); -extern "C" double vtk_superquadric_get_size(vtkNew sself); -extern "C" void vtk_superquadric_toroidal_on(vtkNew sself); -extern "C" void vtk_superquadric_toroidal_off(vtkNew sself); -extern "C" int vtk_superquadric_get_toroidal(vtkNew sself); -extern "C" void vtk_superquadric_set_toroidal(vtkNew sself, int _arg); -extern "C" vtkNew < vtkTable > vtkTable_new () ; -extern "C" void vtkTable_destructor (vtkNew < vtkTable > sself) ; -extern "C" void * vtkTable_get_ptr (vtkNew < vtkTable > sself) ; -extern "C" void vtk_table_dump(vtkNew sself, unsigned int colWidth, int rowLimit); -extern "C" int vtk_table_get_data_object_type(vtkNew sself); -extern "C" long long vtk_table_get_number_of_rows(vtkNew sself); -extern "C" void vtk_table_set_number_of_rows(vtkNew sself, const long long p0); -extern "C" long long vtk_table_insert_next_blank_row(vtkNew sself, double default_num_val); -extern "C" void vtk_table_remove_row(vtkNew sself, long long row); -extern "C" long long vtk_table_get_number_of_columns(vtkNew sself); -extern "C" const char* vtk_table_get_column_name(vtkNew sself, long long col); -extern "C" void vtk_table_remove_column_by_name(vtkNew sself, const char name); -extern "C" void vtk_table_remove_column(vtkNew sself, long long col); -extern "C" void vtk_table_initialize(vtkNew sself); -extern "C" long long vtk_table_get_number_of_elements(vtkNew sself, int type); -extern "C" vtkNew < vtkTetra > vtkTetra_new () ; -extern "C" void vtkTetra_destructor (vtkNew < vtkTetra > sself) ; -extern "C" void * vtkTetra_get_ptr (vtkNew < vtkTetra > sself) ; -extern "C" void vtk_tetra_get_edge_points(vtkNew sself, long long edgeId, const long long pts); -extern "C" void vtk_tetra_get_edge_points(vtkNew sself, int edgeId, int pts); -extern "C" long long vtk_tetra_get_face_points(vtkNew sself, long long faceId, const long long pts); -extern "C" void vtk_tetra_get_face_points(vtkNew sself, int faceId, int pts); -extern "C" void vtk_tetra_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); -extern "C" long long vtk_tetra_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); -extern "C" long long vtk_tetra_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); -extern "C" long long vtk_tetra_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); -extern "C" long long vtk_tetra_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); -extern "C" bool vtk_tetra_get_centroid(vtkNew sself, double centroid); -extern "C" int vtk_tetra_get_cell_type(vtkNew sself); -extern "C" int vtk_tetra_get_number_of_edges(vtkNew sself); -extern "C" int vtk_tetra_get_number_of_faces(vtkNew sself); -extern "C" int vtk_tetra_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_tetra_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_tetra_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_tetra_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int* vtk_tetra_get_triangle_cases(vtkNew sself, int caseId); -extern "C" int vtk_tetra_get_parametric_center(vtkNew sself, double pcoords); -extern "C" double vtk_tetra_get_parametric_distance(vtkNew sself, const double pcoords); -extern "C" void vtk_tetra_tetra_center(vtkNew sself, double p1, double p2, double p3, double p4, double center); -extern "C" double vtk_tetra_circumsphere(vtkNew sself, double x1, double x2, double x3, double x4, double center); -extern "C" double vtk_tetra_insphere(vtkNew sself, double p1, double p2, double p3, double p4, double center); -extern "C" int vtk_tetra_barycentric_coords(vtkNew sself, double x, double x1, double x2, double x3, double x4, double bcoords); -extern "C" double vtk_tetra_compute_volume(vtkNew sself, double p1, double p2, double p3, double p4); -extern "C" int vtk_tetra_jacobian_inverse(vtkNew sself, double inverse, double derivs); -extern "C" void vtk_tetra_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_tetra_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_tetra_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_tetra_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_tetra_get_face_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_tetra_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_tetra_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_tetra_get_point_to_incident_edges_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_tetra_get_point_to_incident_faces_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_tetra_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); -extern "C" vtkNew < vtkTree > vtkTree_new () ; -extern "C" void vtkTree_destructor (vtkNew < vtkTree > sself) ; -extern "C" void * vtkTree_get_ptr (vtkNew < vtkTree > sself) ; -extern "C" long long vtk_tree_get_root(vtkNew sself); -extern "C" long long vtk_tree_get_number_of_children(vtkNew sself, long long v); -extern "C" long long vtk_tree_get_child(vtkNew sself, long long v, long long i); -extern "C" long long vtk_tree_get_parent(vtkNew sself, long long v); -extern "C" long long vtk_tree_get_level(vtkNew sself, long long v); -extern "C" bool vtk_tree_is_leaf(vtkNew sself, long long vertex); -extern "C" vtkNew < vtkTreeBFSIterator > vtkTreeBFSIterator_new () ; -extern "C" void vtkTreeBFSIterator_destructor (vtkNew < vtkTreeBFSIterator > sself) ; -extern "C" void * vtkTreeBFSIterator_get_ptr (vtkNew < vtkTreeBFSIterator > sself) ; -extern "C" vtkNew < vtkTreeDFSIterator > vtkTreeDFSIterator_new () ; -extern "C" void vtkTreeDFSIterator_destructor (vtkNew < vtkTreeDFSIterator > sself) ; -extern "C" void * vtkTreeDFSIterator_get_ptr (vtkNew < vtkTreeDFSIterator > sself) ; -extern "C" void vtk_tree_dfs_iterator_set_mode(vtkNew sself, int mode); -extern "C" int vtk_tree_dfs_iterator_get_mode(vtkNew sself); -extern "C" vtkNew < vtkTriQuadraticHexahedron > vtkTriQuadraticHexahedron_new () ; -extern "C" void vtkTriQuadraticHexahedron_destructor (vtkNew < vtkTriQuadraticHexahedron > sself) ; -extern "C" void * vtkTriQuadraticHexahedron_get_ptr (vtkNew < vtkTriQuadraticHexahedron > sself) ; -extern "C" int vtk_tri_quadratic_hexahedron_get_cell_type(vtkNew sself); -extern "C" int vtk_tri_quadratic_hexahedron_get_cell_dimension(vtkNew sself); -extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_edges(vtkNew sself); -extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_faces(vtkNew sself); -extern "C" int vtk_tri_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_tri_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_tri_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_tri_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_tri_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_tri_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_tri_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_tri_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_tri_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_tri_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId); -extern "C" void vtk_tri_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" vtkNew < vtkTriQuadraticPyramid > vtkTriQuadraticPyramid_new () ; -extern "C" void vtkTriQuadraticPyramid_destructor (vtkNew < vtkTriQuadraticPyramid > sself) ; -extern "C" void * vtkTriQuadraticPyramid_get_ptr (vtkNew < vtkTriQuadraticPyramid > sself) ; -extern "C" int vtk_tri_quadratic_pyramid_get_cell_type(vtkNew sself); -extern "C" int vtk_tri_quadratic_pyramid_get_cell_dimension(vtkNew sself); -extern "C" int vtk_tri_quadratic_pyramid_get_number_of_edges(vtkNew sself); -extern "C" int vtk_tri_quadratic_pyramid_get_number_of_faces(vtkNew sself); -extern "C" int vtk_tri_quadratic_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_tri_quadratic_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_tri_quadratic_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_tri_quadratic_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_tri_quadratic_pyramid_get_parametric_center(vtkNew sself, double pcoords); -extern "C" double vtk_tri_quadratic_pyramid_get_parametric_distance(vtkNew sself, const double pcoords); -extern "C" void vtk_tri_quadratic_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_tri_quadratic_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_tri_quadratic_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_tri_quadratic_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_tri_quadratic_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" const long long* vtk_tri_quadratic_pyramid_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_tri_quadratic_pyramid_get_face_array(vtkNew sself, long long faceId); -extern "C" vtkNew < vtkTriangle > vtkTriangle_new () ; -extern "C" void vtkTriangle_destructor (vtkNew < vtkTriangle > sself) ; -extern "C" void * vtkTriangle_get_ptr (vtkNew < vtkTriangle > sself) ; -extern "C" int vtk_triangle_get_cell_type(vtkNew sself); -extern "C" int vtk_triangle_get_cell_dimension(vtkNew sself); -extern "C" int vtk_triangle_get_number_of_edges(vtkNew sself); -extern "C" int vtk_triangle_get_number_of_faces(vtkNew sself); -extern "C" int vtk_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" void vtk_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" double vtk_triangle_compute_area(vtkNew sself); -extern "C" void vtk_triangle_interpolation_functions(vtkNew sself, const double pcoords, double sf); -extern "C" void vtk_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_triangle_interpolate_functions(vtkNew sself, const double pcoords, double sf); -extern "C" void vtk_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" const long long* vtk_triangle_get_edge_array(vtkNew sself, long long edgeId); -extern "C" int vtk_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" int vtk_triangle_get_parametric_center(vtkNew sself, double pcoords); -extern "C" double vtk_triangle_get_parametric_distance(vtkNew sself, const double pcoords); -extern "C" void vtk_triangle_triangle_center(vtkNew sself, const double p1, const double p2, const double p3, double center); -extern "C" double vtk_triangle_triangle_area(vtkNew sself, const double p1, const double p2, const double p3); -extern "C" double vtk_triangle_circumcircle(vtkNew sself, const double p1, const double p2, const double p3, double center); -extern "C" int vtk_triangle_barycentric_coords(vtkNew sself, const double x, const double x1, const double x2, const double x3, double bcoords); -extern "C" int vtk_triangle_project_to_2_d(vtkNew sself, const double x1, const double x2, const double x3, double v1, double v2, double v3); -extern "C" void vtk_triangle_compute_normal(vtkNew sself, const double v1, const double v2, const double v3, double n); -extern "C" void vtk_triangle_compute_normal_direction(vtkNew sself, const double v1, const double v2, const double v3, double n); -extern "C" int vtk_triangle_triangles_intersect(vtkNew sself, const double p1, const double q1, const double r1, const double p2, const double q2, const double r2); -extern "C" int vtk_triangle_point_in_triangle(vtkNew sself, const double x, const double x1, const double x2, const double x3, const double tol2); -extern "C" void vtk_triangle_compute_quadric(vtkNew sself, const double x1, const double x2, const double x3, double quadric); -extern "C" vtkNew < vtkTriangleStrip > vtkTriangleStrip_new () ; -extern "C" void vtkTriangleStrip_destructor (vtkNew < vtkTriangleStrip > sself) ; -extern "C" void * vtkTriangleStrip_get_ptr (vtkNew < vtkTriangleStrip > sself) ; -extern "C" int vtk_triangle_strip_get_cell_type(vtkNew sself); -extern "C" int vtk_triangle_strip_get_cell_dimension(vtkNew sself); -extern "C" int vtk_triangle_strip_get_number_of_edges(vtkNew sself); -extern "C" int vtk_triangle_strip_get_number_of_faces(vtkNew sself); -extern "C" int vtk_triangle_strip_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_triangle_strip_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_triangle_strip_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_triangle_strip_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_triangle_strip_get_parametric_center(vtkNew sself, double pcoords); -extern "C" vtkNew < vtkUndirectedGraph > vtkUndirectedGraph_new () ; -extern "C" void vtkUndirectedGraph_destructor (vtkNew < vtkUndirectedGraph > sself) ; -extern "C" void * vtkUndirectedGraph_get_ptr (vtkNew < vtkUndirectedGraph > sself) ; -extern "C" long long vtk_undirected_graph_get_in_degree(vtkNew sself, long long v); -extern "C" vtkNew < vtkUniformGrid > vtkUniformGrid_new () ; -extern "C" void vtkUniformGrid_destructor (vtkNew < vtkUniformGrid > sself) ; -extern "C" void * vtkUniformGrid_get_ptr (vtkNew < vtkUniformGrid > sself) ; -extern "C" int vtk_uniform_grid_get_grid_description(vtkNew sself); -extern "C" void vtk_uniform_grid_blank_point(vtkNew sself, long long ptId); -extern "C" void vtk_uniform_grid_un_blank_point(vtkNew sself, long long ptId); -extern "C" void vtk_uniform_grid_blank_point(vtkNew sself, const int i, const int j, const int k); -extern "C" void vtk_uniform_grid_un_blank_point(vtkNew sself, const int i, const int j, const int k); -extern "C" void vtk_uniform_grid_blank_cell(vtkNew sself, long long ptId); -extern "C" void vtk_uniform_grid_un_blank_cell(vtkNew sself, long long ptId); -extern "C" void vtk_uniform_grid_blank_cell(vtkNew sself, const int i, const int j, const int k); -extern "C" void vtk_uniform_grid_un_blank_cell(vtkNew sself, const int i, const int j, const int k); -extern "C" unsigned char vtk_uniform_grid_is_point_visible(vtkNew sself, long long pointId); -extern "C" unsigned char vtk_uniform_grid_is_cell_visible(vtkNew sself, long long cellId); -extern "C" vtkNew < vtkUniformGridAMR > vtkUniformGridAMR_new () ; -extern "C" void vtkUniformGridAMR_destructor (vtkNew < vtkUniformGridAMR > sself) ; -extern "C" void * vtkUniformGridAMR_get_ptr (vtkNew < vtkUniformGridAMR > sself) ; -extern "C" int vtk_uniform_grid_amr_get_data_object_type(vtkNew sself); -extern "C" void vtk_uniform_grid_amr_initialize(vtkNew sself); -extern "C" void vtk_uniform_grid_amr_initialize(vtkNew sself, int numLevels, const int blocksPerLevel); -extern "C" void vtk_uniform_grid_amr_set_grid_description(vtkNew sself, int gridDescription); -extern "C" int vtk_uniform_grid_amr_get_grid_description(vtkNew sself); -extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_levels(vtkNew sself); -extern "C" unsigned int vtk_uniform_grid_amr_get_total_number_of_blocks(vtkNew sself); -extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_data_sets(vtkNew sself, const unsigned int level); -extern "C" void vtk_uniform_grid_amr_get_bounds(vtkNew sself, double bounds); -extern "C" const double* vtk_uniform_grid_amr_get_bounds(vtkNew sself); -extern "C" void vtk_uniform_grid_amr_get_min(vtkNew sself, double min); -extern "C" void vtk_uniform_grid_amr_get_max(vtkNew sself, double max); -extern "C" int vtk_uniform_grid_amr_get_composite_index(vtkNew sself, const unsigned int level, const unsigned int index); -extern "C" void vtk_uniform_grid_amr_get_level_and_index(vtkNew sself, const unsigned int compositeIdx, unsigned int level, unsigned int idx); -extern "C" vtkNew < vtkUniformGridAMRDataIterator > vtkUniformGridAMRDataIterator_new () ; -extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkNew < vtkUniformGridAMRDataIterator > sself) ; -extern "C" void * vtkUniformGridAMRDataIterator_get_ptr (vtkNew < vtkUniformGridAMRDataIterator > sself) ; -extern "C" int vtk_uniform_grid_amr_data_iterator_has_current_meta_data(vtkNew sself); -extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_flat_index(vtkNew sself); -extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_level(vtkNew sself); -extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_index(vtkNew sself); -extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_first_item(vtkNew sself); -extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_next_item(vtkNew sself); -extern "C" int vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(vtkNew sself); -extern "C" vtkNew < vtkUniformHyperTreeGrid > vtkUniformHyperTreeGrid_new () ; -extern "C" void vtkUniformHyperTreeGrid_destructor (vtkNew < vtkUniformHyperTreeGrid > sself) ; -extern "C" void * vtkUniformHyperTreeGrid_get_ptr (vtkNew < vtkUniformHyperTreeGrid > sself) ; -extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkNew sself, const double _arg); -extern "C" double* vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself); -extern "C" void vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself, double _arg); -extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0, double p1, double p2); -extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0); -extern "C" double* vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself); -extern "C" void vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself, double _arg1, double _arg2, double _arg3); -extern "C" void vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself, double _arg); -extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0); -extern "C" void vtk_uniform_hyper_tree_grid_get_level_zero_origin_from_index(vtkNew sself, long long p0, double p1); -extern "C" unsigned long vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(vtkNew sself); -extern "C" vtkNew < vtkUnstructuredGrid > vtkUnstructuredGrid_new () ; -extern "C" void vtkUnstructuredGrid_destructor (vtkNew < vtkUnstructuredGrid > sself) ; -extern "C" void * vtkUnstructuredGrid_get_ptr (vtkNew < vtkUnstructuredGrid > sself) ; -extern "C" int vtk_unstructured_grid_get_data_object_type(vtkNew sself); -extern "C" bool vtk_unstructured_grid_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize); -extern "C" bool vtk_unstructured_grid_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize); -extern "C" void vtk_unstructured_grid_allocate(vtkNew sself, long long numCells, int extSize); -extern "C" void vtk_unstructured_grid_reset(vtkNew sself); -extern "C" int vtk_unstructured_grid_get_cell_type(vtkNew sself, long long cellId); -extern "C" void vtk_unstructured_grid_get_cell_points(vtkNew sself, long long cellId, long long npts, const long long pts); -extern "C" void vtk_unstructured_grid_get_point_cells(vtkNew sself, long long ptId, long long ncells, long long cells); -extern "C" void vtk_unstructured_grid_get_point_cells(vtkNew sself, long long ptId, unsigned short ncells, long long cells); -extern "C" void vtk_unstructured_grid_squeeze(vtkNew sself); -extern "C" void vtk_unstructured_grid_initialize(vtkNew sself); -extern "C" int vtk_unstructured_grid_get_max_cell_size(vtkNew sself); -extern "C" void vtk_unstructured_grid_build_links(vtkNew sself); -extern "C" void vtk_unstructured_grid_get_face_stream(vtkNew sself, long long cellId, long long nfaces, const long long ptIds); -extern "C" bool vtk_unstructured_grid_is_cell_boundary(vtkNew sself, long long cellId, long long npts, const long long ptIds); -extern "C" long long vtk_unstructured_grid_insert_next_linked_cell(vtkNew sself, int type, int npts, const long long pts); -extern "C" void vtk_unstructured_grid_remove_reference_to_cell(vtkNew sself, long long ptId, long long cellId); -extern "C" void vtk_unstructured_grid_add_reference_to_cell(vtkNew sself, long long ptId, long long cellId); -extern "C" void vtk_unstructured_grid_resize_cell_list(vtkNew sself, long long ptId, int size); -extern "C" int vtk_unstructured_grid_get_piece(vtkNew sself); -extern "C" int vtk_unstructured_grid_get_number_of_pieces(vtkNew sself); -extern "C" int vtk_unstructured_grid_get_ghost_level(vtkNew sself); -extern "C" int vtk_unstructured_grid_is_homogeneous(vtkNew sself); -extern "C" void vtk_unstructured_grid_remove_ghost_cells(vtkNew sself); -extern "C" long long* vtk_unstructured_grid_get_faces(vtkNew sself, long long cellId); -extern "C" int vtk_unstructured_grid_initialize_faces_representation(vtkNew sself, long long numPrevCells); -extern "C" unsigned long vtk_unstructured_grid_get_mesh_m_time(vtkNew sself); -extern "C" void vtk_unstructured_grid_convert_face_stream_point_ids(vtkNew sself, long long nfaces, long long faceStream, long long idMap); -extern "C" vtkNew < vtkUnstructuredGridCellIterator > vtkUnstructuredGridCellIterator_new () ; -extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkNew < vtkUnstructuredGridCellIterator > sself) ; -extern "C" void * vtkUnstructuredGridCellIterator_get_ptr (vtkNew < vtkUnstructuredGridCellIterator > sself) ; -extern "C" bool vtk_unstructured_grid_cell_iterator_is_done_with_traversal(vtkNew sself); -extern "C" long long vtk_unstructured_grid_cell_iterator_get_cell_id(vtkNew sself); -extern "C" void vtk_unstructured_grid_cell_iterator_go_to_cell(vtkNew sself, long long cellId); -extern "C" vtkNew < vtkVertex > vtkVertex_new () ; -extern "C" void vtkVertex_destructor (vtkNew < vtkVertex > sself) ; -extern "C" void * vtkVertex_get_ptr (vtkNew < vtkVertex > sself) ; -extern "C" int vtk_vertex_get_cell_type(vtkNew sself); -extern "C" int vtk_vertex_get_cell_dimension(vtkNew sself); -extern "C" int vtk_vertex_get_number_of_edges(vtkNew sself); -extern "C" int vtk_vertex_get_number_of_faces(vtkNew sself); -extern "C" int vtk_vertex_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_vertex_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_vertex_inflate(vtkNew sself, double p0); -extern "C" int vtk_vertex_get_parametric_center(vtkNew sself, double pcoords); -extern "C" int vtk_vertex_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_vertex_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" void vtk_vertex_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_vertex_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_vertex_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_vertex_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" vtkNew < vtkVertexListIterator > vtkVertexListIterator_new () ; -extern "C" void vtkVertexListIterator_destructor (vtkNew < vtkVertexListIterator > sself) ; -extern "C" void * vtkVertexListIterator_get_ptr (vtkNew < vtkVertexListIterator > sself) ; -extern "C" long long vtk_vertex_list_iterator_next(vtkNew sself); -extern "C" bool vtk_vertex_list_iterator_has_next(vtkNew sself); -extern "C" vtkNew < vtkVoxel > vtkVoxel_new () ; -extern "C" void vtkVoxel_destructor (vtkNew < vtkVoxel > sself) ; -extern "C" void * vtkVoxel_get_ptr (vtkNew < vtkVoxel > sself) ; -extern "C" void vtk_voxel_get_edge_points(vtkNew sself, long long edgeId, const long long pts); -extern "C" void vtk_voxel_get_edge_points(vtkNew sself, int edgeId, int pts); -extern "C" long long vtk_voxel_get_face_points(vtkNew sself, long long faceId, const long long pts); -extern "C" void vtk_voxel_get_face_points(vtkNew sself, int faceId, int pts); -extern "C" void vtk_voxel_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); -extern "C" long long vtk_voxel_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faces); -extern "C" long long vtk_voxel_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edges); -extern "C" long long vtk_voxel_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faces); -extern "C" long long vtk_voxel_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); -extern "C" bool vtk_voxel_get_centroid(vtkNew sself, double centroid); -extern "C" double vtk_voxel_compute_bounding_sphere(vtkNew sself, double center); -extern "C" int vtk_voxel_get_cell_type(vtkNew sself); -extern "C" int vtk_voxel_get_number_of_edges(vtkNew sself); -extern "C" int vtk_voxel_get_number_of_faces(vtkNew sself); -extern "C" int vtk_voxel_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_voxel_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_voxel_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_voxel_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int vtk_voxel_inflate(vtkNew sself, double dist); -extern "C" void vtk_voxel_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_voxel_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_voxel_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_voxel_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" int* vtk_voxel_get_triangle_cases(vtkNew sself, int caseId); -extern "C" const long long* vtk_voxel_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_voxel_get_face_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_voxel_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_voxel_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_voxel_get_point_to_incident_edges_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_voxel_get_point_to_incident_faces_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_voxel_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); -extern "C" vtkNew < vtkWedge > vtkWedge_new () ; -extern "C" void vtkWedge_destructor (vtkNew < vtkWedge > sself) ; -extern "C" void * vtkWedge_get_ptr (vtkNew < vtkWedge > sself) ; -extern "C" void vtk_wedge_get_edge_points(vtkNew sself, long long edgeId, const long long pts); -extern "C" void vtk_wedge_get_edge_points(vtkNew sself, int edgeId, int pts); -extern "C" long long vtk_wedge_get_face_points(vtkNew sself, long long faceId, const long long pts); -extern "C" void vtk_wedge_get_face_points(vtkNew sself, int faceId, int pts); -extern "C" void vtk_wedge_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts); -extern "C" long long vtk_wedge_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds); -extern "C" long long vtk_wedge_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds); -extern "C" long long vtk_wedge_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds); -extern "C" long long vtk_wedge_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts); -extern "C" bool vtk_wedge_get_centroid(vtkNew sself, double centroid); -extern "C" int vtk_wedge_get_cell_type(vtkNew sself); -extern "C" int vtk_wedge_get_number_of_edges(vtkNew sself); -extern "C" int vtk_wedge_get_number_of_faces(vtkNew sself); -extern "C" int vtk_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights); -extern "C" void vtk_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights); -extern "C" int vtk_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId); -extern "C" void vtk_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs); -extern "C" int* vtk_wedge_get_triangle_cases(vtkNew sself, int caseId); -extern "C" int vtk_wedge_get_parametric_center(vtkNew sself, double pcoords); -extern "C" void vtk_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" void vtk_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights); -extern "C" void vtk_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs); -extern "C" int vtk_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs); -extern "C" const long long* vtk_wedge_get_edge_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_wedge_get_face_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_wedge_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId); -extern "C" const long long* vtk_wedge_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId); -extern "C" const long long* vtk_wedge_get_point_to_incident_edges_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_wedge_get_point_to_incident_faces_array(vtkNew sself, long long pointId); -extern "C" const long long* vtk_wedge_get_point_to_one_ring_points_array(vtkNew sself, long long pointId); -extern "C" vtkNew < vtkXMLDataElement > vtkXMLDataElement_new () ; -extern "C" void vtkXMLDataElement_destructor (vtkNew < vtkXMLDataElement > sself) ; -extern "C" void * vtkXMLDataElement_get_ptr (vtkNew < vtkXMLDataElement > sself) ; -extern "C" char* vtk_xml_data_element_get_name(vtkNew sself); -extern "C" void vtk_xml_data_element_set_name(vtkNew sself, const char _arg); -extern "C" char* vtk_xml_data_element_get_id(vtkNew sself); -extern "C" void vtk_xml_data_element_set_id(vtkNew sself, const char _arg); -extern "C" const char* vtk_xml_data_element_get_attribute(vtkNew sself, const char name); -extern "C" void vtk_xml_data_element_set_attribute(vtkNew sself, const char name, const char value); -extern "C" void vtk_xml_data_element_set_character_data(vtkNew sself, const char data, int length); -extern "C" void vtk_xml_data_element_add_character_data(vtkNew sself, const char c, size_t length); -extern "C" char* vtk_xml_data_element_get_character_data(vtkNew sself); -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, int value); -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, float value); -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, double value); -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, long value); -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, unsigned long value); -extern "C" void vtk_xml_data_element_set_int_attribute(vtkNew sself, const char name, int value); -extern "C" void vtk_xml_data_element_set_float_attribute(vtkNew sself, const char name, float value); -extern "C" void vtk_xml_data_element_set_double_attribute(vtkNew sself, const char name, double value); -extern "C" void vtk_xml_data_element_set_unsigned_long_attribute(vtkNew sself, const char name, unsigned long value); -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, int value); -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, float value); -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, double value); -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, long value); -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, unsigned long value); -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const int value); -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const float value); -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const double value); -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const unsigned long value); -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, long long value); -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, long long value); -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const long long value); -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, unsigned long long value); -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, unsigned long long value); -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const unsigned long long value); -extern "C" int vtk_xml_data_element_get_word_type_attribute(vtkNew sself, const char name, int value); -extern "C" int vtk_xml_data_element_get_number_of_attributes(vtkNew sself); -extern "C" const char* vtk_xml_data_element_get_attribute_name(vtkNew sself, int idx); -extern "C" const char* vtk_xml_data_element_get_attribute_value(vtkNew sself, int idx); -extern "C" void vtk_xml_data_element_remove_attribute(vtkNew sself, const char name); -extern "C" void vtk_xml_data_element_remove_all_attributes(vtkNew sself); -extern "C" int vtk_xml_data_element_get_number_of_nested_elements(vtkNew sself); -extern "C" void vtk_xml_data_element_remove_all_nested_elements(vtkNew sself); -extern "C" long long vtk_xml_data_element_get_xml_byte_index(vtkNew sself); -extern "C" void vtk_xml_data_element_set_xml_byte_index(vtkNew sself, long long _arg); -extern "C" void vtk_xml_data_element_set_attribute_encoding(vtkNew sself, int _arg); -extern "C" int vtk_xml_data_element_get_attribute_encoding_min_value(vtkNew sself); -extern "C" int vtk_xml_data_element_get_attribute_encoding_max_value(vtkNew sself); -extern "C" int vtk_xml_data_element_get_attribute_encoding(vtkNew sself); -extern "C" void vtk_xml_data_element_print_xml(vtkNew sself, const char fname); -extern "C" int vtk_xml_data_element_get_character_data_width(vtkNew sself); -extern "C" void vtk_xml_data_element_set_character_data_width(vtkNew sself, int _arg); +extern "C" vtkAMRDataInternals * vtkAMRDataInternals_new () ; +extern "C" void vtkAMRDataInternals_destructor (vtkAMRDataInternals * sself) ; +extern "C" void * vtkAMRDataInternals_get_ptr (vtkAMRDataInternals * sself) ; +extern "C" void vtk_amr_data_internals_initialize(vtkAMRDataInternals* sself); +extern "C" bool vtk_amr_data_internals_empty(vtkAMRDataInternals* sself); +extern "C" unsigned int vtk_amr_data_internals_get_number_of_blocks(vtkAMRDataInternals* sself); +extern "C" vtkAdjacentVertexIterator * vtkAdjacentVertexIterator_new () ; +extern "C" void vtkAdjacentVertexIterator_destructor (vtkAdjacentVertexIterator * sself) ; +extern "C" void * vtkAdjacentVertexIterator_get_ptr (vtkAdjacentVertexIterator * sself) ; +extern "C" long long vtk_adjacent_vertex_iterator_get_vertex(vtkAdjacentVertexIterator* sself); +extern "C" long long vtk_adjacent_vertex_iterator_next(vtkAdjacentVertexIterator* sself); +extern "C" bool vtk_adjacent_vertex_iterator_has_next(vtkAdjacentVertexIterator* sself); +extern "C" vtkAnimationScene * vtkAnimationScene_new () ; +extern "C" void vtkAnimationScene_destructor (vtkAnimationScene * sself) ; +extern "C" void * vtkAnimationScene_get_ptr (vtkAnimationScene * sself) ; +extern "C" void vtk_animation_scene_set_play_mode(vtkAnimationScene* sself, int _arg); +extern "C" void vtk_animation_scene_set_mode_to_sequence(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_set_mode_to_real_time(vtkAnimationScene* sself); +extern "C" int vtk_animation_scene_get_play_mode(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_set_frame_rate(vtkAnimationScene* sself, double _arg); +extern "C" double vtk_animation_scene_get_frame_rate(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_remove_all_cues(vtkAnimationScene* sself); +extern "C" int vtk_animation_scene_get_number_of_cues(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_play(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_stop(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_set_loop(vtkAnimationScene* sself, int _arg); +extern "C" int vtk_animation_scene_get_loop(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_set_animation_time(vtkAnimationScene* sself, double time); +extern "C" void vtk_animation_scene_set_time_mode(vtkAnimationScene* sself, int mode); +extern "C" int vtk_animation_scene_is_in_play(vtkAnimationScene* sself); +extern "C" vtkAnnotation * vtkAnnotation_new () ; +extern "C" void vtkAnnotation_destructor (vtkAnnotation * sself) ; +extern "C" void * vtkAnnotation_get_ptr (vtkAnnotation * sself) ; +extern "C" int vtk_annotation_get_data_object_type(vtkAnnotation* sself); +extern "C" void vtk_annotation_initialize(vtkAnnotation* sself); +extern "C" unsigned long vtk_annotation_get_m_time(vtkAnnotation* sself); +extern "C" vtkAnnotationLayers * vtkAnnotationLayers_new () ; +extern "C" void vtkAnnotationLayers_destructor (vtkAnnotationLayers * sself) ; +extern "C" void * vtkAnnotationLayers_get_ptr (vtkAnnotationLayers * sself) ; +extern "C" int vtk_annotation_layers_get_data_object_type(vtkAnnotationLayers* sself); +extern "C" unsigned int vtk_annotation_layers_get_number_of_annotations(vtkAnnotationLayers* sself); +extern "C" void vtk_annotation_layers_initialize(vtkAnnotationLayers* sself); +extern "C" unsigned long vtk_annotation_layers_get_m_time(vtkAnnotationLayers* sself); +extern "C" vtkArrayData * vtkArrayData_new () ; +extern "C" void vtkArrayData_destructor (vtkArrayData * sself) ; +extern "C" void * vtkArrayData_get_ptr (vtkArrayData * sself) ; +extern "C" void vtk_array_data_clear_arrays(vtkArrayData* sself); +extern "C" long long vtk_array_data_get_number_of_arrays(vtkArrayData* sself); +extern "C" int vtk_array_data_get_data_object_type(vtkArrayData* sself); +extern "C" vtkAttributesErrorMetric * vtkAttributesErrorMetric_new () ; +extern "C" void vtkAttributesErrorMetric_destructor (vtkAttributesErrorMetric * sself) ; +extern "C" void * vtkAttributesErrorMetric_get_ptr (vtkAttributesErrorMetric * sself) ; +extern "C" double vtk_attributes_error_metric_get_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself); +extern "C" void vtk_attributes_error_metric_set_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself, double value); +extern "C" double vtk_attributes_error_metric_get_attribute_tolerance(vtkAttributesErrorMetric* sself); +extern "C" void vtk_attributes_error_metric_set_attribute_tolerance(vtkAttributesErrorMetric* sself, double value); +extern "C" vtkBSPCuts * vtkBSPCuts_new () ; +extern "C" void vtkBSPCuts_destructor (vtkBSPCuts * sself) ; +extern "C" void * vtkBSPCuts_get_ptr (vtkBSPCuts * sself) ; +extern "C" int vtk_bsp_cuts_get_data_object_type(vtkBSPCuts* sself); +extern "C" int vtk_bsp_cuts_get_number_of_cuts(vtkBSPCuts* sself); +extern "C" void vtk_bsp_cuts_print_tree(vtkBSPCuts* sself); +extern "C" void vtk_bsp_cuts_print_arrays(vtkBSPCuts* sself); +extern "C" vtkBSPIntersections * vtkBSPIntersections_new () ; +extern "C" void vtkBSPIntersections_destructor (vtkBSPIntersections * sself) ; +extern "C" void * vtkBSPIntersections_get_ptr (vtkBSPIntersections * sself) ; +extern "C" int vtk_bsp_intersections_get_number_of_regions(vtkBSPIntersections* sself); +extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkBSPIntersections* sself, int regionId, double x, double y, double z, double rSquared); +extern "C" int vtk_bsp_intersections_get_compute_intersections_using_data_bounds(vtkBSPIntersections* sself); +extern "C" void vtk_bsp_intersections_set_compute_intersections_using_data_bounds(vtkBSPIntersections* sself, int c); +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_on(vtkBSPIntersections* sself); +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_off(vtkBSPIntersections* sself); +extern "C" vtkBezierCurve * vtkBezierCurve_new () ; +extern "C" void vtkBezierCurve_destructor (vtkBezierCurve * sself) ; +extern "C" void * vtkBezierCurve_get_ptr (vtkBezierCurve * sself) ; +extern "C" int vtk_bezier_curve_get_cell_type(vtkBezierCurve* sself); +extern "C" vtkBezierHexahedron * vtkBezierHexahedron_new () ; +extern "C" void vtkBezierHexahedron_destructor (vtkBezierHexahedron * sself) ; +extern "C" void * vtkBezierHexahedron_get_ptr (vtkBezierHexahedron * sself) ; +extern "C" int vtk_bezier_hexahedron_get_cell_type(vtkBezierHexahedron* sself); +extern "C" vtkBezierInterpolation * vtkBezierInterpolation_new () ; +extern "C" void vtkBezierInterpolation_destructor (vtkBezierInterpolation * sself) ; +extern "C" void * vtkBezierInterpolation_get_ptr (vtkBezierInterpolation * sself) ; +extern "C" vtkBezierQuadrilateral * vtkBezierQuadrilateral_new () ; +extern "C" void vtkBezierQuadrilateral_destructor (vtkBezierQuadrilateral * sself) ; +extern "C" void * vtkBezierQuadrilateral_get_ptr (vtkBezierQuadrilateral * sself) ; +extern "C" int vtk_bezier_quadrilateral_get_cell_type(vtkBezierQuadrilateral* sself); +extern "C" vtkBezierTetra * vtkBezierTetra_new () ; +extern "C" void vtkBezierTetra_destructor (vtkBezierTetra * sself) ; +extern "C" void * vtkBezierTetra_get_ptr (vtkBezierTetra * sself) ; +extern "C" int vtk_bezier_tetra_get_cell_type(vtkBezierTetra* sself); +extern "C" vtkBezierTriangle * vtkBezierTriangle_new () ; +extern "C" void vtkBezierTriangle_destructor (vtkBezierTriangle * sself) ; +extern "C" void * vtkBezierTriangle_get_ptr (vtkBezierTriangle * sself) ; +extern "C" int vtk_bezier_triangle_get_cell_type(vtkBezierTriangle* sself); +extern "C" vtkBezierWedge * vtkBezierWedge_new () ; +extern "C" void vtkBezierWedge_destructor (vtkBezierWedge * sself) ; +extern "C" void * vtkBezierWedge_get_ptr (vtkBezierWedge * sself) ; +extern "C" int vtk_bezier_wedge_get_cell_type(vtkBezierWedge* sself); +extern "C" vtkBiQuadraticQuad * vtkBiQuadraticQuad_new () ; +extern "C" void vtkBiQuadraticQuad_destructor (vtkBiQuadraticQuad * sself) ; +extern "C" void * vtkBiQuadraticQuad_get_ptr (vtkBiQuadraticQuad * sself) ; +extern "C" int vtk_bi_quadratic_quad_get_cell_type(vtkBiQuadraticQuad* sself); +extern "C" int vtk_bi_quadratic_quad_get_cell_dimension(vtkBiQuadraticQuad* sself); +extern "C" int vtk_bi_quadratic_quad_get_number_of_edges(vtkBiQuadraticQuad* sself); +extern "C" int vtk_bi_quadratic_quad_get_number_of_faces(vtkBiQuadraticQuad* sself); +extern "C" vtkBiQuadraticQuadraticHexahedron * vtkBiQuadraticQuadraticHexahedron_new () ; +extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkBiQuadraticQuadraticHexahedron * sself) ; +extern "C" void * vtkBiQuadraticQuadraticHexahedron_get_ptr (vtkBiQuadraticQuadraticHexahedron * sself) ; +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(vtkBiQuadraticQuadraticHexahedron* sself); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(vtkBiQuadraticQuadraticHexahedron* sself); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(vtkBiQuadraticQuadraticHexahedron* sself); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(vtkBiQuadraticQuadraticHexahedron* sself); +extern "C" vtkBiQuadraticQuadraticWedge * vtkBiQuadraticQuadraticWedge_new () ; +extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkBiQuadraticQuadraticWedge * sself) ; +extern "C" void * vtkBiQuadraticQuadraticWedge_get_ptr (vtkBiQuadraticQuadraticWedge * sself) ; +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_type(vtkBiQuadraticQuadraticWedge* sself); +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(vtkBiQuadraticQuadraticWedge* sself); +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(vtkBiQuadraticQuadraticWedge* sself); +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(vtkBiQuadraticQuadraticWedge* sself); +extern "C" vtkBiQuadraticTriangle * vtkBiQuadraticTriangle_new () ; +extern "C" void vtkBiQuadraticTriangle_destructor (vtkBiQuadraticTriangle * sself) ; +extern "C" void * vtkBiQuadraticTriangle_get_ptr (vtkBiQuadraticTriangle * sself) ; +extern "C" int vtk_bi_quadratic_triangle_get_cell_type(vtkBiQuadraticTriangle* sself); +extern "C" int vtk_bi_quadratic_triangle_get_cell_dimension(vtkBiQuadraticTriangle* sself); +extern "C" int vtk_bi_quadratic_triangle_get_number_of_edges(vtkBiQuadraticTriangle* sself); +extern "C" int vtk_bi_quadratic_triangle_get_number_of_faces(vtkBiQuadraticTriangle* sself); +extern "C" vtkBox * vtkBox_new () ; +extern "C" void vtkBox_destructor (vtkBox * sself) ; +extern "C" void * vtkBox_get_ptr (vtkBox * sself) ; +extern "C" void vtk_box_set_x_min(vtkBox* sself, double x, double y, double z); +extern "C" void vtk_box_get_x_min(vtkBox* sself, double& x, double& y, double& z); +extern "C" void vtk_box_set_x_max(vtkBox* sself, double x, double y, double z); +extern "C" void vtk_box_get_x_max(vtkBox* sself, double& x, double& y, double& z); +extern "C" void vtk_box_set_bounds(vtkBox* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" void vtk_box_get_bounds(vtkBox* sself, double& xMin, double& xMax, double& yMin, double& yMax, double& zMin, double& zMax); +extern "C" vtkCellArray * vtkCellArray_new () ; +extern "C" void vtkCellArray_destructor (vtkCellArray * sself) ; +extern "C" void * vtkCellArray_get_ptr (vtkCellArray * sself) ; +extern "C" int vtk_cell_array_allocate(vtkCellArray* sself, long long sz, long long ext); +extern "C" bool vtk_cell_array_allocate_estimate(vtkCellArray* sself, long long numCells, long long maxCellSize); +extern "C" bool vtk_cell_array_allocate_exact(vtkCellArray* sself, long long numCells, long long connectivitySize); +extern "C" bool vtk_cell_array_resize_exact(vtkCellArray* sself, long long numCells, long long connectivitySize); +extern "C" void vtk_cell_array_initialize(vtkCellArray* sself); +extern "C" void vtk_cell_array_reset(vtkCellArray* sself); +extern "C" void vtk_cell_array_squeeze(vtkCellArray* sself); +extern "C" bool vtk_cell_array_is_valid(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_number_of_cells(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_number_of_offsets(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_number_of_connectivity_ids(vtkCellArray* sself); +extern "C" bool vtk_cell_array_is_storage_64_bit(vtkCellArray* sself); +extern "C" bool vtk_cell_array_is_storage_shareable(vtkCellArray* sself); +extern "C" void vtk_cell_array_use_32_bit_storage(vtkCellArray* sself); +extern "C" void vtk_cell_array_use_64_bit_storage(vtkCellArray* sself); +extern "C" void vtk_cell_array_use_default_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_can_convert_to_32_bit_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_can_convert_to_64_bit_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_can_convert_to_default_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_convert_to_32_bit_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_convert_to_64_bit_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_convert_to_default_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_convert_to_smallest_storage(vtkCellArray* sself); +extern "C" long long vtk_cell_array_is_homogeneous(vtkCellArray* sself); +extern "C" void vtk_cell_array_init_traversal(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_cell_size(vtkCellArray* sself, const long long cellId); +extern "C" void vtk_cell_array_insert_cell_point(vtkCellArray* sself, long long id); +extern "C" void vtk_cell_array_update_cell_count(vtkCellArray* sself, int npts); +extern "C" long long vtk_cell_array_get_traversal_cell_id(vtkCellArray* sself); +extern "C" void vtk_cell_array_set_traversal_cell_id(vtkCellArray* sself, long long cellId); +extern "C" void vtk_cell_array_reverse_cell_at_id(vtkCellArray* sself, long long cellId); +extern "C" int vtk_cell_array_get_max_cell_size(vtkCellArray* sself); +extern "C" unsigned long vtk_cell_array_get_actual_memory_size(vtkCellArray* sself); +extern "C" void vtk_cell_array_set_number_of_cells(vtkCellArray* sself, long long p0); +extern "C" long long vtk_cell_array_estimate_size(vtkCellArray* sself, long long numCells, int maxPtsPerCell); +extern "C" long long vtk_cell_array_get_size(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_number_of_connectivity_entries(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_insert_location(vtkCellArray* sself, int npts); +extern "C" long long vtk_cell_array_get_traversal_location(vtkCellArray* sself); +extern "C" void vtk_cell_array_set_traversal_location(vtkCellArray* sself, long long loc); +extern "C" void vtk_cell_array_reverse_cell(vtkCellArray* sself, long long loc); +extern "C" vtkCellArrayIterator * vtkCellArrayIterator_new () ; +extern "C" void vtkCellArrayIterator_destructor (vtkCellArrayIterator * sself) ; +extern "C" void * vtkCellArrayIterator_get_ptr (vtkCellArrayIterator * sself) ; +extern "C" void vtk_cell_array_iterator_go_to_cell(vtkCellArrayIterator* sself, long long cellId); +extern "C" void vtk_cell_array_iterator_go_to_first_cell(vtkCellArrayIterator* sself); +extern "C" void vtk_cell_array_iterator_go_to_next_cell(vtkCellArrayIterator* sself); +extern "C" bool vtk_cell_array_iterator_is_done_with_traversal(vtkCellArrayIterator* sself); +extern "C" long long vtk_cell_array_iterator_get_current_cell_id(vtkCellArrayIterator* sself); +extern "C" void vtk_cell_array_iterator_reverse_current_cell(vtkCellArrayIterator* sself); +extern "C" vtkCellData * vtkCellData_new () ; +extern "C" void vtkCellData_destructor (vtkCellData * sself) ; +extern "C" void * vtkCellData_get_ptr (vtkCellData * sself) ; +extern "C" vtkCellLinks * vtkCellLinks_new () ; +extern "C" void vtkCellLinks_destructor (vtkCellLinks * sself) ; +extern "C" void * vtkCellLinks_get_ptr (vtkCellLinks * sself) ; +extern "C" void vtk_cell_links_allocate(vtkCellLinks* sself, long long numLinks, long long ext); +extern "C" void vtk_cell_links_initialize(vtkCellLinks* sself); +extern "C" long long vtk_cell_links_get_ncells(vtkCellLinks* sself, long long ptId); +extern "C" long long vtk_cell_links_insert_next_point(vtkCellLinks* sself, int numLinks); +extern "C" void vtk_cell_links_insert_next_cell_reference(vtkCellLinks* sself, long long ptId, long long cellId); +extern "C" void vtk_cell_links_delete_point(vtkCellLinks* sself, long long ptId); +extern "C" void vtk_cell_links_remove_cell_reference(vtkCellLinks* sself, long long cellId, long long ptId); +extern "C" void vtk_cell_links_add_cell_reference(vtkCellLinks* sself, long long cellId, long long ptId); +extern "C" void vtk_cell_links_resize_cell_list(vtkCellLinks* sself, long long ptId, int size); +extern "C" void vtk_cell_links_squeeze(vtkCellLinks* sself); +extern "C" void vtk_cell_links_reset(vtkCellLinks* sself); +extern "C" unsigned long vtk_cell_links_get_actual_memory_size(vtkCellLinks* sself); +extern "C" vtkCellLocator * vtkCellLocator_new () ; +extern "C" void vtkCellLocator_destructor (vtkCellLocator * sself) ; +extern "C" void * vtkCellLocator_get_ptr (vtkCellLocator * sself) ; +extern "C" void vtk_cell_locator_set_number_of_cells_per_bucket(vtkCellLocator* sself, int N); +extern "C" int vtk_cell_locator_get_number_of_cells_per_bucket(vtkCellLocator* sself); +extern "C" int vtk_cell_locator_get_number_of_buckets(vtkCellLocator* sself); +extern "C" void vtk_cell_locator_free_search_structure(vtkCellLocator* sself); +extern "C" void vtk_cell_locator_build_locator(vtkCellLocator* sself); +extern "C" void vtk_cell_locator_build_locator_if_needed(vtkCellLocator* sself); +extern "C" void vtk_cell_locator_force_build_locator(vtkCellLocator* sself); +extern "C" void vtk_cell_locator_build_locator_internal(vtkCellLocator* sself); +extern "C" vtkCellLocatorStrategy * vtkCellLocatorStrategy_new () ; +extern "C" void vtkCellLocatorStrategy_destructor (vtkCellLocatorStrategy * sself) ; +extern "C" void * vtkCellLocatorStrategy_get_ptr (vtkCellLocatorStrategy * sself) ; +extern "C" vtkCellTypes * vtkCellTypes_new () ; +extern "C" void vtkCellTypes_destructor (vtkCellTypes * sself) ; +extern "C" void * vtkCellTypes_get_ptr (vtkCellTypes * sself) ; +extern "C" int vtk_cell_types_allocate(vtkCellTypes* sself, long long sz, long long ext); +extern "C" void vtk_cell_types_insert_cell(vtkCellTypes* sself, long long id, unsigned char type, long long loc); +extern "C" long long vtk_cell_types_insert_next_cell(vtkCellTypes* sself, unsigned char type, long long loc); +extern "C" long long vtk_cell_types_get_cell_location(vtkCellTypes* sself, long long cellId); +extern "C" void vtk_cell_types_delete_cell(vtkCellTypes* sself, long long cellId); +extern "C" long long vtk_cell_types_get_number_of_types(vtkCellTypes* sself); +extern "C" int vtk_cell_types_is_type(vtkCellTypes* sself, unsigned char type); +extern "C" long long vtk_cell_types_insert_next_type(vtkCellTypes* sself, unsigned char type); +extern "C" unsigned char vtk_cell_types_get_cell_type(vtkCellTypes* sself, long long cellId); +extern "C" void vtk_cell_types_squeeze(vtkCellTypes* sself); +extern "C" void vtk_cell_types_reset(vtkCellTypes* sself); +extern "C" unsigned long vtk_cell_types_get_actual_memory_size(vtkCellTypes* sself); +extern "C" const char* vtk_cell_types_get_class_name_from_type_id(vtkCellTypes* sself, int typeId); +extern "C" int vtk_cell_types_get_type_id_from_class_name(vtkCellTypes* sself, const char* classname); +extern "C" int vtk_cell_types_is_linear(vtkCellTypes* sself, unsigned char type); +extern "C" vtkClosestNPointsStrategy * vtkClosestNPointsStrategy_new () ; +extern "C" void vtkClosestNPointsStrategy_destructor (vtkClosestNPointsStrategy * sself) ; +extern "C" void * vtkClosestNPointsStrategy_get_ptr (vtkClosestNPointsStrategy * sself) ; +extern "C" void vtk_closest_n_points_strategy_set_closest_n_points(vtkClosestNPointsStrategy* sself, int _arg); +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_min_value(vtkClosestNPointsStrategy* sself); +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_max_value(vtkClosestNPointsStrategy* sself); +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points(vtkClosestNPointsStrategy* sself); +extern "C" vtkClosestPointStrategy * vtkClosestPointStrategy_new () ; +extern "C" void vtkClosestPointStrategy_destructor (vtkClosestPointStrategy * sself) ; +extern "C" void * vtkClosestPointStrategy_get_ptr (vtkClosestPointStrategy * sself) ; +extern "C" vtkCone * vtkCone_new () ; +extern "C" void vtkCone_destructor (vtkCone * sself) ; +extern "C" void * vtkCone_get_ptr (vtkCone * sself) ; +extern "C" void vtk_cone_set_angle(vtkCone* sself, double _arg); +extern "C" double vtk_cone_get_angle_min_value(vtkCone* sself); +extern "C" double vtk_cone_get_angle_max_value(vtkCone* sself); +extern "C" double vtk_cone_get_angle(vtkCone* sself); +extern "C" vtkConvexPointSet * vtkConvexPointSet_new () ; +extern "C" void vtkConvexPointSet_destructor (vtkConvexPointSet * sself) ; +extern "C" void * vtkConvexPointSet_get_ptr (vtkConvexPointSet * sself) ; +extern "C" int vtk_convex_point_set_has_fixed_topology(vtkConvexPointSet* sself); +extern "C" int vtk_convex_point_set_get_cell_type(vtkConvexPointSet* sself); +extern "C" int vtk_convex_point_set_requires_initialization(vtkConvexPointSet* sself); +extern "C" int vtk_convex_point_set_get_number_of_edges(vtkConvexPointSet* sself); +extern "C" int vtk_convex_point_set_get_number_of_faces(vtkConvexPointSet* sself); +extern "C" int vtk_convex_point_set_is_primary_cell(vtkConvexPointSet* sself); +extern "C" vtkCubicLine * vtkCubicLine_new () ; +extern "C" void vtkCubicLine_destructor (vtkCubicLine * sself) ; +extern "C" void * vtkCubicLine_get_ptr (vtkCubicLine * sself) ; +extern "C" int vtk_cubic_line_get_cell_type(vtkCubicLine* sself); +extern "C" int vtk_cubic_line_get_cell_dimension(vtkCubicLine* sself); +extern "C" int vtk_cubic_line_get_number_of_edges(vtkCubicLine* sself); +extern "C" int vtk_cubic_line_get_number_of_faces(vtkCubicLine* sself); +extern "C" vtkCylinder * vtkCylinder_new () ; +extern "C" void vtkCylinder_destructor (vtkCylinder * sself) ; +extern "C" void * vtkCylinder_get_ptr (vtkCylinder * sself) ; +extern "C" void vtk_cylinder_set_radius(vtkCylinder* sself, double _arg); +extern "C" double vtk_cylinder_get_radius(vtkCylinder* sself); +extern "C" void vtk_cylinder_set_center(vtkCylinder* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cylinder_set_axis(vtkCylinder* sself, double ax, double ay, double az); +extern "C" vtkDataAssembly * vtkDataAssembly_new () ; +extern "C" void vtkDataAssembly_destructor (vtkDataAssembly * sself) ; +extern "C" void * vtkDataAssembly_get_ptr (vtkDataAssembly * sself) ; +extern "C" void vtk_data_assembly_initialize(vtkDataAssembly* sself); +extern "C" bool vtk_data_assembly_initialize_from_xml(vtkDataAssembly* sself, const char* xmlcontents); +extern "C" int vtk_data_assembly_get_root_node(vtkDataAssembly* sself); +extern "C" void vtk_data_assembly_set_root_node_name(vtkDataAssembly* sself, const char* name); +extern "C" const char* vtk_data_assembly_get_root_node_name(vtkDataAssembly* sself); +extern "C" int vtk_data_assembly_add_node(vtkDataAssembly* sself, const char* name, int parent); +extern "C" bool vtk_data_assembly_remove_node(vtkDataAssembly* sself, int id); +extern "C" void vtk_data_assembly_set_node_name(vtkDataAssembly* sself, int id, const char* name); +extern "C" const char* vtk_data_assembly_get_node_name(vtkDataAssembly* sself, int id); +extern "C" int vtk_data_assembly_get_first_node_by_path(vtkDataAssembly* sself, const char* path); +extern "C" bool vtk_data_assembly_add_data_set_index(vtkDataAssembly* sself, int id, unsigned int dataset_index); +extern "C" bool vtk_data_assembly_add_data_set_index_range(vtkDataAssembly* sself, int id, unsigned int index_start, int count); +extern "C" bool vtk_data_assembly_remove_data_set_index(vtkDataAssembly* sself, int id, unsigned int dataset_index); +extern "C" bool vtk_data_assembly_remove_all_data_set_indices(vtkDataAssembly* sself, int id, bool traverse_subtree); +extern "C" int vtk_data_assembly_find_first_node_with_name(vtkDataAssembly* sself, const char* name, int traversal_order); +extern "C" int vtk_data_assembly_get_number_of_children(vtkDataAssembly* sself, int parent); +extern "C" int vtk_data_assembly_get_child(vtkDataAssembly* sself, int parent, int index); +extern "C" int vtk_data_assembly_get_child_index(vtkDataAssembly* sself, int parent, int child); +extern "C" int vtk_data_assembly_get_parent(vtkDataAssembly* sself, int id); +extern "C" bool vtk_data_assembly_has_attribute(vtkDataAssembly* sself, int id, const char* name); +extern "C" void vtk_data_assembly_set_attribute(vtkDataAssembly* sself, int id, const char* name, const char* value); +extern "C" bool vtk_data_assembly_get_attribute(vtkDataAssembly* sself, int id, const char* name, const char* value); +extern "C" const char* vtk_data_assembly_get_attribute_or_default(vtkDataAssembly* sself, int id, const char* name, const char* default_value); +extern "C" bool vtk_data_assembly_is_node_name_valid(vtkDataAssembly* sself, const char* name); +extern "C" bool vtk_data_assembly_is_node_name_reserved(vtkDataAssembly* sself, const char* name); +extern "C" vtkDataAssemblyUtilities * vtkDataAssemblyUtilities_new () ; +extern "C" void vtkDataAssemblyUtilities_destructor (vtkDataAssemblyUtilities * sself) ; +extern "C" void * vtkDataAssemblyUtilities_get_ptr (vtkDataAssemblyUtilities * sself) ; +extern "C" const char* vtk_data_assembly_utilities_hierarchy_name(vtkDataAssemblyUtilities* sself); +extern "C" vtkDataObject * vtkDataObject_new () ; +extern "C" void vtkDataObject_destructor (vtkDataObject * sself) ; +extern "C" void * vtkDataObject_get_ptr (vtkDataObject * sself) ; +extern "C" unsigned long vtk_data_object_get_m_time(vtkDataObject* sself); +extern "C" void vtk_data_object_initialize(vtkDataObject* sself); +extern "C" void vtk_data_object_release_data(vtkDataObject* sself); +extern "C" int vtk_data_object_get_data_released(vtkDataObject* sself); +extern "C" void vtk_data_object_set_global_release_data_flag(vtkDataObject* sself, int val); +extern "C" void vtk_data_object_global_release_data_flag_on(vtkDataObject* sself); +extern "C" void vtk_data_object_global_release_data_flag_off(vtkDataObject* sself); +extern "C" int vtk_data_object_get_global_release_data_flag(vtkDataObject* sself); +extern "C" int vtk_data_object_get_data_object_type(vtkDataObject* sself); +extern "C" unsigned long vtk_data_object_get_update_time(vtkDataObject* sself); +extern "C" unsigned long vtk_data_object_get_actual_memory_size(vtkDataObject* sself); +extern "C" void vtk_data_object_data_has_been_generated(vtkDataObject* sself); +extern "C" void vtk_data_object_prepare_for_new_data(vtkDataObject* sself); +extern "C" int vtk_data_object_get_extent_type(vtkDataObject* sself); +extern "C" long long vtk_data_object_get_number_of_elements(vtkDataObject* sself, int type); +extern "C" const char* vtk_data_object_get_association_type_as_string(vtkDataObject* sself, int associationType); +extern "C" int vtk_data_object_get_association_type_from_string(vtkDataObject* sself, const char* associationName); +extern "C" vtkDataObjectCollection * vtkDataObjectCollection_new () ; +extern "C" void vtkDataObjectCollection_destructor (vtkDataObjectCollection * sself) ; +extern "C" void * vtkDataObjectCollection_get_ptr (vtkDataObjectCollection * sself) ; +extern "C" int vtk_data_object_collection_get_number_of_items(vtkDataObjectCollection* sself); +extern "C" vtkDataObjectTreeIterator * vtkDataObjectTreeIterator_new () ; +extern "C" void vtkDataObjectTreeIterator_destructor (vtkDataObjectTreeIterator * sself) ; +extern "C" void * vtkDataObjectTreeIterator_get_ptr (vtkDataObjectTreeIterator * sself) ; +extern "C" void vtk_data_object_tree_iterator_go_to_first_item(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_go_to_next_item(vtkDataObjectTreeIterator* sself); +extern "C" int vtk_data_object_tree_iterator_is_done_with_traversal(vtkDataObjectTreeIterator* sself); +extern "C" int vtk_data_object_tree_iterator_has_current_meta_data(vtkDataObjectTreeIterator* sself); +extern "C" unsigned int vtk_data_object_tree_iterator_get_current_flat_index(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_set_visit_only_leaves(vtkDataObjectTreeIterator* sself, int _arg); +extern "C" int vtk_data_object_tree_iterator_get_visit_only_leaves(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_on(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_off(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_set_traverse_sub_tree(vtkDataObjectTreeIterator* sself, int _arg); +extern "C" int vtk_data_object_tree_iterator_get_traverse_sub_tree(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_on(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_off(vtkDataObjectTreeIterator* sself); +extern "C" vtkDataObjectTypes * vtkDataObjectTypes_new () ; +extern "C" void vtkDataObjectTypes_destructor (vtkDataObjectTypes * sself) ; +extern "C" void * vtkDataObjectTypes_get_ptr (vtkDataObjectTypes * sself) ; +extern "C" const char* vtk_data_object_types_get_class_name_from_type_id(vtkDataObjectTypes* sself, int typeId); +extern "C" int vtk_data_object_types_get_type_id_from_class_name(vtkDataObjectTypes* sself, const char* classname); +extern "C" bool vtk_data_object_types_type_id_is_a(vtkDataObjectTypes* sself, int typeId, int targetTypeId); +extern "C" int vtk_data_object_types_get_common_base_type_id(vtkDataObjectTypes* sself, int typeA, int typeB); +extern "C" vtkDataSetAttributes * vtkDataSetAttributes_new () ; +extern "C" void vtkDataSetAttributes_destructor (vtkDataSetAttributes * sself) ; +extern "C" void * vtkDataSetAttributes_get_ptr (vtkDataSetAttributes * sself) ; +extern "C" void vtk_data_set_attributes_initialize(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_update(vtkDataSetAttributes* sself); +extern "C" const char* vtk_data_set_attributes_ghost_array_name(vtkDataSetAttributes* sself); +extern "C" int vtk_data_set_attributes_set_active_scalars(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_vectors(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_normals(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_tangents(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_t_coords(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_tensors(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_global_ids(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_pedigree_ids(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_rational_weights(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_higher_order_degrees(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_attribute(vtkDataSetAttributes* sself, const char* name, int attributeType); +extern "C" int vtk_data_set_attributes_is_array_an_attribute(vtkDataSetAttributes* sself, int idx); +extern "C" const char* vtk_data_set_attributes_get_attribute_type_as_string(vtkDataSetAttributes* sself, int attributeType); +extern "C" const char* vtk_data_set_attributes_get_long_attribute_type_as_string(vtkDataSetAttributes* sself, int attributeType); +extern "C" void vtk_data_set_attributes_set_copy_attribute(vtkDataSetAttributes* sself, int index, int value, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_attribute(vtkDataSetAttributes* sself, int index, int ctype); +extern "C" void vtk_data_set_attributes_set_copy_scalars(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_scalars(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_scalars_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_scalars_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_vectors(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_vectors(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_vectors_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_vectors_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_normals(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_normals(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_normals_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_normals_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_tangents(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_tangents(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_tangents_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_tangents_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_t_coords(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_t_coords(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_t_coords_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_t_coords_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_tensors(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_tensors(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_tensors_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_tensors_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_global_ids(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_global_ids(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_global_ids_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_global_ids_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_pedigree_ids(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_pedigree_ids(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_rational_weights(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_rational_weights(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_rational_weights_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_rational_weights_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_higher_order_degrees(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_higher_order_degrees(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_all_on(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_all_off(vtkDataSetAttributes* sself, int ctype); +extern "C" vtkDataSetCellIterator * vtkDataSetCellIterator_new () ; +extern "C" void vtkDataSetCellIterator_destructor (vtkDataSetCellIterator * sself) ; +extern "C" void * vtkDataSetCellIterator_get_ptr (vtkDataSetCellIterator * sself) ; +extern "C" bool vtk_data_set_cell_iterator_is_done_with_traversal(vtkDataSetCellIterator* sself); +extern "C" long long vtk_data_set_cell_iterator_get_cell_id(vtkDataSetCellIterator* sself); +extern "C" vtkDataSetCollection * vtkDataSetCollection_new () ; +extern "C" void vtkDataSetCollection_destructor (vtkDataSetCollection * sself) ; +extern "C" void * vtkDataSetCollection_get_ptr (vtkDataSetCollection * sself) ; +extern "C" int vtk_data_set_collection_get_number_of_items(vtkDataSetCollection* sself); +extern "C" vtkDirectedAcyclicGraph * vtkDirectedAcyclicGraph_new () ; +extern "C" void vtkDirectedAcyclicGraph_destructor (vtkDirectedAcyclicGraph * sself) ; +extern "C" void * vtkDirectedAcyclicGraph_get_ptr (vtkDirectedAcyclicGraph * sself) ; +extern "C" vtkDirectedGraph * vtkDirectedGraph_new () ; +extern "C" void vtkDirectedGraph_destructor (vtkDirectedGraph * sself) ; +extern "C" void * vtkDirectedGraph_get_ptr (vtkDirectedGraph * sself) ; +extern "C" vtkEdgeListIterator * vtkEdgeListIterator_new () ; +extern "C" void vtkEdgeListIterator_destructor (vtkEdgeListIterator * sself) ; +extern "C" void * vtkEdgeListIterator_get_ptr (vtkEdgeListIterator * sself) ; +extern "C" bool vtk_edge_list_iterator_has_next(vtkEdgeListIterator* sself); +extern "C" vtkEdgeTable * vtkEdgeTable_new () ; +extern "C" void vtkEdgeTable_destructor (vtkEdgeTable * sself) ; +extern "C" void * vtkEdgeTable_get_ptr (vtkEdgeTable * sself) ; +extern "C" void vtk_edge_table_initialize(vtkEdgeTable* sself); +extern "C" int vtk_edge_table_init_edge_insertion(vtkEdgeTable* sself, long long numPoints, int storeAttributes); +extern "C" long long vtk_edge_table_insert_edge(vtkEdgeTable* sself, long long p1, long long p2); +extern "C" long long vtk_edge_table_is_edge(vtkEdgeTable* sself, long long p1, long long p2); +extern "C" long long vtk_edge_table_get_number_of_edges(vtkEdgeTable* sself); +extern "C" void vtk_edge_table_init_traversal(vtkEdgeTable* sself); +extern "C" long long vtk_edge_table_get_next_edge(vtkEdgeTable* sself, long long& p1, long long& p2); +extern "C" void vtk_edge_table_reset(vtkEdgeTable* sself); +extern "C" vtkEmptyCell * vtkEmptyCell_new () ; +extern "C" void vtkEmptyCell_destructor (vtkEmptyCell * sself) ; +extern "C" void * vtkEmptyCell_get_ptr (vtkEmptyCell * sself) ; +extern "C" int vtk_empty_cell_get_cell_type(vtkEmptyCell* sself); +extern "C" int vtk_empty_cell_get_cell_dimension(vtkEmptyCell* sself); +extern "C" int vtk_empty_cell_get_number_of_edges(vtkEmptyCell* sself); +extern "C" int vtk_empty_cell_get_number_of_faces(vtkEmptyCell* sself); +extern "C" vtkExplicitStructuredGrid * vtkExplicitStructuredGrid_new () ; +extern "C" void vtkExplicitStructuredGrid_destructor (vtkExplicitStructuredGrid * sself) ; +extern "C" void * vtkExplicitStructuredGrid_get_ptr (vtkExplicitStructuredGrid * sself) ; +extern "C" int vtk_explicit_structured_grid_get_data_object_type(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_initialize(vtkExplicitStructuredGrid* sself); +extern "C" int vtk_explicit_structured_grid_get_cell_type(vtkExplicitStructuredGrid* sself, long long cellId); +extern "C" int vtk_explicit_structured_grid_get_data_dimension(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkExplicitStructuredGrid* sself, int i, int j, int k); +extern "C" int vtk_explicit_structured_grid_get_extent_type(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_set_extent(vtkExplicitStructuredGrid* sself, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" void vtk_explicit_structured_grid_build_links(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_compute_cell_structured_coords(vtkExplicitStructuredGrid* sself, long long cellId, int& i, int& j, int& k, bool adjustForExtent); +extern "C" long long vtk_explicit_structured_grid_compute_cell_id(vtkExplicitStructuredGrid* sself, int i, int j, int k, bool adjustForExtent); +extern "C" void vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name(vtkExplicitStructuredGrid* sself, const char* _arg); +extern "C" void vtk_explicit_structured_grid_blank_cell(vtkExplicitStructuredGrid* sself, long long cellId); +extern "C" void vtk_explicit_structured_grid_un_blank_cell(vtkExplicitStructuredGrid* sself, long long cellId); +extern "C" bool vtk_explicit_structured_grid_has_any_blank_cells(vtkExplicitStructuredGrid* sself); +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_visible(vtkExplicitStructuredGrid* sself, long long cellId); +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_ghost(vtkExplicitStructuredGrid* sself, long long cellId); +extern "C" bool vtk_explicit_structured_grid_has_any_ghost_cells(vtkExplicitStructuredGrid* sself); +extern "C" unsigned long vtk_explicit_structured_grid_get_actual_memory_size(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_check_and_reorder_faces(vtkExplicitStructuredGrid* sself); +extern "C" vtkExtractStructuredGridHelper * vtkExtractStructuredGridHelper_new () ; +extern "C" void vtkExtractStructuredGridHelper_destructor (vtkExtractStructuredGridHelper * sself) ; +extern "C" void * vtkExtractStructuredGridHelper_get_ptr (vtkExtractStructuredGridHelper * sself) ; +extern "C" bool vtk_extract_structured_grid_helper_is_valid(vtkExtractStructuredGridHelper* sself); +extern "C" int vtk_extract_structured_grid_helper_get_size(vtkExtractStructuredGridHelper* sself, const int dim); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value(vtkExtractStructuredGridHelper* sself, int dim, int outExtVal); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value(vtkExtractStructuredGridHelper* sself, int dim, int outExtVal); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx); +extern "C" vtkFieldData * vtkFieldData_new () ; +extern "C" void vtkFieldData_destructor (vtkFieldData * sself) ; +extern "C" void * vtkFieldData_get_ptr (vtkFieldData * sself) ; +extern "C" void vtk_field_data_initialize(vtkFieldData* sself); +extern "C" int vtk_field_data_allocate(vtkFieldData* sself, long long sz, long long ext); +extern "C" void vtk_field_data_allocate_arrays(vtkFieldData* sself, int num); +extern "C" int vtk_field_data_get_number_of_arrays(vtkFieldData* sself); +extern "C" void vtk_field_data_null_data(vtkFieldData* sself, long long id); +extern "C" void vtk_field_data_remove_array(vtkFieldData* sself, const char* name); +extern "C" int vtk_field_data_has_array(vtkFieldData* sself, const char* name); +extern "C" const char* vtk_field_data_get_array_name(vtkFieldData* sself, int i); +extern "C" void vtk_field_data_copy_field_on(vtkFieldData* sself, const char* name); +extern "C" void vtk_field_data_copy_field_off(vtkFieldData* sself, const char* name); +extern "C" void vtk_field_data_copy_all_on(vtkFieldData* sself, int unused); +extern "C" void vtk_field_data_copy_all_off(vtkFieldData* sself, int unused); +extern "C" void vtk_field_data_squeeze(vtkFieldData* sself); +extern "C" void vtk_field_data_reset(vtkFieldData* sself); +extern "C" unsigned long vtk_field_data_get_actual_memory_size(vtkFieldData* sself); +extern "C" unsigned long vtk_field_data_get_m_time(vtkFieldData* sself); +extern "C" int vtk_field_data_get_array_containing_component(vtkFieldData* sself, int i, int& arrayComp); +extern "C" int vtk_field_data_get_number_of_components(vtkFieldData* sself); +extern "C" long long vtk_field_data_get_number_of_tuples(vtkFieldData* sself); +extern "C" void vtk_field_data_set_number_of_tuples(vtkFieldData* sself, const long long number); +extern "C" vtkGenericAttributeCollection * vtkGenericAttributeCollection_new () ; +extern "C" void vtkGenericAttributeCollection_destructor (vtkGenericAttributeCollection * sself) ; +extern "C" void * vtkGenericAttributeCollection_get_ptr (vtkGenericAttributeCollection * sself) ; +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_get_number_of_components(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_get_number_of_point_centered_components(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_get_max_number_of_components(vtkGenericAttributeCollection* sself); +extern "C" unsigned long vtk_generic_attribute_collection_get_actual_memory_size(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_is_empty(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_find_attribute(vtkGenericAttributeCollection* sself, const char* name); +extern "C" int vtk_generic_attribute_collection_get_attribute_index(vtkGenericAttributeCollection* sself, int i); +extern "C" void vtk_generic_attribute_collection_remove_attribute(vtkGenericAttributeCollection* sself, int i); +extern "C" void vtk_generic_attribute_collection_reset(vtkGenericAttributeCollection* sself); +extern "C" unsigned long vtk_generic_attribute_collection_get_m_time(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_get_active_attribute(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_get_active_component(vtkGenericAttributeCollection* sself); +extern "C" void vtk_generic_attribute_collection_set_active_attribute(vtkGenericAttributeCollection* sself, int attribute, int component); +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate(vtkGenericAttributeCollection* sself); +extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(vtkGenericAttributeCollection* sself); +extern "C" vtkGenericCell * vtkGenericCell_new () ; +extern "C" void vtkGenericCell_destructor (vtkGenericCell * sself) ; +extern "C" void * vtkGenericCell_get_ptr (vtkGenericCell * sself) ; +extern "C" int vtk_generic_cell_get_cell_type(vtkGenericCell* sself); +extern "C" int vtk_generic_cell_get_cell_dimension(vtkGenericCell* sself); +extern "C" int vtk_generic_cell_get_number_of_edges(vtkGenericCell* sself); +extern "C" int vtk_generic_cell_get_number_of_faces(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type(vtkGenericCell* sself, int cellType); +extern "C" void vtk_generic_cell_set_cell_type_to_empty_cell(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_vertex(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_poly_vertex(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_line(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_poly_line(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_triangle(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_triangle_strip(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_polygon(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_pixel(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quad(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_tetra(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_voxel(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_wedge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_pyramid(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_pentagonal_prism(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_hexagonal_prism(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_polyhedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_convex_point_set(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_edge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_cubic_line(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_triangle(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_quad(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_polygon(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_tetra(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_wedge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_pyramid(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_quad(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quad(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_triangle(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_tetra(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_curve(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_wedge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_triangle(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_tetra(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_curve(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_quadrilateral(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_wedge(vtkGenericCell* sself); +extern "C" vtkGenericEdgeTable * vtkGenericEdgeTable_new () ; +extern "C" void vtkGenericEdgeTable_destructor (vtkGenericEdgeTable * sself) ; +extern "C" void * vtkGenericEdgeTable_get_ptr (vtkGenericEdgeTable * sself) ; +extern "C" void vtk_generic_edge_table_insert_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long cellId, int ref, long long& ptId); +extern "C" int vtk_generic_edge_table_remove_edge(vtkGenericEdgeTable* sself, long long e1, long long e2); +extern "C" int vtk_generic_edge_table_check_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long& ptId); +extern "C" int vtk_generic_edge_table_increment_edge_reference_count(vtkGenericEdgeTable* sself, long long e1, long long e2, long long cellId); +extern "C" int vtk_generic_edge_table_check_edge_reference_count(vtkGenericEdgeTable* sself, long long e1, long long e2); +extern "C" void vtk_generic_edge_table_initialize(vtkGenericEdgeTable* sself, long long start); +extern "C" int vtk_generic_edge_table_get_number_of_components(vtkGenericEdgeTable* sself); +extern "C" void vtk_generic_edge_table_set_number_of_components(vtkGenericEdgeTable* sself, int count); +extern "C" int vtk_generic_edge_table_check_point(vtkGenericEdgeTable* sself, long long ptId); +extern "C" void vtk_generic_edge_table_remove_point(vtkGenericEdgeTable* sself, long long ptId); +extern "C" void vtk_generic_edge_table_increment_point_reference_count(vtkGenericEdgeTable* sself, long long ptId); +extern "C" void vtk_generic_edge_table_dump_table(vtkGenericEdgeTable* sself); +extern "C" void vtk_generic_edge_table_load_factor(vtkGenericEdgeTable* sself); +extern "C" vtkGenericInterpolatedVelocityField * vtkGenericInterpolatedVelocityField_new () ; +extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkGenericInterpolatedVelocityField * sself) ; +extern "C" void * vtkGenericInterpolatedVelocityField_get_ptr (vtkGenericInterpolatedVelocityField * sself) ; +extern "C" void vtk_generic_interpolated_velocity_field_clear_last_cell(vtkGenericInterpolatedVelocityField* sself); +extern "C" int vtk_generic_interpolated_velocity_field_get_caching(vtkGenericInterpolatedVelocityField* sself); +extern "C" void vtk_generic_interpolated_velocity_field_set_caching(vtkGenericInterpolatedVelocityField* sself, int _arg); +extern "C" void vtk_generic_interpolated_velocity_field_caching_on(vtkGenericInterpolatedVelocityField* sself); +extern "C" void vtk_generic_interpolated_velocity_field_caching_off(vtkGenericInterpolatedVelocityField* sself); +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_hit(vtkGenericInterpolatedVelocityField* sself); +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_miss(vtkGenericInterpolatedVelocityField* sself); +extern "C" void vtk_generic_interpolated_velocity_field_select_vectors(vtkGenericInterpolatedVelocityField* sself, const char* fieldName); +extern "C" vtkGeometricErrorMetric * vtkGeometricErrorMetric_new () ; +extern "C" void vtkGeometricErrorMetric_destructor (vtkGeometricErrorMetric * sself) ; +extern "C" void * vtkGeometricErrorMetric_get_ptr (vtkGeometricErrorMetric * sself) ; +extern "C" double vtk_geometric_error_metric_get_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself); +extern "C" void vtk_geometric_error_metric_set_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself, double value); +extern "C" int vtk_geometric_error_metric_get_relative(vtkGeometricErrorMetric* sself); +extern "C" vtkGraphEdge * vtkGraphEdge_new () ; +extern "C" void vtkGraphEdge_destructor (vtkGraphEdge * sself) ; +extern "C" void * vtkGraphEdge_get_ptr (vtkGraphEdge * sself) ; +extern "C" void vtk_graph_edge_set_source(vtkGraphEdge* sself, long long _arg); +extern "C" long long vtk_graph_edge_get_source(vtkGraphEdge* sself); +extern "C" void vtk_graph_edge_set_target(vtkGraphEdge* sself, long long _arg); +extern "C" long long vtk_graph_edge_get_target(vtkGraphEdge* sself); +extern "C" void vtk_graph_edge_set_id(vtkGraphEdge* sself, long long _arg); +extern "C" long long vtk_graph_edge_get_id(vtkGraphEdge* sself); +extern "C" vtkGraphInternals * vtkGraphInternals_new () ; +extern "C" void vtkGraphInternals_destructor (vtkGraphInternals * sself) ; +extern "C" void * vtkGraphInternals_get_ptr (vtkGraphInternals * sself) ; +extern "C" vtkHexagonalPrism * vtkHexagonalPrism_new () ; +extern "C" void vtkHexagonalPrism_destructor (vtkHexagonalPrism * sself) ; +extern "C" void * vtkHexagonalPrism_get_ptr (vtkHexagonalPrism * sself) ; +extern "C" int vtk_hexagonal_prism_get_cell_type(vtkHexagonalPrism* sself); +extern "C" int vtk_hexagonal_prism_get_number_of_edges(vtkHexagonalPrism* sself); +extern "C" int vtk_hexagonal_prism_get_number_of_faces(vtkHexagonalPrism* sself); +extern "C" vtkHexahedron * vtkHexahedron_new () ; +extern "C" void vtkHexahedron_destructor (vtkHexahedron * sself) ; +extern "C" void * vtkHexahedron_get_ptr (vtkHexahedron * sself) ; +extern "C" int vtk_hexahedron_get_cell_type(vtkHexahedron* sself); +extern "C" int vtk_hexahedron_get_number_of_edges(vtkHexahedron* sself); +extern "C" int vtk_hexahedron_get_number_of_faces(vtkHexahedron* sself); +extern "C" vtkHierarchicalBoxDataIterator * vtkHierarchicalBoxDataIterator_new () ; +extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkHierarchicalBoxDataIterator * sself) ; +extern "C" void * vtkHierarchicalBoxDataIterator_get_ptr (vtkHierarchicalBoxDataIterator * sself) ; +extern "C" vtkHierarchicalBoxDataSet * vtkHierarchicalBoxDataSet_new () ; +extern "C" void vtkHierarchicalBoxDataSet_destructor (vtkHierarchicalBoxDataSet * sself) ; +extern "C" void * vtkHierarchicalBoxDataSet_get_ptr (vtkHierarchicalBoxDataSet * sself) ; +extern "C" vtkHyperTreeGrid * vtkHyperTreeGrid_new () ; +extern "C" void vtkHyperTreeGrid_destructor (vtkHyperTreeGrid * sself) ; +extern "C" void * vtkHyperTreeGrid_get_ptr (vtkHyperTreeGrid * sself) ; +extern "C" void vtk_hyper_tree_grid_set_mode_squeeze(vtkHyperTreeGrid* sself, const char* _arg); +extern "C" void vtk_hyper_tree_grid_squeeze(vtkHyperTreeGrid* sself); +extern "C" int vtk_hyper_tree_grid_get_data_object_type(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkHyperTreeGrid* sself, unsigned int i, unsigned int j, unsigned int k); +extern "C" void vtk_hyper_tree_grid_set_extent(vtkHyperTreeGrid* sself, int x1, int x2, int y1, int y2, int z1, int z2); +extern "C" unsigned int vtk_hyper_tree_grid_get_dimension(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_get_1_d_axis(vtkHyperTreeGrid* sself, unsigned int& axis); +extern "C" void vtk_hyper_tree_grid_get_2_d_axes(vtkHyperTreeGrid* sself, unsigned int& axis1, unsigned int& axis2); +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_children(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_transposed_root_indexing(vtkHyperTreeGrid* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_get_transposed_root_indexing(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_kji(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_ijk(vtkHyperTreeGrid* sself); +extern "C" unsigned int vtk_hyper_tree_grid_get_orientation(vtkHyperTreeGrid* sself); +extern "C" bool vtk_hyper_tree_grid_get_freeze_state(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_branch_factor(vtkHyperTreeGrid* sself, unsigned int p0); +extern "C" unsigned int vtk_hyper_tree_grid_get_branch_factor(vtkHyperTreeGrid* sself); +extern "C" long long vtk_hyper_tree_grid_get_max_number_of_trees(vtkHyperTreeGrid* sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_vertices(vtkHyperTreeGrid* sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_non_empty_trees(vtkHyperTreeGrid* sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_leaves(vtkHyperTreeGrid* sself); +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkHyperTreeGrid* sself, long long p0); +extern "C" void vtk_hyper_tree_grid_set_fixed_coordinates(vtkHyperTreeGrid* sself, unsigned int axis, double value); +extern "C" bool vtk_hyper_tree_grid_has_mask(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_has_interface(vtkHyperTreeGrid* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_get_has_interface(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_has_interface_on(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_has_interface_off(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_interface_normals_name(vtkHyperTreeGrid* sself, const char* _arg); +extern "C" void vtk_hyper_tree_grid_set_interface_intercepts_name(vtkHyperTreeGrid* sself, const char* _arg); +extern "C" void vtk_hyper_tree_grid_set_depth_limiter(vtkHyperTreeGrid* sself, unsigned int _arg); +extern "C" unsigned int vtk_hyper_tree_grid_get_depth_limiter(vtkHyperTreeGrid* sself); +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_x(vtkHyperTreeGrid* sself, double value); +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_y(vtkHyperTreeGrid* sself, double value); +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_z(vtkHyperTreeGrid* sself, double value); +extern "C" void vtk_hyper_tree_grid_initialize(vtkHyperTreeGrid* sself); +extern "C" int vtk_hyper_tree_grid_get_extent_type(vtkHyperTreeGrid* sself); +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size_bytes(vtkHyperTreeGrid* sself); +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size(vtkHyperTreeGrid* sself); +extern "C" unsigned int vtk_hyper_tree_grid_get_child_mask(vtkHyperTreeGrid* sself, unsigned int p0); +extern "C" void vtk_hyper_tree_grid_get_index_from_level_zero_coordinates(vtkHyperTreeGrid* sself, long long& p0, unsigned int p1, unsigned int p2, unsigned int p3); +extern "C" long long vtk_hyper_tree_grid_get_shifted_level_zero_index(vtkHyperTreeGrid* sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3); +extern "C" void vtk_hyper_tree_grid_get_level_zero_coordinates_from_index(vtkHyperTreeGrid* sself, long long p0, unsigned int& p1, unsigned int& p2, unsigned int& p3); +extern "C" long long vtk_hyper_tree_grid_get_global_node_index_max(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_initialize_local_index_node(vtkHyperTreeGrid* sself); +extern "C" bool vtk_hyper_tree_grid_has_any_ghost_cells(vtkHyperTreeGrid* sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_elements(vtkHyperTreeGrid* sself, int type); +extern "C" vtkHyperTreeGridNonOrientedCursor * vtkHyperTreeGridNonOrientedCursor_new () ; +extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkHyperTreeGridNonOrientedCursor * sself) ; +extern "C" void * vtkHyperTreeGridNonOrientedCursor_get_ptr (vtkHyperTreeGridNonOrientedCursor * sself) ; +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_has_tree(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_dimension(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(vtkHyperTreeGridNonOrientedCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local(vtkHyperTreeGridNonOrientedCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_mask(vtkHyperTreeGridNonOrientedCursor* sself, bool state); +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_masked(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_leaf(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_root(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_cursor_get_level(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_child(vtkHyperTreeGridNonOrientedCursor* sself, unsigned char ichild); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_root(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_parent(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" vtkHyperTreeGridNonOrientedGeometryCursor * vtkHyperTreeGridNonOrientedGeometryCursor_new () ; +extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkHyperTreeGridNonOrientedGeometryCursor * sself) ; +extern "C" void * vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr (vtkHyperTreeGridNonOrientedGeometryCursor * sself) ; +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start(vtkHyperTreeGridNonOrientedGeometryCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local(vtkHyperTreeGridNonOrientedGeometryCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask(vtkHyperTreeGridNonOrientedGeometryCursor* sself, bool state); +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child(vtkHyperTreeGridNonOrientedGeometryCursor* sself, unsigned char ichild); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursor * vtkHyperTreeGridNonOrientedMooreSuperCursor_new () ; +extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursor * sself) ; +extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr (vtkHyperTreeGridNonOrientedMooreSuperCursor * sself) ; +extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursorLight * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new () ; +extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursorLight * sself) ; +extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr (vtkHyperTreeGridNonOrientedMooreSuperCursorLight * sself) ; +extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new () ; +extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * sself) ; +extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr (vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * sself) ; +extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new () ; +extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * sself) ; +extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr (vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * sself) ; +extern "C" vtkHyperTreeGridOrientedCursor * vtkHyperTreeGridOrientedCursor_new () ; +extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkHyperTreeGridOrientedCursor * sself) ; +extern "C" void * vtkHyperTreeGridOrientedCursor_get_ptr (vtkHyperTreeGridOrientedCursor * sself) ; +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_has_tree(vtkHyperTreeGridOrientedCursor* sself); +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(vtkHyperTreeGridOrientedCursor* sself); +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(vtkHyperTreeGridOrientedCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_dimension(vtkHyperTreeGridOrientedCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(vtkHyperTreeGridOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(vtkHyperTreeGridOrientedCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local(vtkHyperTreeGridOrientedCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_mask(vtkHyperTreeGridOrientedCursor* sself, bool state); +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_masked(vtkHyperTreeGridOrientedCursor* sself); +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_leaf(vtkHyperTreeGridOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf(vtkHyperTreeGridOrientedCursor* sself); +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_root(vtkHyperTreeGridOrientedCursor* sself); +extern "C" unsigned int vtk_hyper_tree_grid_oriented_cursor_get_level(vtkHyperTreeGridOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_to_child(vtkHyperTreeGridOrientedCursor* sself, unsigned char ichild); +extern "C" vtkHyperTreeGridOrientedGeometryCursor * vtkHyperTreeGridOrientedGeometryCursor_new () ; +extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkHyperTreeGridOrientedGeometryCursor * sself) ; +extern "C" void * vtkHyperTreeGridOrientedGeometryCursor_get_ptr (vtkHyperTreeGridOrientedGeometryCursor * sself) ; +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start(vtkHyperTreeGridOrientedGeometryCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local(vtkHyperTreeGridOrientedGeometryCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask(vtkHyperTreeGridOrientedGeometryCursor* sself, bool state); +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_root(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" unsigned int vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(vtkHyperTreeGridOrientedGeometryCursor* sself, unsigned char ichild); +extern "C" vtkImageData * vtkImageData_new () ; +extern "C" void vtkImageData_destructor (vtkImageData * sself) ; +extern "C" void * vtkImageData_get_ptr (vtkImageData * sself) ; +extern "C" int vtk_image_data_get_data_object_type(vtkImageData* sself); +extern "C" long long vtk_image_data_get_number_of_cells(vtkImageData* sself); +extern "C" long long vtk_image_data_get_number_of_points(vtkImageData* sself); +extern "C" long long vtk_image_data_find_point(vtkImageData* sself, double x, double y, double z); +extern "C" int vtk_image_data_get_cell_type(vtkImageData* sself, long long cellId); +extern "C" int vtk_image_data_get_max_cell_size(vtkImageData* sself); +extern "C" void vtk_image_data_initialize(vtkImageData* sself); +extern "C" unsigned char vtk_image_data_is_point_visible(vtkImageData* sself, long long ptId); +extern "C" unsigned char vtk_image_data_is_cell_visible(vtkImageData* sself, long long cellId); +extern "C" bool vtk_image_data_has_any_blank_points(vtkImageData* sself); +extern "C" bool vtk_image_data_has_any_blank_cells(vtkImageData* sself); +extern "C" void vtk_image_data_set_dimensions(vtkImageData* sself, int i, int j, int k); +extern "C" int vtk_image_data_get_data_dimension(vtkImageData* sself); +extern "C" void vtk_image_data_set_extent(vtkImageData* sself, int x1, int x2, int y1, int y2, int z1, int z2); +extern "C" void* vtk_image_data_get_scalar_pointer(vtkImageData* sself, int x, int y, int z); +extern "C" long long vtk_image_data_get_scalar_index(vtkImageData* sself, int x, int y, int z); +extern "C" float vtk_image_data_get_scalar_component_as_float(vtkImageData* sself, int x, int y, int z, int component); +extern "C" void vtk_image_data_set_scalar_component_from_float(vtkImageData* sself, int x, int y, int z, int component, float v); +extern "C" double vtk_image_data_get_scalar_component_as_double(vtkImageData* sself, int x, int y, int z, int component); +extern "C" void vtk_image_data_set_scalar_component_from_double(vtkImageData* sself, int x, int y, int z, int component, double v); +extern "C" void vtk_image_data_allocate_scalars(vtkImageData* sself, int dataType, int numComponents); +extern "C" void vtk_image_data_set_spacing(vtkImageData* sself, double i, double j, double k); +extern "C" void vtk_image_data_set_origin(vtkImageData* sself, double i, double j, double k); +extern "C" const char* vtk_image_data_get_scalar_type_as_string(vtkImageData* sself); +extern "C" void vtk_image_data_prepare_for_new_data(vtkImageData* sself); +extern "C" int vtk_image_data_get_extent_type(vtkImageData* sself); +extern "C" vtkImageTransform * vtkImageTransform_new () ; +extern "C" void vtkImageTransform_destructor (vtkImageTransform * sself) ; +extern "C" void * vtkImageTransform_get_ptr (vtkImageTransform * sself) ; +extern "C" vtkImplicitBoolean * vtkImplicitBoolean_new () ; +extern "C" void vtkImplicitBoolean_destructor (vtkImplicitBoolean * sself) ; +extern "C" void * vtkImplicitBoolean_get_ptr (vtkImplicitBoolean * sself) ; +extern "C" unsigned long vtk_implicit_boolean_get_m_time(vtkImplicitBoolean* sself); +extern "C" void vtk_implicit_boolean_set_operation_type(vtkImplicitBoolean* sself, int _arg); +extern "C" int vtk_implicit_boolean_get_operation_type_min_value(vtkImplicitBoolean* sself); +extern "C" int vtk_implicit_boolean_get_operation_type_max_value(vtkImplicitBoolean* sself); +extern "C" int vtk_implicit_boolean_get_operation_type(vtkImplicitBoolean* sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_union(vtkImplicitBoolean* sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_intersection(vtkImplicitBoolean* sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_difference(vtkImplicitBoolean* sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(vtkImplicitBoolean* sself); +extern "C" const char* vtk_implicit_boolean_get_operation_type_as_string(vtkImplicitBoolean* sself); +extern "C" vtkImplicitDataSet * vtkImplicitDataSet_new () ; +extern "C" void vtkImplicitDataSet_destructor (vtkImplicitDataSet * sself) ; +extern "C" void * vtkImplicitDataSet_get_ptr (vtkImplicitDataSet * sself) ; +extern "C" unsigned long vtk_implicit_data_set_get_m_time(vtkImplicitDataSet* sself); +extern "C" void vtk_implicit_data_set_set_out_value(vtkImplicitDataSet* sself, double _arg); +extern "C" double vtk_implicit_data_set_get_out_value(vtkImplicitDataSet* sself); +extern "C" void vtk_implicit_data_set_set_out_gradient(vtkImplicitDataSet* sself, double _arg1, double _arg2, double _arg3); +extern "C" vtkImplicitFunctionCollection * vtkImplicitFunctionCollection_new () ; +extern "C" void vtkImplicitFunctionCollection_destructor (vtkImplicitFunctionCollection * sself) ; +extern "C" void * vtkImplicitFunctionCollection_get_ptr (vtkImplicitFunctionCollection * sself) ; +extern "C" vtkImplicitHalo * vtkImplicitHalo_new () ; +extern "C" void vtkImplicitHalo_destructor (vtkImplicitHalo * sself) ; +extern "C" void * vtkImplicitHalo_get_ptr (vtkImplicitHalo * sself) ; +extern "C" void vtk_implicit_halo_set_radius(vtkImplicitHalo* sself, double _arg); +extern "C" double vtk_implicit_halo_get_radius(vtkImplicitHalo* sself); +extern "C" void vtk_implicit_halo_set_center(vtkImplicitHalo* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_implicit_halo_set_fade_out(vtkImplicitHalo* sself, double _arg); +extern "C" double vtk_implicit_halo_get_fade_out(vtkImplicitHalo* sself); +extern "C" vtkImplicitSelectionLoop * vtkImplicitSelectionLoop_new () ; +extern "C" void vtkImplicitSelectionLoop_destructor (vtkImplicitSelectionLoop * sself) ; +extern "C" void * vtkImplicitSelectionLoop_get_ptr (vtkImplicitSelectionLoop * sself) ; +extern "C" void vtk_implicit_selection_loop_set_automatic_normal_generation(vtkImplicitSelectionLoop* sself, int _arg); +extern "C" int vtk_implicit_selection_loop_get_automatic_normal_generation(vtkImplicitSelectionLoop* sself); +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_on(vtkImplicitSelectionLoop* sself); +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_off(vtkImplicitSelectionLoop* sself); +extern "C" void vtk_implicit_selection_loop_set_normal(vtkImplicitSelectionLoop* sself, double _arg1, double _arg2, double _arg3); +extern "C" unsigned long vtk_implicit_selection_loop_get_m_time(vtkImplicitSelectionLoop* sself); +extern "C" vtkImplicitSum * vtkImplicitSum_new () ; +extern "C" void vtkImplicitSum_destructor (vtkImplicitSum * sself) ; +extern "C" void * vtkImplicitSum_get_ptr (vtkImplicitSum * sself) ; +extern "C" unsigned long vtk_implicit_sum_get_m_time(vtkImplicitSum* sself); +extern "C" void vtk_implicit_sum_remove_all_functions(vtkImplicitSum* sself); +extern "C" void vtk_implicit_sum_set_normalize_by_weight(vtkImplicitSum* sself, int _arg); +extern "C" int vtk_implicit_sum_get_normalize_by_weight(vtkImplicitSum* sself); +extern "C" void vtk_implicit_sum_normalize_by_weight_on(vtkImplicitSum* sself); +extern "C" void vtk_implicit_sum_normalize_by_weight_off(vtkImplicitSum* sself); +extern "C" vtkImplicitVolume * vtkImplicitVolume_new () ; +extern "C" void vtkImplicitVolume_destructor (vtkImplicitVolume * sself) ; +extern "C" void * vtkImplicitVolume_get_ptr (vtkImplicitVolume * sself) ; +extern "C" unsigned long vtk_implicit_volume_get_m_time(vtkImplicitVolume* sself); +extern "C" void vtk_implicit_volume_set_out_value(vtkImplicitVolume* sself, double _arg); +extern "C" double vtk_implicit_volume_get_out_value(vtkImplicitVolume* sself); +extern "C" void vtk_implicit_volume_set_out_gradient(vtkImplicitVolume* sself, double _arg1, double _arg2, double _arg3); +extern "C" vtkImplicitWindowFunction * vtkImplicitWindowFunction_new () ; +extern "C" void vtkImplicitWindowFunction_destructor (vtkImplicitWindowFunction * sself) ; +extern "C" void * vtkImplicitWindowFunction_get_ptr (vtkImplicitWindowFunction * sself) ; +extern "C" void vtk_implicit_window_function_set_window_range(vtkImplicitWindowFunction* sself, double _arg1, double _arg2); +extern "C" void vtk_implicit_window_function_set_window_values(vtkImplicitWindowFunction* sself, double _arg1, double _arg2); +extern "C" unsigned long vtk_implicit_window_function_get_m_time(vtkImplicitWindowFunction* sself); +extern "C" vtkInEdgeIterator * vtkInEdgeIterator_new () ; +extern "C" void vtkInEdgeIterator_destructor (vtkInEdgeIterator * sself) ; +extern "C" void * vtkInEdgeIterator_get_ptr (vtkInEdgeIterator * sself) ; +extern "C" long long vtk_in_edge_iterator_get_vertex(vtkInEdgeIterator* sself); +extern "C" bool vtk_in_edge_iterator_has_next(vtkInEdgeIterator* sself); +extern "C" vtkIncrementalOctreeNode * vtkIncrementalOctreeNode_new () ; +extern "C" void vtkIncrementalOctreeNode_destructor (vtkIncrementalOctreeNode * sself) ; +extern "C" void * vtkIncrementalOctreeNode_get_ptr (vtkIncrementalOctreeNode * sself) ; +extern "C" int vtk_incremental_octree_node_get_number_of_points(vtkIncrementalOctreeNode* sself); +extern "C" void vtk_incremental_octree_node_delete_child_nodes(vtkIncrementalOctreeNode* sself); +extern "C" void vtk_incremental_octree_node_set_bounds(vtkIncrementalOctreeNode* sself, double x1, double x2, double y1, double y2, double z1, double z2); +extern "C" int vtk_incremental_octree_node_is_leaf(vtkIncrementalOctreeNode* sself); +extern "C" int vtk_incremental_octree_node_get_number_of_levels(vtkIncrementalOctreeNode* sself); +extern "C" int vtk_incremental_octree_node_get_id(vtkIncrementalOctreeNode* sself); +extern "C" vtkIncrementalOctreePointLocator * vtkIncrementalOctreePointLocator_new () ; +extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkIncrementalOctreePointLocator * sself) ; +extern "C" void * vtkIncrementalOctreePointLocator_get_ptr (vtkIncrementalOctreePointLocator * sself) ; +extern "C" void vtk_incremental_octree_point_locator_set_max_points_per_leaf(vtkIncrementalOctreePointLocator* sself, int _arg); +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value(vtkIncrementalOctreePointLocator* sself); +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value(vtkIncrementalOctreePointLocator* sself); +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_set_build_cubic_octree(vtkIncrementalOctreePointLocator* sself, int _arg); +extern "C" int vtk_incremental_octree_point_locator_get_build_cubic_octree(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_on(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_off(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_initialize(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_free_search_structure(vtkIncrementalOctreePointLocator* sself); +extern "C" int vtk_incremental_octree_point_locator_get_number_of_points(vtkIncrementalOctreePointLocator* sself); +extern "C" int vtk_incremental_octree_point_locator_get_number_of_nodes(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_build_locator(vtkIncrementalOctreePointLocator* sself); +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkIncrementalOctreePointLocator* sself, double x, double y, double z); +extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkIncrementalOctreePointLocator* sself, double x, double y, double z); +extern "C" int vtk_incremental_octree_point_locator_get_number_of_levels(vtkIncrementalOctreePointLocator* sself); +extern "C" vtkIterativeClosestPointTransform * vtkIterativeClosestPointTransform_new () ; +extern "C" void vtkIterativeClosestPointTransform_destructor (vtkIterativeClosestPointTransform * sself) ; +extern "C" void * vtkIterativeClosestPointTransform_get_ptr (vtkIterativeClosestPointTransform * sself) ; +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself); +extern "C" int vtk_iterative_closest_point_transform_get_number_of_iterations(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_check_mean_distance(vtkIterativeClosestPointTransform* sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_check_mean_distance(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_on(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_off(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode(vtkIterativeClosestPointTransform* sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value(vtkIterativeClosestPointTransform* sself); +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value(vtkIterativeClosestPointTransform* sself); +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value(vtkIterativeClosestPointTransform* sself); +extern "C" const char* vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_maximum_mean_distance(vtkIterativeClosestPointTransform* sself, double _arg); +extern "C" double vtk_iterative_closest_point_transform_get_maximum_mean_distance(vtkIterativeClosestPointTransform* sself); +extern "C" double vtk_iterative_closest_point_transform_get_mean_distance(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks(vtkIterativeClosestPointTransform* sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_start_by_matching_centroids(vtkIterativeClosestPointTransform* sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_start_by_matching_centroids(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_on(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_off(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_inverse(vtkIterativeClosestPointTransform* sself); +extern "C" vtkKdNode * vtkKdNode_new () ; +extern "C" void vtkKdNode_destructor (vtkKdNode * sself) ; +extern "C" void * vtkKdNode_get_ptr (vtkKdNode * sself) ; +extern "C" void vtk_kd_node_set_dim(vtkKdNode* sself, int _arg); +extern "C" int vtk_kd_node_get_dim(vtkKdNode* sself); +extern "C" double vtk_kd_node_get_division_position(vtkKdNode* sself); +extern "C" void vtk_kd_node_set_number_of_points(vtkKdNode* sself, int _arg); +extern "C" int vtk_kd_node_get_number_of_points(vtkKdNode* sself); +extern "C" void vtk_kd_node_set_bounds(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2); +extern "C" void vtk_kd_node_set_data_bounds(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2); +extern "C" void vtk_kd_node_set_id(vtkKdNode* sself, int _arg); +extern "C" int vtk_kd_node_get_id(vtkKdNode* sself); +extern "C" int vtk_kd_node_get_min_id(vtkKdNode* sself); +extern "C" int vtk_kd_node_get_max_id(vtkKdNode* sself); +extern "C" void vtk_kd_node_set_min_id(vtkKdNode* sself, int _arg); +extern "C" void vtk_kd_node_set_max_id(vtkKdNode* sself, int _arg); +extern "C" void vtk_kd_node_delete_child_nodes(vtkKdNode* sself); +extern "C" int vtk_kd_node_intersects_box(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds); +extern "C" int vtk_kd_node_intersects_sphere_2(vtkKdNode* sself, double x, double y, double z, double rSquared, int useDataBounds); +extern "C" int vtk_kd_node_contains_box(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds); +extern "C" int vtk_kd_node_contains_point(vtkKdNode* sself, double x, double y, double z, int useDataBounds); +extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkKdNode* sself, double x, double y, double z, int useDataBounds); +extern "C" double vtk_kd_node_get_distance_2_to_inner_boundary(vtkKdNode* sself, double x, double y, double z); +extern "C" void vtk_kd_node_print_node(vtkKdNode* sself, int depth); +extern "C" void vtk_kd_node_print_verbose_node(vtkKdNode* sself, int depth); +extern "C" vtkKdTree * vtkKdTree_new () ; +extern "C" void vtkKdTree_destructor (vtkKdTree * sself) ; +extern "C" void * vtkKdTree_get_ptr (vtkKdTree * sself) ; +extern "C" void vtk_kd_tree_timing_on(vtkKdTree* sself); +extern "C" void vtk_kd_tree_timing_off(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_timing(vtkKdTree* sself, int _arg); +extern "C" int vtk_kd_tree_get_timing(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_min_cells(vtkKdTree* sself, int _arg); +extern "C" int vtk_kd_tree_get_min_cells(vtkKdTree* sself); +extern "C" int vtk_kd_tree_get_number_of_regions_or_less(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_number_of_regions_or_less(vtkKdTree* sself, int _arg); +extern "C" int vtk_kd_tree_get_number_of_regions_or_more(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_number_of_regions_or_more(vtkKdTree* sself, int _arg); +extern "C" double vtk_kd_tree_get_fudge_factor(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_fudge_factor(vtkKdTree* sself, double _arg); +extern "C" void vtk_kd_tree_omit_x_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_y_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_z_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_xy_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_yz_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_zx_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_no_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_remove_data_set(vtkKdTree* sself, int index); +extern "C" void vtk_kd_tree_remove_all_data_sets(vtkKdTree* sself); +extern "C" int vtk_kd_tree_get_number_of_data_sets(vtkKdTree* sself); +extern "C" int vtk_kd_tree_get_number_of_regions(vtkKdTree* sself); +extern "C" void vtk_kd_tree_print_tree(vtkKdTree* sself); +extern "C" void vtk_kd_tree_print_verbose_tree(vtkKdTree* sself); +extern "C" void vtk_kd_tree_print_region(vtkKdTree* sself, int id); +extern "C" void vtk_kd_tree_set_include_region_boundary_cells(vtkKdTree* sself, int _arg); +extern "C" int vtk_kd_tree_get_include_region_boundary_cells(vtkKdTree* sself); +extern "C" void vtk_kd_tree_include_region_boundary_cells_on(vtkKdTree* sself); +extern "C" void vtk_kd_tree_include_region_boundary_cells_off(vtkKdTree* sself); +extern "C" void vtk_kd_tree_delete_cell_lists(vtkKdTree* sself); +extern "C" int vtk_kd_tree_get_region_containing_point(vtkKdTree* sself, double x, double y, double z); +extern "C" void vtk_kd_tree_build_locator(vtkKdTree* sself); +extern "C" void vtk_kd_tree_free_search_structure(vtkKdTree* sself); +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_on(vtkKdTree* sself); +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_off(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_generate_representation_using_data_bounds(vtkKdTree* sself, int _arg); +extern "C" int vtk_kd_tree_get_generate_representation_using_data_bounds(vtkKdTree* sself); +extern "C" int vtk_kd_tree_new_geometry(vtkKdTree* sself); +extern "C" void vtk_kd_tree_invalidate_geometry(vtkKdTree* sself); +extern "C" vtkKdTreePointLocator * vtkKdTreePointLocator_new () ; +extern "C" void vtkKdTreePointLocator_destructor (vtkKdTreePointLocator * sself) ; +extern "C" void * vtkKdTreePointLocator_get_ptr (vtkKdTreePointLocator * sself) ; +extern "C" void vtk_kd_tree_point_locator_free_search_structure(vtkKdTreePointLocator* sself); +extern "C" void vtk_kd_tree_point_locator_build_locator(vtkKdTreePointLocator* sself); +extern "C" vtkLagrangeCurve * vtkLagrangeCurve_new () ; +extern "C" void vtkLagrangeCurve_destructor (vtkLagrangeCurve * sself) ; +extern "C" void * vtkLagrangeCurve_get_ptr (vtkLagrangeCurve * sself) ; +extern "C" int vtk_lagrange_curve_get_cell_type(vtkLagrangeCurve* sself); +extern "C" vtkLagrangeHexahedron * vtkLagrangeHexahedron_new () ; +extern "C" void vtkLagrangeHexahedron_destructor (vtkLagrangeHexahedron * sself) ; +extern "C" void * vtkLagrangeHexahedron_get_ptr (vtkLagrangeHexahedron * sself) ; +extern "C" int vtk_lagrange_hexahedron_get_cell_type(vtkLagrangeHexahedron* sself); +extern "C" vtkLagrangeInterpolation * vtkLagrangeInterpolation_new () ; +extern "C" void vtkLagrangeInterpolation_destructor (vtkLagrangeInterpolation * sself) ; +extern "C" void * vtkLagrangeInterpolation_get_ptr (vtkLagrangeInterpolation * sself) ; +extern "C" vtkLagrangeQuadrilateral * vtkLagrangeQuadrilateral_new () ; +extern "C" void vtkLagrangeQuadrilateral_destructor (vtkLagrangeQuadrilateral * sself) ; +extern "C" void * vtkLagrangeQuadrilateral_get_ptr (vtkLagrangeQuadrilateral * sself) ; +extern "C" int vtk_lagrange_quadrilateral_get_cell_type(vtkLagrangeQuadrilateral* sself); +extern "C" vtkLagrangeTetra * vtkLagrangeTetra_new () ; +extern "C" void vtkLagrangeTetra_destructor (vtkLagrangeTetra * sself) ; +extern "C" void * vtkLagrangeTetra_get_ptr (vtkLagrangeTetra * sself) ; +extern "C" int vtk_lagrange_tetra_get_cell_type(vtkLagrangeTetra* sself); +extern "C" vtkLagrangeTriangle * vtkLagrangeTriangle_new () ; +extern "C" void vtkLagrangeTriangle_destructor (vtkLagrangeTriangle * sself) ; +extern "C" void * vtkLagrangeTriangle_get_ptr (vtkLagrangeTriangle * sself) ; +extern "C" int vtk_lagrange_triangle_get_cell_type(vtkLagrangeTriangle* sself); +extern "C" vtkLagrangeWedge * vtkLagrangeWedge_new () ; +extern "C" void vtkLagrangeWedge_destructor (vtkLagrangeWedge * sself) ; +extern "C" void * vtkLagrangeWedge_get_ptr (vtkLagrangeWedge * sself) ; +extern "C" int vtk_lagrange_wedge_get_cell_type(vtkLagrangeWedge* sself); +extern "C" vtkLine * vtkLine_new () ; +extern "C" void vtkLine_destructor (vtkLine * sself) ; +extern "C" void * vtkLine_get_ptr (vtkLine * sself) ; +extern "C" int vtk_line_get_cell_type(vtkLine* sself); +extern "C" int vtk_line_get_cell_dimension(vtkLine* sself); +extern "C" int vtk_line_get_number_of_edges(vtkLine* sself); +extern "C" int vtk_line_get_number_of_faces(vtkLine* sself); +extern "C" int vtk_line_inflate(vtkLine* sself, double dist); +extern "C" vtkMeanValueCoordinatesInterpolator * vtkMeanValueCoordinatesInterpolator_new () ; +extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkMeanValueCoordinatesInterpolator * sself) ; +extern "C" void * vtkMeanValueCoordinatesInterpolator_get_ptr (vtkMeanValueCoordinatesInterpolator * sself) ; +extern "C" vtkMergePoints * vtkMergePoints_new () ; +extern "C" void vtkMergePoints_destructor (vtkMergePoints * sself) ; +extern "C" void * vtkMergePoints_get_ptr (vtkMergePoints * sself) ; +extern "C" vtkMolecule * vtkMolecule_new () ; +extern "C" void vtkMolecule_destructor (vtkMolecule * sself) ; +extern "C" void * vtkMolecule_get_ptr (vtkMolecule * sself) ; +extern "C" long long vtk_molecule_get_number_of_atoms(vtkMolecule* sself); +extern "C" long long vtk_molecule_get_number_of_bonds(vtkMolecule* sself); +extern "C" unsigned short vtk_molecule_get_atom_atomic_number(vtkMolecule* sself, long long atomId); +extern "C" void vtk_molecule_set_atom_atomic_number(vtkMolecule* sself, long long atomId, unsigned short atomicNum); +extern "C" void vtk_molecule_set_bond_order(vtkMolecule* sself, long long bondId, unsigned short order); +extern "C" unsigned short vtk_molecule_get_bond_order(vtkMolecule* sself, long long bondId); +extern "C" double vtk_molecule_get_bond_length(vtkMolecule* sself, long long bondId); +extern "C" bool vtk_molecule_has_lattice(vtkMolecule* sself); +extern "C" void vtk_molecule_clear_lattice(vtkMolecule* sself); +extern "C" void vtk_molecule_allocate_atom_ghost_array(vtkMolecule* sself); +extern "C" void vtk_molecule_allocate_bond_ghost_array(vtkMolecule* sself); +extern "C" long long vtk_molecule_get_bond_id(vtkMolecule* sself, long long a, long long b); +extern "C" void vtk_molecule_set_atomic_number_array_name(vtkMolecule* sself, const char* _arg); +extern "C" void vtk_molecule_set_bond_orders_array_name(vtkMolecule* sself, const char* _arg); +extern "C" vtkMultiBlockDataSet * vtkMultiBlockDataSet_new () ; +extern "C" void vtkMultiBlockDataSet_destructor (vtkMultiBlockDataSet * sself) ; +extern "C" void * vtkMultiBlockDataSet_get_ptr (vtkMultiBlockDataSet * sself) ; +extern "C" void vtk_multi_block_data_set_set_number_of_blocks(vtkMultiBlockDataSet* sself, unsigned int numBlocks); +extern "C" unsigned int vtk_multi_block_data_set_get_number_of_blocks(vtkMultiBlockDataSet* sself); +extern "C" void vtk_multi_block_data_set_remove_block(vtkMultiBlockDataSet* sself, unsigned int blockno); +extern "C" int vtk_multi_block_data_set_has_meta_data(vtkMultiBlockDataSet* sself, unsigned int blockno); +extern "C" vtkMultiPieceDataSet * vtkMultiPieceDataSet_new () ; +extern "C" void vtkMultiPieceDataSet_destructor (vtkMultiPieceDataSet * sself) ; +extern "C" void * vtkMultiPieceDataSet_get_ptr (vtkMultiPieceDataSet * sself) ; +extern "C" void vtk_multi_piece_data_set_set_number_of_pieces(vtkMultiPieceDataSet* sself, unsigned int numpieces); +extern "C" unsigned int vtk_multi_piece_data_set_get_number_of_pieces(vtkMultiPieceDataSet* sself); +extern "C" vtkMutableDirectedGraph * vtkMutableDirectedGraph_new () ; +extern "C" void vtkMutableDirectedGraph_destructor (vtkMutableDirectedGraph * sself) ; +extern "C" void * vtkMutableDirectedGraph_get_ptr (vtkMutableDirectedGraph * sself) ; +extern "C" long long vtk_mutable_directed_graph_set_number_of_vertices(vtkMutableDirectedGraph* sself, long long numVerts); +extern "C" long long vtk_mutable_directed_graph_add_vertex(vtkMutableDirectedGraph* sself); +extern "C" void vtk_mutable_directed_graph_lazy_add_vertex(vtkMutableDirectedGraph* sself); +extern "C" void vtk_mutable_directed_graph_remove_vertex(vtkMutableDirectedGraph* sself, long long v); +extern "C" void vtk_mutable_directed_graph_remove_edge(vtkMutableDirectedGraph* sself, long long e); +extern "C" vtkMutableUndirectedGraph * vtkMutableUndirectedGraph_new () ; +extern "C" void vtkMutableUndirectedGraph_destructor (vtkMutableUndirectedGraph * sself) ; +extern "C" void * vtkMutableUndirectedGraph_get_ptr (vtkMutableUndirectedGraph * sself) ; +extern "C" long long vtk_mutable_undirected_graph_set_number_of_vertices(vtkMutableUndirectedGraph* sself, long long numVerts); +extern "C" long long vtk_mutable_undirected_graph_add_vertex(vtkMutableUndirectedGraph* sself); +extern "C" void vtk_mutable_undirected_graph_lazy_add_vertex(vtkMutableUndirectedGraph* sself); +extern "C" void vtk_mutable_undirected_graph_lazy_add_edge(vtkMutableUndirectedGraph* sself, long long u, long long v); +extern "C" void vtk_mutable_undirected_graph_remove_vertex(vtkMutableUndirectedGraph* sself, long long v); +extern "C" void vtk_mutable_undirected_graph_remove_edge(vtkMutableUndirectedGraph* sself, long long e); +extern "C" vtkNonMergingPointLocator * vtkNonMergingPointLocator_new () ; +extern "C" void vtkNonMergingPointLocator_destructor (vtkNonMergingPointLocator * sself) ; +extern "C" void * vtkNonMergingPointLocator_get_ptr (vtkNonMergingPointLocator * sself) ; +extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNonMergingPointLocator* sself, double p0, double p1, double p2); +extern "C" vtkNonOverlappingAMR * vtkNonOverlappingAMR_new () ; +extern "C" void vtkNonOverlappingAMR_destructor (vtkNonOverlappingAMR * sself) ; +extern "C" void * vtkNonOverlappingAMR_get_ptr (vtkNonOverlappingAMR * sself) ; +extern "C" int vtk_non_overlapping_amr_get_data_object_type(vtkNonOverlappingAMR* sself); +extern "C" vtkOctreePointLocator * vtkOctreePointLocator_new () ; +extern "C" void vtkOctreePointLocator_destructor (vtkOctreePointLocator * sself) ; +extern "C" void * vtkOctreePointLocator_get_ptr (vtkOctreePointLocator * sself) ; +extern "C" void vtk_octree_point_locator_set_maximum_points_per_region(vtkOctreePointLocator* sself, int _arg); +extern "C" int vtk_octree_point_locator_get_maximum_points_per_region(vtkOctreePointLocator* sself); +extern "C" void vtk_octree_point_locator_set_create_cubic_octants(vtkOctreePointLocator* sself, int _arg); +extern "C" int vtk_octree_point_locator_get_create_cubic_octants(vtkOctreePointLocator* sself); +extern "C" double vtk_octree_point_locator_get_fudge_factor(vtkOctreePointLocator* sself); +extern "C" void vtk_octree_point_locator_set_fudge_factor(vtkOctreePointLocator* sself, double _arg); +extern "C" int vtk_octree_point_locator_get_number_of_leaf_nodes(vtkOctreePointLocator* sself); +extern "C" int vtk_octree_point_locator_get_region_containing_point(vtkOctreePointLocator* sself, double x, double y, double z); +extern "C" void vtk_octree_point_locator_build_locator(vtkOctreePointLocator* sself); +extern "C" long long vtk_octree_point_locator_find_closest_point(vtkOctreePointLocator* sself, double x, double y, double z, double& dist2); +extern "C" void vtk_octree_point_locator_free_search_structure(vtkOctreePointLocator* sself); +extern "C" vtkOctreePointLocatorNode * vtkOctreePointLocatorNode_new () ; +extern "C" void vtkOctreePointLocatorNode_destructor (vtkOctreePointLocatorNode * sself) ; +extern "C" void * vtkOctreePointLocatorNode_get_ptr (vtkOctreePointLocatorNode * sself) ; +extern "C" void vtk_octree_point_locator_node_set_number_of_points(vtkOctreePointLocatorNode* sself, int numberOfPoints); +extern "C" int vtk_octree_point_locator_node_get_number_of_points(vtkOctreePointLocatorNode* sself); +extern "C" void vtk_octree_point_locator_node_set_bounds(vtkOctreePointLocatorNode* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" void vtk_octree_point_locator_node_set_data_bounds(vtkOctreePointLocatorNode* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" int vtk_octree_point_locator_node_get_id(vtkOctreePointLocatorNode* sself); +extern "C" int vtk_octree_point_locator_node_get_min_id(vtkOctreePointLocatorNode* sself); +extern "C" void vtk_octree_point_locator_node_create_child_nodes(vtkOctreePointLocatorNode* sself); +extern "C" void vtk_octree_point_locator_node_delete_child_nodes(vtkOctreePointLocatorNode* sself); +extern "C" int vtk_octree_point_locator_node_contains_point(vtkOctreePointLocatorNode* sself, double x, double y, double z, int useDataBounds); +extern "C" vtkOrderedTriangulator * vtkOrderedTriangulator_new () ; +extern "C" void vtkOrderedTriangulator_destructor (vtkOrderedTriangulator * sself) ; +extern "C" void * vtkOrderedTriangulator_get_ptr (vtkOrderedTriangulator * sself) ; +extern "C" void vtk_ordered_triangulator_init_triangulation(vtkOrderedTriangulator* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts); +extern "C" void vtk_ordered_triangulator_triangulate(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_template_triangulate(vtkOrderedTriangulator* sself, int cellType, int numPts, int numEdges); +extern "C" void vtk_ordered_triangulator_update_point_type(vtkOrderedTriangulator* sself, long long internalId, int type); +extern "C" long long vtk_ordered_triangulator_get_point_id(vtkOrderedTriangulator* sself, long long internalId); +extern "C" int vtk_ordered_triangulator_get_number_of_points(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_set_use_templates(vtkOrderedTriangulator* sself, int _arg); +extern "C" int vtk_ordered_triangulator_get_use_templates(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_use_templates_on(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_use_templates_off(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_set_pre_sorted(vtkOrderedTriangulator* sself, int _arg); +extern "C" int vtk_ordered_triangulator_get_pre_sorted(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_pre_sorted_on(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_pre_sorted_off(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_set_use_two_sort_ids(vtkOrderedTriangulator* sself, int _arg); +extern "C" int vtk_ordered_triangulator_get_use_two_sort_ids(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_on(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_off(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_init_tetra_traversal(vtkOrderedTriangulator* sself); +extern "C" vtkOutEdgeIterator * vtkOutEdgeIterator_new () ; +extern "C" void vtkOutEdgeIterator_destructor (vtkOutEdgeIterator * sself) ; +extern "C" void * vtkOutEdgeIterator_get_ptr (vtkOutEdgeIterator * sself) ; +extern "C" long long vtk_out_edge_iterator_get_vertex(vtkOutEdgeIterator* sself); +extern "C" bool vtk_out_edge_iterator_has_next(vtkOutEdgeIterator* sself); +extern "C" vtkOverlappingAMR * vtkOverlappingAMR_new () ; +extern "C" void vtkOverlappingAMR_destructor (vtkOverlappingAMR * sself) ; +extern "C" void * vtkOverlappingAMR_get_ptr (vtkOverlappingAMR * sself) ; +extern "C" void vtk_overlapping_amr_set_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level, int refRatio); +extern "C" int vtk_overlapping_amr_get_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level); +extern "C" void vtk_overlapping_amr_set_amr_block_source_index(vtkOverlappingAMR* sself, unsigned int level, unsigned int id, int sourceId); +extern "C" int vtk_overlapping_amr_get_amr_block_source_index(vtkOverlappingAMR* sself, unsigned int level, unsigned int id); +extern "C" bool vtk_overlapping_amr_has_children_information(vtkOverlappingAMR* sself); +extern "C" void vtk_overlapping_amr_generate_parent_child_information(vtkOverlappingAMR* sself); +extern "C" void vtk_overlapping_amr_print_parent_child_info(vtkOverlappingAMR* sself, unsigned int level, unsigned int index); +extern "C" void vtk_overlapping_amr_audit(vtkOverlappingAMR* sself); +extern "C" vtkPartitionedDataSet * vtkPartitionedDataSet_new () ; +extern "C" void vtkPartitionedDataSet_destructor (vtkPartitionedDataSet * sself) ; +extern "C" void * vtkPartitionedDataSet_get_ptr (vtkPartitionedDataSet * sself) ; +extern "C" void vtk_partitioned_data_set_set_number_of_partitions(vtkPartitionedDataSet* sself, unsigned int numPartitions); +extern "C" unsigned int vtk_partitioned_data_set_get_number_of_partitions(vtkPartitionedDataSet* sself); +extern "C" int vtk_partitioned_data_set_has_meta_data(vtkPartitionedDataSet* sself, unsigned int idx); +extern "C" void vtk_partitioned_data_set_remove_null_partitions(vtkPartitionedDataSet* sself); +extern "C" vtkPartitionedDataSetCollection * vtkPartitionedDataSetCollection_new () ; +extern "C" void vtkPartitionedDataSetCollection_destructor (vtkPartitionedDataSetCollection * sself) ; +extern "C" void * vtkPartitionedDataSetCollection_get_ptr (vtkPartitionedDataSetCollection * sself) ; +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself, unsigned int numDataSets); +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself); +extern "C" void vtk_partitioned_data_set_collection_remove_partitioned_data_set(vtkPartitionedDataSetCollection* sself, unsigned int idx); +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitions(vtkPartitionedDataSetCollection* sself, unsigned int idx); +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitions(vtkPartitionedDataSetCollection* sself, unsigned int idx, unsigned int numPartitions); +extern "C" int vtk_partitioned_data_set_collection_has_meta_data(vtkPartitionedDataSetCollection* sself, unsigned int idx); +extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkPartitionedDataSetCollection* sself, unsigned int idx); +extern "C" unsigned long vtk_partitioned_data_set_collection_get_m_time(vtkPartitionedDataSetCollection* sself); +extern "C" vtkPath * vtkPath_new () ; +extern "C" void vtkPath_destructor (vtkPath * sself) ; +extern "C" void * vtkPath_get_ptr (vtkPath * sself) ; +extern "C" int vtk_path_get_data_object_type(vtkPath* sself); +extern "C" void vtk_path_insert_next_point(vtkPath* sself, double x, double y, double z, int code); +extern "C" long long vtk_path_get_number_of_cells(vtkPath* sself); +extern "C" int vtk_path_get_max_cell_size(vtkPath* sself); +extern "C" void vtk_path_allocate(vtkPath* sself, long long size, int extSize); +extern "C" void vtk_path_reset(vtkPath* sself); +extern "C" vtkPentagonalPrism * vtkPentagonalPrism_new () ; +extern "C" void vtkPentagonalPrism_destructor (vtkPentagonalPrism * sself) ; +extern "C" void * vtkPentagonalPrism_get_ptr (vtkPentagonalPrism * sself) ; +extern "C" int vtk_pentagonal_prism_get_cell_type(vtkPentagonalPrism* sself); +extern "C" int vtk_pentagonal_prism_get_number_of_edges(vtkPentagonalPrism* sself); +extern "C" int vtk_pentagonal_prism_get_number_of_faces(vtkPentagonalPrism* sself); +extern "C" vtkPerlinNoise * vtkPerlinNoise_new () ; +extern "C" void vtkPerlinNoise_destructor (vtkPerlinNoise * sself) ; +extern "C" void * vtkPerlinNoise_get_ptr (vtkPerlinNoise * sself) ; +extern "C" void vtk_perlin_noise_set_frequency(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_perlin_noise_set_phase(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_perlin_noise_set_amplitude(vtkPerlinNoise* sself, double _arg); +extern "C" double vtk_perlin_noise_get_amplitude(vtkPerlinNoise* sself); +extern "C" vtkPiecewiseFunction * vtkPiecewiseFunction_new () ; +extern "C" void vtkPiecewiseFunction_destructor (vtkPiecewiseFunction * sself) ; +extern "C" void * vtkPiecewiseFunction_get_ptr (vtkPiecewiseFunction * sself) ; +extern "C" int vtk_piecewise_function_get_data_object_type(vtkPiecewiseFunction* sself); +extern "C" int vtk_piecewise_function_get_size(vtkPiecewiseFunction* sself); +extern "C" int vtk_piecewise_function_add_point(vtkPiecewiseFunction* sself, double x, double y); +extern "C" bool vtk_piecewise_function_remove_point_by_index(vtkPiecewiseFunction* sself, size_t id); +extern "C" int vtk_piecewise_function_remove_point(vtkPiecewiseFunction* sself, double x); +extern "C" void vtk_piecewise_function_remove_all_points(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_add_segment(vtkPiecewiseFunction* sself, double x1, double y1, double x2, double y2); +extern "C" double vtk_piecewise_function_get_value(vtkPiecewiseFunction* sself, double x); +extern "C" void vtk_piecewise_function_set_clamping(vtkPiecewiseFunction* sself, int _arg); +extern "C" int vtk_piecewise_function_get_clamping(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_clamping_on(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_clamping_off(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_set_use_log_scale(vtkPiecewiseFunction* sself, bool _arg); +extern "C" bool vtk_piecewise_function_get_use_log_scale(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_use_log_scale_on(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_use_log_scale_off(vtkPiecewiseFunction* sself); +extern "C" const char* vtk_piecewise_function_get_type(vtkPiecewiseFunction* sself); +extern "C" double vtk_piecewise_function_get_first_non_zero_value(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_initialize(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_set_allow_duplicate_scalars(vtkPiecewiseFunction* sself, int _arg); +extern "C" int vtk_piecewise_function_get_allow_duplicate_scalars(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_on(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_off(vtkPiecewiseFunction* sself); +extern "C" int vtk_piecewise_function_estimate_min_number_of_samples(vtkPiecewiseFunction* sself, const double& x1, const double& x2); +extern "C" vtkPixel * vtkPixel_new () ; +extern "C" void vtkPixel_destructor (vtkPixel * sself) ; +extern "C" void * vtkPixel_get_ptr (vtkPixel * sself) ; +extern "C" int vtk_pixel_get_cell_type(vtkPixel* sself); +extern "C" int vtk_pixel_get_cell_dimension(vtkPixel* sself); +extern "C" int vtk_pixel_get_number_of_edges(vtkPixel* sself); +extern "C" int vtk_pixel_get_number_of_faces(vtkPixel* sself); +extern "C" int vtk_pixel_inflate(vtkPixel* sself, double dist); +extern "C" vtkPlane * vtkPlane_new () ; +extern "C" void vtkPlane_destructor (vtkPlane * sself) ; +extern "C" void * vtkPlane_get_ptr (vtkPlane * sself) ; +extern "C" void vtk_plane_set_normal(vtkPlane* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_plane_set_origin(vtkPlane* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_plane_push(vtkPlane* sself, double distance); +extern "C" vtkPlaneCollection * vtkPlaneCollection_new () ; +extern "C" void vtkPlaneCollection_destructor (vtkPlaneCollection * sself) ; +extern "C" void * vtkPlaneCollection_get_ptr (vtkPlaneCollection * sself) ; +extern "C" int vtk_plane_collection_get_number_of_items(vtkPlaneCollection* sself); +extern "C" vtkPlanes * vtkPlanes_new () ; +extern "C" void vtkPlanes_destructor (vtkPlanes * sself) ; +extern "C" void * vtkPlanes_get_ptr (vtkPlanes * sself) ; +extern "C" void vtk_planes_set_bounds(vtkPlanes* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax); +extern "C" int vtk_planes_get_number_of_planes(vtkPlanes* sself); +extern "C" vtkPlanesIntersection * vtkPlanesIntersection_new () ; +extern "C" void vtkPlanesIntersection_destructor (vtkPlanesIntersection * sself) ; +extern "C" void * vtkPlanesIntersection_get_ptr (vtkPlanesIntersection * sself) ; +extern "C" int vtk_planes_intersection_get_number_of_region_vertices(vtkPlanesIntersection* sself); +extern "C" int vtk_planes_intersection_get_num_region_vertices(vtkPlanesIntersection* sself); +extern "C" vtkPointData * vtkPointData_new () ; +extern "C" void vtkPointData_destructor (vtkPointData * sself) ; +extern "C" void * vtkPointData_get_ptr (vtkPointData * sself) ; +extern "C" void vtk_point_data_null_point(vtkPointData* sself, long long ptId); +extern "C" vtkPointLocator * vtkPointLocator_new () ; +extern "C" void vtkPointLocator_destructor (vtkPointLocator * sself) ; +extern "C" void * vtkPointLocator_get_ptr (vtkPointLocator * sself) ; +extern "C" void vtk_point_locator_set_divisions(vtkPointLocator* sself, int _arg1, int _arg2, int _arg3); +extern "C" void vtk_point_locator_set_number_of_points_per_bucket(vtkPointLocator* sself, int _arg); +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_min_value(vtkPointLocator* sself); +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_max_value(vtkPointLocator* sself); +extern "C" int vtk_point_locator_get_number_of_points_per_bucket(vtkPointLocator* sself); +extern "C" long long vtk_point_locator_is_inserted_point(vtkPointLocator* sself, double x, double y, double z); +extern "C" void vtk_point_locator_initialize(vtkPointLocator* sself); +extern "C" void vtk_point_locator_free_search_structure(vtkPointLocator* sself); +extern "C" void vtk_point_locator_build_locator(vtkPointLocator* sself); +extern "C" vtkPointSet * vtkPointSet_new () ; +extern "C" void vtkPointSet_destructor (vtkPointSet * sself) ; +extern "C" void * vtkPointSet_get_ptr (vtkPointSet * sself) ; +extern "C" void vtk_point_set_set_editable(vtkPointSet* sself, bool _arg); +extern "C" bool vtk_point_set_get_editable(vtkPointSet* sself); +extern "C" void vtk_point_set_editable_on(vtkPointSet* sself); +extern "C" void vtk_point_set_editable_off(vtkPointSet* sself); +extern "C" void vtk_point_set_initialize(vtkPointSet* sself); +extern "C" long long vtk_point_set_get_number_of_points(vtkPointSet* sself); +extern "C" long long vtk_point_set_get_number_of_cells(vtkPointSet* sself); +extern "C" int vtk_point_set_get_max_cell_size(vtkPointSet* sself); +extern "C" int vtk_point_set_get_cell_type(vtkPointSet* sself, long long p0); +extern "C" void vtk_point_set_build_point_locator(vtkPointSet* sself); +extern "C" void vtk_point_set_build_locator(vtkPointSet* sself); +extern "C" void vtk_point_set_build_cell_locator(vtkPointSet* sself); +extern "C" unsigned long vtk_point_set_get_m_time(vtkPointSet* sself); +extern "C" void vtk_point_set_compute_bounds(vtkPointSet* sself); +extern "C" void vtk_point_set_squeeze(vtkPointSet* sself); +extern "C" vtkPointSetCellIterator * vtkPointSetCellIterator_new () ; +extern "C" void vtkPointSetCellIterator_destructor (vtkPointSetCellIterator * sself) ; +extern "C" void * vtkPointSetCellIterator_get_ptr (vtkPointSetCellIterator * sself) ; +extern "C" bool vtk_point_set_cell_iterator_is_done_with_traversal(vtkPointSetCellIterator* sself); +extern "C" long long vtk_point_set_cell_iterator_get_cell_id(vtkPointSetCellIterator* sself); +extern "C" vtkPointsProjectedHull * vtkPointsProjectedHull_new () ; +extern "C" void vtkPointsProjectedHull_destructor (vtkPointsProjectedHull * sself) ; +extern "C" void * vtkPointsProjectedHull_get_ptr (vtkPointsProjectedHull * sself) ; +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_x(vtkPointsProjectedHull* sself); +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_y(vtkPointsProjectedHull* sself); +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_z(vtkPointsProjectedHull* sself); +extern "C" void vtk_points_projected_hull_update(vtkPointsProjectedHull* sself); +extern "C" vtkPolyData * vtkPolyData_new () ; +extern "C" void vtkPolyData_destructor (vtkPolyData * sself) ; +extern "C" void * vtkPolyData_get_ptr (vtkPolyData * sself) ; +extern "C" int vtk_poly_data_get_data_object_type(vtkPolyData* sself); +extern "C" long long vtk_poly_data_get_number_of_cells(vtkPolyData* sself); +extern "C" int vtk_poly_data_get_cell_type(vtkPolyData* sself, long long cellId); +extern "C" void vtk_poly_data_compute_cells_bounds(vtkPolyData* sself); +extern "C" void vtk_poly_data_squeeze(vtkPolyData* sself); +extern "C" int vtk_poly_data_get_max_cell_size(vtkPolyData* sself); +extern "C" long long vtk_poly_data_get_cell_id_relative_to_cell_array(vtkPolyData* sself, long long cellId); +extern "C" long long vtk_poly_data_get_number_of_verts(vtkPolyData* sself); +extern "C" long long vtk_poly_data_get_number_of_lines(vtkPolyData* sself); +extern "C" long long vtk_poly_data_get_number_of_polys(vtkPolyData* sself); +extern "C" long long vtk_poly_data_get_number_of_strips(vtkPolyData* sself); +extern "C" bool vtk_poly_data_allocate_estimate(vtkPolyData* sself, long long numCells, long long maxCellSize); +extern "C" bool vtk_poly_data_allocate_exact(vtkPolyData* sself, long long numCells, long long connectivitySize); +extern "C" void vtk_poly_data_allocate(vtkPolyData* sself, long long numCells, int extSize); +extern "C" void vtk_poly_data_reset(vtkPolyData* sself); +extern "C" void vtk_poly_data_build_cells(vtkPolyData* sself); +extern "C" bool vtk_poly_data_need_to_build_cells(vtkPolyData* sself); +extern "C" void vtk_poly_data_build_links(vtkPolyData* sself, int initialSize); +extern "C" void vtk_poly_data_delete_cells(vtkPolyData* sself); +extern "C" void vtk_poly_data_delete_links(vtkPolyData* sself); +extern "C" int vtk_poly_data_is_triangle(vtkPolyData* sself, int v1, int v2, int v3); +extern "C" int vtk_poly_data_is_edge(vtkPolyData* sself, long long p1, long long p2); +extern "C" int vtk_poly_data_is_point_used_by_cell(vtkPolyData* sself, long long ptId, long long cellId); +extern "C" void vtk_poly_data_replace_cell_point(vtkPolyData* sself, long long cellId, long long oldPtId, long long newPtId); +extern "C" void vtk_poly_data_reverse_cell(vtkPolyData* sself, long long cellId); +extern "C" void vtk_poly_data_delete_point(vtkPolyData* sself, long long ptId); +extern "C" void vtk_poly_data_delete_cell(vtkPolyData* sself, long long cellId); +extern "C" void vtk_poly_data_remove_deleted_cells(vtkPolyData* sself); +extern "C" long long vtk_poly_data_insert_next_linked_point(vtkPolyData* sself, int numLinks); +extern "C" void vtk_poly_data_remove_cell_reference(vtkPolyData* sself, long long cellId); +extern "C" void vtk_poly_data_add_cell_reference(vtkPolyData* sself, long long cellId); +extern "C" void vtk_poly_data_remove_reference_to_cell(vtkPolyData* sself, long long ptId, long long cellId); +extern "C" void vtk_poly_data_add_reference_to_cell(vtkPolyData* sself, long long ptId, long long cellId); +extern "C" void vtk_poly_data_resize_cell_list(vtkPolyData* sself, long long ptId, int size); +extern "C" void vtk_poly_data_initialize(vtkPolyData* sself); +extern "C" int vtk_poly_data_get_piece(vtkPolyData* sself); +extern "C" int vtk_poly_data_get_number_of_pieces(vtkPolyData* sself); +extern "C" int vtk_poly_data_get_ghost_level(vtkPolyData* sself); +extern "C" void vtk_poly_data_remove_ghost_cells(vtkPolyData* sself); +extern "C" unsigned long vtk_poly_data_get_mesh_m_time(vtkPolyData* sself); +extern "C" unsigned long vtk_poly_data_get_m_time(vtkPolyData* sself); +extern "C" vtkPolyDataCollection * vtkPolyDataCollection_new () ; +extern "C" void vtkPolyDataCollection_destructor (vtkPolyDataCollection * sself) ; +extern "C" void * vtkPolyDataCollection_get_ptr (vtkPolyDataCollection * sself) ; +extern "C" vtkPolyLine * vtkPolyLine_new () ; +extern "C" void vtkPolyLine_destructor (vtkPolyLine * sself) ; +extern "C" void * vtkPolyLine_get_ptr (vtkPolyLine * sself) ; +extern "C" int vtk_poly_line_get_cell_type(vtkPolyLine* sself); +extern "C" int vtk_poly_line_get_cell_dimension(vtkPolyLine* sself); +extern "C" int vtk_poly_line_get_number_of_edges(vtkPolyLine* sself); +extern "C" int vtk_poly_line_get_number_of_faces(vtkPolyLine* sself); +extern "C" vtkPolyPlane * vtkPolyPlane_new () ; +extern "C" void vtkPolyPlane_destructor (vtkPolyPlane * sself) ; +extern "C" void * vtkPolyPlane_get_ptr (vtkPolyPlane * sself) ; +extern "C" unsigned long vtk_poly_plane_get_m_time(vtkPolyPlane* sself); +extern "C" vtkPolyVertex * vtkPolyVertex_new () ; +extern "C" void vtkPolyVertex_destructor (vtkPolyVertex * sself) ; +extern "C" void * vtkPolyVertex_get_ptr (vtkPolyVertex * sself) ; +extern "C" int vtk_poly_vertex_get_cell_type(vtkPolyVertex* sself); +extern "C" int vtk_poly_vertex_get_cell_dimension(vtkPolyVertex* sself); +extern "C" int vtk_poly_vertex_get_number_of_edges(vtkPolyVertex* sself); +extern "C" int vtk_poly_vertex_get_number_of_faces(vtkPolyVertex* sself); +extern "C" vtkPolygon * vtkPolygon_new () ; +extern "C" void vtkPolygon_destructor (vtkPolygon * sself) ; +extern "C" void * vtkPolygon_get_ptr (vtkPolygon * sself) ; +extern "C" int vtk_polygon_get_cell_type(vtkPolygon* sself); +extern "C" int vtk_polygon_get_cell_dimension(vtkPolygon* sself); +extern "C" int vtk_polygon_get_number_of_edges(vtkPolygon* sself); +extern "C" int vtk_polygon_get_number_of_faces(vtkPolygon* sself); +extern "C" double vtk_polygon_compute_area(vtkPolygon* sself); +extern "C" bool vtk_polygon_is_convex(vtkPolygon* sself); +extern "C" bool vtk_polygon_get_use_mvc_interpolation(vtkPolygon* sself); +extern "C" void vtk_polygon_set_use_mvc_interpolation(vtkPolygon* sself, bool _arg); +extern "C" void vtk_polygon_set_tolerance(vtkPolygon* sself, double _arg); +extern "C" double vtk_polygon_get_tolerance_min_value(vtkPolygon* sself); +extern "C" double vtk_polygon_get_tolerance_max_value(vtkPolygon* sself); +extern "C" double vtk_polygon_get_tolerance(vtkPolygon* sself); +extern "C" int vtk_polygon_ear_cut_triangulation(vtkPolygon* sself, int measure); +extern "C" int vtk_polygon_unbiased_ear_cut_triangulation(vtkPolygon* sself, int seed, int measure); +extern "C" vtkPolyhedron * vtkPolyhedron_new () ; +extern "C" void vtkPolyhedron_destructor (vtkPolyhedron * sself) ; +extern "C" void * vtkPolyhedron_get_ptr (vtkPolyhedron * sself) ; +extern "C" int vtk_polyhedron_get_cell_type(vtkPolyhedron* sself); +extern "C" int vtk_polyhedron_requires_initialization(vtkPolyhedron* sself); +extern "C" int vtk_polyhedron_get_number_of_edges(vtkPolyhedron* sself); +extern "C" int vtk_polyhedron_get_number_of_faces(vtkPolyhedron* sself); +extern "C" int vtk_polyhedron_is_primary_cell(vtkPolyhedron* sself); +extern "C" int vtk_polyhedron_requires_explicit_face_representation(vtkPolyhedron* sself); +extern "C" bool vtk_polyhedron_is_convex(vtkPolyhedron* sself); +extern "C" vtkPyramid * vtkPyramid_new () ; +extern "C" void vtkPyramid_destructor (vtkPyramid * sself) ; +extern "C" void * vtkPyramid_get_ptr (vtkPyramid * sself) ; +extern "C" int vtk_pyramid_get_cell_type(vtkPyramid* sself); +extern "C" int vtk_pyramid_get_number_of_edges(vtkPyramid* sself); +extern "C" int vtk_pyramid_get_number_of_faces(vtkPyramid* sself); +extern "C" vtkQuad * vtkQuad_new () ; +extern "C" void vtkQuad_destructor (vtkQuad * sself) ; +extern "C" void * vtkQuad_get_ptr (vtkQuad * sself) ; +extern "C" int vtk_quad_get_cell_type(vtkQuad* sself); +extern "C" int vtk_quad_get_cell_dimension(vtkQuad* sself); +extern "C" int vtk_quad_get_number_of_edges(vtkQuad* sself); +extern "C" int vtk_quad_get_number_of_faces(vtkQuad* sself); +extern "C" vtkQuadraticEdge * vtkQuadraticEdge_new () ; +extern "C" void vtkQuadraticEdge_destructor (vtkQuadraticEdge * sself) ; +extern "C" void * vtkQuadraticEdge_get_ptr (vtkQuadraticEdge * sself) ; +extern "C" int vtk_quadratic_edge_get_cell_type(vtkQuadraticEdge* sself); +extern "C" int vtk_quadratic_edge_get_cell_dimension(vtkQuadraticEdge* sself); +extern "C" int vtk_quadratic_edge_get_number_of_edges(vtkQuadraticEdge* sself); +extern "C" int vtk_quadratic_edge_get_number_of_faces(vtkQuadraticEdge* sself); +extern "C" vtkQuadraticHexahedron * vtkQuadraticHexahedron_new () ; +extern "C" void vtkQuadraticHexahedron_destructor (vtkQuadraticHexahedron * sself) ; +extern "C" void * vtkQuadraticHexahedron_get_ptr (vtkQuadraticHexahedron * sself) ; +extern "C" int vtk_quadratic_hexahedron_get_cell_type(vtkQuadraticHexahedron* sself); +extern "C" int vtk_quadratic_hexahedron_get_cell_dimension(vtkQuadraticHexahedron* sself); +extern "C" int vtk_quadratic_hexahedron_get_number_of_edges(vtkQuadraticHexahedron* sself); +extern "C" int vtk_quadratic_hexahedron_get_number_of_faces(vtkQuadraticHexahedron* sself); +extern "C" vtkQuadraticLinearQuad * vtkQuadraticLinearQuad_new () ; +extern "C" void vtkQuadraticLinearQuad_destructor (vtkQuadraticLinearQuad * sself) ; +extern "C" void * vtkQuadraticLinearQuad_get_ptr (vtkQuadraticLinearQuad * sself) ; +extern "C" int vtk_quadratic_linear_quad_get_cell_type(vtkQuadraticLinearQuad* sself); +extern "C" int vtk_quadratic_linear_quad_get_cell_dimension(vtkQuadraticLinearQuad* sself); +extern "C" int vtk_quadratic_linear_quad_get_number_of_edges(vtkQuadraticLinearQuad* sself); +extern "C" int vtk_quadratic_linear_quad_get_number_of_faces(vtkQuadraticLinearQuad* sself); +extern "C" vtkQuadraticLinearWedge * vtkQuadraticLinearWedge_new () ; +extern "C" void vtkQuadraticLinearWedge_destructor (vtkQuadraticLinearWedge * sself) ; +extern "C" void * vtkQuadraticLinearWedge_get_ptr (vtkQuadraticLinearWedge * sself) ; +extern "C" int vtk_quadratic_linear_wedge_get_cell_type(vtkQuadraticLinearWedge* sself); +extern "C" int vtk_quadratic_linear_wedge_get_cell_dimension(vtkQuadraticLinearWedge* sself); +extern "C" int vtk_quadratic_linear_wedge_get_number_of_edges(vtkQuadraticLinearWedge* sself); +extern "C" int vtk_quadratic_linear_wedge_get_number_of_faces(vtkQuadraticLinearWedge* sself); +extern "C" vtkQuadraticPolygon * vtkQuadraticPolygon_new () ; +extern "C" void vtkQuadraticPolygon_destructor (vtkQuadraticPolygon * sself) ; +extern "C" void * vtkQuadraticPolygon_get_ptr (vtkQuadraticPolygon * sself) ; +extern "C" int vtk_quadratic_polygon_get_cell_type(vtkQuadraticPolygon* sself); +extern "C" int vtk_quadratic_polygon_get_cell_dimension(vtkQuadraticPolygon* sself); +extern "C" int vtk_quadratic_polygon_get_number_of_edges(vtkQuadraticPolygon* sself); +extern "C" int vtk_quadratic_polygon_get_number_of_faces(vtkQuadraticPolygon* sself); +extern "C" bool vtk_quadratic_polygon_get_use_mvc_interpolation(vtkQuadraticPolygon* sself); +extern "C" void vtk_quadratic_polygon_set_use_mvc_interpolation(vtkQuadraticPolygon* sself, bool _arg); +extern "C" vtkQuadraticPyramid * vtkQuadraticPyramid_new () ; +extern "C" void vtkQuadraticPyramid_destructor (vtkQuadraticPyramid * sself) ; +extern "C" void * vtkQuadraticPyramid_get_ptr (vtkQuadraticPyramid * sself) ; +extern "C" int vtk_quadratic_pyramid_get_cell_type(vtkQuadraticPyramid* sself); +extern "C" int vtk_quadratic_pyramid_get_cell_dimension(vtkQuadraticPyramid* sself); +extern "C" int vtk_quadratic_pyramid_get_number_of_edges(vtkQuadraticPyramid* sself); +extern "C" int vtk_quadratic_pyramid_get_number_of_faces(vtkQuadraticPyramid* sself); +extern "C" vtkQuadraticQuad * vtkQuadraticQuad_new () ; +extern "C" void vtkQuadraticQuad_destructor (vtkQuadraticQuad * sself) ; +extern "C" void * vtkQuadraticQuad_get_ptr (vtkQuadraticQuad * sself) ; +extern "C" int vtk_quadratic_quad_get_cell_type(vtkQuadraticQuad* sself); +extern "C" int vtk_quadratic_quad_get_cell_dimension(vtkQuadraticQuad* sself); +extern "C" int vtk_quadratic_quad_get_number_of_edges(vtkQuadraticQuad* sself); +extern "C" int vtk_quadratic_quad_get_number_of_faces(vtkQuadraticQuad* sself); +extern "C" vtkQuadraticTetra * vtkQuadraticTetra_new () ; +extern "C" void vtkQuadraticTetra_destructor (vtkQuadraticTetra * sself) ; +extern "C" void * vtkQuadraticTetra_get_ptr (vtkQuadraticTetra * sself) ; +extern "C" int vtk_quadratic_tetra_get_cell_type(vtkQuadraticTetra* sself); +extern "C" int vtk_quadratic_tetra_get_cell_dimension(vtkQuadraticTetra* sself); +extern "C" int vtk_quadratic_tetra_get_number_of_edges(vtkQuadraticTetra* sself); +extern "C" int vtk_quadratic_tetra_get_number_of_faces(vtkQuadraticTetra* sself); +extern "C" vtkQuadraticTriangle * vtkQuadraticTriangle_new () ; +extern "C" void vtkQuadraticTriangle_destructor (vtkQuadraticTriangle * sself) ; +extern "C" void * vtkQuadraticTriangle_get_ptr (vtkQuadraticTriangle * sself) ; +extern "C" int vtk_quadratic_triangle_get_cell_type(vtkQuadraticTriangle* sself); +extern "C" int vtk_quadratic_triangle_get_cell_dimension(vtkQuadraticTriangle* sself); +extern "C" int vtk_quadratic_triangle_get_number_of_edges(vtkQuadraticTriangle* sself); +extern "C" int vtk_quadratic_triangle_get_number_of_faces(vtkQuadraticTriangle* sself); +extern "C" vtkQuadraticWedge * vtkQuadraticWedge_new () ; +extern "C" void vtkQuadraticWedge_destructor (vtkQuadraticWedge * sself) ; +extern "C" void * vtkQuadraticWedge_get_ptr (vtkQuadraticWedge * sself) ; +extern "C" int vtk_quadratic_wedge_get_cell_type(vtkQuadraticWedge* sself); +extern "C" int vtk_quadratic_wedge_get_cell_dimension(vtkQuadraticWedge* sself); +extern "C" int vtk_quadratic_wedge_get_number_of_edges(vtkQuadraticWedge* sself); +extern "C" int vtk_quadratic_wedge_get_number_of_faces(vtkQuadraticWedge* sself); +extern "C" vtkQuadratureSchemeDefinition * vtkQuadratureSchemeDefinition_new () ; +extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkQuadratureSchemeDefinition * sself) ; +extern "C" void * vtkQuadratureSchemeDefinition_get_ptr (vtkQuadratureSchemeDefinition * sself) ; +extern "C" void vtk_quadrature_scheme_definition_clear(vtkQuadratureSchemeDefinition* sself); +extern "C" int vtk_quadrature_scheme_definition_get_cell_type(vtkQuadratureSchemeDefinition* sself); +extern "C" int vtk_quadrature_scheme_definition_get_quadrature_key(vtkQuadratureSchemeDefinition* sself); +extern "C" int vtk_quadrature_scheme_definition_get_number_of_nodes(vtkQuadratureSchemeDefinition* sself); +extern "C" int vtk_quadrature_scheme_definition_get_number_of_quadrature_points(vtkQuadratureSchemeDefinition* sself); +extern "C" vtkQuadric * vtkQuadric_new () ; +extern "C" void vtkQuadric_destructor (vtkQuadric * sself) ; +extern "C" void * vtkQuadric_get_ptr (vtkQuadric * sself) ; +extern "C" void vtk_quadric_set_coefficients(vtkQuadric* sself, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9); +extern "C" vtkRectilinearGrid * vtkRectilinearGrid_new () ; +extern "C" void vtkRectilinearGrid_destructor (vtkRectilinearGrid * sself) ; +extern "C" void * vtkRectilinearGrid_get_ptr (vtkRectilinearGrid * sself) ; +extern "C" int vtk_rectilinear_grid_get_data_object_type(vtkRectilinearGrid* sself); +extern "C" void vtk_rectilinear_grid_initialize(vtkRectilinearGrid* sself); +extern "C" long long vtk_rectilinear_grid_get_number_of_cells(vtkRectilinearGrid* sself); +extern "C" long long vtk_rectilinear_grid_get_number_of_points(vtkRectilinearGrid* sself); +extern "C" int vtk_rectilinear_grid_get_cell_type(vtkRectilinearGrid* sself, long long cellId); +extern "C" int vtk_rectilinear_grid_get_max_cell_size(vtkRectilinearGrid* sself); +extern "C" unsigned char vtk_rectilinear_grid_is_point_visible(vtkRectilinearGrid* sself, long long ptId); +extern "C" unsigned char vtk_rectilinear_grid_is_cell_visible(vtkRectilinearGrid* sself, long long cellId); +extern "C" bool vtk_rectilinear_grid_has_any_blank_points(vtkRectilinearGrid* sself); +extern "C" bool vtk_rectilinear_grid_has_any_blank_cells(vtkRectilinearGrid* sself); +extern "C" void vtk_rectilinear_grid_set_dimensions(vtkRectilinearGrid* sself, int i, int j, int k); +extern "C" int vtk_rectilinear_grid_get_data_dimension(vtkRectilinearGrid* sself); +extern "C" void vtk_rectilinear_grid_set_extent(vtkRectilinearGrid* sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax); +extern "C" int vtk_rectilinear_grid_get_extent_type(vtkRectilinearGrid* sself); +extern "C" const char* vtk_rectilinear_grid_get_scalar_type_as_string(vtkRectilinearGrid* sself); +extern "C" vtkReebGraph * vtkReebGraph_new () ; +extern "C" void vtkReebGraph_destructor (vtkReebGraph * sself) ; +extern "C" void * vtkReebGraph_get_ptr (vtkReebGraph * sself) ; +extern "C" int vtk_reeb_graph_stream_triangle(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2); +extern "C" int vtk_reeb_graph_stream_tetrahedron(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2, long long vertex3Id, double scalar3); +extern "C" void vtk_reeb_graph_close_stream(vtkReebGraph* sself); +extern "C" vtkReebGraphSimplificationMetric * vtkReebGraphSimplificationMetric_new () ; +extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkReebGraphSimplificationMetric * sself) ; +extern "C" void * vtkReebGraphSimplificationMetric_get_ptr (vtkReebGraphSimplificationMetric * sself) ; +extern "C" void vtk_reeb_graph_simplification_metric_set_lower_bound(vtkReebGraphSimplificationMetric* sself, double _arg); +extern "C" double vtk_reeb_graph_simplification_metric_get_lower_bound(vtkReebGraphSimplificationMetric* sself); +extern "C" void vtk_reeb_graph_simplification_metric_set_upper_bound(vtkReebGraphSimplificationMetric* sself, double _arg); +extern "C" double vtk_reeb_graph_simplification_metric_get_upper_bound(vtkReebGraphSimplificationMetric* sself); +extern "C" vtkSelection * vtkSelection_new () ; +extern "C" void vtkSelection_destructor (vtkSelection * sself) ; +extern "C" void * vtkSelection_get_ptr (vtkSelection * sself) ; +extern "C" int vtk_selection_get_data_object_type(vtkSelection* sself); +extern "C" unsigned int vtk_selection_get_number_of_nodes(vtkSelection* sself); +extern "C" void vtk_selection_remove_node(vtkSelection* sself, unsigned int idx); +extern "C" void vtk_selection_remove_all_nodes(vtkSelection* sself); +extern "C" void vtk_selection_set_expression(vtkSelection* sself, const char* _arg); +extern "C" unsigned long vtk_selection_get_m_time(vtkSelection* sself); +extern "C" void vtk_selection_dump(vtkSelection* sself); +extern "C" vtkSelectionNode * vtkSelectionNode_new () ; +extern "C" void vtkSelectionNode_destructor (vtkSelectionNode * sself) ; +extern "C" void * vtkSelectionNode_get_ptr (vtkSelectionNode * sself) ; +extern "C" void vtk_selection_node_initialize(vtkSelectionNode* sself); +extern "C" unsigned long vtk_selection_node_get_m_time(vtkSelectionNode* sself); +extern "C" void vtk_selection_node_set_content_type(vtkSelectionNode* sself, int type); +extern "C" int vtk_selection_node_get_content_type(vtkSelectionNode* sself); +extern "C" const char* vtk_selection_node_get_content_type_as_string(vtkSelectionNode* sself, int type); +extern "C" void vtk_selection_node_set_field_type(vtkSelectionNode* sself, int type); +extern "C" int vtk_selection_node_get_field_type(vtkSelectionNode* sself); +extern "C" const char* vtk_selection_node_get_field_type_as_string(vtkSelectionNode* sself, int type); +extern "C" int vtk_selection_node_get_field_type_from_string(vtkSelectionNode* sself, const char* type); +extern "C" int vtk_selection_node_convert_selection_field_to_attribute_type(vtkSelectionNode* sself, int val); +extern "C" int vtk_selection_node_convert_attribute_type_to_selection_field(vtkSelectionNode* sself, int val); +extern "C" void vtk_selection_node_set_query_string(vtkSelectionNode* sself, const char* _arg); +extern "C" vtkSimpleCellTessellator * vtkSimpleCellTessellator_new () ; +extern "C" void vtkSimpleCellTessellator_destructor (vtkSimpleCellTessellator * sself) ; +extern "C" void * vtkSimpleCellTessellator_get_ptr (vtkSimpleCellTessellator * sself) ; +extern "C" void vtk_simple_cell_tessellator_reset(vtkSimpleCellTessellator* sself); +extern "C" int vtk_simple_cell_tessellator_get_fixed_subdivisions(vtkSimpleCellTessellator* sself); +extern "C" int vtk_simple_cell_tessellator_get_max_subdivision_level(vtkSimpleCellTessellator* sself); +extern "C" int vtk_simple_cell_tessellator_get_max_adaptive_subdivisions(vtkSimpleCellTessellator* sself); +extern "C" void vtk_simple_cell_tessellator_set_fixed_subdivisions(vtkSimpleCellTessellator* sself, int level); +extern "C" void vtk_simple_cell_tessellator_set_max_subdivision_level(vtkSimpleCellTessellator* sself, int level); +extern "C" void vtk_simple_cell_tessellator_set_subdivision_levels(vtkSimpleCellTessellator* sself, int fixed, int maxLevel); +extern "C" vtkSmoothErrorMetric * vtkSmoothErrorMetric_new () ; +extern "C" void vtkSmoothErrorMetric_destructor (vtkSmoothErrorMetric * sself) ; +extern "C" void * vtkSmoothErrorMetric_get_ptr (vtkSmoothErrorMetric * sself) ; +extern "C" double vtk_smooth_error_metric_get_angle_tolerance(vtkSmoothErrorMetric* sself); +extern "C" void vtk_smooth_error_metric_set_angle_tolerance(vtkSmoothErrorMetric* sself, double value); +extern "C" vtkSortFieldData * vtkSortFieldData_new () ; +extern "C" void vtkSortFieldData_destructor (vtkSortFieldData * sself) ; +extern "C" void * vtkSortFieldData_get_ptr (vtkSortFieldData * sself) ; +extern "C" vtkSphere * vtkSphere_new () ; +extern "C" void vtkSphere_destructor (vtkSphere * sself) ; +extern "C" void * vtkSphere_get_ptr (vtkSphere * sself) ; +extern "C" void vtk_sphere_set_radius(vtkSphere* sself, double _arg); +extern "C" double vtk_sphere_get_radius(vtkSphere* sself); +extern "C" void vtk_sphere_set_center(vtkSphere* sself, double _arg1, double _arg2, double _arg3); +extern "C" vtkSpheres * vtkSpheres_new () ; +extern "C" void vtkSpheres_destructor (vtkSpheres * sself) ; +extern "C" void * vtkSpheres_get_ptr (vtkSpheres * sself) ; +extern "C" int vtk_spheres_get_number_of_spheres(vtkSpheres* sself); +extern "C" vtkStaticCellLinks * vtkStaticCellLinks_new () ; +extern "C" void vtkStaticCellLinks_destructor (vtkStaticCellLinks * sself) ; +extern "C" void * vtkStaticCellLinks_get_ptr (vtkStaticCellLinks * sself) ; +extern "C" long long vtk_static_cell_links_get_number_of_cells(vtkStaticCellLinks* sself, long long ptId); +extern "C" long long vtk_static_cell_links_get_ncells(vtkStaticCellLinks* sself, long long ptId); +extern "C" void vtk_static_cell_links_initialize(vtkStaticCellLinks* sself); +extern "C" void vtk_static_cell_links_squeeze(vtkStaticCellLinks* sself); +extern "C" void vtk_static_cell_links_reset(vtkStaticCellLinks* sself); +extern "C" unsigned long vtk_static_cell_links_get_actual_memory_size(vtkStaticCellLinks* sself); +extern "C" vtkStaticCellLocator * vtkStaticCellLocator_new () ; +extern "C" void vtkStaticCellLocator_destructor (vtkStaticCellLocator * sself) ; +extern "C" void * vtkStaticCellLocator_get_ptr (vtkStaticCellLocator * sself) ; +extern "C" void vtk_static_cell_locator_set_divisions(vtkStaticCellLocator* sself, int _arg1, int _arg2, int _arg3); +extern "C" void vtk_static_cell_locator_free_search_structure(vtkStaticCellLocator* sself); +extern "C" void vtk_static_cell_locator_build_locator(vtkStaticCellLocator* sself); +extern "C" void vtk_static_cell_locator_set_max_number_of_buckets(vtkStaticCellLocator* sself, long long _arg); +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_min_value(vtkStaticCellLocator* sself); +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_max_value(vtkStaticCellLocator* sself); +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets(vtkStaticCellLocator* sself); +extern "C" bool vtk_static_cell_locator_get_large_ids(vtkStaticCellLocator* sself); +extern "C" void vtk_static_cell_locator_set_use_diagonal_length_tolerance(vtkStaticCellLocator* sself, bool _arg); +extern "C" bool vtk_static_cell_locator_get_use_diagonal_length_tolerance(vtkStaticCellLocator* sself); +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_on(vtkStaticCellLocator* sself); +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_off(vtkStaticCellLocator* sself); +extern "C" vtkStaticPointLocator * vtkStaticPointLocator_new () ; +extern "C" void vtkStaticPointLocator_destructor (vtkStaticPointLocator * sself) ; +extern "C" void * vtkStaticPointLocator_get_ptr (vtkStaticPointLocator * sself) ; +extern "C" void vtk_static_point_locator_set_number_of_points_per_bucket(vtkStaticPointLocator* sself, int _arg); +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator* sself); +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator* sself); +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket(vtkStaticPointLocator* sself); +extern "C" void vtk_static_point_locator_set_divisions(vtkStaticPointLocator* sself, int _arg1, int _arg2, int _arg3); +extern "C" void vtk_static_point_locator_initialize(vtkStaticPointLocator* sself); +extern "C" void vtk_static_point_locator_free_search_structure(vtkStaticPointLocator* sself); +extern "C" void vtk_static_point_locator_build_locator(vtkStaticPointLocator* sself); +extern "C" long long vtk_static_point_locator_get_number_of_points_in_bucket(vtkStaticPointLocator* sself, long long bNum); +extern "C" void vtk_static_point_locator_set_max_number_of_buckets(vtkStaticPointLocator* sself, long long _arg); +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_min_value(vtkStaticPointLocator* sself); +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_max_value(vtkStaticPointLocator* sself); +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets(vtkStaticPointLocator* sself); +extern "C" bool vtk_static_point_locator_get_large_ids(vtkStaticPointLocator* sself); +extern "C" vtkStaticPointLocator2D * vtkStaticPointLocator2D_new () ; +extern "C" void vtkStaticPointLocator2D_destructor (vtkStaticPointLocator2D * sself) ; +extern "C" void * vtkStaticPointLocator2D_get_ptr (vtkStaticPointLocator2D * sself) ; +extern "C" void vtk_static_point_locator_2_d_set_number_of_points_per_bucket(vtkStaticPointLocator2D* sself, int _arg); +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator2D* sself); +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator2D* sself); +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket(vtkStaticPointLocator2D* sself); +extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkStaticPointLocator2D* sself, int _arg1, int _arg2); +extern "C" void vtk_static_point_locator_2_d_initialize(vtkStaticPointLocator2D* sself); +extern "C" void vtk_static_point_locator_2_d_free_search_structure(vtkStaticPointLocator2D* sself); +extern "C" void vtk_static_point_locator_2_d_build_locator(vtkStaticPointLocator2D* sself); +extern "C" long long vtk_static_point_locator_2_d_get_number_of_points_in_bucket(vtkStaticPointLocator2D* sself, long long bNum); +extern "C" void vtk_static_point_locator_2_d_set_max_number_of_buckets(vtkStaticPointLocator2D* sself, long long _arg); +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(vtkStaticPointLocator2D* sself); +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(vtkStaticPointLocator2D* sself); +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets(vtkStaticPointLocator2D* sself); +extern "C" bool vtk_static_point_locator_2_d_get_large_ids(vtkStaticPointLocator2D* sself); +extern "C" vtkStructuredExtent * vtkStructuredExtent_new () ; +extern "C" void vtkStructuredExtent_destructor (vtkStructuredExtent * sself) ; +extern "C" void * vtkStructuredExtent_get_ptr (vtkStructuredExtent * sself) ; +extern "C" vtkStructuredGrid * vtkStructuredGrid_new () ; +extern "C" void vtkStructuredGrid_destructor (vtkStructuredGrid * sself) ; +extern "C" void * vtkStructuredGrid_get_ptr (vtkStructuredGrid * sself) ; +extern "C" int vtk_structured_grid_get_data_object_type(vtkStructuredGrid* sself); +extern "C" long long vtk_structured_grid_get_number_of_points(vtkStructuredGrid* sself); +extern "C" int vtk_structured_grid_get_cell_type(vtkStructuredGrid* sself, long long cellId); +extern "C" void vtk_structured_grid_set_dimensions(vtkStructuredGrid* sself, int i, int j, int k); +extern "C" int vtk_structured_grid_get_data_dimension(vtkStructuredGrid* sself); +extern "C" void vtk_structured_grid_set_extent(vtkStructuredGrid* sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax); +extern "C" int vtk_structured_grid_get_extent_type(vtkStructuredGrid* sself); +extern "C" void vtk_structured_grid_blank_point(vtkStructuredGrid* sself, long long ptId); +extern "C" void vtk_structured_grid_un_blank_point(vtkStructuredGrid* sself, long long ptId); +extern "C" void vtk_structured_grid_blank_cell(vtkStructuredGrid* sself, long long ptId); +extern "C" void vtk_structured_grid_un_blank_cell(vtkStructuredGrid* sself, long long ptId); +extern "C" unsigned char vtk_structured_grid_is_point_visible(vtkStructuredGrid* sself, long long ptId); +extern "C" unsigned char vtk_structured_grid_is_cell_visible(vtkStructuredGrid* sself, long long cellId); +extern "C" bool vtk_structured_grid_has_any_blank_points(vtkStructuredGrid* sself); +extern "C" bool vtk_structured_grid_has_any_blank_cells(vtkStructuredGrid* sself); +extern "C" vtkStructuredPoints * vtkStructuredPoints_new () ; +extern "C" void vtkStructuredPoints_destructor (vtkStructuredPoints * sself) ; +extern "C" void * vtkStructuredPoints_get_ptr (vtkStructuredPoints * sself) ; +extern "C" int vtk_structured_points_get_data_object_type(vtkStructuredPoints* sself); +extern "C" vtkStructuredPointsCollection * vtkStructuredPointsCollection_new () ; +extern "C" void vtkStructuredPointsCollection_destructor (vtkStructuredPointsCollection * sself) ; +extern "C" void * vtkStructuredPointsCollection_get_ptr (vtkStructuredPointsCollection * sself) ; +extern "C" vtkSuperquadric * vtkSuperquadric_new () ; +extern "C" void vtkSuperquadric_destructor (vtkSuperquadric * sself) ; +extern "C" void * vtkSuperquadric_get_ptr (vtkSuperquadric * sself) ; +extern "C" void vtk_superquadric_set_center(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_superquadric_set_scale(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3); +extern "C" double vtk_superquadric_get_thickness(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_set_thickness(vtkSuperquadric* sself, double _arg); +extern "C" double vtk_superquadric_get_thickness_min_value(vtkSuperquadric* sself); +extern "C" double vtk_superquadric_get_thickness_max_value(vtkSuperquadric* sself); +extern "C" double vtk_superquadric_get_phi_roundness(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_set_phi_roundness(vtkSuperquadric* sself, double e); +extern "C" double vtk_superquadric_get_theta_roundness(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_set_theta_roundness(vtkSuperquadric* sself, double e); +extern "C" void vtk_superquadric_set_size(vtkSuperquadric* sself, double _arg); +extern "C" double vtk_superquadric_get_size(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_toroidal_on(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_toroidal_off(vtkSuperquadric* sself); +extern "C" int vtk_superquadric_get_toroidal(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_set_toroidal(vtkSuperquadric* sself, int _arg); +extern "C" vtkTable * vtkTable_new () ; +extern "C" void vtkTable_destructor (vtkTable * sself) ; +extern "C" void * vtkTable_get_ptr (vtkTable * sself) ; +extern "C" void vtk_table_dump(vtkTable* sself, unsigned int colWidth, int rowLimit); +extern "C" int vtk_table_get_data_object_type(vtkTable* sself); +extern "C" long long vtk_table_get_number_of_rows(vtkTable* sself); +extern "C" void vtk_table_set_number_of_rows(vtkTable* sself, const long long p0); +extern "C" long long vtk_table_insert_next_blank_row(vtkTable* sself, double default_num_val); +extern "C" void vtk_table_remove_row(vtkTable* sself, long long row); +extern "C" long long vtk_table_get_number_of_columns(vtkTable* sself); +extern "C" const char* vtk_table_get_column_name(vtkTable* sself, long long col); +extern "C" void vtk_table_remove_column_by_name(vtkTable* sself, const char* name); +extern "C" void vtk_table_remove_column(vtkTable* sself, long long col); +extern "C" void vtk_table_initialize(vtkTable* sself); +extern "C" long long vtk_table_get_number_of_elements(vtkTable* sself, int type); +extern "C" vtkTetra * vtkTetra_new () ; +extern "C" void vtkTetra_destructor (vtkTetra * sself) ; +extern "C" void * vtkTetra_get_ptr (vtkTetra * sself) ; +extern "C" int vtk_tetra_get_cell_type(vtkTetra* sself); +extern "C" int vtk_tetra_get_number_of_edges(vtkTetra* sself); +extern "C" int vtk_tetra_get_number_of_faces(vtkTetra* sself); +extern "C" vtkTree * vtkTree_new () ; +extern "C" void vtkTree_destructor (vtkTree * sself) ; +extern "C" void * vtkTree_get_ptr (vtkTree * sself) ; +extern "C" long long vtk_tree_get_root(vtkTree* sself); +extern "C" long long vtk_tree_get_number_of_children(vtkTree* sself, long long v); +extern "C" long long vtk_tree_get_child(vtkTree* sself, long long v, long long i); +extern "C" long long vtk_tree_get_parent(vtkTree* sself, long long v); +extern "C" long long vtk_tree_get_level(vtkTree* sself, long long v); +extern "C" bool vtk_tree_is_leaf(vtkTree* sself, long long vertex); +extern "C" vtkTreeBFSIterator * vtkTreeBFSIterator_new () ; +extern "C" void vtkTreeBFSIterator_destructor (vtkTreeBFSIterator * sself) ; +extern "C" void * vtkTreeBFSIterator_get_ptr (vtkTreeBFSIterator * sself) ; +extern "C" vtkTreeDFSIterator * vtkTreeDFSIterator_new () ; +extern "C" void vtkTreeDFSIterator_destructor (vtkTreeDFSIterator * sself) ; +extern "C" void * vtkTreeDFSIterator_get_ptr (vtkTreeDFSIterator * sself) ; +extern "C" void vtk_tree_dfs_iterator_set_mode(vtkTreeDFSIterator* sself, int mode); +extern "C" int vtk_tree_dfs_iterator_get_mode(vtkTreeDFSIterator* sself); +extern "C" vtkTriQuadraticHexahedron * vtkTriQuadraticHexahedron_new () ; +extern "C" void vtkTriQuadraticHexahedron_destructor (vtkTriQuadraticHexahedron * sself) ; +extern "C" void * vtkTriQuadraticHexahedron_get_ptr (vtkTriQuadraticHexahedron * sself) ; +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_type(vtkTriQuadraticHexahedron* sself); +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_dimension(vtkTriQuadraticHexahedron* sself); +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_edges(vtkTriQuadraticHexahedron* sself); +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_faces(vtkTriQuadraticHexahedron* sself); +extern "C" vtkTriQuadraticPyramid * vtkTriQuadraticPyramid_new () ; +extern "C" void vtkTriQuadraticPyramid_destructor (vtkTriQuadraticPyramid * sself) ; +extern "C" void * vtkTriQuadraticPyramid_get_ptr (vtkTriQuadraticPyramid * sself) ; +extern "C" int vtk_tri_quadratic_pyramid_get_cell_type(vtkTriQuadraticPyramid* sself); +extern "C" int vtk_tri_quadratic_pyramid_get_cell_dimension(vtkTriQuadraticPyramid* sself); +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_edges(vtkTriQuadraticPyramid* sself); +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_faces(vtkTriQuadraticPyramid* sself); +extern "C" vtkTriangle * vtkTriangle_new () ; +extern "C" void vtkTriangle_destructor (vtkTriangle * sself) ; +extern "C" void * vtkTriangle_get_ptr (vtkTriangle * sself) ; +extern "C" int vtk_triangle_get_cell_type(vtkTriangle* sself); +extern "C" int vtk_triangle_get_cell_dimension(vtkTriangle* sself); +extern "C" int vtk_triangle_get_number_of_edges(vtkTriangle* sself); +extern "C" int vtk_triangle_get_number_of_faces(vtkTriangle* sself); +extern "C" double vtk_triangle_compute_area(vtkTriangle* sself); +extern "C" vtkTriangleStrip * vtkTriangleStrip_new () ; +extern "C" void vtkTriangleStrip_destructor (vtkTriangleStrip * sself) ; +extern "C" void * vtkTriangleStrip_get_ptr (vtkTriangleStrip * sself) ; +extern "C" int vtk_triangle_strip_get_cell_type(vtkTriangleStrip* sself); +extern "C" int vtk_triangle_strip_get_cell_dimension(vtkTriangleStrip* sself); +extern "C" int vtk_triangle_strip_get_number_of_edges(vtkTriangleStrip* sself); +extern "C" int vtk_triangle_strip_get_number_of_faces(vtkTriangleStrip* sself); +extern "C" vtkUndirectedGraph * vtkUndirectedGraph_new () ; +extern "C" void vtkUndirectedGraph_destructor (vtkUndirectedGraph * sself) ; +extern "C" void * vtkUndirectedGraph_get_ptr (vtkUndirectedGraph * sself) ; +extern "C" long long vtk_undirected_graph_get_in_degree(vtkUndirectedGraph* sself, long long v); +extern "C" vtkUniformGrid * vtkUniformGrid_new () ; +extern "C" void vtkUniformGrid_destructor (vtkUniformGrid * sself) ; +extern "C" void * vtkUniformGrid_get_ptr (vtkUniformGrid * sself) ; +extern "C" int vtk_uniform_grid_get_grid_description(vtkUniformGrid* sself); +extern "C" void vtk_uniform_grid_blank_point(vtkUniformGrid* sself, long long ptId); +extern "C" void vtk_uniform_grid_un_blank_point(vtkUniformGrid* sself, long long ptId); +extern "C" void vtk_uniform_grid_blank_cell(vtkUniformGrid* sself, long long ptId); +extern "C" void vtk_uniform_grid_un_blank_cell(vtkUniformGrid* sself, long long ptId); +extern "C" unsigned char vtk_uniform_grid_is_point_visible(vtkUniformGrid* sself, long long pointId); +extern "C" unsigned char vtk_uniform_grid_is_cell_visible(vtkUniformGrid* sself, long long cellId); +extern "C" vtkUniformGridAMR * vtkUniformGridAMR_new () ; +extern "C" void vtkUniformGridAMR_destructor (vtkUniformGridAMR * sself) ; +extern "C" void * vtkUniformGridAMR_get_ptr (vtkUniformGridAMR * sself) ; +extern "C" int vtk_uniform_grid_amr_get_data_object_type(vtkUniformGridAMR* sself); +extern "C" void vtk_uniform_grid_amr_initialize(vtkUniformGridAMR* sself); +extern "C" void vtk_uniform_grid_amr_set_grid_description(vtkUniformGridAMR* sself, int gridDescription); +extern "C" int vtk_uniform_grid_amr_get_grid_description(vtkUniformGridAMR* sself); +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_levels(vtkUniformGridAMR* sself); +extern "C" unsigned int vtk_uniform_grid_amr_get_total_number_of_blocks(vtkUniformGridAMR* sself); +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_data_sets(vtkUniformGridAMR* sself, const unsigned int level); +extern "C" int vtk_uniform_grid_amr_get_composite_index(vtkUniformGridAMR* sself, const unsigned int level, const unsigned int index); +extern "C" void vtk_uniform_grid_amr_get_level_and_index(vtkUniformGridAMR* sself, const unsigned int compositeIdx, unsigned int& level, unsigned int& idx); +extern "C" vtkUniformGridAMRDataIterator * vtkUniformGridAMRDataIterator_new () ; +extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkUniformGridAMRDataIterator * sself) ; +extern "C" void * vtkUniformGridAMRDataIterator_get_ptr (vtkUniformGridAMRDataIterator * sself) ; +extern "C" int vtk_uniform_grid_amr_data_iterator_has_current_meta_data(vtkUniformGridAMRDataIterator* sself); +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_flat_index(vtkUniformGridAMRDataIterator* sself); +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_level(vtkUniformGridAMRDataIterator* sself); +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_index(vtkUniformGridAMRDataIterator* sself); +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_first_item(vtkUniformGridAMRDataIterator* sself); +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_next_item(vtkUniformGridAMRDataIterator* sself); +extern "C" int vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(vtkUniformGridAMRDataIterator* sself); +extern "C" vtkUniformHyperTreeGrid * vtkUniformHyperTreeGrid_new () ; +extern "C" void vtkUniformHyperTreeGrid_destructor (vtkUniformHyperTreeGrid * sself) ; +extern "C" void * vtkUniformHyperTreeGrid_get_ptr (vtkUniformHyperTreeGrid * sself) ; +extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkUniformHyperTreeGrid* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkUniformHyperTreeGrid* sself, double p0, double p1, double p2); +extern "C" unsigned long vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(vtkUniformHyperTreeGrid* sself); +extern "C" vtkUnstructuredGrid * vtkUnstructuredGrid_new () ; +extern "C" void vtkUnstructuredGrid_destructor (vtkUnstructuredGrid * sself) ; +extern "C" void * vtkUnstructuredGrid_get_ptr (vtkUnstructuredGrid * sself) ; +extern "C" int vtk_unstructured_grid_get_data_object_type(vtkUnstructuredGrid* sself); +extern "C" bool vtk_unstructured_grid_allocate_estimate(vtkUnstructuredGrid* sself, long long numCells, long long maxCellSize); +extern "C" bool vtk_unstructured_grid_allocate_exact(vtkUnstructuredGrid* sself, long long numCells, long long connectivitySize); +extern "C" void vtk_unstructured_grid_allocate(vtkUnstructuredGrid* sself, long long numCells, int extSize); +extern "C" void vtk_unstructured_grid_reset(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_get_cell_type(vtkUnstructuredGrid* sself, long long cellId); +extern "C" void vtk_unstructured_grid_squeeze(vtkUnstructuredGrid* sself); +extern "C" void vtk_unstructured_grid_initialize(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_get_max_cell_size(vtkUnstructuredGrid* sself); +extern "C" void vtk_unstructured_grid_build_links(vtkUnstructuredGrid* sself); +extern "C" void vtk_unstructured_grid_remove_reference_to_cell(vtkUnstructuredGrid* sself, long long ptId, long long cellId); +extern "C" void vtk_unstructured_grid_add_reference_to_cell(vtkUnstructuredGrid* sself, long long ptId, long long cellId); +extern "C" void vtk_unstructured_grid_resize_cell_list(vtkUnstructuredGrid* sself, long long ptId, int size); +extern "C" int vtk_unstructured_grid_get_piece(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_get_number_of_pieces(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_get_ghost_level(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_is_homogeneous(vtkUnstructuredGrid* sself); +extern "C" void vtk_unstructured_grid_remove_ghost_cells(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_initialize_faces_representation(vtkUnstructuredGrid* sself, long long numPrevCells); +extern "C" unsigned long vtk_unstructured_grid_get_mesh_m_time(vtkUnstructuredGrid* sself); +extern "C" vtkUnstructuredGridCellIterator * vtkUnstructuredGridCellIterator_new () ; +extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkUnstructuredGridCellIterator * sself) ; +extern "C" void * vtkUnstructuredGridCellIterator_get_ptr (vtkUnstructuredGridCellIterator * sself) ; +extern "C" bool vtk_unstructured_grid_cell_iterator_is_done_with_traversal(vtkUnstructuredGridCellIterator* sself); +extern "C" long long vtk_unstructured_grid_cell_iterator_get_cell_id(vtkUnstructuredGridCellIterator* sself); +extern "C" void vtk_unstructured_grid_cell_iterator_go_to_cell(vtkUnstructuredGridCellIterator* sself, long long cellId); +extern "C" vtkVertex * vtkVertex_new () ; +extern "C" void vtkVertex_destructor (vtkVertex * sself) ; +extern "C" void * vtkVertex_get_ptr (vtkVertex * sself) ; +extern "C" int vtk_vertex_get_cell_type(vtkVertex* sself); +extern "C" int vtk_vertex_get_cell_dimension(vtkVertex* sself); +extern "C" int vtk_vertex_get_number_of_edges(vtkVertex* sself); +extern "C" int vtk_vertex_get_number_of_faces(vtkVertex* sself); +extern "C" int vtk_vertex_inflate(vtkVertex* sself, double p0); +extern "C" vtkVertexListIterator * vtkVertexListIterator_new () ; +extern "C" void vtkVertexListIterator_destructor (vtkVertexListIterator * sself) ; +extern "C" void * vtkVertexListIterator_get_ptr (vtkVertexListIterator * sself) ; +extern "C" long long vtk_vertex_list_iterator_next(vtkVertexListIterator* sself); +extern "C" bool vtk_vertex_list_iterator_has_next(vtkVertexListIterator* sself); +extern "C" vtkVoxel * vtkVoxel_new () ; +extern "C" void vtkVoxel_destructor (vtkVoxel * sself) ; +extern "C" void * vtkVoxel_get_ptr (vtkVoxel * sself) ; +extern "C" int vtk_voxel_get_cell_type(vtkVoxel* sself); +extern "C" int vtk_voxel_get_number_of_edges(vtkVoxel* sself); +extern "C" int vtk_voxel_get_number_of_faces(vtkVoxel* sself); +extern "C" int vtk_voxel_inflate(vtkVoxel* sself, double dist); +extern "C" vtkWedge * vtkWedge_new () ; +extern "C" void vtkWedge_destructor (vtkWedge * sself) ; +extern "C" void * vtkWedge_get_ptr (vtkWedge * sself) ; +extern "C" int vtk_wedge_get_cell_type(vtkWedge* sself); +extern "C" int vtk_wedge_get_number_of_edges(vtkWedge* sself); +extern "C" int vtk_wedge_get_number_of_faces(vtkWedge* sself); +extern "C" vtkXMLDataElement * vtkXMLDataElement_new () ; +extern "C" void vtkXMLDataElement_destructor (vtkXMLDataElement * sself) ; +extern "C" void * vtkXMLDataElement_get_ptr (vtkXMLDataElement * sself) ; +extern "C" void vtk_xml_data_element_set_name(vtkXMLDataElement* sself, const char* _arg); +extern "C" void vtk_xml_data_element_set_id(vtkXMLDataElement* sself, const char* _arg); +extern "C" const char* vtk_xml_data_element_get_attribute(vtkXMLDataElement* sself, const char* name); +extern "C" void vtk_xml_data_element_set_attribute(vtkXMLDataElement* sself, const char* name, const char* value); +extern "C" void vtk_xml_data_element_set_character_data(vtkXMLDataElement* sself, const char* data, int length); +extern "C" void vtk_xml_data_element_add_character_data(vtkXMLDataElement* sself, const char* c, size_t length); +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkXMLDataElement* sself, const char* name, int& value); +extern "C" void vtk_xml_data_element_set_int_attribute(vtkXMLDataElement* sself, const char* name, int value); +extern "C" void vtk_xml_data_element_set_float_attribute(vtkXMLDataElement* sself, const char* name, float value); +extern "C" void vtk_xml_data_element_set_double_attribute(vtkXMLDataElement* sself, const char* name, double value); +extern "C" void vtk_xml_data_element_set_unsigned_long_attribute(vtkXMLDataElement* sself, const char* name, unsigned long value); +extern "C" int vtk_xml_data_element_get_word_type_attribute(vtkXMLDataElement* sself, const char* name, int& value); +extern "C" int vtk_xml_data_element_get_number_of_attributes(vtkXMLDataElement* sself); +extern "C" const char* vtk_xml_data_element_get_attribute_name(vtkXMLDataElement* sself, int idx); +extern "C" const char* vtk_xml_data_element_get_attribute_value(vtkXMLDataElement* sself, int idx); +extern "C" void vtk_xml_data_element_remove_attribute(vtkXMLDataElement* sself, const char* name); +extern "C" void vtk_xml_data_element_remove_all_attributes(vtkXMLDataElement* sself); +extern "C" int vtk_xml_data_element_get_number_of_nested_elements(vtkXMLDataElement* sself); +extern "C" void vtk_xml_data_element_remove_all_nested_elements(vtkXMLDataElement* sself); +extern "C" long long vtk_xml_data_element_get_xml_byte_index(vtkXMLDataElement* sself); +extern "C" void vtk_xml_data_element_set_xml_byte_index(vtkXMLDataElement* sself, long long _arg); +extern "C" void vtk_xml_data_element_set_attribute_encoding(vtkXMLDataElement* sself, int _arg); +extern "C" int vtk_xml_data_element_get_attribute_encoding_min_value(vtkXMLDataElement* sself); +extern "C" int vtk_xml_data_element_get_attribute_encoding_max_value(vtkXMLDataElement* sself); +extern "C" int vtk_xml_data_element_get_attribute_encoding(vtkXMLDataElement* sself); +extern "C" void vtk_xml_data_element_print_xml(vtkXMLDataElement* sself, const char* fname); +extern "C" int vtk_xml_data_element_get_character_data_width(vtkXMLDataElement* sself); +extern "C" void vtk_xml_data_element_set_character_data_width(vtkXMLDataElement* sself, int _arg); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h index 813b96f..5506ede 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h @@ -74,366 +74,319 @@ #include // Declare exported functions -extern "C" vtkNew < vtkAlgorithm > vtkAlgorithm_new () ; -extern "C" void vtkAlgorithm_destructor (vtkNew < vtkAlgorithm > sself) ; -extern "C" void * vtkAlgorithm_get_ptr (vtkNew < vtkAlgorithm > sself) ; -extern "C" int vtk_algorithm_has_executive(vtkNew sself); -extern "C" int vtk_algorithm_get_number_of_input_ports(vtkNew sself); -extern "C" int vtk_algorithm_get_number_of_output_ports(vtkNew sself); -extern "C" void vtk_algorithm_set_abort_execute(vtkNew sself, int _arg); -extern "C" int vtk_algorithm_get_abort_execute(vtkNew sself); -extern "C" void vtk_algorithm_abort_execute_on(vtkNew sself); -extern "C" void vtk_algorithm_abort_execute_off(vtkNew sself); -extern "C" double vtk_algorithm_get_progress(vtkNew sself); -extern "C" void vtk_algorithm_set_progress(vtkNew sself, double p0); -extern "C" void vtk_algorithm_update_progress(vtkNew sself, double amount); -extern "C" void vtk_algorithm_set_progress_shift_scale(vtkNew sself, double shift, double scale); -extern "C" double vtk_algorithm_get_progress_shift(vtkNew sself); -extern "C" double vtk_algorithm_get_progress_scale(vtkNew sself); -extern "C" void vtk_algorithm_set_progress_text(vtkNew sself, const char ptext); -extern "C" char* vtk_algorithm_get_progress_text(vtkNew sself); -extern "C" unsigned long vtk_algorithm_get_error_code(vtkNew sself); -extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, int fieldAssociation, const char name); -extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, int fieldAssociation, int fieldAttributeType); -extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, const char fieldAssociation, const char attributeTypeorName); -extern "C" void vtk_algorithm_remove_all_inputs(vtkNew sself); -extern "C" void vtk_algorithm_remove_input_connection(vtkNew sself, int port, int idx); -extern "C" void vtk_algorithm_remove_all_input_connections(vtkNew sself, int port); -extern "C" int vtk_algorithm_get_number_of_input_connections(vtkNew sself, int port); -extern "C" int vtk_algorithm_get_total_number_of_input_connections(vtkNew sself); -extern "C" void vtk_algorithm_update(vtkNew sself, int port); -extern "C" void vtk_algorithm_update(vtkNew sself); -extern "C" int vtk_algorithm_update_piece(vtkNew sself, int piece, int numPieces, int ghostLevels, const int extents); -extern "C" int vtk_algorithm_update_extent(vtkNew sself, const int extents); -extern "C" int vtk_algorithm_update_time_step(vtkNew sself, double time, int piece, int numPieces, int ghostLevels, const int extents); -extern "C" void vtk_algorithm_update_information(vtkNew sself); -extern "C" void vtk_algorithm_update_data_object(vtkNew sself); -extern "C" void vtk_algorithm_propagate_update_extent(vtkNew sself); -extern "C" void vtk_algorithm_update_whole_extent(vtkNew sself); -extern "C" void vtk_algorithm_convert_total_input_to_port_connection(vtkNew sself, int ind, int port, int conn); -extern "C" void vtk_algorithm_set_release_data_flag(vtkNew sself, int p0); -extern "C" int vtk_algorithm_get_release_data_flag(vtkNew sself); -extern "C" void vtk_algorithm_release_data_flag_on(vtkNew sself); -extern "C" void vtk_algorithm_release_data_flag_off(vtkNew sself); -extern "C" int* vtk_algorithm_get_update_extent(vtkNew sself); -extern "C" int* vtk_algorithm_get_update_extent(vtkNew sself, int port); -extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1); -extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int port, int x0, int x1, int y0, int y1, int z0, int z1); -extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int extent); -extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int port, int extent); -extern "C" int vtk_algorithm_get_update_piece(vtkNew sself); -extern "C" int vtk_algorithm_get_update_piece(vtkNew sself, int port); -extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkNew sself); -extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkNew sself, int port); -extern "C" int vtk_algorithm_get_update_ghost_level(vtkNew sself); -extern "C" int vtk_algorithm_get_update_ghost_level(vtkNew sself, int port); -extern "C" vtkNew < vtkAlgorithmOutput > vtkAlgorithmOutput_new () ; -extern "C" void vtkAlgorithmOutput_destructor (vtkNew < vtkAlgorithmOutput > sself) ; -extern "C" void * vtkAlgorithmOutput_get_ptr (vtkNew < vtkAlgorithmOutput > sself) ; -extern "C" void vtk_algorithm_output_set_index(vtkNew sself, int index); -extern "C" int vtk_algorithm_output_get_index(vtkNew sself); -extern "C" vtkNew < vtkAnnotationLayersAlgorithm > vtkAnnotationLayersAlgorithm_new () ; -extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkNew < vtkAnnotationLayersAlgorithm > sself) ; -extern "C" void * vtkAnnotationLayersAlgorithm_get_ptr (vtkNew < vtkAnnotationLayersAlgorithm > sself) ; -extern "C" vtkNew < vtkArrayDataAlgorithm > vtkArrayDataAlgorithm_new () ; -extern "C" void vtkArrayDataAlgorithm_destructor (vtkNew < vtkArrayDataAlgorithm > sself) ; -extern "C" void * vtkArrayDataAlgorithm_get_ptr (vtkNew < vtkArrayDataAlgorithm > sself) ; -extern "C" vtkNew < vtkCachedStreamingDemandDrivenPipeline > vtkCachedStreamingDemandDrivenPipeline_new () ; -extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) ; -extern "C" void * vtkCachedStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) ; -extern "C" void vtk_cached_streaming_demand_driven_pipeline_set_cache_size(vtkNew sself, int size); -extern "C" int vtk_cached_streaming_demand_driven_pipeline_get_cache_size(vtkNew sself); -extern "C" vtkNew < vtkCastToConcrete > vtkCastToConcrete_new () ; -extern "C" void vtkCastToConcrete_destructor (vtkNew < vtkCastToConcrete > sself) ; -extern "C" void * vtkCastToConcrete_get_ptr (vtkNew < vtkCastToConcrete > sself) ; -extern "C" vtkNew < vtkCompositeDataPipeline > vtkCompositeDataPipeline_new () ; -extern "C" void vtkCompositeDataPipeline_destructor (vtkNew < vtkCompositeDataPipeline > sself) ; -extern "C" void * vtkCompositeDataPipeline_get_ptr (vtkNew < vtkCompositeDataPipeline > sself) ; -extern "C" vtkNew < vtkCompositeDataSetAlgorithm > vtkCompositeDataSetAlgorithm_new () ; -extern "C" void vtkCompositeDataSetAlgorithm_destructor (vtkNew < vtkCompositeDataSetAlgorithm > sself) ; -extern "C" void * vtkCompositeDataSetAlgorithm_get_ptr (vtkNew < vtkCompositeDataSetAlgorithm > sself) ; -extern "C" vtkNew < vtkDataObjectAlgorithm > vtkDataObjectAlgorithm_new () ; -extern "C" void vtkDataObjectAlgorithm_destructor (vtkNew < vtkDataObjectAlgorithm > sself) ; -extern "C" void * vtkDataObjectAlgorithm_get_ptr (vtkNew < vtkDataObjectAlgorithm > sself) ; -extern "C" vtkNew < vtkDataSetAlgorithm > vtkDataSetAlgorithm_new () ; -extern "C" void vtkDataSetAlgorithm_destructor (vtkNew < vtkDataSetAlgorithm > sself) ; -extern "C" void * vtkDataSetAlgorithm_get_ptr (vtkNew < vtkDataSetAlgorithm > sself) ; -extern "C" vtkNew < vtkDemandDrivenPipeline > vtkDemandDrivenPipeline_new () ; -extern "C" void vtkDemandDrivenPipeline_destructor (vtkNew < vtkDemandDrivenPipeline > sself) ; -extern "C" void * vtkDemandDrivenPipeline_get_ptr (vtkNew < vtkDemandDrivenPipeline > sself) ; -extern "C" unsigned long vtk_demand_driven_pipeline_get_pipeline_m_time(vtkNew sself); -extern "C" int vtk_demand_driven_pipeline_set_release_data_flag(vtkNew sself, int port, int n); -extern "C" int vtk_demand_driven_pipeline_get_release_data_flag(vtkNew sself, int port); -extern "C" int vtk_demand_driven_pipeline_update_pipeline_m_time(vtkNew sself); -extern "C" int vtk_demand_driven_pipeline_update_data_object(vtkNew sself); -extern "C" int vtk_demand_driven_pipeline_update_data(vtkNew sself, int outputPort); -extern "C" vtkNew < vtkDirectedGraphAlgorithm > vtkDirectedGraphAlgorithm_new () ; -extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkNew < vtkDirectedGraphAlgorithm > sself) ; -extern "C" void * vtkDirectedGraphAlgorithm_get_ptr (vtkNew < vtkDirectedGraphAlgorithm > sself) ; -extern "C" vtkNew < vtkEnsembleSource > vtkEnsembleSource_new () ; -extern "C" void vtkEnsembleSource_destructor (vtkNew < vtkEnsembleSource > sself) ; -extern "C" void * vtkEnsembleSource_get_ptr (vtkNew < vtkEnsembleSource > sself) ; -extern "C" void vtk_ensemble_source_remove_all_members(vtkNew sself); -extern "C" unsigned int vtk_ensemble_source_get_number_of_members(vtkNew sself); -extern "C" void vtk_ensemble_source_set_current_member(vtkNew sself, unsigned int _arg); -extern "C" unsigned int vtk_ensemble_source_get_current_member(vtkNew sself); -extern "C" vtkNew < vtkExplicitStructuredGridAlgorithm > vtkExplicitStructuredGridAlgorithm_new () ; -extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) ; -extern "C" void * vtkExplicitStructuredGridAlgorithm_get_ptr (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) ; -extern "C" vtkNew < vtkExtentRCBPartitioner > vtkExtentRCBPartitioner_new () ; -extern "C" void vtkExtentRCBPartitioner_destructor (vtkNew < vtkExtentRCBPartitioner > sself) ; -extern "C" void * vtkExtentRCBPartitioner_get_ptr (vtkNew < vtkExtentRCBPartitioner > sself) ; -extern "C" void vtk_extent_rcb_partitioner_set_number_of_partitions(vtkNew sself, const int N); -extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkNew sself, int imin, int imax, int jmin, int jmax, int kmin, int kmax); -extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkNew sself, int ext); -extern "C" void vtk_extent_rcb_partitioner_set_duplicate_nodes(vtkNew sself, int _arg); -extern "C" int vtk_extent_rcb_partitioner_get_duplicate_nodes(vtkNew sself); -extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_on(vtkNew sself); -extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_off(vtkNew sself); -extern "C" void vtk_extent_rcb_partitioner_set_number_of_ghost_layers(vtkNew sself, int _arg); -extern "C" int vtk_extent_rcb_partitioner_get_number_of_ghost_layers(vtkNew sself); -extern "C" int vtk_extent_rcb_partitioner_get_num_extents(vtkNew sself); -extern "C" void vtk_extent_rcb_partitioner_partition(vtkNew sself); -extern "C" void vtk_extent_rcb_partitioner_get_partition_extent(vtkNew sself, const int idx, int ext); -extern "C" vtkNew < vtkExtentSplitter > vtkExtentSplitter_new () ; -extern "C" void vtkExtentSplitter_destructor (vtkNew < vtkExtentSplitter > sself) ; -extern "C" void * vtkExtentSplitter_get_ptr (vtkNew < vtkExtentSplitter > sself) ; -extern "C" void vtk_extent_splitter_add_extent_source(vtkNew sself, int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1); -extern "C" void vtk_extent_splitter_add_extent_source(vtkNew sself, int id, int priority, int extent); -extern "C" void vtk_extent_splitter_remove_extent_source(vtkNew sself, int id); -extern "C" void vtk_extent_splitter_remove_all_extent_sources(vtkNew sself); -extern "C" void vtk_extent_splitter_add_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1); -extern "C" void vtk_extent_splitter_add_extent(vtkNew sself, int extent); -extern "C" int vtk_extent_splitter_compute_sub_extents(vtkNew sself); -extern "C" int vtk_extent_splitter_get_number_of_sub_extents(vtkNew sself); -extern "C" int* vtk_extent_splitter_get_sub_extent(vtkNew sself, int index); -extern "C" void vtk_extent_splitter_get_sub_extent(vtkNew sself, int index, int extent); -extern "C" int vtk_extent_splitter_get_sub_extent_source(vtkNew sself, int index); -extern "C" int vtk_extent_splitter_get_point_mode(vtkNew sself); -extern "C" void vtk_extent_splitter_set_point_mode(vtkNew sself, int _arg); -extern "C" void vtk_extent_splitter_point_mode_on(vtkNew sself); -extern "C" void vtk_extent_splitter_point_mode_off(vtkNew sself); -extern "C" vtkNew < vtkExtentTranslator > vtkExtentTranslator_new () ; -extern "C" void vtkExtentTranslator_destructor (vtkNew < vtkExtentTranslator > sself) ; -extern "C" void * vtkExtentTranslator_get_ptr (vtkNew < vtkExtentTranslator > sself) ; -extern "C" void vtk_extent_translator_set_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_extent_translator_set_whole_extent(vtkNew sself, const int _arg); -extern "C" int* vtk_extent_translator_get_whole_extent(vtkNew sself); -extern "C" void vtk_extent_translator_get_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_extent_translator_get_whole_extent(vtkNew sself, int _arg); -extern "C" void vtk_extent_translator_set_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_extent_translator_set_extent(vtkNew sself, const int _arg); -extern "C" int* vtk_extent_translator_get_extent(vtkNew sself); -extern "C" void vtk_extent_translator_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_extent_translator_get_extent(vtkNew sself, int _arg); -extern "C" void vtk_extent_translator_set_piece(vtkNew sself, int _arg); -extern "C" int vtk_extent_translator_get_piece(vtkNew sself); -extern "C" void vtk_extent_translator_set_number_of_pieces(vtkNew sself, int _arg); -extern "C" int vtk_extent_translator_get_number_of_pieces(vtkNew sself); -extern "C" void vtk_extent_translator_set_ghost_level(vtkNew sself, int _arg); -extern "C" int vtk_extent_translator_get_ghost_level(vtkNew sself); -extern "C" int vtk_extent_translator_piece_to_extent(vtkNew sself); -extern "C" int vtk_extent_translator_piece_to_extent_by_points(vtkNew sself); -extern "C" int vtk_extent_translator_piece_to_extent_thread_safe(vtkNew sself, int piece, int numPieces, int ghostLevel, int wholeExtent, int resultExtent, int splitMode, int byPoints); -extern "C" void vtk_extent_translator_set_split_mode_to_block(vtkNew sself); -extern "C" void vtk_extent_translator_set_split_mode_to_x_slab(vtkNew sself); -extern "C" void vtk_extent_translator_set_split_mode_to_y_slab(vtkNew sself); -extern "C" void vtk_extent_translator_set_split_mode_to_z_slab(vtkNew sself); -extern "C" int vtk_extent_translator_get_split_mode(vtkNew sself); -extern "C" void vtk_extent_translator_set_split_path(vtkNew sself, int len, int splitpath); -extern "C" vtkNew < vtkGraphAlgorithm > vtkGraphAlgorithm_new () ; -extern "C" void vtkGraphAlgorithm_destructor (vtkNew < vtkGraphAlgorithm > sself) ; -extern "C" void * vtkGraphAlgorithm_get_ptr (vtkNew < vtkGraphAlgorithm > sself) ; -extern "C" vtkNew < vtkHierarchicalBoxDataSetAlgorithm > vtkHierarchicalBoxDataSetAlgorithm_new () ; -extern "C" void vtkHierarchicalBoxDataSetAlgorithm_destructor (vtkNew < vtkHierarchicalBoxDataSetAlgorithm > sself) ; -extern "C" void * vtkHierarchicalBoxDataSetAlgorithm_get_ptr (vtkNew < vtkHierarchicalBoxDataSetAlgorithm > sself) ; -extern "C" vtkNew < vtkImageToStructuredGrid > vtkImageToStructuredGrid_new () ; -extern "C" void vtkImageToStructuredGrid_destructor (vtkNew < vtkImageToStructuredGrid > sself) ; -extern "C" void * vtkImageToStructuredGrid_get_ptr (vtkNew < vtkImageToStructuredGrid > sself) ; -extern "C" vtkNew < vtkImageToStructuredPoints > vtkImageToStructuredPoints_new () ; -extern "C" void vtkImageToStructuredPoints_destructor (vtkNew < vtkImageToStructuredPoints > sself) ; -extern "C" void * vtkImageToStructuredPoints_get_ptr (vtkNew < vtkImageToStructuredPoints > sself) ; -extern "C" vtkNew < vtkMoleculeAlgorithm > vtkMoleculeAlgorithm_new () ; -extern "C" void vtkMoleculeAlgorithm_destructor (vtkNew < vtkMoleculeAlgorithm > sself) ; -extern "C" void * vtkMoleculeAlgorithm_get_ptr (vtkNew < vtkMoleculeAlgorithm > sself) ; -extern "C" vtkNew < vtkMultiBlockDataSetAlgorithm > vtkMultiBlockDataSetAlgorithm_new () ; -extern "C" void vtkMultiBlockDataSetAlgorithm_destructor (vtkNew < vtkMultiBlockDataSetAlgorithm > sself) ; -extern "C" void * vtkMultiBlockDataSetAlgorithm_get_ptr (vtkNew < vtkMultiBlockDataSetAlgorithm > sself) ; -extern "C" vtkNew < vtkMultiTimeStepAlgorithm > vtkMultiTimeStepAlgorithm_new () ; -extern "C" void vtkMultiTimeStepAlgorithm_destructor (vtkNew < vtkMultiTimeStepAlgorithm > sself) ; -extern "C" void * vtkMultiTimeStepAlgorithm_get_ptr (vtkNew < vtkMultiTimeStepAlgorithm > sself) ; -extern "C" vtkNew < vtkNonOverlappingAMRAlgorithm > vtkNonOverlappingAMRAlgorithm_new () ; -extern "C" void vtkNonOverlappingAMRAlgorithm_destructor (vtkNew < vtkNonOverlappingAMRAlgorithm > sself) ; -extern "C" void * vtkNonOverlappingAMRAlgorithm_get_ptr (vtkNew < vtkNonOverlappingAMRAlgorithm > sself) ; -extern "C" vtkNew < vtkOverlappingAMRAlgorithm > vtkOverlappingAMRAlgorithm_new () ; -extern "C" void vtkOverlappingAMRAlgorithm_destructor (vtkNew < vtkOverlappingAMRAlgorithm > sself) ; -extern "C" void * vtkOverlappingAMRAlgorithm_get_ptr (vtkNew < vtkOverlappingAMRAlgorithm > sself) ; -extern "C" vtkNew < vtkPassInputTypeAlgorithm > vtkPassInputTypeAlgorithm_new () ; -extern "C" void vtkPassInputTypeAlgorithm_destructor (vtkNew < vtkPassInputTypeAlgorithm > sself) ; -extern "C" void * vtkPassInputTypeAlgorithm_get_ptr (vtkNew < vtkPassInputTypeAlgorithm > sself) ; -extern "C" vtkNew < vtkPiecewiseFunctionAlgorithm > vtkPiecewiseFunctionAlgorithm_new () ; -extern "C" void vtkPiecewiseFunctionAlgorithm_destructor (vtkNew < vtkPiecewiseFunctionAlgorithm > sself) ; -extern "C" void * vtkPiecewiseFunctionAlgorithm_get_ptr (vtkNew < vtkPiecewiseFunctionAlgorithm > sself) ; -extern "C" vtkNew < vtkPiecewiseFunctionShiftScale > vtkPiecewiseFunctionShiftScale_new () ; -extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkNew < vtkPiecewiseFunctionShiftScale > sself) ; -extern "C" void * vtkPiecewiseFunctionShiftScale_get_ptr (vtkNew < vtkPiecewiseFunctionShiftScale > sself) ; -extern "C" void vtk_piecewise_function_shift_scale_set_position_shift(vtkNew sself, double _arg); -extern "C" void vtk_piecewise_function_shift_scale_set_position_scale(vtkNew sself, double _arg); -extern "C" void vtk_piecewise_function_shift_scale_set_value_shift(vtkNew sself, double _arg); -extern "C" void vtk_piecewise_function_shift_scale_set_value_scale(vtkNew sself, double _arg); -extern "C" double vtk_piecewise_function_shift_scale_get_position_shift(vtkNew sself); -extern "C" double vtk_piecewise_function_shift_scale_get_position_scale(vtkNew sself); -extern "C" double vtk_piecewise_function_shift_scale_get_value_shift(vtkNew sself); -extern "C" double vtk_piecewise_function_shift_scale_get_value_scale(vtkNew sself); -extern "C" vtkNew < vtkPointSetAlgorithm > vtkPointSetAlgorithm_new () ; -extern "C" void vtkPointSetAlgorithm_destructor (vtkNew < vtkPointSetAlgorithm > sself) ; -extern "C" void * vtkPointSetAlgorithm_get_ptr (vtkNew < vtkPointSetAlgorithm > sself) ; -extern "C" vtkNew < vtkPolyDataAlgorithm > vtkPolyDataAlgorithm_new () ; -extern "C" void vtkPolyDataAlgorithm_destructor (vtkNew < vtkPolyDataAlgorithm > sself) ; -extern "C" void * vtkPolyDataAlgorithm_get_ptr (vtkNew < vtkPolyDataAlgorithm > sself) ; -extern "C" vtkNew < vtkProgressObserver > vtkProgressObserver_new () ; -extern "C" void vtkProgressObserver_destructor (vtkNew < vtkProgressObserver > sself) ; -extern "C" void * vtkProgressObserver_get_ptr (vtkNew < vtkProgressObserver > sself) ; -extern "C" void vtk_progress_observer_update_progress(vtkNew sself, double amount); -extern "C" double vtk_progress_observer_get_progress(vtkNew sself); -extern "C" vtkNew < vtkReaderExecutive > vtkReaderExecutive_new () ; -extern "C" void vtkReaderExecutive_destructor (vtkNew < vtkReaderExecutive > sself) ; -extern "C" void * vtkReaderExecutive_get_ptr (vtkNew < vtkReaderExecutive > sself) ; -extern "C" vtkNew < vtkRectilinearGridAlgorithm > vtkRectilinearGridAlgorithm_new () ; -extern "C" void vtkRectilinearGridAlgorithm_destructor (vtkNew < vtkRectilinearGridAlgorithm > sself) ; -extern "C" void * vtkRectilinearGridAlgorithm_get_ptr (vtkNew < vtkRectilinearGridAlgorithm > sself) ; -extern "C" vtkNew < vtkSMPProgressObserver > vtkSMPProgressObserver_new () ; -extern "C" void vtkSMPProgressObserver_destructor (vtkNew < vtkSMPProgressObserver > sself) ; -extern "C" void * vtkSMPProgressObserver_get_ptr (vtkNew < vtkSMPProgressObserver > sself) ; -extern "C" void vtk_smp_progress_observer_update_progress(vtkNew sself, double progress); -extern "C" vtkNew < vtkSelectionAlgorithm > vtkSelectionAlgorithm_new () ; -extern "C" void vtkSelectionAlgorithm_destructor (vtkNew < vtkSelectionAlgorithm > sself) ; -extern "C" void * vtkSelectionAlgorithm_get_ptr (vtkNew < vtkSelectionAlgorithm > sself) ; -extern "C" vtkNew < vtkSimpleScalarTree > vtkSimpleScalarTree_new () ; -extern "C" void vtkSimpleScalarTree_destructor (vtkNew < vtkSimpleScalarTree > sself) ; -extern "C" void * vtkSimpleScalarTree_get_ptr (vtkNew < vtkSimpleScalarTree > sself) ; -extern "C" void vtk_simple_scalar_tree_set_branching_factor(vtkNew sself, int _arg); -extern "C" int vtk_simple_scalar_tree_get_branching_factor_min_value(vtkNew sself); -extern "C" int vtk_simple_scalar_tree_get_branching_factor_max_value(vtkNew sself); -extern "C" int vtk_simple_scalar_tree_get_branching_factor(vtkNew sself); -extern "C" int vtk_simple_scalar_tree_get_level(vtkNew sself); -extern "C" void vtk_simple_scalar_tree_set_max_level(vtkNew sself, int _arg); -extern "C" int vtk_simple_scalar_tree_get_max_level_min_value(vtkNew sself); -extern "C" int vtk_simple_scalar_tree_get_max_level_max_value(vtkNew sself); -extern "C" int vtk_simple_scalar_tree_get_max_level(vtkNew sself); -extern "C" void vtk_simple_scalar_tree_build_tree(vtkNew sself); -extern "C" void vtk_simple_scalar_tree_initialize(vtkNew sself); -extern "C" void vtk_simple_scalar_tree_init_traversal(vtkNew sself, double scalarValue); -extern "C" long long vtk_simple_scalar_tree_get_number_of_cell_batches(vtkNew sself, double scalarValue); -extern "C" const long long* vtk_simple_scalar_tree_get_cell_batch(vtkNew sself, long long batchNum, long long numCells); -extern "C" vtkNew < vtkSpanSpace > vtkSpanSpace_new () ; -extern "C" void vtkSpanSpace_destructor (vtkNew < vtkSpanSpace > sself) ; -extern "C" void * vtkSpanSpace_get_ptr (vtkNew < vtkSpanSpace > sself) ; -extern "C" void vtk_span_space_set_scalar_range(vtkNew sself, double _arg1, double _arg2); -extern "C" void vtk_span_space_set_scalar_range(vtkNew sself, const double _arg); -extern "C" double* vtk_span_space_get_scalar_range(vtkNew sself); -extern "C" void vtk_span_space_get_scalar_range(vtkNew sself, double data); -extern "C" void vtk_span_space_set_compute_scalar_range(vtkNew sself, int _arg); -extern "C" int vtk_span_space_get_compute_scalar_range(vtkNew sself); -extern "C" void vtk_span_space_compute_scalar_range_on(vtkNew sself); -extern "C" void vtk_span_space_compute_scalar_range_off(vtkNew sself); -extern "C" void vtk_span_space_set_resolution(vtkNew sself, long long _arg); -extern "C" long long vtk_span_space_get_resolution_min_value(vtkNew sself); -extern "C" long long vtk_span_space_get_resolution_max_value(vtkNew sself); -extern "C" long long vtk_span_space_get_resolution(vtkNew sself); -extern "C" void vtk_span_space_set_compute_resolution(vtkNew sself, int _arg); -extern "C" int vtk_span_space_get_compute_resolution(vtkNew sself); -extern "C" void vtk_span_space_compute_resolution_on(vtkNew sself); -extern "C" void vtk_span_space_compute_resolution_off(vtkNew sself); -extern "C" void vtk_span_space_set_number_of_cells_per_bucket(vtkNew sself, int _arg); -extern "C" int vtk_span_space_get_number_of_cells_per_bucket_min_value(vtkNew sself); -extern "C" int vtk_span_space_get_number_of_cells_per_bucket_max_value(vtkNew sself); -extern "C" int vtk_span_space_get_number_of_cells_per_bucket(vtkNew sself); -extern "C" void vtk_span_space_initialize(vtkNew sself); -extern "C" void vtk_span_space_build_tree(vtkNew sself); -extern "C" void vtk_span_space_init_traversal(vtkNew sself, double scalarValue); -extern "C" long long vtk_span_space_get_number_of_cell_batches(vtkNew sself, double scalarValue); -extern "C" const long long* vtk_span_space_get_cell_batch(vtkNew sself, long long batchNum, long long numCells); -extern "C" void vtk_span_space_set_batch_size(vtkNew sself, long long _arg); -extern "C" long long vtk_span_space_get_batch_size_min_value(vtkNew sself); -extern "C" long long vtk_span_space_get_batch_size_max_value(vtkNew sself); -extern "C" long long vtk_span_space_get_batch_size(vtkNew sself); -extern "C" vtkNew < vtkSphereTree > vtkSphereTree_new () ; -extern "C" void vtkSphereTree_destructor (vtkNew < vtkSphereTree > sself) ; -extern "C" void * vtkSphereTree_get_ptr (vtkNew < vtkSphereTree > sself) ; -extern "C" void vtk_sphere_tree_build(vtkNew sself); -extern "C" void vtk_sphere_tree_set_build_hierarchy(vtkNew sself, bool _arg); -extern "C" bool vtk_sphere_tree_get_build_hierarchy(vtkNew sself); -extern "C" void vtk_sphere_tree_build_hierarchy_on(vtkNew sself); -extern "C" void vtk_sphere_tree_build_hierarchy_off(vtkNew sself); -extern "C" const unsigned char* vtk_sphere_tree_select_point(vtkNew sself, double point, long long numSelected); -extern "C" const unsigned char* vtk_sphere_tree_select_line(vtkNew sself, double origin, double ray, long long numSelected); -extern "C" const unsigned char* vtk_sphere_tree_select_plane(vtkNew sself, double origin, double normal, long long numSelected); -extern "C" void vtk_sphere_tree_set_resolution(vtkNew sself, int _arg); -extern "C" int vtk_sphere_tree_get_resolution_min_value(vtkNew sself); -extern "C" int vtk_sphere_tree_get_resolution_max_value(vtkNew sself); -extern "C" int vtk_sphere_tree_get_resolution(vtkNew sself); -extern "C" void vtk_sphere_tree_set_max_level(vtkNew sself, int _arg); -extern "C" int vtk_sphere_tree_get_max_level_min_value(vtkNew sself); -extern "C" int vtk_sphere_tree_get_max_level_max_value(vtkNew sself); -extern "C" int vtk_sphere_tree_get_max_level(vtkNew sself); -extern "C" int vtk_sphere_tree_get_number_of_levels(vtkNew sself); -extern "C" const double* vtk_sphere_tree_get_cell_spheres(vtkNew sself); -extern "C" const double* vtk_sphere_tree_get_tree_spheres(vtkNew sself, int level, long long numSpheres); -extern "C" vtkNew < vtkStreamingDemandDrivenPipeline > vtkStreamingDemandDrivenPipeline_new () ; -extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkNew < vtkStreamingDemandDrivenPipeline > sself) ; -extern "C" void * vtkStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkStreamingDemandDrivenPipeline > sself) ; -extern "C" int vtk_streaming_demand_driven_pipeline_update(vtkNew sself); -extern "C" int vtk_streaming_demand_driven_pipeline_update_whole_extent(vtkNew sself); -extern "C" int vtk_streaming_demand_driven_pipeline_propagate_update_extent(vtkNew sself, int outputPort); -extern "C" int vtk_streaming_demand_driven_pipeline_propagate_time(vtkNew sself, int outputPort); -extern "C" int vtk_streaming_demand_driven_pipeline_update_time_dependent_information(vtkNew sself, int outputPort); -extern "C" int vtk_streaming_demand_driven_pipeline_set_request_exact_extent(vtkNew sself, int port, int flag); -extern "C" int vtk_streaming_demand_driven_pipeline_get_request_exact_extent(vtkNew sself, int port); -extern "C" vtkNew < vtkStructuredGridAlgorithm > vtkStructuredGridAlgorithm_new () ; -extern "C" void vtkStructuredGridAlgorithm_destructor (vtkNew < vtkStructuredGridAlgorithm > sself) ; -extern "C" void * vtkStructuredGridAlgorithm_get_ptr (vtkNew < vtkStructuredGridAlgorithm > sself) ; -extern "C" vtkNew < vtkTableAlgorithm > vtkTableAlgorithm_new () ; -extern "C" void vtkTableAlgorithm_destructor (vtkNew < vtkTableAlgorithm > sself) ; -extern "C" void * vtkTableAlgorithm_get_ptr (vtkNew < vtkTableAlgorithm > sself) ; -extern "C" vtkNew < vtkThreadedCompositeDataPipeline > vtkThreadedCompositeDataPipeline_new () ; -extern "C" void vtkThreadedCompositeDataPipeline_destructor (vtkNew < vtkThreadedCompositeDataPipeline > sself) ; -extern "C" void * vtkThreadedCompositeDataPipeline_get_ptr (vtkNew < vtkThreadedCompositeDataPipeline > sself) ; -extern "C" vtkNew < vtkTreeAlgorithm > vtkTreeAlgorithm_new () ; -extern "C" void vtkTreeAlgorithm_destructor (vtkNew < vtkTreeAlgorithm > sself) ; -extern "C" void * vtkTreeAlgorithm_get_ptr (vtkNew < vtkTreeAlgorithm > sself) ; -extern "C" vtkNew < vtkTrivialConsumer > vtkTrivialConsumer_new () ; -extern "C" void vtkTrivialConsumer_destructor (vtkNew < vtkTrivialConsumer > sself) ; -extern "C" void * vtkTrivialConsumer_get_ptr (vtkNew < vtkTrivialConsumer > sself) ; -extern "C" vtkNew < vtkTrivialProducer > vtkTrivialProducer_new () ; -extern "C" void vtkTrivialProducer_destructor (vtkNew < vtkTrivialProducer > sself) ; -extern "C" void * vtkTrivialProducer_get_ptr (vtkNew < vtkTrivialProducer > sself) ; -extern "C" unsigned long vtk_trivial_producer_get_m_time(vtkNew sself); -extern "C" void vtk_trivial_producer_set_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_trivial_producer_set_whole_extent(vtkNew sself, const int _arg); -extern "C" int* vtk_trivial_producer_get_whole_extent(vtkNew sself); -extern "C" void vtk_trivial_producer_get_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); -extern "C" void vtk_trivial_producer_get_whole_extent(vtkNew sself, int _arg); -extern "C" vtkNew < vtkUndirectedGraphAlgorithm > vtkUndirectedGraphAlgorithm_new () ; -extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkNew < vtkUndirectedGraphAlgorithm > sself) ; -extern "C" void * vtkUndirectedGraphAlgorithm_get_ptr (vtkNew < vtkUndirectedGraphAlgorithm > sself) ; -extern "C" vtkNew < vtkUniformGridAMRAlgorithm > vtkUniformGridAMRAlgorithm_new () ; -extern "C" void vtkUniformGridAMRAlgorithm_destructor (vtkNew < vtkUniformGridAMRAlgorithm > sself) ; -extern "C" void * vtkUniformGridAMRAlgorithm_get_ptr (vtkNew < vtkUniformGridAMRAlgorithm > sself) ; -extern "C" vtkNew < vtkUniformGridPartitioner > vtkUniformGridPartitioner_new () ; -extern "C" void vtkUniformGridPartitioner_destructor (vtkNew < vtkUniformGridPartitioner > sself) ; -extern "C" void * vtkUniformGridPartitioner_get_ptr (vtkNew < vtkUniformGridPartitioner > sself) ; -extern "C" int vtk_uniform_grid_partitioner_get_number_of_partitions(vtkNew sself); -extern "C" void vtk_uniform_grid_partitioner_set_number_of_partitions(vtkNew sself, int _arg); -extern "C" int vtk_uniform_grid_partitioner_get_number_of_ghost_layers(vtkNew sself); -extern "C" void vtk_uniform_grid_partitioner_set_number_of_ghost_layers(vtkNew sself, int _arg); -extern "C" int vtk_uniform_grid_partitioner_get_duplicate_nodes(vtkNew sself); -extern "C" void vtk_uniform_grid_partitioner_set_duplicate_nodes(vtkNew sself, int _arg); -extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_on(vtkNew sself); -extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_off(vtkNew sself); -extern "C" vtkNew < vtkUnstructuredGridAlgorithm > vtkUnstructuredGridAlgorithm_new () ; -extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkNew < vtkUnstructuredGridAlgorithm > sself) ; -extern "C" void * vtkUnstructuredGridAlgorithm_get_ptr (vtkNew < vtkUnstructuredGridAlgorithm > sself) ; -extern "C" vtkNew < vtkUnstructuredGridBaseAlgorithm > vtkUnstructuredGridBaseAlgorithm_new () ; -extern "C" void vtkUnstructuredGridBaseAlgorithm_destructor (vtkNew < vtkUnstructuredGridBaseAlgorithm > sself) ; -extern "C" void * vtkUnstructuredGridBaseAlgorithm_get_ptr (vtkNew < vtkUnstructuredGridBaseAlgorithm > sself) ; +extern "C" vtkAlgorithm * vtkAlgorithm_new () ; +extern "C" void vtkAlgorithm_destructor (vtkAlgorithm * sself) ; +extern "C" void * vtkAlgorithm_get_ptr (vtkAlgorithm * sself) ; +extern "C" int vtk_algorithm_has_executive(vtkAlgorithm* sself); +extern "C" int vtk_algorithm_get_number_of_input_ports(vtkAlgorithm* sself); +extern "C" int vtk_algorithm_get_number_of_output_ports(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_set_abort_execute(vtkAlgorithm* sself, int _arg); +extern "C" int vtk_algorithm_get_abort_execute(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_abort_execute_on(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_abort_execute_off(vtkAlgorithm* sself); +extern "C" double vtk_algorithm_get_progress(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_set_progress(vtkAlgorithm* sself, double p0); +extern "C" void vtk_algorithm_update_progress(vtkAlgorithm* sself, double amount); +extern "C" void vtk_algorithm_set_progress_shift_scale(vtkAlgorithm* sself, double shift, double scale); +extern "C" double vtk_algorithm_get_progress_shift(vtkAlgorithm* sself); +extern "C" double vtk_algorithm_get_progress_scale(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_set_progress_text(vtkAlgorithm* sself, const char* ptext); +extern "C" unsigned long vtk_algorithm_get_error_code(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_set_input_array_to_process(vtkAlgorithm* sself, int idx, int port, int connection, int fieldAssociation, const char* name); +extern "C" void vtk_algorithm_remove_all_inputs(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_remove_all_input_connections(vtkAlgorithm* sself, int port); +extern "C" int vtk_algorithm_get_number_of_input_connections(vtkAlgorithm* sself, int port); +extern "C" int vtk_algorithm_get_total_number_of_input_connections(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_update(vtkAlgorithm* sself, int port); +extern "C" void vtk_algorithm_update_information(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_update_data_object(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_propagate_update_extent(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_update_whole_extent(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_convert_total_input_to_port_connection(vtkAlgorithm* sself, int ind, int& port, int& conn); +extern "C" void vtk_algorithm_set_release_data_flag(vtkAlgorithm* sself, int p0); +extern "C" int vtk_algorithm_get_release_data_flag(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_release_data_flag_on(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_release_data_flag_off(vtkAlgorithm* sself); +extern "C" int vtk_algorithm_get_update_piece(vtkAlgorithm* sself); +extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkAlgorithm* sself); +extern "C" int vtk_algorithm_get_update_ghost_level(vtkAlgorithm* sself); +extern "C" vtkAlgorithmOutput * vtkAlgorithmOutput_new () ; +extern "C" void vtkAlgorithmOutput_destructor (vtkAlgorithmOutput * sself) ; +extern "C" void * vtkAlgorithmOutput_get_ptr (vtkAlgorithmOutput * sself) ; +extern "C" void vtk_algorithm_output_set_index(vtkAlgorithmOutput* sself, int index); +extern "C" int vtk_algorithm_output_get_index(vtkAlgorithmOutput* sself); +extern "C" vtkAnnotationLayersAlgorithm * vtkAnnotationLayersAlgorithm_new () ; +extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkAnnotationLayersAlgorithm * sself) ; +extern "C" void * vtkAnnotationLayersAlgorithm_get_ptr (vtkAnnotationLayersAlgorithm * sself) ; +extern "C" vtkArrayDataAlgorithm * vtkArrayDataAlgorithm_new () ; +extern "C" void vtkArrayDataAlgorithm_destructor (vtkArrayDataAlgorithm * sself) ; +extern "C" void * vtkArrayDataAlgorithm_get_ptr (vtkArrayDataAlgorithm * sself) ; +extern "C" vtkCachedStreamingDemandDrivenPipeline * vtkCachedStreamingDemandDrivenPipeline_new () ; +extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkCachedStreamingDemandDrivenPipeline * sself) ; +extern "C" void * vtkCachedStreamingDemandDrivenPipeline_get_ptr (vtkCachedStreamingDemandDrivenPipeline * sself) ; +extern "C" void vtk_cached_streaming_demand_driven_pipeline_set_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself, int size); +extern "C" int vtk_cached_streaming_demand_driven_pipeline_get_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself); +extern "C" vtkCastToConcrete * vtkCastToConcrete_new () ; +extern "C" void vtkCastToConcrete_destructor (vtkCastToConcrete * sself) ; +extern "C" void * vtkCastToConcrete_get_ptr (vtkCastToConcrete * sself) ; +extern "C" vtkCompositeDataPipeline * vtkCompositeDataPipeline_new () ; +extern "C" void vtkCompositeDataPipeline_destructor (vtkCompositeDataPipeline * sself) ; +extern "C" void * vtkCompositeDataPipeline_get_ptr (vtkCompositeDataPipeline * sself) ; +extern "C" vtkCompositeDataSetAlgorithm * vtkCompositeDataSetAlgorithm_new () ; +extern "C" void vtkCompositeDataSetAlgorithm_destructor (vtkCompositeDataSetAlgorithm * sself) ; +extern "C" void * vtkCompositeDataSetAlgorithm_get_ptr (vtkCompositeDataSetAlgorithm * sself) ; +extern "C" vtkDataObjectAlgorithm * vtkDataObjectAlgorithm_new () ; +extern "C" void vtkDataObjectAlgorithm_destructor (vtkDataObjectAlgorithm * sself) ; +extern "C" void * vtkDataObjectAlgorithm_get_ptr (vtkDataObjectAlgorithm * sself) ; +extern "C" vtkDataSetAlgorithm * vtkDataSetAlgorithm_new () ; +extern "C" void vtkDataSetAlgorithm_destructor (vtkDataSetAlgorithm * sself) ; +extern "C" void * vtkDataSetAlgorithm_get_ptr (vtkDataSetAlgorithm * sself) ; +extern "C" vtkDemandDrivenPipeline * vtkDemandDrivenPipeline_new () ; +extern "C" void vtkDemandDrivenPipeline_destructor (vtkDemandDrivenPipeline * sself) ; +extern "C" void * vtkDemandDrivenPipeline_get_ptr (vtkDemandDrivenPipeline * sself) ; +extern "C" unsigned long vtk_demand_driven_pipeline_get_pipeline_m_time(vtkDemandDrivenPipeline* sself); +extern "C" int vtk_demand_driven_pipeline_set_release_data_flag(vtkDemandDrivenPipeline* sself, int port, int n); +extern "C" int vtk_demand_driven_pipeline_get_release_data_flag(vtkDemandDrivenPipeline* sself, int port); +extern "C" int vtk_demand_driven_pipeline_update_pipeline_m_time(vtkDemandDrivenPipeline* sself); +extern "C" int vtk_demand_driven_pipeline_update_data_object(vtkDemandDrivenPipeline* sself); +extern "C" int vtk_demand_driven_pipeline_update_data(vtkDemandDrivenPipeline* sself, int outputPort); +extern "C" vtkDirectedGraphAlgorithm * vtkDirectedGraphAlgorithm_new () ; +extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkDirectedGraphAlgorithm * sself) ; +extern "C" void * vtkDirectedGraphAlgorithm_get_ptr (vtkDirectedGraphAlgorithm * sself) ; +extern "C" vtkEnsembleSource * vtkEnsembleSource_new () ; +extern "C" void vtkEnsembleSource_destructor (vtkEnsembleSource * sself) ; +extern "C" void * vtkEnsembleSource_get_ptr (vtkEnsembleSource * sself) ; +extern "C" void vtk_ensemble_source_remove_all_members(vtkEnsembleSource* sself); +extern "C" unsigned int vtk_ensemble_source_get_number_of_members(vtkEnsembleSource* sself); +extern "C" void vtk_ensemble_source_set_current_member(vtkEnsembleSource* sself, unsigned int _arg); +extern "C" unsigned int vtk_ensemble_source_get_current_member(vtkEnsembleSource* sself); +extern "C" vtkExplicitStructuredGridAlgorithm * vtkExplicitStructuredGridAlgorithm_new () ; +extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkExplicitStructuredGridAlgorithm * sself) ; +extern "C" void * vtkExplicitStructuredGridAlgorithm_get_ptr (vtkExplicitStructuredGridAlgorithm * sself) ; +extern "C" vtkExtentRCBPartitioner * vtkExtentRCBPartitioner_new () ; +extern "C" void vtkExtentRCBPartitioner_destructor (vtkExtentRCBPartitioner * sself) ; +extern "C" void * vtkExtentRCBPartitioner_get_ptr (vtkExtentRCBPartitioner * sself) ; +extern "C" void vtk_extent_rcb_partitioner_set_number_of_partitions(vtkExtentRCBPartitioner* sself, const int N); +extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkExtentRCBPartitioner* sself, int imin, int imax, int jmin, int jmax, int kmin, int kmax); +extern "C" void vtk_extent_rcb_partitioner_set_duplicate_nodes(vtkExtentRCBPartitioner* sself, int _arg); +extern "C" int vtk_extent_rcb_partitioner_get_duplicate_nodes(vtkExtentRCBPartitioner* sself); +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_on(vtkExtentRCBPartitioner* sself); +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_off(vtkExtentRCBPartitioner* sself); +extern "C" void vtk_extent_rcb_partitioner_set_number_of_ghost_layers(vtkExtentRCBPartitioner* sself, int _arg); +extern "C" int vtk_extent_rcb_partitioner_get_number_of_ghost_layers(vtkExtentRCBPartitioner* sself); +extern "C" int vtk_extent_rcb_partitioner_get_num_extents(vtkExtentRCBPartitioner* sself); +extern "C" void vtk_extent_rcb_partitioner_partition(vtkExtentRCBPartitioner* sself); +extern "C" vtkExtentSplitter * vtkExtentSplitter_new () ; +extern "C" void vtkExtentSplitter_destructor (vtkExtentSplitter * sself) ; +extern "C" void * vtkExtentSplitter_get_ptr (vtkExtentSplitter * sself) ; +extern "C" void vtk_extent_splitter_add_extent_source(vtkExtentSplitter* sself, int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" void vtk_extent_splitter_remove_extent_source(vtkExtentSplitter* sself, int id); +extern "C" void vtk_extent_splitter_remove_all_extent_sources(vtkExtentSplitter* sself); +extern "C" void vtk_extent_splitter_add_extent(vtkExtentSplitter* sself, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" int vtk_extent_splitter_compute_sub_extents(vtkExtentSplitter* sself); +extern "C" int vtk_extent_splitter_get_number_of_sub_extents(vtkExtentSplitter* sself); +extern "C" int vtk_extent_splitter_get_sub_extent_source(vtkExtentSplitter* sself, int index); +extern "C" int vtk_extent_splitter_get_point_mode(vtkExtentSplitter* sself); +extern "C" void vtk_extent_splitter_set_point_mode(vtkExtentSplitter* sself, int _arg); +extern "C" void vtk_extent_splitter_point_mode_on(vtkExtentSplitter* sself); +extern "C" void vtk_extent_splitter_point_mode_off(vtkExtentSplitter* sself); +extern "C" vtkExtentTranslator * vtkExtentTranslator_new () ; +extern "C" void vtkExtentTranslator_destructor (vtkExtentTranslator * sself) ; +extern "C" void * vtkExtentTranslator_get_ptr (vtkExtentTranslator * sself) ; +extern "C" void vtk_extent_translator_set_whole_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_extent_translator_set_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_extent_translator_set_piece(vtkExtentTranslator* sself, int _arg); +extern "C" int vtk_extent_translator_get_piece(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_number_of_pieces(vtkExtentTranslator* sself, int _arg); +extern "C" int vtk_extent_translator_get_number_of_pieces(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_ghost_level(vtkExtentTranslator* sself, int _arg); +extern "C" int vtk_extent_translator_get_ghost_level(vtkExtentTranslator* sself); +extern "C" int vtk_extent_translator_piece_to_extent(vtkExtentTranslator* sself); +extern "C" int vtk_extent_translator_piece_to_extent_by_points(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_split_mode_to_block(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_split_mode_to_x_slab(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_split_mode_to_y_slab(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_split_mode_to_z_slab(vtkExtentTranslator* sself); +extern "C" int vtk_extent_translator_get_split_mode(vtkExtentTranslator* sself); +extern "C" vtkGraphAlgorithm * vtkGraphAlgorithm_new () ; +extern "C" void vtkGraphAlgorithm_destructor (vtkGraphAlgorithm * sself) ; +extern "C" void * vtkGraphAlgorithm_get_ptr (vtkGraphAlgorithm * sself) ; +extern "C" vtkHierarchicalBoxDataSetAlgorithm * vtkHierarchicalBoxDataSetAlgorithm_new () ; +extern "C" void vtkHierarchicalBoxDataSetAlgorithm_destructor (vtkHierarchicalBoxDataSetAlgorithm * sself) ; +extern "C" void * vtkHierarchicalBoxDataSetAlgorithm_get_ptr (vtkHierarchicalBoxDataSetAlgorithm * sself) ; +extern "C" vtkImageToStructuredGrid * vtkImageToStructuredGrid_new () ; +extern "C" void vtkImageToStructuredGrid_destructor (vtkImageToStructuredGrid * sself) ; +extern "C" void * vtkImageToStructuredGrid_get_ptr (vtkImageToStructuredGrid * sself) ; +extern "C" vtkImageToStructuredPoints * vtkImageToStructuredPoints_new () ; +extern "C" void vtkImageToStructuredPoints_destructor (vtkImageToStructuredPoints * sself) ; +extern "C" void * vtkImageToStructuredPoints_get_ptr (vtkImageToStructuredPoints * sself) ; +extern "C" vtkMoleculeAlgorithm * vtkMoleculeAlgorithm_new () ; +extern "C" void vtkMoleculeAlgorithm_destructor (vtkMoleculeAlgorithm * sself) ; +extern "C" void * vtkMoleculeAlgorithm_get_ptr (vtkMoleculeAlgorithm * sself) ; +extern "C" vtkMultiBlockDataSetAlgorithm * vtkMultiBlockDataSetAlgorithm_new () ; +extern "C" void vtkMultiBlockDataSetAlgorithm_destructor (vtkMultiBlockDataSetAlgorithm * sself) ; +extern "C" void * vtkMultiBlockDataSetAlgorithm_get_ptr (vtkMultiBlockDataSetAlgorithm * sself) ; +extern "C" vtkMultiTimeStepAlgorithm * vtkMultiTimeStepAlgorithm_new () ; +extern "C" void vtkMultiTimeStepAlgorithm_destructor (vtkMultiTimeStepAlgorithm * sself) ; +extern "C" void * vtkMultiTimeStepAlgorithm_get_ptr (vtkMultiTimeStepAlgorithm * sself) ; +extern "C" vtkNonOverlappingAMRAlgorithm * vtkNonOverlappingAMRAlgorithm_new () ; +extern "C" void vtkNonOverlappingAMRAlgorithm_destructor (vtkNonOverlappingAMRAlgorithm * sself) ; +extern "C" void * vtkNonOverlappingAMRAlgorithm_get_ptr (vtkNonOverlappingAMRAlgorithm * sself) ; +extern "C" vtkOverlappingAMRAlgorithm * vtkOverlappingAMRAlgorithm_new () ; +extern "C" void vtkOverlappingAMRAlgorithm_destructor (vtkOverlappingAMRAlgorithm * sself) ; +extern "C" void * vtkOverlappingAMRAlgorithm_get_ptr (vtkOverlappingAMRAlgorithm * sself) ; +extern "C" vtkPassInputTypeAlgorithm * vtkPassInputTypeAlgorithm_new () ; +extern "C" void vtkPassInputTypeAlgorithm_destructor (vtkPassInputTypeAlgorithm * sself) ; +extern "C" void * vtkPassInputTypeAlgorithm_get_ptr (vtkPassInputTypeAlgorithm * sself) ; +extern "C" vtkPiecewiseFunctionAlgorithm * vtkPiecewiseFunctionAlgorithm_new () ; +extern "C" void vtkPiecewiseFunctionAlgorithm_destructor (vtkPiecewiseFunctionAlgorithm * sself) ; +extern "C" void * vtkPiecewiseFunctionAlgorithm_get_ptr (vtkPiecewiseFunctionAlgorithm * sself) ; +extern "C" vtkPiecewiseFunctionShiftScale * vtkPiecewiseFunctionShiftScale_new () ; +extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkPiecewiseFunctionShiftScale * sself) ; +extern "C" void * vtkPiecewiseFunctionShiftScale_get_ptr (vtkPiecewiseFunctionShiftScale * sself) ; +extern "C" void vtk_piecewise_function_shift_scale_set_position_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg); +extern "C" void vtk_piecewise_function_shift_scale_set_position_scale(vtkPiecewiseFunctionShiftScale* sself, double _arg); +extern "C" void vtk_piecewise_function_shift_scale_set_value_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg); +extern "C" void vtk_piecewise_function_shift_scale_set_value_scale(vtkPiecewiseFunctionShiftScale* sself, double _arg); +extern "C" double vtk_piecewise_function_shift_scale_get_position_shift(vtkPiecewiseFunctionShiftScale* sself); +extern "C" double vtk_piecewise_function_shift_scale_get_position_scale(vtkPiecewiseFunctionShiftScale* sself); +extern "C" double vtk_piecewise_function_shift_scale_get_value_shift(vtkPiecewiseFunctionShiftScale* sself); +extern "C" double vtk_piecewise_function_shift_scale_get_value_scale(vtkPiecewiseFunctionShiftScale* sself); +extern "C" vtkPointSetAlgorithm * vtkPointSetAlgorithm_new () ; +extern "C" void vtkPointSetAlgorithm_destructor (vtkPointSetAlgorithm * sself) ; +extern "C" void * vtkPointSetAlgorithm_get_ptr (vtkPointSetAlgorithm * sself) ; +extern "C" vtkPolyDataAlgorithm * vtkPolyDataAlgorithm_new () ; +extern "C" void vtkPolyDataAlgorithm_destructor (vtkPolyDataAlgorithm * sself) ; +extern "C" void * vtkPolyDataAlgorithm_get_ptr (vtkPolyDataAlgorithm * sself) ; +extern "C" vtkProgressObserver * vtkProgressObserver_new () ; +extern "C" void vtkProgressObserver_destructor (vtkProgressObserver * sself) ; +extern "C" void * vtkProgressObserver_get_ptr (vtkProgressObserver * sself) ; +extern "C" void vtk_progress_observer_update_progress(vtkProgressObserver* sself, double amount); +extern "C" double vtk_progress_observer_get_progress(vtkProgressObserver* sself); +extern "C" vtkReaderExecutive * vtkReaderExecutive_new () ; +extern "C" void vtkReaderExecutive_destructor (vtkReaderExecutive * sself) ; +extern "C" void * vtkReaderExecutive_get_ptr (vtkReaderExecutive * sself) ; +extern "C" vtkRectilinearGridAlgorithm * vtkRectilinearGridAlgorithm_new () ; +extern "C" void vtkRectilinearGridAlgorithm_destructor (vtkRectilinearGridAlgorithm * sself) ; +extern "C" void * vtkRectilinearGridAlgorithm_get_ptr (vtkRectilinearGridAlgorithm * sself) ; +extern "C" vtkSMPProgressObserver * vtkSMPProgressObserver_new () ; +extern "C" void vtkSMPProgressObserver_destructor (vtkSMPProgressObserver * sself) ; +extern "C" void * vtkSMPProgressObserver_get_ptr (vtkSMPProgressObserver * sself) ; +extern "C" void vtk_smp_progress_observer_update_progress(vtkSMPProgressObserver* sself, double progress); +extern "C" vtkSelectionAlgorithm * vtkSelectionAlgorithm_new () ; +extern "C" void vtkSelectionAlgorithm_destructor (vtkSelectionAlgorithm * sself) ; +extern "C" void * vtkSelectionAlgorithm_get_ptr (vtkSelectionAlgorithm * sself) ; +extern "C" vtkSimpleScalarTree * vtkSimpleScalarTree_new () ; +extern "C" void vtkSimpleScalarTree_destructor (vtkSimpleScalarTree * sself) ; +extern "C" void * vtkSimpleScalarTree_get_ptr (vtkSimpleScalarTree * sself) ; +extern "C" void vtk_simple_scalar_tree_set_branching_factor(vtkSimpleScalarTree* sself, int _arg); +extern "C" int vtk_simple_scalar_tree_get_branching_factor_min_value(vtkSimpleScalarTree* sself); +extern "C" int vtk_simple_scalar_tree_get_branching_factor_max_value(vtkSimpleScalarTree* sself); +extern "C" int vtk_simple_scalar_tree_get_branching_factor(vtkSimpleScalarTree* sself); +extern "C" int vtk_simple_scalar_tree_get_level(vtkSimpleScalarTree* sself); +extern "C" void vtk_simple_scalar_tree_set_max_level(vtkSimpleScalarTree* sself, int _arg); +extern "C" int vtk_simple_scalar_tree_get_max_level_min_value(vtkSimpleScalarTree* sself); +extern "C" int vtk_simple_scalar_tree_get_max_level_max_value(vtkSimpleScalarTree* sself); +extern "C" int vtk_simple_scalar_tree_get_max_level(vtkSimpleScalarTree* sself); +extern "C" void vtk_simple_scalar_tree_build_tree(vtkSimpleScalarTree* sself); +extern "C" void vtk_simple_scalar_tree_initialize(vtkSimpleScalarTree* sself); +extern "C" void vtk_simple_scalar_tree_init_traversal(vtkSimpleScalarTree* sself, double scalarValue); +extern "C" long long vtk_simple_scalar_tree_get_number_of_cell_batches(vtkSimpleScalarTree* sself, double scalarValue); +extern "C" vtkSpanSpace * vtkSpanSpace_new () ; +extern "C" void vtkSpanSpace_destructor (vtkSpanSpace * sself) ; +extern "C" void * vtkSpanSpace_get_ptr (vtkSpanSpace * sself) ; +extern "C" void vtk_span_space_set_scalar_range(vtkSpanSpace* sself, double _arg1, double _arg2); +extern "C" void vtk_span_space_set_compute_scalar_range(vtkSpanSpace* sself, int _arg); +extern "C" int vtk_span_space_get_compute_scalar_range(vtkSpanSpace* sself); +extern "C" void vtk_span_space_compute_scalar_range_on(vtkSpanSpace* sself); +extern "C" void vtk_span_space_compute_scalar_range_off(vtkSpanSpace* sself); +extern "C" void vtk_span_space_set_resolution(vtkSpanSpace* sself, long long _arg); +extern "C" long long vtk_span_space_get_resolution_min_value(vtkSpanSpace* sself); +extern "C" long long vtk_span_space_get_resolution_max_value(vtkSpanSpace* sself); +extern "C" long long vtk_span_space_get_resolution(vtkSpanSpace* sself); +extern "C" void vtk_span_space_set_compute_resolution(vtkSpanSpace* sself, int _arg); +extern "C" int vtk_span_space_get_compute_resolution(vtkSpanSpace* sself); +extern "C" void vtk_span_space_compute_resolution_on(vtkSpanSpace* sself); +extern "C" void vtk_span_space_compute_resolution_off(vtkSpanSpace* sself); +extern "C" void vtk_span_space_set_number_of_cells_per_bucket(vtkSpanSpace* sself, int _arg); +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_min_value(vtkSpanSpace* sself); +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_max_value(vtkSpanSpace* sself); +extern "C" int vtk_span_space_get_number_of_cells_per_bucket(vtkSpanSpace* sself); +extern "C" void vtk_span_space_initialize(vtkSpanSpace* sself); +extern "C" void vtk_span_space_build_tree(vtkSpanSpace* sself); +extern "C" void vtk_span_space_init_traversal(vtkSpanSpace* sself, double scalarValue); +extern "C" long long vtk_span_space_get_number_of_cell_batches(vtkSpanSpace* sself, double scalarValue); +extern "C" void vtk_span_space_set_batch_size(vtkSpanSpace* sself, long long _arg); +extern "C" long long vtk_span_space_get_batch_size_min_value(vtkSpanSpace* sself); +extern "C" long long vtk_span_space_get_batch_size_max_value(vtkSpanSpace* sself); +extern "C" long long vtk_span_space_get_batch_size(vtkSpanSpace* sself); +extern "C" vtkSphereTree * vtkSphereTree_new () ; +extern "C" void vtkSphereTree_destructor (vtkSphereTree * sself) ; +extern "C" void * vtkSphereTree_get_ptr (vtkSphereTree * sself) ; +extern "C" void vtk_sphere_tree_build(vtkSphereTree* sself); +extern "C" void vtk_sphere_tree_set_build_hierarchy(vtkSphereTree* sself, bool _arg); +extern "C" bool vtk_sphere_tree_get_build_hierarchy(vtkSphereTree* sself); +extern "C" void vtk_sphere_tree_build_hierarchy_on(vtkSphereTree* sself); +extern "C" void vtk_sphere_tree_build_hierarchy_off(vtkSphereTree* sself); +extern "C" void vtk_sphere_tree_set_resolution(vtkSphereTree* sself, int _arg); +extern "C" int vtk_sphere_tree_get_resolution_min_value(vtkSphereTree* sself); +extern "C" int vtk_sphere_tree_get_resolution_max_value(vtkSphereTree* sself); +extern "C" int vtk_sphere_tree_get_resolution(vtkSphereTree* sself); +extern "C" void vtk_sphere_tree_set_max_level(vtkSphereTree* sself, int _arg); +extern "C" int vtk_sphere_tree_get_max_level_min_value(vtkSphereTree* sself); +extern "C" int vtk_sphere_tree_get_max_level_max_value(vtkSphereTree* sself); +extern "C" int vtk_sphere_tree_get_max_level(vtkSphereTree* sself); +extern "C" int vtk_sphere_tree_get_number_of_levels(vtkSphereTree* sself); +extern "C" vtkStreamingDemandDrivenPipeline * vtkStreamingDemandDrivenPipeline_new () ; +extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkStreamingDemandDrivenPipeline * sself) ; +extern "C" void * vtkStreamingDemandDrivenPipeline_get_ptr (vtkStreamingDemandDrivenPipeline * sself) ; +extern "C" int vtk_streaming_demand_driven_pipeline_update(vtkStreamingDemandDrivenPipeline* sself); +extern "C" int vtk_streaming_demand_driven_pipeline_update_whole_extent(vtkStreamingDemandDrivenPipeline* sself); +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_update_extent(vtkStreamingDemandDrivenPipeline* sself, int outputPort); +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_time(vtkStreamingDemandDrivenPipeline* sself, int outputPort); +extern "C" int vtk_streaming_demand_driven_pipeline_update_time_dependent_information(vtkStreamingDemandDrivenPipeline* sself, int outputPort); +extern "C" int vtk_streaming_demand_driven_pipeline_set_request_exact_extent(vtkStreamingDemandDrivenPipeline* sself, int port, int flag); +extern "C" int vtk_streaming_demand_driven_pipeline_get_request_exact_extent(vtkStreamingDemandDrivenPipeline* sself, int port); +extern "C" vtkStructuredGridAlgorithm * vtkStructuredGridAlgorithm_new () ; +extern "C" void vtkStructuredGridAlgorithm_destructor (vtkStructuredGridAlgorithm * sself) ; +extern "C" void * vtkStructuredGridAlgorithm_get_ptr (vtkStructuredGridAlgorithm * sself) ; +extern "C" vtkTableAlgorithm * vtkTableAlgorithm_new () ; +extern "C" void vtkTableAlgorithm_destructor (vtkTableAlgorithm * sself) ; +extern "C" void * vtkTableAlgorithm_get_ptr (vtkTableAlgorithm * sself) ; +extern "C" vtkThreadedCompositeDataPipeline * vtkThreadedCompositeDataPipeline_new () ; +extern "C" void vtkThreadedCompositeDataPipeline_destructor (vtkThreadedCompositeDataPipeline * sself) ; +extern "C" void * vtkThreadedCompositeDataPipeline_get_ptr (vtkThreadedCompositeDataPipeline * sself) ; +extern "C" vtkTreeAlgorithm * vtkTreeAlgorithm_new () ; +extern "C" void vtkTreeAlgorithm_destructor (vtkTreeAlgorithm * sself) ; +extern "C" void * vtkTreeAlgorithm_get_ptr (vtkTreeAlgorithm * sself) ; +extern "C" vtkTrivialConsumer * vtkTrivialConsumer_new () ; +extern "C" void vtkTrivialConsumer_destructor (vtkTrivialConsumer * sself) ; +extern "C" void * vtkTrivialConsumer_get_ptr (vtkTrivialConsumer * sself) ; +extern "C" vtkTrivialProducer * vtkTrivialProducer_new () ; +extern "C" void vtkTrivialProducer_destructor (vtkTrivialProducer * sself) ; +extern "C" void * vtkTrivialProducer_get_ptr (vtkTrivialProducer * sself) ; +extern "C" unsigned long vtk_trivial_producer_get_m_time(vtkTrivialProducer* sself); +extern "C" void vtk_trivial_producer_set_whole_extent(vtkTrivialProducer* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" vtkUndirectedGraphAlgorithm * vtkUndirectedGraphAlgorithm_new () ; +extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkUndirectedGraphAlgorithm * sself) ; +extern "C" void * vtkUndirectedGraphAlgorithm_get_ptr (vtkUndirectedGraphAlgorithm * sself) ; +extern "C" vtkUniformGridAMRAlgorithm * vtkUniformGridAMRAlgorithm_new () ; +extern "C" void vtkUniformGridAMRAlgorithm_destructor (vtkUniformGridAMRAlgorithm * sself) ; +extern "C" void * vtkUniformGridAMRAlgorithm_get_ptr (vtkUniformGridAMRAlgorithm * sself) ; +extern "C" vtkUniformGridPartitioner * vtkUniformGridPartitioner_new () ; +extern "C" void vtkUniformGridPartitioner_destructor (vtkUniformGridPartitioner * sself) ; +extern "C" void * vtkUniformGridPartitioner_get_ptr (vtkUniformGridPartitioner * sself) ; +extern "C" int vtk_uniform_grid_partitioner_get_number_of_partitions(vtkUniformGridPartitioner* sself); +extern "C" void vtk_uniform_grid_partitioner_set_number_of_partitions(vtkUniformGridPartitioner* sself, int _arg); +extern "C" int vtk_uniform_grid_partitioner_get_number_of_ghost_layers(vtkUniformGridPartitioner* sself); +extern "C" void vtk_uniform_grid_partitioner_set_number_of_ghost_layers(vtkUniformGridPartitioner* sself, int _arg); +extern "C" int vtk_uniform_grid_partitioner_get_duplicate_nodes(vtkUniformGridPartitioner* sself); +extern "C" void vtk_uniform_grid_partitioner_set_duplicate_nodes(vtkUniformGridPartitioner* sself, int _arg); +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_on(vtkUniformGridPartitioner* sself); +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_off(vtkUniformGridPartitioner* sself); +extern "C" vtkUnstructuredGridAlgorithm * vtkUnstructuredGridAlgorithm_new () ; +extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkUnstructuredGridAlgorithm * sself) ; +extern "C" void * vtkUnstructuredGridAlgorithm_get_ptr (vtkUnstructuredGridAlgorithm * sself) ; +extern "C" vtkUnstructuredGridBaseAlgorithm * vtkUnstructuredGridBaseAlgorithm_new () ; +extern "C" void vtkUnstructuredGridBaseAlgorithm_destructor (vtkUnstructuredGridBaseAlgorithm * sself) ; +extern "C" void * vtkUnstructuredGridBaseAlgorithm_get_ptr (vtkUnstructuredGridBaseAlgorithm * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h index 14cd942..89d67a5 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h @@ -20,157 +20,90 @@ #include // Declare exported functions -extern "C" vtkNew < vtkAmoebaMinimizer > vtkAmoebaMinimizer_new () ; -extern "C" void vtkAmoebaMinimizer_destructor (vtkNew < vtkAmoebaMinimizer > sself) ; -extern "C" void * vtkAmoebaMinimizer_get_ptr (vtkNew < vtkAmoebaMinimizer > sself) ; -extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkNew sself, const char name, double value); -extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkNew sself, int i, double value); -extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkNew sself, const char name, double scale); -extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkNew sself, const char name); -extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkNew sself, int i, double scale); -extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkNew sself, int i); -extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkNew sself, const char name); -extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkNew sself, int i); -extern "C" const char* vtk_amoeba_minimizer_get_parameter_name(vtkNew sself, int i); -extern "C" int vtk_amoeba_minimizer_get_number_of_parameters(vtkNew sself); -extern "C" void vtk_amoeba_minimizer_initialize(vtkNew sself); -extern "C" void vtk_amoeba_minimizer_minimize(vtkNew sself); -extern "C" int vtk_amoeba_minimizer_iterate(vtkNew sself); -extern "C" void vtk_amoeba_minimizer_set_function_value(vtkNew sself, double _arg); -extern "C" double vtk_amoeba_minimizer_get_function_value(vtkNew sself); -extern "C" void vtk_amoeba_minimizer_set_contraction_ratio(vtkNew sself, double _arg); -extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_min_value(vtkNew sself); -extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_max_value(vtkNew sself); -extern "C" double vtk_amoeba_minimizer_get_contraction_ratio(vtkNew sself); -extern "C" void vtk_amoeba_minimizer_set_expansion_ratio(vtkNew sself, double _arg); -extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_min_value(vtkNew sself); -extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_max_value(vtkNew sself); -extern "C" double vtk_amoeba_minimizer_get_expansion_ratio(vtkNew sself); -extern "C" void vtk_amoeba_minimizer_set_tolerance(vtkNew sself, double _arg); -extern "C" double vtk_amoeba_minimizer_get_tolerance(vtkNew sself); -extern "C" void vtk_amoeba_minimizer_set_parameter_tolerance(vtkNew sself, double _arg); -extern "C" double vtk_amoeba_minimizer_get_parameter_tolerance(vtkNew sself); -extern "C" void vtk_amoeba_minimizer_set_max_iterations(vtkNew sself, int _arg); -extern "C" int vtk_amoeba_minimizer_get_max_iterations(vtkNew sself); -extern "C" int vtk_amoeba_minimizer_get_iterations(vtkNew sself); -extern "C" int vtk_amoeba_minimizer_get_function_evaluations(vtkNew sself); -extern "C" void vtk_amoeba_minimizer_evaluate_function(vtkNew sself); -extern "C" vtkNew < vtkFFT > vtkFFT_new () ; -extern "C" void vtkFFT_destructor (vtkNew < vtkFFT > sself) ; -extern "C" void * vtkFFT_get_ptr (vtkNew < vtkFFT > sself) ; -extern "C" double vtk_fft_hanning_generator(vtkNew sself, const size_t x, const size_t size); -extern "C" double vtk_fft_bartlett_generator(vtkNew sself, const size_t x, const size_t size); -extern "C" double vtk_fft_sine_generator(vtkNew sself, const size_t x, const size_t size); -extern "C" double vtk_fft_blackman_generator(vtkNew sself, const size_t x, const size_t size); -extern "C" double vtk_fft_rectangular_generator(vtkNew sself, const size_t x, const size_t size); -extern "C" vtkNew < vtkMatrix3x3 > vtkMatrix3x3_new () ; -extern "C" void vtkMatrix3x3_destructor (vtkNew < vtkMatrix3x3 > sself) ; -extern "C" void * vtkMatrix3x3_get_ptr (vtkNew < vtkMatrix3x3 > sself) ; -extern "C" void vtk_matrix_3_x_3_deep_copy(vtkNew sself, double elements, const double newElements); -extern "C" void vtk_matrix_3_x_3_deep_copy(vtkNew sself, const double elements); -extern "C" void vtk_matrix_3_x_3_zero(vtkNew sself); -extern "C" void vtk_matrix_3_x_3_zero(vtkNew sself, double elements); -extern "C" void vtk_matrix_3_x_3_identity(vtkNew sself); -extern "C" void vtk_matrix_3_x_3_identity(vtkNew sself, double elements); -extern "C" void vtk_matrix_3_x_3_invert(vtkNew sself); -extern "C" void vtk_matrix_3_x_3_invert(vtkNew sself, const double inElements, double outElements); -extern "C" void vtk_matrix_3_x_3_transpose(vtkNew sself); -extern "C" void vtk_matrix_3_x_3_transpose(vtkNew sself, const double inElements, double outElements); -extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const float in, float out); -extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double in, double out); -extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double elements, const float in, float out); -extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double elements, const double in, double out); -extern "C" void vtk_matrix_3_x_3_multiply_3_x_3(vtkNew sself, const double a, const double b, double c); -extern "C" void vtk_matrix_3_x_3_adjoint(vtkNew sself, const double inElements, double outElements); -extern "C" double vtk_matrix_3_x_3_determinant(vtkNew sself); -extern "C" double vtk_matrix_3_x_3_determinant(vtkNew sself, const double elements); -extern "C" void vtk_matrix_3_x_3_set_element(vtkNew sself, int i, int j, double value); -extern "C" double vtk_matrix_3_x_3_get_element(vtkNew sself, int i, int j); -extern "C" bool vtk_matrix_3_x_3_is_identity(vtkNew sself); -extern "C" double* vtk_matrix_3_x_3_get_data(vtkNew sself); -extern "C" const double* vtk_matrix_3_x_3_get_data(vtkNew sself); -extern "C" vtkNew < vtkMatrix4x4 > vtkMatrix4x4_new () ; -extern "C" void vtkMatrix4x4_destructor (vtkNew < vtkMatrix4x4 > sself) ; -extern "C" void * vtkMatrix4x4_get_ptr (vtkNew < vtkMatrix4x4 > sself) ; -extern "C" void vtk_matrix_4_x_4_deep_copy(vtkNew sself, double destination, const double source); -extern "C" void vtk_matrix_4_x_4_deep_copy(vtkNew sself, const double elements); -extern "C" void vtk_matrix_4_x_4_zero(vtkNew sself); -extern "C" void vtk_matrix_4_x_4_zero(vtkNew sself, double elements); -extern "C" void vtk_matrix_4_x_4_identity(vtkNew sself); -extern "C" void vtk_matrix_4_x_4_identity(vtkNew sself, double elements); -extern "C" bool vtk_matrix_4_x_4_is_identity(vtkNew sself); -extern "C" void vtk_matrix_4_x_4_invert(vtkNew sself); -extern "C" void vtk_matrix_4_x_4_invert(vtkNew sself, const double inElements, double outElements); -extern "C" void vtk_matrix_4_x_4_transpose(vtkNew sself); -extern "C" void vtk_matrix_4_x_4_transpose(vtkNew sself, const double inElements, double outElements); -extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const float in, float out); -extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double in, double out); -extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double elements, const float in, float out); -extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double elements, const double in, double out); -extern "C" float* vtk_matrix_4_x_4_multiply_point(vtkNew sself, const float in); -extern "C" double* vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double in); -extern "C" float* vtk_matrix_4_x_4_multiply_float_point(vtkNew sself, const float in); -extern "C" double* vtk_matrix_4_x_4_multiply_double_point(vtkNew sself, const double in); -extern "C" void vtk_matrix_4_x_4_multiply_4_x_4(vtkNew sself, const double a, const double b, double c); -extern "C" void vtk_matrix_4_x_4_multiply_4_x_4(vtkNew sself, const double a, const double b, float c); -extern "C" void vtk_matrix_4_x_4_multiply_and_transpose_4_x_4(vtkNew sself, const double a, const double b, float c); -extern "C" void vtk_matrix_4_x_4_adjoint(vtkNew sself, const double inElements, double outElements); -extern "C" double vtk_matrix_4_x_4_determinant(vtkNew sself); -extern "C" double vtk_matrix_4_x_4_determinant(vtkNew sself, const double elements); -extern "C" void vtk_matrix_4_x_4_set_element(vtkNew sself, int i, int j, double value); -extern "C" double vtk_matrix_4_x_4_get_element(vtkNew sself, int i, int j); -extern "C" double* vtk_matrix_4_x_4_get_data(vtkNew sself); -extern "C" const double* vtk_matrix_4_x_4_get_data(vtkNew sself); -extern "C" vtkNew < vtkPolynomialSolversUnivariate > vtkPolynomialSolversUnivariate_new () ; -extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkNew < vtkPolynomialSolversUnivariate > sself) ; -extern "C" void * vtkPolynomialSolversUnivariate_get_ptr (vtkNew < vtkPolynomialSolversUnivariate > sself) ; -extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol); -extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType); -extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType, bool divideGCD); -extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol); -extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType); -extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType, bool divideGCD); -extern "C" int vtk_polynomial_solvers_univariate_filter_roots(vtkNew sself, double P, int d, double upperBnds, int rootcount, double diameter); -extern "C" int vtk_polynomial_solvers_univariate_lin_bairstow_solve(vtkNew sself, double c, int d, double r, double tolerance); -extern "C" int vtk_polynomial_solvers_univariate_ferrari_solve(vtkNew sself, double c, double r, int m, double tol); -extern "C" int vtk_polynomial_solvers_univariate_tartaglia_cardan_solve(vtkNew sself, double c, double r, int m, double tol); -extern "C" double* vtk_polynomial_solvers_univariate_solve_cubic(vtkNew sself, double c0, double c1, double c2, double c3); -extern "C" double* vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c0, double c1, double c2); -extern "C" double* vtk_polynomial_solvers_univariate_solve_linear(vtkNew sself, double c0, double c1); -extern "C" int vtk_polynomial_solvers_univariate_solve_cubic(vtkNew sself, double c0, double c1, double c2, double c3, double r1, double r2, double r3, int num_roots); -extern "C" int vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c0, double c1, double c2, double r1, double r2, int num_roots); -extern "C" int vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c, double r, int m); -extern "C" int vtk_polynomial_solvers_univariate_solve_linear(vtkNew sself, double c0, double c1, double r1, int num_roots); -extern "C" void vtk_polynomial_solvers_univariate_set_division_tolerance(vtkNew sself, double tol); -extern "C" double vtk_polynomial_solvers_univariate_get_division_tolerance(vtkNew sself); -extern "C" vtkNew < vtkQuaternionInterpolator > vtkQuaternionInterpolator_new () ; -extern "C" void vtkQuaternionInterpolator_destructor (vtkNew < vtkQuaternionInterpolator > sself) ; -extern "C" void * vtkQuaternionInterpolator_get_ptr (vtkNew < vtkQuaternionInterpolator > sself) ; -extern "C" int vtk_quaternion_interpolator_get_number_of_quaternions(vtkNew sself); -extern "C" double vtk_quaternion_interpolator_get_minimum_t(vtkNew sself); -extern "C" double vtk_quaternion_interpolator_get_maximum_t(vtkNew sself); -extern "C" void vtk_quaternion_interpolator_initialize(vtkNew sself); -extern "C" void vtk_quaternion_interpolator_add_quaternion(vtkNew sself, double t, double q); -extern "C" void vtk_quaternion_interpolator_remove_quaternion(vtkNew sself, double t); -extern "C" void vtk_quaternion_interpolator_interpolate_quaternion(vtkNew sself, double t, double q); -extern "C" int vtk_quaternion_interpolator_get_search_method(vtkNew sself); -extern "C" void vtk_quaternion_interpolator_set_search_method(vtkNew sself, int type); -extern "C" void vtk_quaternion_interpolator_set_interpolation_type(vtkNew sself, int _arg); -extern "C" int vtk_quaternion_interpolator_get_interpolation_type_min_value(vtkNew sself); -extern "C" int vtk_quaternion_interpolator_get_interpolation_type_max_value(vtkNew sself); -extern "C" int vtk_quaternion_interpolator_get_interpolation_type(vtkNew sself); -extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_linear(vtkNew sself); -extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_spline(vtkNew sself); -extern "C" vtkNew < vtkRungeKutta2 > vtkRungeKutta2_new () ; -extern "C" void vtkRungeKutta2_destructor (vtkNew < vtkRungeKutta2 > sself) ; -extern "C" void * vtkRungeKutta2_get_ptr (vtkNew < vtkRungeKutta2 > sself) ; -extern "C" int vtk_runge_kutta_2_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData); -extern "C" vtkNew < vtkRungeKutta4 > vtkRungeKutta4_new () ; -extern "C" void vtkRungeKutta4_destructor (vtkNew < vtkRungeKutta4 > sself) ; -extern "C" void * vtkRungeKutta4_get_ptr (vtkNew < vtkRungeKutta4 > sself) ; -extern "C" int vtk_runge_kutta_4_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData); -extern "C" vtkNew < vtkRungeKutta45 > vtkRungeKutta45_new () ; -extern "C" void vtkRungeKutta45_destructor (vtkNew < vtkRungeKutta45 > sself) ; -extern "C" void * vtkRungeKutta45_get_ptr (vtkNew < vtkRungeKutta45 > sself) ; -extern "C" int vtk_runge_kutta_45_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData); -extern "C" int vtk_runge_kutta_45_compute_next_step(vtkNew sself, double xprev, double dxprev, double xnext, double t, double delT, double delTActual, double minStep, double maxStep, double maxError, double estErr, void userData); +extern "C" vtkAmoebaMinimizer * vtkAmoebaMinimizer_new () ; +extern "C" void vtkAmoebaMinimizer_destructor (vtkAmoebaMinimizer * sself) ; +extern "C" void * vtkAmoebaMinimizer_get_ptr (vtkAmoebaMinimizer * sself) ; +extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkAmoebaMinimizer* sself, const char* name, double value); +extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkAmoebaMinimizer* sself, const char* name, double scale); +extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkAmoebaMinimizer* sself, const char* name); +extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkAmoebaMinimizer* sself, const char* name); +extern "C" const char* vtk_amoeba_minimizer_get_parameter_name(vtkAmoebaMinimizer* sself, int i); +extern "C" int vtk_amoeba_minimizer_get_number_of_parameters(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_initialize(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_minimize(vtkAmoebaMinimizer* sself); +extern "C" int vtk_amoeba_minimizer_iterate(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_function_value(vtkAmoebaMinimizer* sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_function_value(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_contraction_ratio(vtkAmoebaMinimizer* sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_min_value(vtkAmoebaMinimizer* sself); +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_max_value(vtkAmoebaMinimizer* sself); +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_expansion_ratio(vtkAmoebaMinimizer* sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_min_value(vtkAmoebaMinimizer* sself); +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_max_value(vtkAmoebaMinimizer* sself); +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_tolerance(vtkAmoebaMinimizer* sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_tolerance(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_parameter_tolerance(vtkAmoebaMinimizer* sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_parameter_tolerance(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_max_iterations(vtkAmoebaMinimizer* sself, int _arg); +extern "C" int vtk_amoeba_minimizer_get_max_iterations(vtkAmoebaMinimizer* sself); +extern "C" int vtk_amoeba_minimizer_get_iterations(vtkAmoebaMinimizer* sself); +extern "C" int vtk_amoeba_minimizer_get_function_evaluations(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_evaluate_function(vtkAmoebaMinimizer* sself); +extern "C" vtkFFT * vtkFFT_new () ; +extern "C" void vtkFFT_destructor (vtkFFT * sself) ; +extern "C" void * vtkFFT_get_ptr (vtkFFT * sself) ; +extern "C" double vtk_fft_hanning_generator(vtkFFT* sself, const size_t x, const size_t size); +extern "C" double vtk_fft_bartlett_generator(vtkFFT* sself, const size_t x, const size_t size); +extern "C" double vtk_fft_sine_generator(vtkFFT* sself, const size_t x, const size_t size); +extern "C" double vtk_fft_blackman_generator(vtkFFT* sself, const size_t x, const size_t size); +extern "C" double vtk_fft_rectangular_generator(vtkFFT* sself, const size_t x, const size_t size); +extern "C" vtkMatrix3x3 * vtkMatrix3x3_new () ; +extern "C" void vtkMatrix3x3_destructor (vtkMatrix3x3 * sself) ; +extern "C" void * vtkMatrix3x3_get_ptr (vtkMatrix3x3 * sself) ; +extern "C" void vtk_matrix_3_x_3_zero(vtkMatrix3x3* sself); +extern "C" void vtk_matrix_3_x_3_identity(vtkMatrix3x3* sself); +extern "C" double vtk_matrix_3_x_3_determinant(vtkMatrix3x3* sself); +extern "C" void vtk_matrix_3_x_3_set_element(vtkMatrix3x3* sself, int i, int j, double value); +extern "C" double vtk_matrix_3_x_3_get_element(vtkMatrix3x3* sself, int i, int j); +extern "C" bool vtk_matrix_3_x_3_is_identity(vtkMatrix3x3* sself); +extern "C" vtkMatrix4x4 * vtkMatrix4x4_new () ; +extern "C" void vtkMatrix4x4_destructor (vtkMatrix4x4 * sself) ; +extern "C" void * vtkMatrix4x4_get_ptr (vtkMatrix4x4 * sself) ; +extern "C" void vtk_matrix_4_x_4_zero(vtkMatrix4x4* sself); +extern "C" void vtk_matrix_4_x_4_identity(vtkMatrix4x4* sself); +extern "C" bool vtk_matrix_4_x_4_is_identity(vtkMatrix4x4* sself); +extern "C" double vtk_matrix_4_x_4_determinant(vtkMatrix4x4* sself); +extern "C" void vtk_matrix_4_x_4_set_element(vtkMatrix4x4* sself, int i, int j, double value); +extern "C" double vtk_matrix_4_x_4_get_element(vtkMatrix4x4* sself, int i, int j); +extern "C" vtkPolynomialSolversUnivariate * vtkPolynomialSolversUnivariate_new () ; +extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkPolynomialSolversUnivariate * sself) ; +extern "C" void * vtkPolynomialSolversUnivariate_get_ptr (vtkPolynomialSolversUnivariate * sself) ; +extern "C" void vtk_polynomial_solvers_univariate_set_division_tolerance(vtkPolynomialSolversUnivariate* sself, double tol); +extern "C" double vtk_polynomial_solvers_univariate_get_division_tolerance(vtkPolynomialSolversUnivariate* sself); +extern "C" vtkQuaternionInterpolator * vtkQuaternionInterpolator_new () ; +extern "C" void vtkQuaternionInterpolator_destructor (vtkQuaternionInterpolator * sself) ; +extern "C" void * vtkQuaternionInterpolator_get_ptr (vtkQuaternionInterpolator * sself) ; +extern "C" int vtk_quaternion_interpolator_get_number_of_quaternions(vtkQuaternionInterpolator* sself); +extern "C" double vtk_quaternion_interpolator_get_minimum_t(vtkQuaternionInterpolator* sself); +extern "C" double vtk_quaternion_interpolator_get_maximum_t(vtkQuaternionInterpolator* sself); +extern "C" void vtk_quaternion_interpolator_initialize(vtkQuaternionInterpolator* sself); +extern "C" void vtk_quaternion_interpolator_remove_quaternion(vtkQuaternionInterpolator* sself, double t); +extern "C" int vtk_quaternion_interpolator_get_search_method(vtkQuaternionInterpolator* sself); +extern "C" void vtk_quaternion_interpolator_set_search_method(vtkQuaternionInterpolator* sself, int type); +extern "C" void vtk_quaternion_interpolator_set_interpolation_type(vtkQuaternionInterpolator* sself, int _arg); +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_min_value(vtkQuaternionInterpolator* sself); +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_max_value(vtkQuaternionInterpolator* sself); +extern "C" int vtk_quaternion_interpolator_get_interpolation_type(vtkQuaternionInterpolator* sself); +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_linear(vtkQuaternionInterpolator* sself); +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_spline(vtkQuaternionInterpolator* sself); +extern "C" vtkRungeKutta2 * vtkRungeKutta2_new () ; +extern "C" void vtkRungeKutta2_destructor (vtkRungeKutta2 * sself) ; +extern "C" void * vtkRungeKutta2_get_ptr (vtkRungeKutta2 * sself) ; +extern "C" vtkRungeKutta4 * vtkRungeKutta4_new () ; +extern "C" void vtkRungeKutta4_destructor (vtkRungeKutta4 * sself) ; +extern "C" void * vtkRungeKutta4_get_ptr (vtkRungeKutta4 * sself) ; +extern "C" vtkRungeKutta45 * vtkRungeKutta45_new () ; +extern "C" void vtkRungeKutta45_destructor (vtkRungeKutta45 * sself) ; +extern "C" void * vtkRungeKutta45_get_ptr (vtkRungeKutta45 * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h index c876a5c..60aec3c 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h @@ -12,134 +12,86 @@ #include // Declare exported functions -extern "C" vtkNew < vtkContourValues > vtkContourValues_new () ; -extern "C" void vtkContourValues_destructor (vtkNew < vtkContourValues > sself) ; -extern "C" void * vtkContourValues_get_ptr (vtkNew < vtkContourValues > sself) ; -extern "C" void vtk_contour_values_set_value(vtkNew sself, int i, double value); -extern "C" double vtk_contour_values_get_value(vtkNew sself, int i); -extern "C" double* vtk_contour_values_get_values(vtkNew sself); -extern "C" void vtk_contour_values_get_values(vtkNew sself, double contourValues); -extern "C" void vtk_contour_values_set_number_of_contours(vtkNew sself, const int number); -extern "C" int vtk_contour_values_get_number_of_contours(vtkNew sself); -extern "C" void vtk_contour_values_generate_values(vtkNew sself, int numContours, double range); -extern "C" void vtk_contour_values_generate_values(vtkNew sself, int numContours, double rangeStart, double rangeEnd); -extern "C" vtkNew < vtkExprTkFunctionParser > vtkExprTkFunctionParser_new () ; -extern "C" void vtkExprTkFunctionParser_destructor (vtkNew < vtkExprTkFunctionParser > sself) ; -extern "C" void * vtkExprTkFunctionParser_get_ptr (vtkNew < vtkExprTkFunctionParser > sself) ; -extern "C" unsigned long vtk_expr_tk_function_parser_get_m_time(vtkNew sself); -extern "C" void vtk_expr_tk_function_parser_set_function(vtkNew sself, const char function); -extern "C" const char* vtk_expr_tk_function_parser_get_function(vtkNew sself); -extern "C" int vtk_expr_tk_function_parser_is_scalar_result(vtkNew sself); -extern "C" int vtk_expr_tk_function_parser_is_vector_result(vtkNew sself); -extern "C" double vtk_expr_tk_function_parser_get_scalar_result(vtkNew sself); -extern "C" double* vtk_expr_tk_function_parser_get_vector_result(vtkNew sself); -extern "C" void vtk_expr_tk_function_parser_get_vector_result(vtkNew sself, double result); -extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkNew sself, const char* variableName, double value); -extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkNew sself, int i, double value); -extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkNew sself, const char* variableName); -extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkNew sself, int i); -extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double xValue, double yValue, double zValue); -extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double values); -extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, int i, double xValue, double yValue, double zValue); -extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, int i, double values); -extern "C" double* vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName); -extern "C" void vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName, double value); -extern "C" double* vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, int i); -extern "C" void vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, int i, double value); -extern "C" int vtk_expr_tk_function_parser_get_number_of_scalar_variables(vtkNew sself); -extern "C" int vtk_expr_tk_function_parser_get_scalar_variable_index(vtkNew sself, const char* name); -extern "C" int vtk_expr_tk_function_parser_get_number_of_vector_variables(vtkNew sself); -extern "C" int vtk_expr_tk_function_parser_get_vector_variable_index(vtkNew sself, const char* name); -extern "C" const char* vtk_expr_tk_function_parser_get_scalar_variable_name(vtkNew sself, int i); -extern "C" const char* vtk_expr_tk_function_parser_get_vector_variable_name(vtkNew sself, int i); -extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkNew sself, int i); -extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkNew sself, const char* variableName); -extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkNew sself, int i); -extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkNew sself, const char* variableName); -extern "C" void vtk_expr_tk_function_parser_remove_all_variables(vtkNew sself); -extern "C" void vtk_expr_tk_function_parser_remove_scalar_variables(vtkNew sself); -extern "C" void vtk_expr_tk_function_parser_remove_vector_variables(vtkNew sself); -extern "C" void vtk_expr_tk_function_parser_set_replace_invalid_values(vtkNew sself, int _arg); -extern "C" int vtk_expr_tk_function_parser_get_replace_invalid_values(vtkNew sself); -extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_on(vtkNew sself); -extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_off(vtkNew sself); -extern "C" void vtk_expr_tk_function_parser_set_replacement_value(vtkNew sself, double _arg); -extern "C" double vtk_expr_tk_function_parser_get_replacement_value(vtkNew sself); -extern "C" void vtk_expr_tk_function_parser_invalidate_function(vtkNew sself); -extern "C" const char* vtk_expr_tk_function_parser_sanitize_name(vtkNew sself, const char name); -extern "C" vtkNew < vtkFunctionParser > vtkFunctionParser_new () ; -extern "C" void vtkFunctionParser_destructor (vtkNew < vtkFunctionParser > sself) ; -extern "C" void * vtkFunctionParser_get_ptr (vtkNew < vtkFunctionParser > sself) ; -extern "C" unsigned long vtk_function_parser_get_m_time(vtkNew sself); -extern "C" void vtk_function_parser_set_function(vtkNew sself, const char function); -extern "C" char* vtk_function_parser_get_function(vtkNew sself); -extern "C" int vtk_function_parser_is_scalar_result(vtkNew sself); -extern "C" int vtk_function_parser_is_vector_result(vtkNew sself); -extern "C" double vtk_function_parser_get_scalar_result(vtkNew sself); -extern "C" double* vtk_function_parser_get_vector_result(vtkNew sself); -extern "C" void vtk_function_parser_get_vector_result(vtkNew sself, double result); -extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, const char variableName, double value); -extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, const char* variableName, double value); -extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, int i, double value); -extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, const char variableName); -extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, const char* variableName); -extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, int i); -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char variableName, double xValue, double yValue, double zValue); -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double xValue, double yValue, double zValue); -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char variableName, const double values); -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, const double values); -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, int i, double xValue, double yValue, double zValue); -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, int i, const double values); -extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, const char variableName); -extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName); -extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, const char variableName, double value); -extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName, double value); -extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, int i); -extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, int i, double value); -extern "C" int vtk_function_parser_get_number_of_scalar_variables(vtkNew sself); -extern "C" int vtk_function_parser_get_scalar_variable_index(vtkNew sself, const char name); -extern "C" int vtk_function_parser_get_scalar_variable_index(vtkNew sself, const char* name); -extern "C" int vtk_function_parser_get_number_of_vector_variables(vtkNew sself); -extern "C" int vtk_function_parser_get_vector_variable_index(vtkNew sself, const char name); -extern "C" int vtk_function_parser_get_vector_variable_index(vtkNew sself, const char* name); -extern "C" const char* vtk_function_parser_get_scalar_variable_name(vtkNew sself, int i); -extern "C" const char* vtk_function_parser_get_vector_variable_name(vtkNew sself, int i); -extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, int i); -extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, const char variableName); -extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, const char* variableName); -extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, int i); -extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, const char variableName); -extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, const char* variableName); -extern "C" void vtk_function_parser_remove_all_variables(vtkNew sself); -extern "C" void vtk_function_parser_remove_scalar_variables(vtkNew sself); -extern "C" void vtk_function_parser_remove_vector_variables(vtkNew sself); -extern "C" void vtk_function_parser_set_replace_invalid_values(vtkNew sself, int _arg); -extern "C" int vtk_function_parser_get_replace_invalid_values(vtkNew sself); -extern "C" void vtk_function_parser_replace_invalid_values_on(vtkNew sself); -extern "C" void vtk_function_parser_replace_invalid_values_off(vtkNew sself); -extern "C" void vtk_function_parser_set_replacement_value(vtkNew sself, double _arg); -extern "C" double vtk_function_parser_get_replacement_value(vtkNew sself); -extern "C" void vtk_function_parser_check_expression(vtkNew sself, int pos, char error); -extern "C" void vtk_function_parser_invalidate_function(vtkNew sself); -extern "C" vtkNew < vtkHeap > vtkHeap_new () ; -extern "C" void vtkHeap_destructor (vtkNew < vtkHeap > sself) ; -extern "C" void * vtkHeap_get_ptr (vtkNew < vtkHeap > sself) ; -extern "C" void* vtk_heap_allocate_memory(vtkNew sself, size_t n); -extern "C" void vtk_heap_set_block_size(vtkNew sself, size_t p0); -extern "C" size_t vtk_heap_get_block_size(vtkNew sself); -extern "C" int vtk_heap_get_number_of_blocks(vtkNew sself); -extern "C" int vtk_heap_get_number_of_allocations(vtkNew sself); -extern "C" void vtk_heap_reset(vtkNew sself); -extern "C" char* vtk_heap_string_dup(vtkNew sself, const char str); -extern "C" vtkNew < vtkResourceFileLocator > vtkResourceFileLocator_new () ; -extern "C" void vtkResourceFileLocator_destructor (vtkNew < vtkResourceFileLocator > sself) ; -extern "C" void * vtkResourceFileLocator_get_ptr (vtkNew < vtkResourceFileLocator > sself) ; -extern "C" void vtk_resource_file_locator_set_print_debug_information(vtkNew sself, bool p0); -extern "C" bool vtk_resource_file_locator_get_print_debug_information(vtkNew sself); -extern "C" void vtk_resource_file_locator_print_debug_information_on(vtkNew sself); -extern "C" void vtk_resource_file_locator_print_debug_information_off(vtkNew sself); -extern "C" void vtk_resource_file_locator_set_log_verbosity(vtkNew sself, int _arg); -extern "C" int vtk_resource_file_locator_get_log_verbosity(vtkNew sself); -extern "C" const char* vtk_resource_file_locator_locate(vtkNew sself, const char* anchor, const char* landmark, const char* defaultDir); -extern "C" const char* vtk_resource_file_locator_get_library_path_for_symbol_unix(vtkNew sself, const char symbolname); -extern "C" const char* vtk_resource_file_locator_get_library_path_for_symbol_win_32(vtkNew sself, const void fptr); +extern "C" vtkContourValues * vtkContourValues_new () ; +extern "C" void vtkContourValues_destructor (vtkContourValues * sself) ; +extern "C" void * vtkContourValues_get_ptr (vtkContourValues * sself) ; +extern "C" void vtk_contour_values_set_value(vtkContourValues* sself, int i, double value); +extern "C" double vtk_contour_values_get_value(vtkContourValues* sself, int i); +extern "C" void vtk_contour_values_set_number_of_contours(vtkContourValues* sself, const int number); +extern "C" int vtk_contour_values_get_number_of_contours(vtkContourValues* sself); +extern "C" void vtk_contour_values_generate_values(vtkContourValues* sself, int numContours, double rangeStart, double rangeEnd); +extern "C" vtkExprTkFunctionParser * vtkExprTkFunctionParser_new () ; +extern "C" void vtkExprTkFunctionParser_destructor (vtkExprTkFunctionParser * sself) ; +extern "C" void * vtkExprTkFunctionParser_get_ptr (vtkExprTkFunctionParser * sself) ; +extern "C" unsigned long vtk_expr_tk_function_parser_get_m_time(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_set_function(vtkExprTkFunctionParser* sself, const char* function); +extern "C" const char* vtk_expr_tk_function_parser_get_function(vtkExprTkFunctionParser* sself); +extern "C" int vtk_expr_tk_function_parser_is_scalar_result(vtkExprTkFunctionParser* sself); +extern "C" int vtk_expr_tk_function_parser_is_vector_result(vtkExprTkFunctionParser* sself); +extern "C" double vtk_expr_tk_function_parser_get_scalar_result(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName, double value); +extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName); +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName, double xValue, double yValue, double zValue); +extern "C" int vtk_expr_tk_function_parser_get_number_of_scalar_variables(vtkExprTkFunctionParser* sself); +extern "C" int vtk_expr_tk_function_parser_get_scalar_variable_index(vtkExprTkFunctionParser* sself, const char*& name); +extern "C" int vtk_expr_tk_function_parser_get_number_of_vector_variables(vtkExprTkFunctionParser* sself); +extern "C" int vtk_expr_tk_function_parser_get_vector_variable_index(vtkExprTkFunctionParser* sself, const char*& name); +extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkExprTkFunctionParser* sself, int i); +extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkExprTkFunctionParser* sself, int i); +extern "C" void vtk_expr_tk_function_parser_remove_all_variables(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_remove_scalar_variables(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_remove_vector_variables(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_set_replace_invalid_values(vtkExprTkFunctionParser* sself, int _arg); +extern "C" int vtk_expr_tk_function_parser_get_replace_invalid_values(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_on(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_off(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_set_replacement_value(vtkExprTkFunctionParser* sself, double _arg); +extern "C" double vtk_expr_tk_function_parser_get_replacement_value(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_invalidate_function(vtkExprTkFunctionParser* sself); +extern "C" vtkFunctionParser * vtkFunctionParser_new () ; +extern "C" void vtkFunctionParser_destructor (vtkFunctionParser * sself) ; +extern "C" void * vtkFunctionParser_get_ptr (vtkFunctionParser * sself) ; +extern "C" unsigned long vtk_function_parser_get_m_time(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_set_function(vtkFunctionParser* sself, const char* function); +extern "C" int vtk_function_parser_is_scalar_result(vtkFunctionParser* sself); +extern "C" int vtk_function_parser_is_vector_result(vtkFunctionParser* sself); +extern "C" double vtk_function_parser_get_scalar_result(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_set_scalar_variable_value(vtkFunctionParser* sself, const char* variableName, double value); +extern "C" double vtk_function_parser_get_scalar_variable_value(vtkFunctionParser* sself, const char* variableName); +extern "C" void vtk_function_parser_set_vector_variable_value(vtkFunctionParser* sself, const char* variableName, double xValue, double yValue, double zValue); +extern "C" int vtk_function_parser_get_number_of_scalar_variables(vtkFunctionParser* sself); +extern "C" int vtk_function_parser_get_scalar_variable_index(vtkFunctionParser* sself, const char* name); +extern "C" int vtk_function_parser_get_number_of_vector_variables(vtkFunctionParser* sself); +extern "C" int vtk_function_parser_get_vector_variable_index(vtkFunctionParser* sself, const char* name); +extern "C" const char* vtk_function_parser_get_scalar_variable_name(vtkFunctionParser* sself, int i); +extern "C" const char* vtk_function_parser_get_vector_variable_name(vtkFunctionParser* sself, int i); +extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkFunctionParser* sself, int i); +extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkFunctionParser* sself, int i); +extern "C" void vtk_function_parser_remove_all_variables(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_remove_scalar_variables(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_remove_vector_variables(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_set_replace_invalid_values(vtkFunctionParser* sself, int _arg); +extern "C" int vtk_function_parser_get_replace_invalid_values(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_replace_invalid_values_on(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_replace_invalid_values_off(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_set_replacement_value(vtkFunctionParser* sself, double _arg); +extern "C" double vtk_function_parser_get_replacement_value(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_invalidate_function(vtkFunctionParser* sself); +extern "C" vtkHeap * vtkHeap_new () ; +extern "C" void vtkHeap_destructor (vtkHeap * sself) ; +extern "C" void * vtkHeap_get_ptr (vtkHeap * sself) ; +extern "C" void* vtk_heap_allocate_memory(vtkHeap* sself, size_t n); +extern "C" void vtk_heap_set_block_size(vtkHeap* sself, size_t p0); +extern "C" size_t vtk_heap_get_block_size(vtkHeap* sself); +extern "C" int vtk_heap_get_number_of_blocks(vtkHeap* sself); +extern "C" int vtk_heap_get_number_of_allocations(vtkHeap* sself); +extern "C" void vtk_heap_reset(vtkHeap* sself); +extern "C" vtkResourceFileLocator * vtkResourceFileLocator_new () ; +extern "C" void vtkResourceFileLocator_destructor (vtkResourceFileLocator * sself) ; +extern "C" void * vtkResourceFileLocator_get_ptr (vtkResourceFileLocator * sself) ; +extern "C" void vtk_resource_file_locator_set_print_debug_information(vtkResourceFileLocator* sself, bool p0); +extern "C" bool vtk_resource_file_locator_get_print_debug_information(vtkResourceFileLocator* sself); +extern "C" void vtk_resource_file_locator_print_debug_information_on(vtkResourceFileLocator* sself); +extern "C" void vtk_resource_file_locator_print_debug_information_off(vtkResourceFileLocator* sself); +extern "C" void vtk_resource_file_locator_set_log_verbosity(vtkResourceFileLocator* sself, int _arg); +extern "C" int vtk_resource_file_locator_get_log_verbosity(vtkResourceFileLocator* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h index 8c27e14..511af77 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h @@ -15,76 +15,75 @@ #include // Declare exported functions -extern "C" vtkNew < vtkClientSocket > vtkClientSocket_new () ; -extern "C" void vtkClientSocket_destructor (vtkNew < vtkClientSocket > sself) ; -extern "C" void * vtkClientSocket_get_ptr (vtkNew < vtkClientSocket > sself) ; -extern "C" int vtk_client_socket_connect_to_server(vtkNew sself, const char hostname, int port); -extern "C" bool vtk_client_socket_get_connecting_side(vtkNew sself); -extern "C" vtkNew < vtkDirectory > vtkDirectory_new () ; -extern "C" void vtkDirectory_destructor (vtkNew < vtkDirectory > sself) ; -extern "C" void * vtkDirectory_get_ptr (vtkNew < vtkDirectory > sself) ; -extern "C" int vtk_directory_open(vtkNew sself, const char dir); -extern "C" long long vtk_directory_get_number_of_files(vtkNew sself); -extern "C" const char* vtk_directory_get_file(vtkNew sself, long long index); -extern "C" int vtk_directory_file_is_directory(vtkNew sself, const char name); -extern "C" const char* vtk_directory_get_current_working_directory(vtkNew sself, char buf, unsigned int len); -extern "C" int vtk_directory_make_directory(vtkNew sself, const char dir); -extern "C" int vtk_directory_delete_directory(vtkNew sself, const char dir); -extern "C" int vtk_directory_rename(vtkNew sself, const char oldname, const char newname); -extern "C" vtkNew < vtkExecutableRunner > vtkExecutableRunner_new () ; -extern "C" void vtkExecutableRunner_destructor (vtkNew < vtkExecutableRunner > sself) ; -extern "C" void * vtkExecutableRunner_get_ptr (vtkNew < vtkExecutableRunner > sself) ; -extern "C" void vtk_executable_runner_execute(vtkNew sself); -extern "C" void vtk_executable_runner_set_timeout(vtkNew sself, double _arg); -extern "C" double vtk_executable_runner_get_timeout(vtkNew sself); -extern "C" void vtk_executable_runner_set_right_trim_result(vtkNew sself, bool _arg); -extern "C" bool vtk_executable_runner_get_right_trim_result(vtkNew sself); -extern "C" void vtk_executable_runner_right_trim_result_on(vtkNew sself); -extern "C" void vtk_executable_runner_right_trim_result_off(vtkNew sself); -extern "C" const char* vtk_executable_runner_get_command(vtkNew sself); -extern "C" void vtk_executable_runner_set_command(vtkNew sself, const char arg); -extern "C" const char* vtk_executable_runner_get_std_out(vtkNew sself); -extern "C" const char* vtk_executable_runner_get_std_err(vtkNew sself); -extern "C" int vtk_executable_runner_get_return_value(vtkNew sself); -extern "C" vtkNew < vtkServerSocket > vtkServerSocket_new () ; -extern "C" void vtkServerSocket_destructor (vtkNew < vtkServerSocket > sself) ; -extern "C" void * vtkServerSocket_get_ptr (vtkNew < vtkServerSocket > sself) ; -extern "C" int vtk_server_socket_create_server(vtkNew sself, int port); -extern "C" int vtk_server_socket_get_server_port(vtkNew sself); -extern "C" vtkNew < vtkSocketCollection > vtkSocketCollection_new () ; -extern "C" void vtkSocketCollection_destructor (vtkNew < vtkSocketCollection > sself) ; -extern "C" void * vtkSocketCollection_get_ptr (vtkNew < vtkSocketCollection > sself) ; -extern "C" int vtk_socket_collection_select_sockets(vtkNew sself, unsigned long msec); -extern "C" vtkNew < vtkThreadMessager > vtkThreadMessager_new () ; -extern "C" void vtkThreadMessager_destructor (vtkNew < vtkThreadMessager > sself) ; -extern "C" void * vtkThreadMessager_get_ptr (vtkNew < vtkThreadMessager > sself) ; -extern "C" void vtk_thread_messager_wait_for_message(vtkNew sself); -extern "C" void vtk_thread_messager_send_wake_message(vtkNew sself); -extern "C" void vtk_thread_messager_enable_wait_for_receiver(vtkNew sself); -extern "C" void vtk_thread_messager_disable_wait_for_receiver(vtkNew sself); -extern "C" void vtk_thread_messager_wait_for_receiver(vtkNew sself); -extern "C" vtkNew < vtkTimerLog > vtkTimerLog_new () ; -extern "C" void vtkTimerLog_destructor (vtkNew < vtkTimerLog > sself) ; -extern "C" void * vtkTimerLog_get_ptr (vtkNew < vtkTimerLog > sself) ; -extern "C" void vtk_timer_log_set_logging(vtkNew sself, int v); -extern "C" int vtk_timer_log_get_logging(vtkNew sself); -extern "C" void vtk_timer_log_logging_on(vtkNew sself); -extern "C" void vtk_timer_log_logging_off(vtkNew sself); -extern "C" void vtk_timer_log_set_max_entries(vtkNew sself, int a); -extern "C" int vtk_timer_log_get_max_entries(vtkNew sself); -extern "C" void vtk_timer_log_dump_log(vtkNew sself, const char filename); -extern "C" void vtk_timer_log_mark_start_event(vtkNew sself, const char EventString); -extern "C" void vtk_timer_log_mark_end_event(vtkNew sself, const char EventString); -extern "C" void vtk_timer_log_insert_timed_event(vtkNew sself, const char EventString, double time, int cpuTicks); -extern "C" int vtk_timer_log_get_number_of_events(vtkNew sself); -extern "C" int vtk_timer_log_get_event_indent(vtkNew sself, int i); -extern "C" double vtk_timer_log_get_event_wall_time(vtkNew sself, int i); -extern "C" const char* vtk_timer_log_get_event_string(vtkNew sself, int i); -extern "C" void vtk_timer_log_mark_event(vtkNew sself, const char EventString); -extern "C" void vtk_timer_log_reset_log(vtkNew sself); -extern "C" void vtk_timer_log_cleanup_log(vtkNew sself); -extern "C" double vtk_timer_log_get_universal_time(vtkNew sself); -extern "C" double vtk_timer_log_get_cpu_time(vtkNew sself); -extern "C" void vtk_timer_log_start_timer(vtkNew sself); -extern "C" void vtk_timer_log_stop_timer(vtkNew sself); -extern "C" double vtk_timer_log_get_elapsed_time(vtkNew sself); +extern "C" vtkClientSocket * vtkClientSocket_new () ; +extern "C" void vtkClientSocket_destructor (vtkClientSocket * sself) ; +extern "C" void * vtkClientSocket_get_ptr (vtkClientSocket * sself) ; +extern "C" int vtk_client_socket_connect_to_server(vtkClientSocket* sself, const char* hostname, int port); +extern "C" bool vtk_client_socket_get_connecting_side(vtkClientSocket* sself); +extern "C" vtkDirectory * vtkDirectory_new () ; +extern "C" void vtkDirectory_destructor (vtkDirectory * sself) ; +extern "C" void * vtkDirectory_get_ptr (vtkDirectory * sself) ; +extern "C" int vtk_directory_open(vtkDirectory* sself, const char* dir); +extern "C" long long vtk_directory_get_number_of_files(vtkDirectory* sself); +extern "C" const char* vtk_directory_get_file(vtkDirectory* sself, long long index); +extern "C" int vtk_directory_file_is_directory(vtkDirectory* sself, const char* name); +extern "C" int vtk_directory_make_directory(vtkDirectory* sself, const char* dir); +extern "C" int vtk_directory_delete_directory(vtkDirectory* sself, const char* dir); +extern "C" int vtk_directory_rename(vtkDirectory* sself, const char* oldname, const char* newname); +extern "C" vtkExecutableRunner * vtkExecutableRunner_new () ; +extern "C" void vtkExecutableRunner_destructor (vtkExecutableRunner * sself) ; +extern "C" void * vtkExecutableRunner_get_ptr (vtkExecutableRunner * sself) ; +extern "C" void vtk_executable_runner_execute(vtkExecutableRunner* sself); +extern "C" void vtk_executable_runner_set_timeout(vtkExecutableRunner* sself, double _arg); +extern "C" double vtk_executable_runner_get_timeout(vtkExecutableRunner* sself); +extern "C" void vtk_executable_runner_set_right_trim_result(vtkExecutableRunner* sself, bool _arg); +extern "C" bool vtk_executable_runner_get_right_trim_result(vtkExecutableRunner* sself); +extern "C" void vtk_executable_runner_right_trim_result_on(vtkExecutableRunner* sself); +extern "C" void vtk_executable_runner_right_trim_result_off(vtkExecutableRunner* sself); +extern "C" const char* vtk_executable_runner_get_command(vtkExecutableRunner* sself); +extern "C" void vtk_executable_runner_set_command(vtkExecutableRunner* sself, const char* arg); +extern "C" const char* vtk_executable_runner_get_std_out(vtkExecutableRunner* sself); +extern "C" const char* vtk_executable_runner_get_std_err(vtkExecutableRunner* sself); +extern "C" int vtk_executable_runner_get_return_value(vtkExecutableRunner* sself); +extern "C" vtkServerSocket * vtkServerSocket_new () ; +extern "C" void vtkServerSocket_destructor (vtkServerSocket * sself) ; +extern "C" void * vtkServerSocket_get_ptr (vtkServerSocket * sself) ; +extern "C" int vtk_server_socket_create_server(vtkServerSocket* sself, int port); +extern "C" int vtk_server_socket_get_server_port(vtkServerSocket* sself); +extern "C" vtkSocketCollection * vtkSocketCollection_new () ; +extern "C" void vtkSocketCollection_destructor (vtkSocketCollection * sself) ; +extern "C" void * vtkSocketCollection_get_ptr (vtkSocketCollection * sself) ; +extern "C" int vtk_socket_collection_select_sockets(vtkSocketCollection* sself, unsigned long msec); +extern "C" vtkThreadMessager * vtkThreadMessager_new () ; +extern "C" void vtkThreadMessager_destructor (vtkThreadMessager * sself) ; +extern "C" void * vtkThreadMessager_get_ptr (vtkThreadMessager * sself) ; +extern "C" void vtk_thread_messager_wait_for_message(vtkThreadMessager* sself); +extern "C" void vtk_thread_messager_send_wake_message(vtkThreadMessager* sself); +extern "C" void vtk_thread_messager_enable_wait_for_receiver(vtkThreadMessager* sself); +extern "C" void vtk_thread_messager_disable_wait_for_receiver(vtkThreadMessager* sself); +extern "C" void vtk_thread_messager_wait_for_receiver(vtkThreadMessager* sself); +extern "C" vtkTimerLog * vtkTimerLog_new () ; +extern "C" void vtkTimerLog_destructor (vtkTimerLog * sself) ; +extern "C" void * vtkTimerLog_get_ptr (vtkTimerLog * sself) ; +extern "C" void vtk_timer_log_set_logging(vtkTimerLog* sself, int v); +extern "C" int vtk_timer_log_get_logging(vtkTimerLog* sself); +extern "C" void vtk_timer_log_logging_on(vtkTimerLog* sself); +extern "C" void vtk_timer_log_logging_off(vtkTimerLog* sself); +extern "C" void vtk_timer_log_set_max_entries(vtkTimerLog* sself, int a); +extern "C" int vtk_timer_log_get_max_entries(vtkTimerLog* sself); +extern "C" void vtk_timer_log_dump_log(vtkTimerLog* sself, const char* filename); +extern "C" void vtk_timer_log_mark_start_event(vtkTimerLog* sself, const char* EventString); +extern "C" void vtk_timer_log_mark_end_event(vtkTimerLog* sself, const char* EventString); +extern "C" void vtk_timer_log_insert_timed_event(vtkTimerLog* sself, const char* EventString, double time, int cpuTicks); +extern "C" int vtk_timer_log_get_number_of_events(vtkTimerLog* sself); +extern "C" int vtk_timer_log_get_event_indent(vtkTimerLog* sself, int i); +extern "C" double vtk_timer_log_get_event_wall_time(vtkTimerLog* sself, int i); +extern "C" const char* vtk_timer_log_get_event_string(vtkTimerLog* sself, int i); +extern "C" void vtk_timer_log_mark_event(vtkTimerLog* sself, const char* EventString); +extern "C" void vtk_timer_log_reset_log(vtkTimerLog* sself); +extern "C" void vtk_timer_log_cleanup_log(vtkTimerLog* sself); +extern "C" double vtk_timer_log_get_universal_time(vtkTimerLog* sself); +extern "C" double vtk_timer_log_get_cpu_time(vtkTimerLog* sself); +extern "C" void vtk_timer_log_start_timer(vtkTimerLog* sself); +extern "C" void vtk_timer_log_stop_timer(vtkTimerLog* sself); +extern "C" double vtk_timer_log_get_elapsed_time(vtkTimerLog* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h index b1dfc3e..7868a1b 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h @@ -24,180 +24,123 @@ #include // Declare exported functions -extern "C" vtkNew < vtkCylindricalTransform > vtkCylindricalTransform_new () ; -extern "C" void vtkCylindricalTransform_destructor (vtkNew < vtkCylindricalTransform > sself) ; -extern "C" void * vtkCylindricalTransform_get_ptr (vtkNew < vtkCylindricalTransform > sself) ; -extern "C" vtkNew < vtkGeneralTransform > vtkGeneralTransform_new () ; -extern "C" void vtkGeneralTransform_destructor (vtkNew < vtkGeneralTransform > sself) ; -extern "C" void * vtkGeneralTransform_get_ptr (vtkNew < vtkGeneralTransform > sself) ; -extern "C" void vtk_general_transform_identity(vtkNew sself); -extern "C" void vtk_general_transform_inverse(vtkNew sself); -extern "C" void vtk_general_transform_translate(vtkNew sself, double x, double y, double z); -extern "C" void vtk_general_transform_translate(vtkNew sself, const double x); -extern "C" void vtk_general_transform_translate(vtkNew sself, const float x); -extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z); -extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, const double axis); -extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, const float axis); -extern "C" void vtk_general_transform_rotate_x(vtkNew sself, double angle); -extern "C" void vtk_general_transform_rotate_y(vtkNew sself, double angle); -extern "C" void vtk_general_transform_rotate_z(vtkNew sself, double angle); -extern "C" void vtk_general_transform_scale(vtkNew sself, double x, double y, double z); -extern "C" void vtk_general_transform_scale(vtkNew sself, const double s); -extern "C" void vtk_general_transform_scale(vtkNew sself, const float s); -extern "C" void vtk_general_transform_concatenate(vtkNew sself, const double elements); -extern "C" void vtk_general_transform_pre_multiply(vtkNew sself); -extern "C" void vtk_general_transform_post_multiply(vtkNew sself); -extern "C" int vtk_general_transform_get_number_of_concatenated_transforms(vtkNew sself); -extern "C" int vtk_general_transform_get_inverse_flag(vtkNew sself); -extern "C" void vtk_general_transform_push(vtkNew sself); -extern "C" void vtk_general_transform_pop(vtkNew sself); -extern "C" void vtk_general_transform_internal_transform_point(vtkNew sself, const float in, float out); -extern "C" void vtk_general_transform_internal_transform_point(vtkNew sself, const double in, double out); -extern "C" void vtk_general_transform_internal_transform_derivative(vtkNew sself, const float in, float out, float derivative); -extern "C" void vtk_general_transform_internal_transform_derivative(vtkNew sself, const double in, double out, double derivative); -extern "C" unsigned long vtk_general_transform_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkIdentityTransform > vtkIdentityTransform_new () ; -extern "C" void vtkIdentityTransform_destructor (vtkNew < vtkIdentityTransform > sself) ; -extern "C" void * vtkIdentityTransform_get_ptr (vtkNew < vtkIdentityTransform > sself) ; -extern "C" void vtk_identity_transform_inverse(vtkNew sself); -extern "C" vtkNew < vtkLandmarkTransform > vtkLandmarkTransform_new () ; -extern "C" void vtkLandmarkTransform_destructor (vtkNew < vtkLandmarkTransform > sself) ; -extern "C" void * vtkLandmarkTransform_get_ptr (vtkNew < vtkLandmarkTransform > sself) ; -extern "C" void vtk_landmark_transform_set_mode(vtkNew sself, int _arg); -extern "C" void vtk_landmark_transform_set_mode_to_rigid_body(vtkNew sself); -extern "C" void vtk_landmark_transform_set_mode_to_similarity(vtkNew sself); -extern "C" void vtk_landmark_transform_set_mode_to_affine(vtkNew sself); -extern "C" int vtk_landmark_transform_get_mode(vtkNew sself); -extern "C" const char* vtk_landmark_transform_get_mode_as_string(vtkNew sself); -extern "C" void vtk_landmark_transform_inverse(vtkNew sself); -extern "C" unsigned long vtk_landmark_transform_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkMatrixToHomogeneousTransform > vtkMatrixToHomogeneousTransform_new () ; -extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkNew < vtkMatrixToHomogeneousTransform > sself) ; -extern "C" void * vtkMatrixToHomogeneousTransform_get_ptr (vtkNew < vtkMatrixToHomogeneousTransform > sself) ; -extern "C" void vtk_matrix_to_homogeneous_transform_inverse(vtkNew sself); -extern "C" unsigned long vtk_matrix_to_homogeneous_transform_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkMatrixToLinearTransform > vtkMatrixToLinearTransform_new () ; -extern "C" void vtkMatrixToLinearTransform_destructor (vtkNew < vtkMatrixToLinearTransform > sself) ; -extern "C" void * vtkMatrixToLinearTransform_get_ptr (vtkNew < vtkMatrixToLinearTransform > sself) ; -extern "C" void vtk_matrix_to_linear_transform_inverse(vtkNew sself); -extern "C" unsigned long vtk_matrix_to_linear_transform_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkPerspectiveTransform > vtkPerspectiveTransform_new () ; -extern "C" void vtkPerspectiveTransform_destructor (vtkNew < vtkPerspectiveTransform > sself) ; -extern "C" void * vtkPerspectiveTransform_get_ptr (vtkNew < vtkPerspectiveTransform > sself) ; -extern "C" void vtk_perspective_transform_identity(vtkNew sself); -extern "C" void vtk_perspective_transform_inverse(vtkNew sself); -extern "C" void vtk_perspective_transform_adjust_viewport(vtkNew sself, double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax); -extern "C" void vtk_perspective_transform_adjust_z_buffer(vtkNew sself, double oldNearZ, double oldFarZ, double newNearZ, double newFarZ); -extern "C" void vtk_perspective_transform_ortho(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar); -extern "C" void vtk_perspective_transform_frustum(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar); -extern "C" void vtk_perspective_transform_perspective(vtkNew sself, double angle, double aspect, double znear, double zfar); -extern "C" void vtk_perspective_transform_shear(vtkNew sself, double dxdz, double dydz, double zplane); -extern "C" void vtk_perspective_transform_stereo(vtkNew sself, double angle, double focaldistance); -extern "C" void vtk_perspective_transform_setup_camera(vtkNew sself, const double position, const double focalpoint, const double viewup); -extern "C" void vtk_perspective_transform_setup_camera(vtkNew sself, double p0, double p1, double p2, double fp0, double fp1, double fp2, double vup0, double vup1, double vup2); -extern "C" void vtk_perspective_transform_translate(vtkNew sself, double x, double y, double z); -extern "C" void vtk_perspective_transform_translate(vtkNew sself, const double x); -extern "C" void vtk_perspective_transform_translate(vtkNew sself, const float x); -extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z); -extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, const double axis); -extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, const float axis); -extern "C" void vtk_perspective_transform_rotate_x(vtkNew sself, double angle); -extern "C" void vtk_perspective_transform_rotate_y(vtkNew sself, double angle); -extern "C" void vtk_perspective_transform_rotate_z(vtkNew sself, double angle); -extern "C" void vtk_perspective_transform_scale(vtkNew sself, double x, double y, double z); -extern "C" void vtk_perspective_transform_scale(vtkNew sself, const double s); -extern "C" void vtk_perspective_transform_scale(vtkNew sself, const float s); -extern "C" void vtk_perspective_transform_set_matrix(vtkNew sself, const double elements); -extern "C" void vtk_perspective_transform_concatenate(vtkNew sself, const double elements); -extern "C" void vtk_perspective_transform_pre_multiply(vtkNew sself); -extern "C" void vtk_perspective_transform_post_multiply(vtkNew sself); -extern "C" int vtk_perspective_transform_get_number_of_concatenated_transforms(vtkNew sself); -extern "C" int vtk_perspective_transform_get_inverse_flag(vtkNew sself); -extern "C" void vtk_perspective_transform_push(vtkNew sself); -extern "C" void vtk_perspective_transform_pop(vtkNew sself); -extern "C" unsigned long vtk_perspective_transform_get_m_time(vtkNew sself); -extern "C" vtkNew < vtkSphericalTransform > vtkSphericalTransform_new () ; -extern "C" void vtkSphericalTransform_destructor (vtkNew < vtkSphericalTransform > sself) ; -extern "C" void * vtkSphericalTransform_get_ptr (vtkNew < vtkSphericalTransform > sself) ; -extern "C" vtkNew < vtkThinPlateSplineTransform > vtkThinPlateSplineTransform_new () ; -extern "C" void vtkThinPlateSplineTransform_destructor (vtkNew < vtkThinPlateSplineTransform > sself) ; -extern "C" void * vtkThinPlateSplineTransform_get_ptr (vtkNew < vtkThinPlateSplineTransform > sself) ; -extern "C" double vtk_thin_plate_spline_transform_get_sigma(vtkNew sself); -extern "C" void vtk_thin_plate_spline_transform_set_sigma(vtkNew sself, double _arg); -extern "C" void vtk_thin_plate_spline_transform_set_basis(vtkNew sself, int basis); -extern "C" int vtk_thin_plate_spline_transform_get_basis(vtkNew sself); -extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r(vtkNew sself); -extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(vtkNew sself); -extern "C" const char* vtk_thin_plate_spline_transform_get_basis_as_string(vtkNew sself); -extern "C" unsigned long vtk_thin_plate_spline_transform_get_m_time(vtkNew sself); -extern "C" bool vtk_thin_plate_spline_transform_get_regularize_bulk_transform(vtkNew sself); -extern "C" void vtk_thin_plate_spline_transform_set_regularize_bulk_transform(vtkNew sself, bool _arg); -extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_on(vtkNew sself); -extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_off(vtkNew sself); -extern "C" vtkNew < vtkTransform > vtkTransform_new () ; -extern "C" void vtkTransform_destructor (vtkNew < vtkTransform > sself) ; -extern "C" void * vtkTransform_get_ptr (vtkNew < vtkTransform > sself) ; -extern "C" void vtk_transform_identity(vtkNew sself); -extern "C" void vtk_transform_inverse(vtkNew sself); -extern "C" void vtk_transform_translate(vtkNew sself, double x, double y, double z); -extern "C" void vtk_transform_translate(vtkNew sself, const double x); -extern "C" void vtk_transform_translate(vtkNew sself, const float x); -extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z); -extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, const double axis); -extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, const float axis); -extern "C" void vtk_transform_rotate_x(vtkNew sself, double angle); -extern "C" void vtk_transform_rotate_y(vtkNew sself, double angle); -extern "C" void vtk_transform_rotate_z(vtkNew sself, double angle); -extern "C" void vtk_transform_scale(vtkNew sself, double x, double y, double z); -extern "C" void vtk_transform_scale(vtkNew sself, const double s); -extern "C" void vtk_transform_scale(vtkNew sself, const float s); -extern "C" void vtk_transform_set_matrix(vtkNew sself, const double elements); -extern "C" void vtk_transform_concatenate(vtkNew sself, const double elements); -extern "C" void vtk_transform_pre_multiply(vtkNew sself); -extern "C" void vtk_transform_post_multiply(vtkNew sself); -extern "C" int vtk_transform_get_number_of_concatenated_transforms(vtkNew sself); -extern "C" void vtk_transform_get_orientation(vtkNew sself, double orient); -extern "C" void vtk_transform_get_orientation(vtkNew sself, float orient); -extern "C" double* vtk_transform_get_orientation(vtkNew sself); -extern "C" void vtk_transform_get_orientation_wxyz(vtkNew sself, double wxyz); -extern "C" void vtk_transform_get_orientation_wxyz(vtkNew sself, float wxyz); -extern "C" double* vtk_transform_get_orientation_wxyz(vtkNew sself); -extern "C" void vtk_transform_get_position(vtkNew sself, double pos); -extern "C" void vtk_transform_get_position(vtkNew sself, float pos); -extern "C" double* vtk_transform_get_position(vtkNew sself); -extern "C" void vtk_transform_get_scale(vtkNew sself, double scale); -extern "C" void vtk_transform_get_scale(vtkNew sself, float scale); -extern "C" double* vtk_transform_get_scale(vtkNew sself); -extern "C" int vtk_transform_get_inverse_flag(vtkNew sself); -extern "C" void vtk_transform_push(vtkNew sself); -extern "C" void vtk_transform_pop(vtkNew sself); -extern "C" unsigned long vtk_transform_get_m_time(vtkNew sself); -extern "C" void vtk_transform_multiply_point(vtkNew sself, const float in, float out); -extern "C" void vtk_transform_multiply_point(vtkNew sself, const double in, double out); -extern "C" vtkNew < vtkTransform2D > vtkTransform2D_new () ; -extern "C" void vtkTransform2D_destructor (vtkNew < vtkTransform2D > sself) ; -extern "C" void * vtkTransform2D_get_ptr (vtkNew < vtkTransform2D > sself) ; -extern "C" void vtk_transform_2_d_identity(vtkNew sself); -extern "C" void vtk_transform_2_d_inverse(vtkNew sself); -extern "C" void vtk_transform_2_d_translate(vtkNew sself, double x, double y); -extern "C" void vtk_transform_2_d_translate(vtkNew sself, const double x); -extern "C" void vtk_transform_2_d_translate(vtkNew sself, const float x); -extern "C" void vtk_transform_2_d_rotate(vtkNew sself, double angle); -extern "C" void vtk_transform_2_d_scale(vtkNew sself, double x, double y); -extern "C" void vtk_transform_2_d_scale(vtkNew sself, const double s); -extern "C" void vtk_transform_2_d_scale(vtkNew sself, const float s); -extern "C" void vtk_transform_2_d_set_matrix(vtkNew sself, const double elements); -extern "C" void vtk_transform_2_d_get_position(vtkNew sself, double pos); -extern "C" void vtk_transform_2_d_get_position(vtkNew sself, float pos); -extern "C" void vtk_transform_2_d_get_scale(vtkNew sself, double scale); -extern "C" void vtk_transform_2_d_get_scale(vtkNew sself, float pos); -extern "C" unsigned long vtk_transform_2_d_get_m_time(vtkNew sself); -extern "C" void vtk_transform_2_d_transform_points(vtkNew sself, const float inPts, float outPts, int n); -extern "C" void vtk_transform_2_d_transform_points(vtkNew sself, const double inPts, double outPts, int n); -extern "C" void vtk_transform_2_d_inverse_transform_points(vtkNew sself, const float inPts, float outPts, int n); -extern "C" void vtk_transform_2_d_inverse_transform_points(vtkNew sself, const double inPts, double outPts, int n); -extern "C" void vtk_transform_2_d_multiply_point(vtkNew sself, const float in, float out); -extern "C" void vtk_transform_2_d_multiply_point(vtkNew sself, const double in, double out); -extern "C" vtkNew < vtkTransformCollection > vtkTransformCollection_new () ; -extern "C" void vtkTransformCollection_destructor (vtkNew < vtkTransformCollection > sself) ; -extern "C" void * vtkTransformCollection_get_ptr (vtkNew < vtkTransformCollection > sself) ; +extern "C" vtkCylindricalTransform * vtkCylindricalTransform_new () ; +extern "C" void vtkCylindricalTransform_destructor (vtkCylindricalTransform * sself) ; +extern "C" void * vtkCylindricalTransform_get_ptr (vtkCylindricalTransform * sself) ; +extern "C" vtkGeneralTransform * vtkGeneralTransform_new () ; +extern "C" void vtkGeneralTransform_destructor (vtkGeneralTransform * sself) ; +extern "C" void * vtkGeneralTransform_get_ptr (vtkGeneralTransform * sself) ; +extern "C" void vtk_general_transform_identity(vtkGeneralTransform* sself); +extern "C" void vtk_general_transform_inverse(vtkGeneralTransform* sself); +extern "C" void vtk_general_transform_translate(vtkGeneralTransform* sself, double x, double y, double z); +extern "C" void vtk_general_transform_rotate_wxyz(vtkGeneralTransform* sself, double angle, double x, double y, double z); +extern "C" void vtk_general_transform_rotate_x(vtkGeneralTransform* sself, double angle); +extern "C" void vtk_general_transform_rotate_y(vtkGeneralTransform* sself, double angle); +extern "C" void vtk_general_transform_rotate_z(vtkGeneralTransform* sself, double angle); +extern "C" void vtk_general_transform_scale(vtkGeneralTransform* sself, double x, double y, double z); +extern "C" void vtk_general_transform_pre_multiply(vtkGeneralTransform* sself); +extern "C" void vtk_general_transform_post_multiply(vtkGeneralTransform* sself); +extern "C" int vtk_general_transform_get_number_of_concatenated_transforms(vtkGeneralTransform* sself); +extern "C" int vtk_general_transform_get_inverse_flag(vtkGeneralTransform* sself); +extern "C" void vtk_general_transform_push(vtkGeneralTransform* sself); +extern "C" void vtk_general_transform_pop(vtkGeneralTransform* sself); +extern "C" unsigned long vtk_general_transform_get_m_time(vtkGeneralTransform* sself); +extern "C" vtkIdentityTransform * vtkIdentityTransform_new () ; +extern "C" void vtkIdentityTransform_destructor (vtkIdentityTransform * sself) ; +extern "C" void * vtkIdentityTransform_get_ptr (vtkIdentityTransform * sself) ; +extern "C" void vtk_identity_transform_inverse(vtkIdentityTransform* sself); +extern "C" vtkLandmarkTransform * vtkLandmarkTransform_new () ; +extern "C" void vtkLandmarkTransform_destructor (vtkLandmarkTransform * sself) ; +extern "C" void * vtkLandmarkTransform_get_ptr (vtkLandmarkTransform * sself) ; +extern "C" void vtk_landmark_transform_set_mode(vtkLandmarkTransform* sself, int _arg); +extern "C" void vtk_landmark_transform_set_mode_to_rigid_body(vtkLandmarkTransform* sself); +extern "C" void vtk_landmark_transform_set_mode_to_similarity(vtkLandmarkTransform* sself); +extern "C" void vtk_landmark_transform_set_mode_to_affine(vtkLandmarkTransform* sself); +extern "C" int vtk_landmark_transform_get_mode(vtkLandmarkTransform* sself); +extern "C" const char* vtk_landmark_transform_get_mode_as_string(vtkLandmarkTransform* sself); +extern "C" void vtk_landmark_transform_inverse(vtkLandmarkTransform* sself); +extern "C" unsigned long vtk_landmark_transform_get_m_time(vtkLandmarkTransform* sself); +extern "C" vtkMatrixToHomogeneousTransform * vtkMatrixToHomogeneousTransform_new () ; +extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkMatrixToHomogeneousTransform * sself) ; +extern "C" void * vtkMatrixToHomogeneousTransform_get_ptr (vtkMatrixToHomogeneousTransform * sself) ; +extern "C" void vtk_matrix_to_homogeneous_transform_inverse(vtkMatrixToHomogeneousTransform* sself); +extern "C" unsigned long vtk_matrix_to_homogeneous_transform_get_m_time(vtkMatrixToHomogeneousTransform* sself); +extern "C" vtkMatrixToLinearTransform * vtkMatrixToLinearTransform_new () ; +extern "C" void vtkMatrixToLinearTransform_destructor (vtkMatrixToLinearTransform * sself) ; +extern "C" void * vtkMatrixToLinearTransform_get_ptr (vtkMatrixToLinearTransform * sself) ; +extern "C" void vtk_matrix_to_linear_transform_inverse(vtkMatrixToLinearTransform* sself); +extern "C" unsigned long vtk_matrix_to_linear_transform_get_m_time(vtkMatrixToLinearTransform* sself); +extern "C" vtkPerspectiveTransform * vtkPerspectiveTransform_new () ; +extern "C" void vtkPerspectiveTransform_destructor (vtkPerspectiveTransform * sself) ; +extern "C" void * vtkPerspectiveTransform_get_ptr (vtkPerspectiveTransform * sself) ; +extern "C" void vtk_perspective_transform_identity(vtkPerspectiveTransform* sself); +extern "C" void vtk_perspective_transform_inverse(vtkPerspectiveTransform* sself); +extern "C" void vtk_perspective_transform_adjust_viewport(vtkPerspectiveTransform* sself, double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax); +extern "C" void vtk_perspective_transform_adjust_z_buffer(vtkPerspectiveTransform* sself, double oldNearZ, double oldFarZ, double newNearZ, double newFarZ); +extern "C" void vtk_perspective_transform_ortho(vtkPerspectiveTransform* sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar); +extern "C" void vtk_perspective_transform_frustum(vtkPerspectiveTransform* sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar); +extern "C" void vtk_perspective_transform_perspective(vtkPerspectiveTransform* sself, double angle, double aspect, double znear, double zfar); +extern "C" void vtk_perspective_transform_shear(vtkPerspectiveTransform* sself, double dxdz, double dydz, double zplane); +extern "C" void vtk_perspective_transform_stereo(vtkPerspectiveTransform* sself, double angle, double focaldistance); +extern "C" void vtk_perspective_transform_setup_camera(vtkPerspectiveTransform* sself, double p0, double p1, double p2, double fp0, double fp1, double fp2, double vup0, double vup1, double vup2); +extern "C" void vtk_perspective_transform_translate(vtkPerspectiveTransform* sself, double x, double y, double z); +extern "C" void vtk_perspective_transform_rotate_wxyz(vtkPerspectiveTransform* sself, double angle, double x, double y, double z); +extern "C" void vtk_perspective_transform_rotate_x(vtkPerspectiveTransform* sself, double angle); +extern "C" void vtk_perspective_transform_rotate_y(vtkPerspectiveTransform* sself, double angle); +extern "C" void vtk_perspective_transform_rotate_z(vtkPerspectiveTransform* sself, double angle); +extern "C" void vtk_perspective_transform_scale(vtkPerspectiveTransform* sself, double x, double y, double z); +extern "C" void vtk_perspective_transform_pre_multiply(vtkPerspectiveTransform* sself); +extern "C" void vtk_perspective_transform_post_multiply(vtkPerspectiveTransform* sself); +extern "C" int vtk_perspective_transform_get_number_of_concatenated_transforms(vtkPerspectiveTransform* sself); +extern "C" int vtk_perspective_transform_get_inverse_flag(vtkPerspectiveTransform* sself); +extern "C" void vtk_perspective_transform_push(vtkPerspectiveTransform* sself); +extern "C" void vtk_perspective_transform_pop(vtkPerspectiveTransform* sself); +extern "C" unsigned long vtk_perspective_transform_get_m_time(vtkPerspectiveTransform* sself); +extern "C" vtkSphericalTransform * vtkSphericalTransform_new () ; +extern "C" void vtkSphericalTransform_destructor (vtkSphericalTransform * sself) ; +extern "C" void * vtkSphericalTransform_get_ptr (vtkSphericalTransform * sself) ; +extern "C" vtkThinPlateSplineTransform * vtkThinPlateSplineTransform_new () ; +extern "C" void vtkThinPlateSplineTransform_destructor (vtkThinPlateSplineTransform * sself) ; +extern "C" void * vtkThinPlateSplineTransform_get_ptr (vtkThinPlateSplineTransform * sself) ; +extern "C" double vtk_thin_plate_spline_transform_get_sigma(vtkThinPlateSplineTransform* sself); +extern "C" void vtk_thin_plate_spline_transform_set_sigma(vtkThinPlateSplineTransform* sself, double _arg); +extern "C" void vtk_thin_plate_spline_transform_set_basis(vtkThinPlateSplineTransform* sself, int basis); +extern "C" int vtk_thin_plate_spline_transform_get_basis(vtkThinPlateSplineTransform* sself); +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r(vtkThinPlateSplineTransform* sself); +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(vtkThinPlateSplineTransform* sself); +extern "C" const char* vtk_thin_plate_spline_transform_get_basis_as_string(vtkThinPlateSplineTransform* sself); +extern "C" unsigned long vtk_thin_plate_spline_transform_get_m_time(vtkThinPlateSplineTransform* sself); +extern "C" bool vtk_thin_plate_spline_transform_get_regularize_bulk_transform(vtkThinPlateSplineTransform* sself); +extern "C" void vtk_thin_plate_spline_transform_set_regularize_bulk_transform(vtkThinPlateSplineTransform* sself, bool _arg); +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_on(vtkThinPlateSplineTransform* sself); +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_off(vtkThinPlateSplineTransform* sself); +extern "C" vtkTransform * vtkTransform_new () ; +extern "C" void vtkTransform_destructor (vtkTransform * sself) ; +extern "C" void * vtkTransform_get_ptr (vtkTransform * sself) ; +extern "C" void vtk_transform_identity(vtkTransform* sself); +extern "C" void vtk_transform_inverse(vtkTransform* sself); +extern "C" void vtk_transform_translate(vtkTransform* sself, double x, double y, double z); +extern "C" void vtk_transform_rotate_wxyz(vtkTransform* sself, double angle, double x, double y, double z); +extern "C" void vtk_transform_rotate_x(vtkTransform* sself, double angle); +extern "C" void vtk_transform_rotate_y(vtkTransform* sself, double angle); +extern "C" void vtk_transform_rotate_z(vtkTransform* sself, double angle); +extern "C" void vtk_transform_scale(vtkTransform* sself, double x, double y, double z); +extern "C" void vtk_transform_pre_multiply(vtkTransform* sself); +extern "C" void vtk_transform_post_multiply(vtkTransform* sself); +extern "C" int vtk_transform_get_number_of_concatenated_transforms(vtkTransform* sself); +extern "C" int vtk_transform_get_inverse_flag(vtkTransform* sself); +extern "C" void vtk_transform_push(vtkTransform* sself); +extern "C" void vtk_transform_pop(vtkTransform* sself); +extern "C" unsigned long vtk_transform_get_m_time(vtkTransform* sself); +extern "C" vtkTransform2D * vtkTransform2D_new () ; +extern "C" void vtkTransform2D_destructor (vtkTransform2D * sself) ; +extern "C" void * vtkTransform2D_get_ptr (vtkTransform2D * sself) ; +extern "C" void vtk_transform_2_d_identity(vtkTransform2D* sself); +extern "C" void vtk_transform_2_d_inverse(vtkTransform2D* sself); +extern "C" void vtk_transform_2_d_translate(vtkTransform2D* sself, double x, double y); +extern "C" void vtk_transform_2_d_rotate(vtkTransform2D* sself, double angle); +extern "C" void vtk_transform_2_d_scale(vtkTransform2D* sself, double x, double y); +extern "C" unsigned long vtk_transform_2_d_get_m_time(vtkTransform2D* sself); +extern "C" vtkTransformCollection * vtkTransformCollection_new () ; +extern "C" void vtkTransformCollection_destructor (vtkTransformCollection * sself) ; +extern "C" void * vtkTransformCollection_get_ptr (vtkTransformCollection * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h b/vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h new file mode 100644 index 0000000..9055216 --- /dev/null +++ b/vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h @@ -0,0 +1,839 @@ +// Default include in all modules +#include +#include + +// Include objects of this module +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Declare exported functions +extern "C" vtkArcSource * vtkArcSource_new () ; +extern "C" void vtkArcSource_destructor (vtkArcSource * sself) ; +extern "C" void * vtkArcSource_get_ptr (vtkArcSource * sself) ; +extern "C" void vtk_arc_source_set_point_1(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_arc_source_set_point_2(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_arc_source_set_center(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_arc_source_set_normal(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_arc_source_set_polar_vector(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_arc_source_set_angle(vtkArcSource* sself, double _arg); +extern "C" double vtk_arc_source_get_angle_min_value(vtkArcSource* sself); +extern "C" double vtk_arc_source_get_angle_max_value(vtkArcSource* sself); +extern "C" double vtk_arc_source_get_angle(vtkArcSource* sself); +extern "C" void vtk_arc_source_set_resolution(vtkArcSource* sself, int _arg); +extern "C" int vtk_arc_source_get_resolution_min_value(vtkArcSource* sself); +extern "C" int vtk_arc_source_get_resolution_max_value(vtkArcSource* sself); +extern "C" int vtk_arc_source_get_resolution(vtkArcSource* sself); +extern "C" void vtk_arc_source_set_negative(vtkArcSource* sself, bool _arg); +extern "C" bool vtk_arc_source_get_negative(vtkArcSource* sself); +extern "C" void vtk_arc_source_negative_on(vtkArcSource* sself); +extern "C" void vtk_arc_source_negative_off(vtkArcSource* sself); +extern "C" void vtk_arc_source_set_use_normal_and_angle(vtkArcSource* sself, bool _arg); +extern "C" bool vtk_arc_source_get_use_normal_and_angle(vtkArcSource* sself); +extern "C" void vtk_arc_source_use_normal_and_angle_on(vtkArcSource* sself); +extern "C" void vtk_arc_source_use_normal_and_angle_off(vtkArcSource* sself); +extern "C" void vtk_arc_source_set_output_points_precision(vtkArcSource* sself, int _arg); +extern "C" int vtk_arc_source_get_output_points_precision(vtkArcSource* sself); +extern "C" vtkArrowSource * vtkArrowSource_new () ; +extern "C" void vtkArrowSource_destructor (vtkArrowSource * sself) ; +extern "C" void * vtkArrowSource_get_ptr (vtkArrowSource * sself) ; +extern "C" void vtk_arrow_source_set_tip_length(vtkArrowSource* sself, double _arg); +extern "C" double vtk_arrow_source_get_tip_length_min_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_tip_length_max_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_tip_length(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_tip_radius(vtkArrowSource* sself, double _arg); +extern "C" double vtk_arrow_source_get_tip_radius_min_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_tip_radius_max_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_tip_radius(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_tip_resolution(vtkArrowSource* sself, int _arg); +extern "C" int vtk_arrow_source_get_tip_resolution_min_value(vtkArrowSource* sself); +extern "C" int vtk_arrow_source_get_tip_resolution_max_value(vtkArrowSource* sself); +extern "C" int vtk_arrow_source_get_tip_resolution(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_shaft_radius(vtkArrowSource* sself, double _arg); +extern "C" double vtk_arrow_source_get_shaft_radius_min_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_shaft_radius_max_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_shaft_radius(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_shaft_resolution(vtkArrowSource* sself, int _arg); +extern "C" int vtk_arrow_source_get_shaft_resolution_min_value(vtkArrowSource* sself); +extern "C" int vtk_arrow_source_get_shaft_resolution_max_value(vtkArrowSource* sself); +extern "C" int vtk_arrow_source_get_shaft_resolution(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_invert_on(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_invert_off(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_invert(vtkArrowSource* sself, bool _arg); +extern "C" bool vtk_arrow_source_get_invert(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_arrow_origin_to_default(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_arrow_origin_to_center(vtkArrowSource* sself); +extern "C" vtkCapsuleSource * vtkCapsuleSource_new () ; +extern "C" void vtkCapsuleSource_destructor (vtkCapsuleSource * sself) ; +extern "C" void * vtkCapsuleSource_get_ptr (vtkCapsuleSource * sself) ; +extern "C" void vtk_capsule_source_set_radius(vtkCapsuleSource* sself, double _arg); +extern "C" double vtk_capsule_source_get_radius_min_value(vtkCapsuleSource* sself); +extern "C" double vtk_capsule_source_get_radius_max_value(vtkCapsuleSource* sself); +extern "C" double vtk_capsule_source_get_radius(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_set_center(vtkCapsuleSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_capsule_source_set_cylinder_length(vtkCapsuleSource* sself, double _arg); +extern "C" double vtk_capsule_source_get_cylinder_length_min_value(vtkCapsuleSource* sself); +extern "C" double vtk_capsule_source_get_cylinder_length_max_value(vtkCapsuleSource* sself); +extern "C" double vtk_capsule_source_get_cylinder_length(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_set_theta_resolution(vtkCapsuleSource* sself, int _arg); +extern "C" int vtk_capsule_source_get_theta_resolution_min_value(vtkCapsuleSource* sself); +extern "C" int vtk_capsule_source_get_theta_resolution_max_value(vtkCapsuleSource* sself); +extern "C" int vtk_capsule_source_get_theta_resolution(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_set_phi_resolution(vtkCapsuleSource* sself, int _arg); +extern "C" int vtk_capsule_source_get_phi_resolution_min_value(vtkCapsuleSource* sself); +extern "C" int vtk_capsule_source_get_phi_resolution_max_value(vtkCapsuleSource* sself); +extern "C" int vtk_capsule_source_get_phi_resolution(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_set_lat_long_tessellation(vtkCapsuleSource* sself, int _arg); +extern "C" int vtk_capsule_source_get_lat_long_tessellation(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_lat_long_tessellation_on(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_lat_long_tessellation_off(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_set_output_points_precision(vtkCapsuleSource* sself, int _arg); +extern "C" int vtk_capsule_source_get_output_points_precision(vtkCapsuleSource* sself); +extern "C" vtkCellTypeSource * vtkCellTypeSource_new () ; +extern "C" void vtkCellTypeSource_destructor (vtkCellTypeSource * sself) ; +extern "C" void * vtkCellTypeSource_get_ptr (vtkCellTypeSource * sself) ; +extern "C" void vtk_cell_type_source_set_cell_type(vtkCellTypeSource* sself, int cellType); +extern "C" int vtk_cell_type_source_get_cell_type(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_set_cell_order(vtkCellTypeSource* sself, int _arg); +extern "C" int vtk_cell_type_source_get_cell_order(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_set_complete_quadratic_simplicial_elements(vtkCellTypeSource* sself, bool _arg); +extern "C" bool vtk_cell_type_source_get_complete_quadratic_simplicial_elements(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_complete_quadratic_simplicial_elements_on(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_complete_quadratic_simplicial_elements_off(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_set_polynomial_field_order(vtkCellTypeSource* sself, int _arg); +extern "C" int vtk_cell_type_source_get_polynomial_field_order_min_value(vtkCellTypeSource* sself); +extern "C" int vtk_cell_type_source_get_polynomial_field_order_max_value(vtkCellTypeSource* sself); +extern "C" int vtk_cell_type_source_get_polynomial_field_order(vtkCellTypeSource* sself); +extern "C" int vtk_cell_type_source_get_cell_dimension(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_set_output_precision(vtkCellTypeSource* sself, int _arg); +extern "C" int vtk_cell_type_source_get_output_precision_min_value(vtkCellTypeSource* sself); +extern "C" int vtk_cell_type_source_get_output_precision_max_value(vtkCellTypeSource* sself); +extern "C" int vtk_cell_type_source_get_output_precision(vtkCellTypeSource* sself); +extern "C" vtkConeSource * vtkConeSource_new () ; +extern "C" void vtkConeSource_destructor (vtkConeSource * sself) ; +extern "C" void * vtkConeSource_get_ptr (vtkConeSource * sself) ; +extern "C" void vtk_cone_source_set_height(vtkConeSource* sself, double _arg); +extern "C" double vtk_cone_source_get_height_min_value(vtkConeSource* sself); +extern "C" double vtk_cone_source_get_height_max_value(vtkConeSource* sself); +extern "C" double vtk_cone_source_get_height(vtkConeSource* sself); +extern "C" void vtk_cone_source_set_radius(vtkConeSource* sself, double _arg); +extern "C" double vtk_cone_source_get_radius_min_value(vtkConeSource* sself); +extern "C" double vtk_cone_source_get_radius_max_value(vtkConeSource* sself); +extern "C" double vtk_cone_source_get_radius(vtkConeSource* sself); +extern "C" void vtk_cone_source_set_resolution(vtkConeSource* sself, int _arg); +extern "C" int vtk_cone_source_get_resolution_min_value(vtkConeSource* sself); +extern "C" int vtk_cone_source_get_resolution_max_value(vtkConeSource* sself); +extern "C" int vtk_cone_source_get_resolution(vtkConeSource* sself); +extern "C" void vtk_cone_source_set_center(vtkConeSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cone_source_set_direction(vtkConeSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cone_source_set_angle(vtkConeSource* sself, double angle); +extern "C" double vtk_cone_source_get_angle(vtkConeSource* sself); +extern "C" void vtk_cone_source_set_capping(vtkConeSource* sself, int _arg); +extern "C" int vtk_cone_source_get_capping(vtkConeSource* sself); +extern "C" void vtk_cone_source_capping_on(vtkConeSource* sself); +extern "C" void vtk_cone_source_capping_off(vtkConeSource* sself); +extern "C" void vtk_cone_source_set_output_points_precision(vtkConeSource* sself, int _arg); +extern "C" int vtk_cone_source_get_output_points_precision(vtkConeSource* sself); +extern "C" vtkCubeSource * vtkCubeSource_new () ; +extern "C" void vtkCubeSource_destructor (vtkCubeSource * sself) ; +extern "C" void * vtkCubeSource_get_ptr (vtkCubeSource * sself) ; +extern "C" void vtk_cube_source_set_x_length(vtkCubeSource* sself, double _arg); +extern "C" double vtk_cube_source_get_x_length_min_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_x_length_max_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_x_length(vtkCubeSource* sself); +extern "C" void vtk_cube_source_set_y_length(vtkCubeSource* sself, double _arg); +extern "C" double vtk_cube_source_get_y_length_min_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_y_length_max_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_y_length(vtkCubeSource* sself); +extern "C" void vtk_cube_source_set_z_length(vtkCubeSource* sself, double _arg); +extern "C" double vtk_cube_source_get_z_length_min_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_z_length_max_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_z_length(vtkCubeSource* sself); +extern "C" void vtk_cube_source_set_center(vtkCubeSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cube_source_set_bounds(vtkCubeSource* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" void vtk_cube_source_set_output_points_precision(vtkCubeSource* sself, int _arg); +extern "C" int vtk_cube_source_get_output_points_precision(vtkCubeSource* sself); +extern "C" vtkCylinderSource * vtkCylinderSource_new () ; +extern "C" void vtkCylinderSource_destructor (vtkCylinderSource * sself) ; +extern "C" void * vtkCylinderSource_get_ptr (vtkCylinderSource * sself) ; +extern "C" void vtk_cylinder_source_set_height(vtkCylinderSource* sself, double _arg); +extern "C" double vtk_cylinder_source_get_height_min_value(vtkCylinderSource* sself); +extern "C" double vtk_cylinder_source_get_height_max_value(vtkCylinderSource* sself); +extern "C" double vtk_cylinder_source_get_height(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_set_radius(vtkCylinderSource* sself, double _arg); +extern "C" double vtk_cylinder_source_get_radius_min_value(vtkCylinderSource* sself); +extern "C" double vtk_cylinder_source_get_radius_max_value(vtkCylinderSource* sself); +extern "C" double vtk_cylinder_source_get_radius(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_set_center(vtkCylinderSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cylinder_source_set_resolution(vtkCylinderSource* sself, int _arg); +extern "C" int vtk_cylinder_source_get_resolution_min_value(vtkCylinderSource* sself); +extern "C" int vtk_cylinder_source_get_resolution_max_value(vtkCylinderSource* sself); +extern "C" int vtk_cylinder_source_get_resolution(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_set_capping(vtkCylinderSource* sself, int _arg); +extern "C" int vtk_cylinder_source_get_capping(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_capping_on(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_capping_off(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_set_output_points_precision(vtkCylinderSource* sself, int _arg); +extern "C" int vtk_cylinder_source_get_output_points_precision(vtkCylinderSource* sself); +extern "C" vtkDiagonalMatrixSource * vtkDiagonalMatrixSource_new () ; +extern "C" void vtkDiagonalMatrixSource_destructor (vtkDiagonalMatrixSource * sself) ; +extern "C" void * vtkDiagonalMatrixSource_get_ptr (vtkDiagonalMatrixSource * sself) ; +extern "C" int vtk_diagonal_matrix_source_get_array_type(vtkDiagonalMatrixSource* sself); +extern "C" void vtk_diagonal_matrix_source_set_array_type(vtkDiagonalMatrixSource* sself, int _arg); +extern "C" long long vtk_diagonal_matrix_source_get_extents(vtkDiagonalMatrixSource* sself); +extern "C" void vtk_diagonal_matrix_source_set_extents(vtkDiagonalMatrixSource* sself, long long _arg); +extern "C" double vtk_diagonal_matrix_source_get_diagonal(vtkDiagonalMatrixSource* sself); +extern "C" void vtk_diagonal_matrix_source_set_diagonal(vtkDiagonalMatrixSource* sself, double _arg); +extern "C" double vtk_diagonal_matrix_source_get_super_diagonal(vtkDiagonalMatrixSource* sself); +extern "C" void vtk_diagonal_matrix_source_set_super_diagonal(vtkDiagonalMatrixSource* sself, double _arg); +extern "C" double vtk_diagonal_matrix_source_get_sub_diagonal(vtkDiagonalMatrixSource* sself); +extern "C" void vtk_diagonal_matrix_source_set_sub_diagonal(vtkDiagonalMatrixSource* sself, double _arg); +extern "C" void vtk_diagonal_matrix_source_set_row_label(vtkDiagonalMatrixSource* sself, const char* _arg); +extern "C" void vtk_diagonal_matrix_source_set_column_label(vtkDiagonalMatrixSource* sself, const char* _arg); +extern "C" vtkDiskSource * vtkDiskSource_new () ; +extern "C" void vtkDiskSource_destructor (vtkDiskSource * sself) ; +extern "C" void * vtkDiskSource_get_ptr (vtkDiskSource * sself) ; +extern "C" void vtk_disk_source_set_inner_radius(vtkDiskSource* sself, double _arg); +extern "C" double vtk_disk_source_get_inner_radius_min_value(vtkDiskSource* sself); +extern "C" double vtk_disk_source_get_inner_radius_max_value(vtkDiskSource* sself); +extern "C" double vtk_disk_source_get_inner_radius(vtkDiskSource* sself); +extern "C" void vtk_disk_source_set_outer_radius(vtkDiskSource* sself, double _arg); +extern "C" double vtk_disk_source_get_outer_radius_min_value(vtkDiskSource* sself); +extern "C" double vtk_disk_source_get_outer_radius_max_value(vtkDiskSource* sself); +extern "C" double vtk_disk_source_get_outer_radius(vtkDiskSource* sself); +extern "C" void vtk_disk_source_set_radial_resolution(vtkDiskSource* sself, int _arg); +extern "C" int vtk_disk_source_get_radial_resolution_min_value(vtkDiskSource* sself); +extern "C" int vtk_disk_source_get_radial_resolution_max_value(vtkDiskSource* sself); +extern "C" int vtk_disk_source_get_radial_resolution(vtkDiskSource* sself); +extern "C" void vtk_disk_source_set_circumferential_resolution(vtkDiskSource* sself, int _arg); +extern "C" int vtk_disk_source_get_circumferential_resolution_min_value(vtkDiskSource* sself); +extern "C" int vtk_disk_source_get_circumferential_resolution_max_value(vtkDiskSource* sself); +extern "C" int vtk_disk_source_get_circumferential_resolution(vtkDiskSource* sself); +extern "C" void vtk_disk_source_set_output_points_precision(vtkDiskSource* sself, int _arg); +extern "C" int vtk_disk_source_get_output_points_precision(vtkDiskSource* sself); +extern "C" vtkEllipseArcSource * vtkEllipseArcSource_new () ; +extern "C" void vtkEllipseArcSource_destructor (vtkEllipseArcSource * sself) ; +extern "C" void * vtkEllipseArcSource_get_ptr (vtkEllipseArcSource * sself) ; +extern "C" void vtk_ellipse_arc_source_set_center(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_ellipse_arc_source_set_normal(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_ellipse_arc_source_set_major_radius_vector(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_ellipse_arc_source_set_start_angle(vtkEllipseArcSource* sself, double _arg); +extern "C" double vtk_ellipse_arc_source_get_start_angle_min_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_start_angle_max_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_start_angle(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_set_segment_angle(vtkEllipseArcSource* sself, double _arg); +extern "C" double vtk_ellipse_arc_source_get_segment_angle_min_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_segment_angle_max_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_segment_angle(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_set_resolution(vtkEllipseArcSource* sself, int _arg); +extern "C" int vtk_ellipse_arc_source_get_resolution_min_value(vtkEllipseArcSource* sself); +extern "C" int vtk_ellipse_arc_source_get_resolution_max_value(vtkEllipseArcSource* sself); +extern "C" int vtk_ellipse_arc_source_get_resolution(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_set_close(vtkEllipseArcSource* sself, bool _arg); +extern "C" bool vtk_ellipse_arc_source_get_close(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_close_on(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_close_off(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_set_output_points_precision(vtkEllipseArcSource* sself, int _arg); +extern "C" int vtk_ellipse_arc_source_get_output_points_precision(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_set_ratio(vtkEllipseArcSource* sself, double _arg); +extern "C" double vtk_ellipse_arc_source_get_ratio_min_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_ratio_max_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_ratio(vtkEllipseArcSource* sself); +extern "C" vtkEllipticalButtonSource * vtkEllipticalButtonSource_new () ; +extern "C" void vtkEllipticalButtonSource_destructor (vtkEllipticalButtonSource * sself) ; +extern "C" void * vtkEllipticalButtonSource_get_ptr (vtkEllipticalButtonSource * sself) ; +extern "C" void vtk_elliptical_button_source_set_width(vtkEllipticalButtonSource* sself, double _arg); +extern "C" double vtk_elliptical_button_source_get_width_min_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_width_max_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_width(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_height(vtkEllipticalButtonSource* sself, double _arg); +extern "C" double vtk_elliptical_button_source_get_height_min_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_height_max_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_height(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_depth(vtkEllipticalButtonSource* sself, double _arg); +extern "C" double vtk_elliptical_button_source_get_depth_min_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_depth_max_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_depth(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_circumferential_resolution(vtkEllipticalButtonSource* sself, int _arg); +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution_min_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution_max_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_texture_resolution(vtkEllipticalButtonSource* sself, int _arg); +extern "C" int vtk_elliptical_button_source_get_texture_resolution_min_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_texture_resolution_max_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_texture_resolution(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_shoulder_resolution(vtkEllipticalButtonSource* sself, int _arg); +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution_min_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution_max_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_radial_ratio(vtkEllipticalButtonSource* sself, double _arg); +extern "C" double vtk_elliptical_button_source_get_radial_ratio_min_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_radial_ratio_max_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_radial_ratio(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_output_points_precision(vtkEllipticalButtonSource* sself, int _arg); +extern "C" int vtk_elliptical_button_source_get_output_points_precision(vtkEllipticalButtonSource* sself); +extern "C" vtkFrustumSource * vtkFrustumSource_new () ; +extern "C" void vtkFrustumSource_destructor (vtkFrustumSource * sself) ; +extern "C" void * vtkFrustumSource_get_ptr (vtkFrustumSource * sself) ; +extern "C" bool vtk_frustum_source_get_show_lines(vtkFrustumSource* sself); +extern "C" void vtk_frustum_source_set_show_lines(vtkFrustumSource* sself, bool _arg); +extern "C" void vtk_frustum_source_show_lines_on(vtkFrustumSource* sself); +extern "C" void vtk_frustum_source_show_lines_off(vtkFrustumSource* sself); +extern "C" double vtk_frustum_source_get_lines_length(vtkFrustumSource* sself); +extern "C" void vtk_frustum_source_set_lines_length(vtkFrustumSource* sself, double _arg); +extern "C" unsigned long vtk_frustum_source_get_m_time(vtkFrustumSource* sself); +extern "C" void vtk_frustum_source_set_output_points_precision(vtkFrustumSource* sself, int _arg); +extern "C" int vtk_frustum_source_get_output_points_precision(vtkFrustumSource* sself); +extern "C" vtkGlyphSource2D * vtkGlyphSource2D_new () ; +extern "C" void vtkGlyphSource2D_destructor (vtkGlyphSource2D * sself) ; +extern "C" void * vtkGlyphSource2D_get_ptr (vtkGlyphSource2D * sself) ; +extern "C" void vtk_glyph_source_2_d_set_center(vtkGlyphSource2D* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_glyph_source_2_d_set_scale(vtkGlyphSource2D* sself, double _arg); +extern "C" double vtk_glyph_source_2_d_get_scale_min_value(vtkGlyphSource2D* sself); +extern "C" double vtk_glyph_source_2_d_get_scale_max_value(vtkGlyphSource2D* sself); +extern "C" double vtk_glyph_source_2_d_get_scale(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_scale_2(vtkGlyphSource2D* sself, double _arg); +extern "C" double vtk_glyph_source_2_d_get_scale_2_min_value(vtkGlyphSource2D* sself); +extern "C" double vtk_glyph_source_2_d_get_scale_2_max_value(vtkGlyphSource2D* sself); +extern "C" double vtk_glyph_source_2_d_get_scale_2(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_color(vtkGlyphSource2D* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_glyph_source_2_d_set_filled(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_filled(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_filled_on(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_filled_off(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_dash(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_dash(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_dash_on(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_dash_off(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_cross(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_cross(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_cross_on(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_cross_off(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_rotation_angle(vtkGlyphSource2D* sself, double _arg); +extern "C" double vtk_glyph_source_2_d_get_rotation_angle(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_resolution(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_resolution_min_value(vtkGlyphSource2D* sself); +extern "C" int vtk_glyph_source_2_d_get_resolution_max_value(vtkGlyphSource2D* sself); +extern "C" int vtk_glyph_source_2_d_get_resolution(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_glyph_type_min_value(vtkGlyphSource2D* sself); +extern "C" int vtk_glyph_source_2_d_get_glyph_type_max_value(vtkGlyphSource2D* sself); +extern "C" int vtk_glyph_source_2_d_get_glyph_type(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_none(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_vertex(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_dash(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_cross(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_thick_cross(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_triangle(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_square(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_circle(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_diamond(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_arrow(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_thick_arrow(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_hooked_arrow(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_edge_arrow(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_output_points_precision(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_output_points_precision(vtkGlyphSource2D* sself); +extern "C" vtkGraphToPolyData * vtkGraphToPolyData_new () ; +extern "C" void vtkGraphToPolyData_destructor (vtkGraphToPolyData * sself) ; +extern "C" void * vtkGraphToPolyData_get_ptr (vtkGraphToPolyData * sself) ; +extern "C" void vtk_graph_to_poly_data_set_edge_glyph_output(vtkGraphToPolyData* sself, bool _arg); +extern "C" bool vtk_graph_to_poly_data_get_edge_glyph_output(vtkGraphToPolyData* sself); +extern "C" void vtk_graph_to_poly_data_edge_glyph_output_on(vtkGraphToPolyData* sself); +extern "C" void vtk_graph_to_poly_data_edge_glyph_output_off(vtkGraphToPolyData* sself); +extern "C" void vtk_graph_to_poly_data_set_edge_glyph_position(vtkGraphToPolyData* sself, double _arg); +extern "C" double vtk_graph_to_poly_data_get_edge_glyph_position(vtkGraphToPolyData* sself); +extern "C" vtkHyperTreeGridSource * vtkHyperTreeGridSource_new () ; +extern "C" void vtkHyperTreeGridSource_destructor (vtkHyperTreeGridSource * sself) ; +extern "C" void * vtkHyperTreeGridSource_get_ptr (vtkHyperTreeGridSource * sself) ; +extern "C" unsigned int vtk_hyper_tree_grid_source_get_maximum_level(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_maximum_level(vtkHyperTreeGridSource* sself, unsigned int levels); +extern "C" unsigned int vtk_hyper_tree_grid_source_get_max_depth(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_max_depth(vtkHyperTreeGridSource* sself, unsigned int levels); +extern "C" void vtk_hyper_tree_grid_source_set_origin(vtkHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_hyper_tree_grid_source_set_grid_scale(vtkHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_hyper_tree_grid_source_set_transposed_root_indexing(vtkHyperTreeGridSource* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_source_get_transposed_root_indexing(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_indexing_mode_to_kji(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_indexing_mode_to_ijk(vtkHyperTreeGridSource* sself); +extern "C" unsigned int vtk_hyper_tree_grid_source_get_orientation(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_branch_factor(vtkHyperTreeGridSource* sself, unsigned int _arg); +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor_min_value(vtkHyperTreeGridSource* sself); +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor_max_value(vtkHyperTreeGridSource* sself); +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_use_descriptor(vtkHyperTreeGridSource* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_source_get_use_descriptor(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_use_descriptor_on(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_use_descriptor_off(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_use_mask(vtkHyperTreeGridSource* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_source_get_use_mask(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_use_mask_on(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_use_mask_off(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_generate_interface_fields(vtkHyperTreeGridSource* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_source_get_generate_interface_fields(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_generate_interface_fields_on(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_generate_interface_fields_off(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_descriptor(vtkHyperTreeGridSource* sself, const char* _arg); +extern "C" void vtk_hyper_tree_grid_source_set_mask(vtkHyperTreeGridSource* sself, const char* _arg); +extern "C" unsigned long vtk_hyper_tree_grid_source_get_m_time(vtkHyperTreeGridSource* sself); +extern "C" vtkLineSource * vtkLineSource_new () ; +extern "C" void vtkLineSource_destructor (vtkLineSource * sself) ; +extern "C" void * vtkLineSource_get_ptr (vtkLineSource * sself) ; +extern "C" void vtk_line_source_set_point_1(vtkLineSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_line_source_set_point_2(vtkLineSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_line_source_set_use_regular_refinement(vtkLineSource* sself, bool _arg); +extern "C" bool vtk_line_source_get_use_regular_refinement(vtkLineSource* sself); +extern "C" void vtk_line_source_use_regular_refinement_on(vtkLineSource* sself); +extern "C" void vtk_line_source_use_regular_refinement_off(vtkLineSource* sself); +extern "C" void vtk_line_source_set_resolution(vtkLineSource* sself, int _arg); +extern "C" int vtk_line_source_get_resolution_min_value(vtkLineSource* sself); +extern "C" int vtk_line_source_get_resolution_max_value(vtkLineSource* sself); +extern "C" int vtk_line_source_get_resolution(vtkLineSource* sself); +extern "C" void vtk_line_source_set_number_of_refinement_ratios(vtkLineSource* sself, int p0); +extern "C" void vtk_line_source_set_refinement_ratio(vtkLineSource* sself, int index, double value); +extern "C" int vtk_line_source_get_number_of_refinement_ratios(vtkLineSource* sself); +extern "C" double vtk_line_source_get_refinement_ratio(vtkLineSource* sself, int index); +extern "C" void vtk_line_source_set_output_points_precision(vtkLineSource* sself, int _arg); +extern "C" int vtk_line_source_get_output_points_precision(vtkLineSource* sself); +extern "C" vtkOutlineCornerFilter * vtkOutlineCornerFilter_new () ; +extern "C" void vtkOutlineCornerFilter_destructor (vtkOutlineCornerFilter * sself) ; +extern "C" void * vtkOutlineCornerFilter_get_ptr (vtkOutlineCornerFilter * sself) ; +extern "C" void vtk_outline_corner_filter_set_corner_factor(vtkOutlineCornerFilter* sself, double _arg); +extern "C" double vtk_outline_corner_filter_get_corner_factor_min_value(vtkOutlineCornerFilter* sself); +extern "C" double vtk_outline_corner_filter_get_corner_factor_max_value(vtkOutlineCornerFilter* sself); +extern "C" double vtk_outline_corner_filter_get_corner_factor(vtkOutlineCornerFilter* sself); +extern "C" vtkOutlineCornerSource * vtkOutlineCornerSource_new () ; +extern "C" void vtkOutlineCornerSource_destructor (vtkOutlineCornerSource * sself) ; +extern "C" void * vtkOutlineCornerSource_get_ptr (vtkOutlineCornerSource * sself) ; +extern "C" void vtk_outline_corner_source_set_corner_factor(vtkOutlineCornerSource* sself, double _arg); +extern "C" double vtk_outline_corner_source_get_corner_factor_min_value(vtkOutlineCornerSource* sself); +extern "C" double vtk_outline_corner_source_get_corner_factor_max_value(vtkOutlineCornerSource* sself); +extern "C" double vtk_outline_corner_source_get_corner_factor(vtkOutlineCornerSource* sself); +extern "C" vtkOutlineSource * vtkOutlineSource_new () ; +extern "C" void vtkOutlineSource_destructor (vtkOutlineSource * sself) ; +extern "C" void * vtkOutlineSource_get_ptr (vtkOutlineSource * sself) ; +extern "C" void vtk_outline_source_set_box_type(vtkOutlineSource* sself, int _arg); +extern "C" int vtk_outline_source_get_box_type(vtkOutlineSource* sself); +extern "C" void vtk_outline_source_set_box_type_to_axis_aligned(vtkOutlineSource* sself); +extern "C" void vtk_outline_source_set_box_type_to_oriented(vtkOutlineSource* sself); +extern "C" void vtk_outline_source_set_bounds(vtkOutlineSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6); +extern "C" void vtk_outline_source_set_generate_faces(vtkOutlineSource* sself, int _arg); +extern "C" void vtk_outline_source_generate_faces_on(vtkOutlineSource* sself); +extern "C" void vtk_outline_source_generate_faces_off(vtkOutlineSource* sself); +extern "C" int vtk_outline_source_get_generate_faces(vtkOutlineSource* sself); +extern "C" void vtk_outline_source_set_output_points_precision(vtkOutlineSource* sself, int _arg); +extern "C" int vtk_outline_source_get_output_points_precision(vtkOutlineSource* sself); +extern "C" vtkParametricFunctionSource * vtkParametricFunctionSource_new () ; +extern "C" void vtkParametricFunctionSource_destructor (vtkParametricFunctionSource * sself) ; +extern "C" void * vtkParametricFunctionSource_get_ptr (vtkParametricFunctionSource * sself) ; +extern "C" void vtk_parametric_function_source_set_u_resolution(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_u_resolution_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_u_resolution_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_u_resolution(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_v_resolution(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_v_resolution_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_v_resolution_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_v_resolution(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_w_resolution(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_w_resolution_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_w_resolution_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_w_resolution(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_generate_texture_coordinates_on(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_generate_texture_coordinates_off(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_generate_texture_coordinates(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_generate_normals_on(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_generate_normals_off(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_generate_normals(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_generate_normals_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_generate_normals_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_generate_normals(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_scalar_mode_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_scalar_mode_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_scalar_mode(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_none(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_v(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u_0(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_v_0(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u_0_v_0(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_modulus(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_phase(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_quadrant(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_x(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_y(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_z(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_distance(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_function_defined(vtkParametricFunctionSource* sself); +extern "C" unsigned long vtk_parametric_function_source_get_m_time(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_output_points_precision(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_output_points_precision(vtkParametricFunctionSource* sself); +extern "C" vtkPartitionedDataSetCollectionSource * vtkPartitionedDataSetCollectionSource_new () ; +extern "C" void vtkPartitionedDataSetCollectionSource_destructor (vtkPartitionedDataSetCollectionSource * sself) ; +extern "C" void * vtkPartitionedDataSetCollectionSource_get_ptr (vtkPartitionedDataSetCollectionSource * sself) ; +extern "C" void vtk_partitioned_data_set_collection_source_set_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself, int _arg); +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_min_value(vtkPartitionedDataSetCollectionSource* sself); +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_max_value(vtkPartitionedDataSetCollectionSource* sself); +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself); +extern "C" vtkPartitionedDataSetSource * vtkPartitionedDataSetSource_new () ; +extern "C" void vtkPartitionedDataSetSource_destructor (vtkPartitionedDataSetSource * sself) ; +extern "C" void * vtkPartitionedDataSetSource_get_ptr (vtkPartitionedDataSetSource * sself) ; +extern "C" void vtk_partitioned_data_set_source_enable_rank(vtkPartitionedDataSetSource* sself, int rank); +extern "C" void vtk_partitioned_data_set_source_enable_all_ranks(vtkPartitionedDataSetSource* sself); +extern "C" void vtk_partitioned_data_set_source_disable_rank(vtkPartitionedDataSetSource* sself, int rank); +extern "C" void vtk_partitioned_data_set_source_disable_all_ranks(vtkPartitionedDataSetSource* sself); +extern "C" bool vtk_partitioned_data_set_source_is_enabled_rank(vtkPartitionedDataSetSource* sself, int rank); +extern "C" void vtk_partitioned_data_set_source_set_number_of_partitions(vtkPartitionedDataSetSource* sself, int _arg); +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions_min_value(vtkPartitionedDataSetSource* sself); +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions_max_value(vtkPartitionedDataSetSource* sself); +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions(vtkPartitionedDataSetSource* sself); +extern "C" vtkPlaneSource * vtkPlaneSource_new () ; +extern "C" void vtkPlaneSource_destructor (vtkPlaneSource * sself) ; +extern "C" void * vtkPlaneSource_get_ptr (vtkPlaneSource * sself) ; +extern "C" void vtk_plane_source_set_x_resolution(vtkPlaneSource* sself, int _arg); +extern "C" int vtk_plane_source_get_x_resolution(vtkPlaneSource* sself); +extern "C" void vtk_plane_source_set_y_resolution(vtkPlaneSource* sself, int _arg); +extern "C" int vtk_plane_source_get_y_resolution(vtkPlaneSource* sself); +extern "C" void vtk_plane_source_set_resolution(vtkPlaneSource* sself, const int xR, const int yR); +extern "C" void vtk_plane_source_get_resolution(vtkPlaneSource* sself, int& xR, int& yR); +extern "C" void vtk_plane_source_set_origin(vtkPlaneSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_plane_source_set_point_1(vtkPlaneSource* sself, double x, double y, double z); +extern "C" void vtk_plane_source_set_point_2(vtkPlaneSource* sself, double x, double y, double z); +extern "C" void vtk_plane_source_set_center(vtkPlaneSource* sself, double x, double y, double z); +extern "C" void vtk_plane_source_set_normal(vtkPlaneSource* sself, double nx, double ny, double nz); +extern "C" void vtk_plane_source_push(vtkPlaneSource* sself, double distance); +extern "C" void vtk_plane_source_set_output_points_precision(vtkPlaneSource* sself, int _arg); +extern "C" int vtk_plane_source_get_output_points_precision(vtkPlaneSource* sself); +extern "C" vtkPlatonicSolidSource * vtkPlatonicSolidSource_new () ; +extern "C" void vtkPlatonicSolidSource_destructor (vtkPlatonicSolidSource * sself) ; +extern "C" void * vtkPlatonicSolidSource_get_ptr (vtkPlatonicSolidSource * sself) ; +extern "C" void vtk_platonic_solid_source_set_solid_type(vtkPlatonicSolidSource* sself, int _arg); +extern "C" int vtk_platonic_solid_source_get_solid_type_min_value(vtkPlatonicSolidSource* sself); +extern "C" int vtk_platonic_solid_source_get_solid_type_max_value(vtkPlatonicSolidSource* sself); +extern "C" int vtk_platonic_solid_source_get_solid_type(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_solid_type_to_tetrahedron(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_solid_type_to_cube(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_solid_type_to_octahedron(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_solid_type_to_icosahedron(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_solid_type_to_dodecahedron(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_output_points_precision(vtkPlatonicSolidSource* sself, int _arg); +extern "C" int vtk_platonic_solid_source_get_output_points_precision(vtkPlatonicSolidSource* sself); +extern "C" vtkPointHandleSource * vtkPointHandleSource_new () ; +extern "C" void vtkPointHandleSource_destructor (vtkPointHandleSource * sself) ; +extern "C" void * vtkPointHandleSource_get_ptr (vtkPointHandleSource * sself) ; +extern "C" void vtk_point_handle_source_set_position(vtkPointHandleSource* sself, double xPos, double yPos, double zPos); +extern "C" void vtk_point_handle_source_set_direction(vtkPointHandleSource* sself, double xDir, double yDir, double zDir); +extern "C" vtkPointSource * vtkPointSource_new () ; +extern "C" void vtkPointSource_destructor (vtkPointSource * sself) ; +extern "C" void * vtkPointSource_get_ptr (vtkPointSource * sself) ; +extern "C" void vtk_point_source_set_number_of_points(vtkPointSource* sself, long long _arg); +extern "C" long long vtk_point_source_get_number_of_points_min_value(vtkPointSource* sself); +extern "C" long long vtk_point_source_get_number_of_points_max_value(vtkPointSource* sself); +extern "C" long long vtk_point_source_get_number_of_points(vtkPointSource* sself); +extern "C" void vtk_point_source_set_center(vtkPointSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_point_source_set_radius(vtkPointSource* sself, double _arg); +extern "C" double vtk_point_source_get_radius_min_value(vtkPointSource* sself); +extern "C" double vtk_point_source_get_radius_max_value(vtkPointSource* sself); +extern "C" double vtk_point_source_get_radius(vtkPointSource* sself); +extern "C" void vtk_point_source_set_distribution(vtkPointSource* sself, int _arg); +extern "C" void vtk_point_source_set_distribution_to_uniform(vtkPointSource* sself); +extern "C" void vtk_point_source_set_distribution_to_shell(vtkPointSource* sself); +extern "C" int vtk_point_source_get_distribution(vtkPointSource* sself); +extern "C" void vtk_point_source_set_output_points_precision(vtkPointSource* sself, int _arg); +extern "C" int vtk_point_source_get_output_points_precision(vtkPointSource* sself); +extern "C" vtkPolyLineSource * vtkPolyLineSource_new () ; +extern "C" void vtkPolyLineSource_destructor (vtkPolyLineSource * sself) ; +extern "C" void * vtkPolyLineSource_get_ptr (vtkPolyLineSource * sself) ; +extern "C" void vtk_poly_line_source_set_closed(vtkPolyLineSource* sself, int _arg); +extern "C" int vtk_poly_line_source_get_closed(vtkPolyLineSource* sself); +extern "C" void vtk_poly_line_source_closed_on(vtkPolyLineSource* sself); +extern "C" void vtk_poly_line_source_closed_off(vtkPolyLineSource* sself); +extern "C" vtkPolyPointSource * vtkPolyPointSource_new () ; +extern "C" void vtkPolyPointSource_destructor (vtkPolyPointSource * sself) ; +extern "C" void * vtkPolyPointSource_get_ptr (vtkPolyPointSource * sself) ; +extern "C" void vtk_poly_point_source_set_number_of_points(vtkPolyPointSource* sself, long long numPoints); +extern "C" long long vtk_poly_point_source_get_number_of_points(vtkPolyPointSource* sself); +extern "C" void vtk_poly_point_source_resize(vtkPolyPointSource* sself, long long numPoints); +extern "C" void vtk_poly_point_source_set_point(vtkPolyPointSource* sself, long long id, double x, double y, double z); +extern "C" unsigned long vtk_poly_point_source_get_m_time(vtkPolyPointSource* sself); +extern "C" vtkProgrammableDataObjectSource * vtkProgrammableDataObjectSource_new () ; +extern "C" void vtkProgrammableDataObjectSource_destructor (vtkProgrammableDataObjectSource * sself) ; +extern "C" void * vtkProgrammableDataObjectSource_get_ptr (vtkProgrammableDataObjectSource * sself) ; +extern "C" vtkProgrammableSource * vtkProgrammableSource_new () ; +extern "C" void vtkProgrammableSource_destructor (vtkProgrammableSource * sself) ; +extern "C" void * vtkProgrammableSource_get_ptr (vtkProgrammableSource * sself) ; +extern "C" vtkRandomHyperTreeGridSource * vtkRandomHyperTreeGridSource_new () ; +extern "C" void vtkRandomHyperTreeGridSource_destructor (vtkRandomHyperTreeGridSource * sself) ; +extern "C" void * vtkRandomHyperTreeGridSource_get_ptr (vtkRandomHyperTreeGridSource * sself) ; +extern "C" void vtk_random_hyper_tree_grid_source_set_dimensions(vtkRandomHyperTreeGridSource* sself, unsigned int _arg1, unsigned int _arg2, unsigned int _arg3); +extern "C" void vtk_random_hyper_tree_grid_source_set_output_bounds(vtkRandomHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6); +extern "C" unsigned int vtk_random_hyper_tree_grid_source_get_seed(vtkRandomHyperTreeGridSource* sself); +extern "C" void vtk_random_hyper_tree_grid_source_set_seed(vtkRandomHyperTreeGridSource* sself, unsigned int _arg); +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth(vtkRandomHyperTreeGridSource* sself); +extern "C" void vtk_random_hyper_tree_grid_source_set_max_depth(vtkRandomHyperTreeGridSource* sself, long long _arg); +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth_min_value(vtkRandomHyperTreeGridSource* sself); +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth_max_value(vtkRandomHyperTreeGridSource* sself); +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction(vtkRandomHyperTreeGridSource* sself); +extern "C" void vtk_random_hyper_tree_grid_source_set_split_fraction(vtkRandomHyperTreeGridSource* sself, double _arg); +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_min_value(vtkRandomHyperTreeGridSource* sself); +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_max_value(vtkRandomHyperTreeGridSource* sself); +extern "C" vtkRectangularButtonSource * vtkRectangularButtonSource_new () ; +extern "C" void vtkRectangularButtonSource_destructor (vtkRectangularButtonSource * sself) ; +extern "C" void * vtkRectangularButtonSource_get_ptr (vtkRectangularButtonSource * sself) ; +extern "C" void vtk_rectangular_button_source_set_width(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_width_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_width_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_width(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_height(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_height_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_height_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_height(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_depth(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_depth_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_depth_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_depth(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_box_ratio(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_box_ratio_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_box_ratio_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_box_ratio(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_texture_ratio(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_texture_ratio_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_texture_ratio_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_texture_ratio(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_texture_height_ratio(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_output_points_precision(vtkRectangularButtonSource* sself, int _arg); +extern "C" int vtk_rectangular_button_source_get_output_points_precision(vtkRectangularButtonSource* sself); +extern "C" vtkRegularPolygonSource * vtkRegularPolygonSource_new () ; +extern "C" void vtkRegularPolygonSource_destructor (vtkRegularPolygonSource * sself) ; +extern "C" void * vtkRegularPolygonSource_get_ptr (vtkRegularPolygonSource * sself) ; +extern "C" void vtk_regular_polygon_source_set_number_of_sides(vtkRegularPolygonSource* sself, int _arg); +extern "C" int vtk_regular_polygon_source_get_number_of_sides_min_value(vtkRegularPolygonSource* sself); +extern "C" int vtk_regular_polygon_source_get_number_of_sides_max_value(vtkRegularPolygonSource* sself); +extern "C" int vtk_regular_polygon_source_get_number_of_sides(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_set_center(vtkRegularPolygonSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_regular_polygon_source_set_normal(vtkRegularPolygonSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_regular_polygon_source_set_radius(vtkRegularPolygonSource* sself, double _arg); +extern "C" double vtk_regular_polygon_source_get_radius(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_set_generate_polygon(vtkRegularPolygonSource* sself, int _arg); +extern "C" int vtk_regular_polygon_source_get_generate_polygon(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_generate_polygon_on(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_generate_polygon_off(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_set_generate_polyline(vtkRegularPolygonSource* sself, int _arg); +extern "C" int vtk_regular_polygon_source_get_generate_polyline(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_generate_polyline_on(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_generate_polyline_off(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_set_output_points_precision(vtkRegularPolygonSource* sself, int _arg); +extern "C" int vtk_regular_polygon_source_get_output_points_precision(vtkRegularPolygonSource* sself); +extern "C" vtkSelectionSource * vtkSelectionSource_new () ; +extern "C" void vtkSelectionSource_destructor (vtkSelectionSource * sself) ; +extern "C" void * vtkSelectionSource_get_ptr (vtkSelectionSource * sself) ; +extern "C" void vtk_selection_source_add_id(vtkSelectionSource* sself, long long piece, long long id); +extern "C" void vtk_selection_source_add_string_id(vtkSelectionSource* sself, long long piece, const char* id); +extern "C" void vtk_selection_source_add_location(vtkSelectionSource* sself, double x, double y, double z); +extern "C" void vtk_selection_source_add_threshold(vtkSelectionSource* sself, double min, double max); +extern "C" void vtk_selection_source_add_block(vtkSelectionSource* sself, long long blockno); +extern "C" void vtk_selection_source_add_block_selector(vtkSelectionSource* sself, const char* selector); +extern "C" void vtk_selection_source_remove_all_block_selectors(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_remove_all_i_ds(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_remove_all_string_i_ds(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_remove_all_thresholds(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_remove_all_locations(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_remove_all_blocks(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_content_type(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_content_type(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_field_type(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_field_type(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_containing_cells(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_containing_cells(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_number_of_layers(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_number_of_layers_min_value(vtkSelectionSource* sself); +extern "C" int vtk_selection_source_get_number_of_layers_max_value(vtkSelectionSource* sself); +extern "C" int vtk_selection_source_get_number_of_layers(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_inverse(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_inverse(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_array_name(vtkSelectionSource* sself, const char* _arg); +extern "C" void vtk_selection_source_set_array_component(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_array_component(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_composite_index(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_composite_index(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_hierarchical_level(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_hierarchical_level(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_hierarchical_index(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_hierarchical_index(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_assembly_name(vtkSelectionSource* sself, const char* _arg); +extern "C" void vtk_selection_source_add_selector(vtkSelectionSource* sself, const char* selector); +extern "C" void vtk_selection_source_remove_all_selectors(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_query_string(vtkSelectionSource* sself, const char* _arg); +extern "C" vtkSphereSource * vtkSphereSource_new () ; +extern "C" void vtkSphereSource_destructor (vtkSphereSource * sself) ; +extern "C" void * vtkSphereSource_get_ptr (vtkSphereSource * sself) ; +extern "C" void vtk_sphere_source_set_radius(vtkSphereSource* sself, double _arg); +extern "C" double vtk_sphere_source_get_radius_min_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_radius_max_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_radius(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_center(vtkSphereSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_sphere_source_set_theta_resolution(vtkSphereSource* sself, int _arg); +extern "C" int vtk_sphere_source_get_theta_resolution_min_value(vtkSphereSource* sself); +extern "C" int vtk_sphere_source_get_theta_resolution_max_value(vtkSphereSource* sself); +extern "C" int vtk_sphere_source_get_theta_resolution(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_phi_resolution(vtkSphereSource* sself, int _arg); +extern "C" int vtk_sphere_source_get_phi_resolution_min_value(vtkSphereSource* sself); +extern "C" int vtk_sphere_source_get_phi_resolution_max_value(vtkSphereSource* sself); +extern "C" int vtk_sphere_source_get_phi_resolution(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_start_theta(vtkSphereSource* sself, double _arg); +extern "C" double vtk_sphere_source_get_start_theta_min_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_start_theta_max_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_start_theta(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_end_theta(vtkSphereSource* sself, double _arg); +extern "C" double vtk_sphere_source_get_end_theta_min_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_end_theta_max_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_end_theta(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_start_phi(vtkSphereSource* sself, double _arg); +extern "C" double vtk_sphere_source_get_start_phi_min_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_start_phi_max_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_start_phi(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_end_phi(vtkSphereSource* sself, double _arg); +extern "C" double vtk_sphere_source_get_end_phi_min_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_end_phi_max_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_end_phi(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_lat_long_tessellation(vtkSphereSource* sself, int _arg); +extern "C" int vtk_sphere_source_get_lat_long_tessellation(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_lat_long_tessellation_on(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_lat_long_tessellation_off(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_output_points_precision(vtkSphereSource* sself, int _arg); +extern "C" int vtk_sphere_source_get_output_points_precision(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_generate_normals(vtkSphereSource* sself, int _arg); +extern "C" int vtk_sphere_source_get_generate_normals(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_generate_normals_on(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_generate_normals_off(vtkSphereSource* sself); +extern "C" vtkSuperquadricSource * vtkSuperquadricSource_new () ; +extern "C" void vtkSuperquadricSource_destructor (vtkSuperquadricSource * sself) ; +extern "C" void * vtkSuperquadricSource_get_ptr (vtkSuperquadricSource * sself) ; +extern "C" void vtk_superquadric_source_set_center(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_superquadric_source_set_scale(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" int vtk_superquadric_source_get_theta_resolution(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_theta_resolution(vtkSuperquadricSource* sself, int i); +extern "C" int vtk_superquadric_source_get_phi_resolution(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_phi_resolution(vtkSuperquadricSource* sself, int i); +extern "C" double vtk_superquadric_source_get_thickness(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_thickness(vtkSuperquadricSource* sself, double _arg); +extern "C" double vtk_superquadric_source_get_thickness_min_value(vtkSuperquadricSource* sself); +extern "C" double vtk_superquadric_source_get_thickness_max_value(vtkSuperquadricSource* sself); +extern "C" double vtk_superquadric_source_get_phi_roundness(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_phi_roundness(vtkSuperquadricSource* sself, double e); +extern "C" double vtk_superquadric_source_get_theta_roundness(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_theta_roundness(vtkSuperquadricSource* sself, double e); +extern "C" void vtk_superquadric_source_set_size(vtkSuperquadricSource* sself, double _arg); +extern "C" double vtk_superquadric_source_get_size(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_axis_of_symmetry(vtkSuperquadricSource* sself, int _arg); +extern "C" int vtk_superquadric_source_get_axis_of_symmetry(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_x_axis_of_symmetry(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_y_axis_of_symmetry(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_z_axis_of_symmetry(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_toroidal_on(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_toroidal_off(vtkSuperquadricSource* sself); +extern "C" int vtk_superquadric_source_get_toroidal(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_toroidal(vtkSuperquadricSource* sself, int _arg); +extern "C" void vtk_superquadric_source_set_output_points_precision(vtkSuperquadricSource* sself, int _arg); +extern "C" int vtk_superquadric_source_get_output_points_precision(vtkSuperquadricSource* sself); +extern "C" vtkTessellatedBoxSource * vtkTessellatedBoxSource_new () ; +extern "C" void vtkTessellatedBoxSource_destructor (vtkTessellatedBoxSource * sself) ; +extern "C" void * vtkTessellatedBoxSource_get_ptr (vtkTessellatedBoxSource * sself) ; +extern "C" void vtk_tessellated_box_source_set_bounds(vtkTessellatedBoxSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6); +extern "C" void vtk_tessellated_box_source_set_level(vtkTessellatedBoxSource* sself, int _arg); +extern "C" int vtk_tessellated_box_source_get_level(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_set_duplicate_shared_points(vtkTessellatedBoxSource* sself, int _arg); +extern "C" int vtk_tessellated_box_source_get_duplicate_shared_points(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_duplicate_shared_points_on(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_duplicate_shared_points_off(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_set_quads(vtkTessellatedBoxSource* sself, int _arg); +extern "C" int vtk_tessellated_box_source_get_quads(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_quads_on(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_quads_off(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_set_output_points_precision(vtkTessellatedBoxSource* sself, int _arg); +extern "C" int vtk_tessellated_box_source_get_output_points_precision(vtkTessellatedBoxSource* sself); +extern "C" vtkTextSource * vtkTextSource_new () ; +extern "C" void vtkTextSource_destructor (vtkTextSource * sself) ; +extern "C" void * vtkTextSource_get_ptr (vtkTextSource * sself) ; +extern "C" void vtk_text_source_set_text(vtkTextSource* sself, const char* _arg); +extern "C" void vtk_text_source_set_backing(vtkTextSource* sself, int _arg); +extern "C" int vtk_text_source_get_backing(vtkTextSource* sself); +extern "C" void vtk_text_source_backing_on(vtkTextSource* sself); +extern "C" void vtk_text_source_backing_off(vtkTextSource* sself); +extern "C" void vtk_text_source_set_foreground_color(vtkTextSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_text_source_set_background_color(vtkTextSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_text_source_set_output_points_precision(vtkTextSource* sself, int _arg); +extern "C" int vtk_text_source_get_output_points_precision(vtkTextSource* sself); +extern "C" vtkTexturedSphereSource * vtkTexturedSphereSource_new () ; +extern "C" void vtkTexturedSphereSource_destructor (vtkTexturedSphereSource * sself) ; +extern "C" void * vtkTexturedSphereSource_get_ptr (vtkTexturedSphereSource * sself) ; +extern "C" void vtk_textured_sphere_source_set_radius(vtkTexturedSphereSource* sself, double _arg); +extern "C" double vtk_textured_sphere_source_get_radius_min_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_radius_max_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_radius(vtkTexturedSphereSource* sself); +extern "C" void vtk_textured_sphere_source_set_theta_resolution(vtkTexturedSphereSource* sself, int _arg); +extern "C" int vtk_textured_sphere_source_get_theta_resolution_min_value(vtkTexturedSphereSource* sself); +extern "C" int vtk_textured_sphere_source_get_theta_resolution_max_value(vtkTexturedSphereSource* sself); +extern "C" int vtk_textured_sphere_source_get_theta_resolution(vtkTexturedSphereSource* sself); +extern "C" void vtk_textured_sphere_source_set_phi_resolution(vtkTexturedSphereSource* sself, int _arg); +extern "C" int vtk_textured_sphere_source_get_phi_resolution_min_value(vtkTexturedSphereSource* sself); +extern "C" int vtk_textured_sphere_source_get_phi_resolution_max_value(vtkTexturedSphereSource* sself); +extern "C" int vtk_textured_sphere_source_get_phi_resolution(vtkTexturedSphereSource* sself); +extern "C" void vtk_textured_sphere_source_set_theta(vtkTexturedSphereSource* sself, double _arg); +extern "C" double vtk_textured_sphere_source_get_theta_min_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_theta_max_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_theta(vtkTexturedSphereSource* sself); +extern "C" void vtk_textured_sphere_source_set_phi(vtkTexturedSphereSource* sself, double _arg); +extern "C" double vtk_textured_sphere_source_get_phi_min_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_phi_max_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_phi(vtkTexturedSphereSource* sself); +extern "C" void vtk_textured_sphere_source_set_output_points_precision(vtkTexturedSphereSource* sself, int _arg); +extern "C" int vtk_textured_sphere_source_get_output_points_precision(vtkTexturedSphereSource* sself); +extern "C" vtkUniformHyperTreeGridSource * vtkUniformHyperTreeGridSource_new () ; +extern "C" void vtkUniformHyperTreeGridSource_destructor (vtkUniformHyperTreeGridSource * sself) ; +extern "C" void * vtkUniformHyperTreeGridSource_get_ptr (vtkUniformHyperTreeGridSource * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp index 2126370..7b622bc 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp @@ -10,18 +10,18 @@ #include // Implement declared functions -extern "C" vtkNew < vtkColorSeries > vtkColorSeries_new () {return vtkNew < vtkColorSeries > () ;} -extern "C" void vtkColorSeries_destructor (vtkNew < vtkColorSeries > sself) {sself . Reset () ; return ;} -extern "C" void * vtkColorSeries_get_ptr (vtkNew < vtkColorSeries > sself) {return sself . GetPointer () ;} -extern "C" void vtk_color_series_set_color_scheme(vtkNew sself, int scheme) { sself->SetColorScheme(scheme); } -extern "C" int vtk_color_series_get_number_of_color_schemes(vtkNew sself) { return sself->GetNumberOfColorSchemes(); } -extern "C" int vtk_color_series_get_color_scheme(vtkNew sself) { return sself->GetColorScheme(); } -extern "C" int vtk_color_series_get_number_of_colors(vtkNew sself) { return sself->GetNumberOfColors(); } -extern "C" void vtk_color_series_set_number_of_colors(vtkNew sself, int numColors) { sself->SetNumberOfColors(numColors); } -extern "C" void vtk_color_series_remove_color(vtkNew sself, int index) { sself->RemoveColor(index); } -extern "C" void vtk_color_series_clear_colors(vtkNew sself) { sself->ClearColors(); } -extern "C" vtkNew < vtkNamedColors > vtkNamedColors_new () {return vtkNew < vtkNamedColors > () ;} -extern "C" void vtkNamedColors_destructor (vtkNew < vtkNamedColors > sself) {sself . Reset () ; return ;} -extern "C" void * vtkNamedColors_get_ptr (vtkNew < vtkNamedColors > sself) {return sself . GetPointer () ;} -extern "C" int vtk_named_colors_get_number_of_colors(vtkNew sself) { return sself->GetNumberOfColors(); } -extern "C" void vtk_named_colors_reset_colors(vtkNew sself) { sself->ResetColors(); } +extern "C" vtkColorSeries * vtkColorSeries_new () {return vtkColorSeries :: New () ;} +extern "C" void vtkColorSeries_destructor (vtkColorSeries * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkColorSeries_get_ptr (vtkColorSeries * sself) {return sself ;} +extern "C" void vtk_color_series_set_color_scheme(vtkColorSeries* sself, int scheme) { sself->SetColorScheme(scheme); } +extern "C" int vtk_color_series_get_number_of_color_schemes(vtkColorSeries* sself) { return sself->GetNumberOfColorSchemes(); } +extern "C" int vtk_color_series_get_color_scheme(vtkColorSeries* sself) { return sself->GetColorScheme(); } +extern "C" int vtk_color_series_get_number_of_colors(vtkColorSeries* sself) { return sself->GetNumberOfColors(); } +extern "C" void vtk_color_series_set_number_of_colors(vtkColorSeries* sself, int numColors) { sself->SetNumberOfColors(numColors); } +extern "C" void vtk_color_series_remove_color(vtkColorSeries* sself, int index) { sself->RemoveColor(index); } +extern "C" void vtk_color_series_clear_colors(vtkColorSeries* sself) { sself->ClearColors(); } +extern "C" vtkNamedColors * vtkNamedColors_new () {return vtkNamedColors :: New () ;} +extern "C" void vtkNamedColors_destructor (vtkNamedColors * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkNamedColors_get_ptr (vtkNamedColors * sself) {return sself ;} +extern "C" int vtk_named_colors_get_number_of_colors(vtkNamedColors* sself) { return sself->GetNumberOfColors(); } +extern "C" void vtk_named_colors_reset_colors(vtkNamedColors* sself) { sself->ResetColors(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp index 86c6bdc..c1b24bb 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp @@ -34,259 +34,215 @@ #include // Implement declared functions -extern "C" vtkNew < vtkCardinalSpline > vtkCardinalSpline_new () {return vtkNew < vtkCardinalSpline > () ;} -extern "C" void vtkCardinalSpline_destructor (vtkNew < vtkCardinalSpline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCardinalSpline_get_ptr (vtkNew < vtkCardinalSpline > sself) {return sself . GetPointer () ;} -extern "C" void vtk_cardinal_spline_compute(vtkNew sself) { sself->Compute(); } -extern "C" double vtk_cardinal_spline_evaluate(vtkNew sself, double t) { return sself->Evaluate(t); } -extern "C" vtkNew < vtkKochanekSpline > vtkKochanekSpline_new () {return vtkNew < vtkKochanekSpline > () ;} -extern "C" void vtkKochanekSpline_destructor (vtkNew < vtkKochanekSpline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkKochanekSpline_get_ptr (vtkNew < vtkKochanekSpline > sself) {return sself . GetPointer () ;} -extern "C" void vtk_kochanek_spline_compute(vtkNew sself) { sself->Compute(); } -extern "C" double vtk_kochanek_spline_evaluate(vtkNew sself, double t) { return sself->Evaluate(t); } -extern "C" void vtk_kochanek_spline_set_default_bias(vtkNew sself, double _arg) { sself->SetDefaultBias(_arg); } -extern "C" double vtk_kochanek_spline_get_default_bias(vtkNew sself) { return sself->GetDefaultBias(); } -extern "C" void vtk_kochanek_spline_set_default_tension(vtkNew sself, double _arg) { sself->SetDefaultTension(_arg); } -extern "C" double vtk_kochanek_spline_get_default_tension(vtkNew sself) { return sself->GetDefaultTension(); } -extern "C" void vtk_kochanek_spline_set_default_continuity(vtkNew sself, double _arg) { sself->SetDefaultContinuity(_arg); } -extern "C" double vtk_kochanek_spline_get_default_continuity(vtkNew sself) { return sself->GetDefaultContinuity(); } -extern "C" vtkNew < vtkParametricBohemianDome > vtkParametricBohemianDome_new () {return vtkNew < vtkParametricBohemianDome > () ;} -extern "C" void vtkParametricBohemianDome_destructor (vtkNew < vtkParametricBohemianDome > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricBohemianDome_get_ptr (vtkNew < vtkParametricBohemianDome > sself) {return sself . GetPointer () ;} -extern "C" double vtk_parametric_bohemian_dome_get_a(vtkNew sself) { return sself->GetA(); } -extern "C" void vtk_parametric_bohemian_dome_set_a(vtkNew sself, double _arg) { sself->SetA(_arg); } -extern "C" double vtk_parametric_bohemian_dome_get_b(vtkNew sself) { return sself->GetB(); } -extern "C" void vtk_parametric_bohemian_dome_set_b(vtkNew sself, double _arg) { sself->SetB(_arg); } -extern "C" double vtk_parametric_bohemian_dome_get_c(vtkNew sself) { return sself->GetC(); } -extern "C" void vtk_parametric_bohemian_dome_set_c(vtkNew sself, double _arg) { sself->SetC(_arg); } -extern "C" int vtk_parametric_bohemian_dome_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_bohemian_dome_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_bohemian_dome_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricBour > vtkParametricBour_new () {return vtkNew < vtkParametricBour > () ;} -extern "C" void vtkParametricBour_destructor (vtkNew < vtkParametricBour > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricBour_get_ptr (vtkNew < vtkParametricBour > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_bour_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_bour_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_bour_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricBoy > vtkParametricBoy_new () {return vtkNew < vtkParametricBoy > () ;} -extern "C" void vtkParametricBoy_destructor (vtkNew < vtkParametricBoy > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricBoy_get_ptr (vtkNew < vtkParametricBoy > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_boy_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_boy_set_z_scale(vtkNew sself, double _arg) { sself->SetZScale(_arg); } -extern "C" double vtk_parametric_boy_get_z_scale(vtkNew sself) { return sself->GetZScale(); } -extern "C" void vtk_parametric_boy_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_boy_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricCatalanMinimal > vtkParametricCatalanMinimal_new () {return vtkNew < vtkParametricCatalanMinimal > () ;} -extern "C" void vtkParametricCatalanMinimal_destructor (vtkNew < vtkParametricCatalanMinimal > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricCatalanMinimal_get_ptr (vtkNew < vtkParametricCatalanMinimal > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_catalan_minimal_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_catalan_minimal_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_catalan_minimal_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricConicSpiral > vtkParametricConicSpiral_new () {return vtkNew < vtkParametricConicSpiral > () ;} -extern "C" void vtkParametricConicSpiral_destructor (vtkNew < vtkParametricConicSpiral > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricConicSpiral_get_ptr (vtkNew < vtkParametricConicSpiral > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_conic_spiral_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_conic_spiral_set_a(vtkNew sself, double _arg) { sself->SetA(_arg); } -extern "C" double vtk_parametric_conic_spiral_get_a(vtkNew sself) { return sself->GetA(); } -extern "C" void vtk_parametric_conic_spiral_set_b(vtkNew sself, double _arg) { sself->SetB(_arg); } -extern "C" double vtk_parametric_conic_spiral_get_b(vtkNew sself) { return sself->GetB(); } -extern "C" void vtk_parametric_conic_spiral_set_c(vtkNew sself, double _arg) { sself->SetC(_arg); } -extern "C" double vtk_parametric_conic_spiral_get_c(vtkNew sself) { return sself->GetC(); } -extern "C" void vtk_parametric_conic_spiral_set_n(vtkNew sself, double _arg) { sself->SetN(_arg); } -extern "C" double vtk_parametric_conic_spiral_get_n(vtkNew sself) { return sself->GetN(); } -extern "C" void vtk_parametric_conic_spiral_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_conic_spiral_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricCrossCap > vtkParametricCrossCap_new () {return vtkNew < vtkParametricCrossCap > () ;} -extern "C" void vtkParametricCrossCap_destructor (vtkNew < vtkParametricCrossCap > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricCrossCap_get_ptr (vtkNew < vtkParametricCrossCap > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_cross_cap_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_cross_cap_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_cross_cap_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricDini > vtkParametricDini_new () {return vtkNew < vtkParametricDini > () ;} -extern "C" void vtkParametricDini_destructor (vtkNew < vtkParametricDini > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricDini_get_ptr (vtkNew < vtkParametricDini > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_dini_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_dini_set_a(vtkNew sself, double _arg) { sself->SetA(_arg); } -extern "C" double vtk_parametric_dini_get_a(vtkNew sself) { return sself->GetA(); } -extern "C" void vtk_parametric_dini_set_b(vtkNew sself, double _arg) { sself->SetB(_arg); } -extern "C" double vtk_parametric_dini_get_b(vtkNew sself) { return sself->GetB(); } -extern "C" void vtk_parametric_dini_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_dini_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricEllipsoid > vtkParametricEllipsoid_new () {return vtkNew < vtkParametricEllipsoid > () ;} -extern "C" void vtkParametricEllipsoid_destructor (vtkNew < vtkParametricEllipsoid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricEllipsoid_get_ptr (vtkNew < vtkParametricEllipsoid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_ellipsoid_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_ellipsoid_set_x_radius(vtkNew sself, double _arg) { sself->SetXRadius(_arg); } -extern "C" double vtk_parametric_ellipsoid_get_x_radius(vtkNew sself) { return sself->GetXRadius(); } -extern "C" void vtk_parametric_ellipsoid_set_y_radius(vtkNew sself, double _arg) { sself->SetYRadius(_arg); } -extern "C" double vtk_parametric_ellipsoid_get_y_radius(vtkNew sself) { return sself->GetYRadius(); } -extern "C" void vtk_parametric_ellipsoid_set_z_radius(vtkNew sself, double _arg) { sself->SetZRadius(_arg); } -extern "C" double vtk_parametric_ellipsoid_get_z_radius(vtkNew sself) { return sself->GetZRadius(); } -extern "C" void vtk_parametric_ellipsoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_ellipsoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricEnneper > vtkParametricEnneper_new () {return vtkNew < vtkParametricEnneper > () ;} -extern "C" void vtkParametricEnneper_destructor (vtkNew < vtkParametricEnneper > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricEnneper_get_ptr (vtkNew < vtkParametricEnneper > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_enneper_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_enneper_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_enneper_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricFigure8Klein > vtkParametricFigure8Klein_new () {return vtkNew < vtkParametricFigure8Klein > () ;} -extern "C" void vtkParametricFigure8Klein_destructor (vtkNew < vtkParametricFigure8Klein > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricFigure8Klein_get_ptr (vtkNew < vtkParametricFigure8Klein > sself) {return sself . GetPointer () ;} -extern "C" void vtk_parametric_figure_8_klein_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } -extern "C" double vtk_parametric_figure_8_klein_get_radius(vtkNew sself) { return sself->GetRadius(); } -extern "C" int vtk_parametric_figure_8_klein_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_figure_8_klein_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_figure_8_klein_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricHenneberg > vtkParametricHenneberg_new () {return vtkNew < vtkParametricHenneberg > () ;} -extern "C" void vtkParametricHenneberg_destructor (vtkNew < vtkParametricHenneberg > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricHenneberg_get_ptr (vtkNew < vtkParametricHenneberg > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_henneberg_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_henneberg_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_henneberg_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricKlein > vtkParametricKlein_new () {return vtkNew < vtkParametricKlein > () ;} -extern "C" void vtkParametricKlein_destructor (vtkNew < vtkParametricKlein > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricKlein_get_ptr (vtkNew < vtkParametricKlein > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_klein_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_klein_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_klein_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricKuen > vtkParametricKuen_new () {return vtkNew < vtkParametricKuen > () ;} -extern "C" void vtkParametricKuen_destructor (vtkNew < vtkParametricKuen > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricKuen_get_ptr (vtkNew < vtkParametricKuen > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_kuen_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_kuen_set_delta_v_0(vtkNew sself, double _arg) { sself->SetDeltaV0(_arg); } -extern "C" double vtk_parametric_kuen_get_delta_v_0(vtkNew sself) { return sself->GetDeltaV0(); } -extern "C" void vtk_parametric_kuen_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_kuen_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricMobius > vtkParametricMobius_new () {return vtkNew < vtkParametricMobius > () ;} -extern "C" void vtkParametricMobius_destructor (vtkNew < vtkParametricMobius > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricMobius_get_ptr (vtkNew < vtkParametricMobius > sself) {return sself . GetPointer () ;} -extern "C" void vtk_parametric_mobius_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } -extern "C" double vtk_parametric_mobius_get_radius(vtkNew sself) { return sself->GetRadius(); } -extern "C" int vtk_parametric_mobius_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_mobius_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_mobius_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricPluckerConoid > vtkParametricPluckerConoid_new () {return vtkNew < vtkParametricPluckerConoid > () ;} -extern "C" void vtkParametricPluckerConoid_destructor (vtkNew < vtkParametricPluckerConoid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricPluckerConoid_get_ptr (vtkNew < vtkParametricPluckerConoid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_plucker_conoid_get_n(vtkNew sself) { return sself->GetN(); } -extern "C" void vtk_parametric_plucker_conoid_set_n(vtkNew sself, int _arg) { sself->SetN(_arg); } -extern "C" int vtk_parametric_plucker_conoid_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_plucker_conoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_plucker_conoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricPseudosphere > vtkParametricPseudosphere_new () {return vtkNew < vtkParametricPseudosphere > () ;} -extern "C" void vtkParametricPseudosphere_destructor (vtkNew < vtkParametricPseudosphere > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricPseudosphere_get_ptr (vtkNew < vtkParametricPseudosphere > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_pseudosphere_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_pseudosphere_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_pseudosphere_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricRandomHills > vtkParametricRandomHills_new () {return vtkNew < vtkParametricRandomHills > () ;} -extern "C" void vtkParametricRandomHills_destructor (vtkNew < vtkParametricRandomHills > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricRandomHills_get_ptr (vtkNew < vtkParametricRandomHills > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_random_hills_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_random_hills_set_number_of_hills(vtkNew sself, int _arg) { sself->SetNumberOfHills(_arg); } -extern "C" int vtk_parametric_random_hills_get_number_of_hills(vtkNew sself) { return sself->GetNumberOfHills(); } -extern "C" void vtk_parametric_random_hills_set_hill_x_variance(vtkNew sself, double _arg) { sself->SetHillXVariance(_arg); } -extern "C" double vtk_parametric_random_hills_get_hill_x_variance(vtkNew sself) { return sself->GetHillXVariance(); } -extern "C" void vtk_parametric_random_hills_set_hill_y_variance(vtkNew sself, double _arg) { sself->SetHillYVariance(_arg); } -extern "C" double vtk_parametric_random_hills_get_hill_y_variance(vtkNew sself) { return sself->GetHillYVariance(); } -extern "C" void vtk_parametric_random_hills_set_hill_amplitude(vtkNew sself, double _arg) { sself->SetHillAmplitude(_arg); } -extern "C" double vtk_parametric_random_hills_get_hill_amplitude(vtkNew sself) { return sself->GetHillAmplitude(); } -extern "C" void vtk_parametric_random_hills_set_random_seed(vtkNew sself, int _arg) { sself->SetRandomSeed(_arg); } -extern "C" int vtk_parametric_random_hills_get_random_seed(vtkNew sself) { return sself->GetRandomSeed(); } -extern "C" void vtk_parametric_random_hills_set_allow_random_generation(vtkNew sself, int _arg) { sself->SetAllowRandomGeneration(_arg); } -extern "C" int vtk_parametric_random_hills_get_allow_random_generation_min_value(vtkNew sself) { return sself->GetAllowRandomGenerationMinValue(); } -extern "C" int vtk_parametric_random_hills_get_allow_random_generation_max_value(vtkNew sself) { return sself->GetAllowRandomGenerationMaxValue(); } -extern "C" int vtk_parametric_random_hills_get_allow_random_generation(vtkNew sself) { return sself->GetAllowRandomGeneration(); } -extern "C" void vtk_parametric_random_hills_allow_random_generation_on(vtkNew sself) { sself->AllowRandomGenerationOn(); } -extern "C" void vtk_parametric_random_hills_allow_random_generation_off(vtkNew sself) { sself->AllowRandomGenerationOff(); } -extern "C" void vtk_parametric_random_hills_set_x_variance_scale_factor(vtkNew sself, double _arg) { sself->SetXVarianceScaleFactor(_arg); } -extern "C" double vtk_parametric_random_hills_get_x_variance_scale_factor(vtkNew sself) { return sself->GetXVarianceScaleFactor(); } -extern "C" void vtk_parametric_random_hills_set_y_variance_scale_factor(vtkNew sself, double _arg) { sself->SetYVarianceScaleFactor(_arg); } -extern "C" double vtk_parametric_random_hills_get_y_variance_scale_factor(vtkNew sself) { return sself->GetYVarianceScaleFactor(); } -extern "C" void vtk_parametric_random_hills_set_amplitude_scale_factor(vtkNew sself, double _arg) { sself->SetAmplitudeScaleFactor(_arg); } -extern "C" double vtk_parametric_random_hills_get_amplitude_scale_factor(vtkNew sself) { return sself->GetAmplitudeScaleFactor(); } -extern "C" void vtk_parametric_random_hills_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_random_hills_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricRoman > vtkParametricRoman_new () {return vtkNew < vtkParametricRoman > () ;} -extern "C" void vtkParametricRoman_destructor (vtkNew < vtkParametricRoman > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricRoman_get_ptr (vtkNew < vtkParametricRoman > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_roman_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_roman_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } -extern "C" double vtk_parametric_roman_get_radius(vtkNew sself) { return sself->GetRadius(); } -extern "C" void vtk_parametric_roman_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_roman_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricSpline > vtkParametricSpline_new () {return vtkNew < vtkParametricSpline > () ;} -extern "C" void vtkParametricSpline_destructor (vtkNew < vtkParametricSpline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricSpline_get_ptr (vtkNew < vtkParametricSpline > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_spline_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_spline_evaluate(vtkNew sself, double u, double Pt, double Du) { sself->Evaluate(u, Pt, Du); } -extern "C" double vtk_parametric_spline_evaluate_scalar(vtkNew sself, double u, double Pt, double Du) { return sself->EvaluateScalar(u, Pt, Du); } -extern "C" void vtk_parametric_spline_set_number_of_points(vtkNew sself, long long numPts) { sself->SetNumberOfPoints(numPts); } -extern "C" void vtk_parametric_spline_set_point(vtkNew sself, long long index, double x, double y, double z) { sself->SetPoint(index, x, y, z); } -extern "C" void vtk_parametric_spline_set_closed(vtkNew sself, int _arg) { sself->SetClosed(_arg); } -extern "C" int vtk_parametric_spline_get_closed(vtkNew sself) { return sself->GetClosed(); } -extern "C" void vtk_parametric_spline_closed_on(vtkNew sself) { sself->ClosedOn(); } -extern "C" void vtk_parametric_spline_closed_off(vtkNew sself) { sself->ClosedOff(); } -extern "C" void vtk_parametric_spline_set_parameterize_by_length(vtkNew sself, int _arg) { sself->SetParameterizeByLength(_arg); } -extern "C" int vtk_parametric_spline_get_parameterize_by_length(vtkNew sself) { return sself->GetParameterizeByLength(); } -extern "C" void vtk_parametric_spline_parameterize_by_length_on(vtkNew sself) { sself->ParameterizeByLengthOn(); } -extern "C" void vtk_parametric_spline_parameterize_by_length_off(vtkNew sself) { sself->ParameterizeByLengthOff(); } -extern "C" void vtk_parametric_spline_set_left_constraint(vtkNew sself, int _arg) { sself->SetLeftConstraint(_arg); } -extern "C" int vtk_parametric_spline_get_left_constraint_min_value(vtkNew sself) { return sself->GetLeftConstraintMinValue(); } -extern "C" int vtk_parametric_spline_get_left_constraint_max_value(vtkNew sself) { return sself->GetLeftConstraintMaxValue(); } -extern "C" int vtk_parametric_spline_get_left_constraint(vtkNew sself) { return sself->GetLeftConstraint(); } -extern "C" void vtk_parametric_spline_set_right_constraint(vtkNew sself, int _arg) { sself->SetRightConstraint(_arg); } -extern "C" int vtk_parametric_spline_get_right_constraint_min_value(vtkNew sself) { return sself->GetRightConstraintMinValue(); } -extern "C" int vtk_parametric_spline_get_right_constraint_max_value(vtkNew sself) { return sself->GetRightConstraintMaxValue(); } -extern "C" int vtk_parametric_spline_get_right_constraint(vtkNew sself) { return sself->GetRightConstraint(); } -extern "C" void vtk_parametric_spline_set_left_value(vtkNew sself, double _arg) { sself->SetLeftValue(_arg); } -extern "C" double vtk_parametric_spline_get_left_value(vtkNew sself) { return sself->GetLeftValue(); } -extern "C" void vtk_parametric_spline_set_right_value(vtkNew sself, double _arg) { sself->SetRightValue(_arg); } -extern "C" double vtk_parametric_spline_get_right_value(vtkNew sself) { return sself->GetRightValue(); } -extern "C" vtkNew < vtkParametricSuperEllipsoid > vtkParametricSuperEllipsoid_new () {return vtkNew < vtkParametricSuperEllipsoid > () ;} -extern "C" void vtkParametricSuperEllipsoid_destructor (vtkNew < vtkParametricSuperEllipsoid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricSuperEllipsoid_get_ptr (vtkNew < vtkParametricSuperEllipsoid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_super_ellipsoid_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_super_ellipsoid_set_x_radius(vtkNew sself, double _arg) { sself->SetXRadius(_arg); } -extern "C" double vtk_parametric_super_ellipsoid_get_x_radius(vtkNew sself) { return sself->GetXRadius(); } -extern "C" void vtk_parametric_super_ellipsoid_set_y_radius(vtkNew sself, double _arg) { sself->SetYRadius(_arg); } -extern "C" double vtk_parametric_super_ellipsoid_get_y_radius(vtkNew sself) { return sself->GetYRadius(); } -extern "C" void vtk_parametric_super_ellipsoid_set_z_radius(vtkNew sself, double _arg) { sself->SetZRadius(_arg); } -extern "C" double vtk_parametric_super_ellipsoid_get_z_radius(vtkNew sself) { return sself->GetZRadius(); } -extern "C" void vtk_parametric_super_ellipsoid_set_n_1(vtkNew sself, double _arg) { sself->SetN1(_arg); } -extern "C" double vtk_parametric_super_ellipsoid_get_n_1(vtkNew sself) { return sself->GetN1(); } -extern "C" void vtk_parametric_super_ellipsoid_set_n_2(vtkNew sself, double _arg) { sself->SetN2(_arg); } -extern "C" double vtk_parametric_super_ellipsoid_get_n_2(vtkNew sself) { return sself->GetN2(); } -extern "C" void vtk_parametric_super_ellipsoid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_super_ellipsoid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricSuperToroid > vtkParametricSuperToroid_new () {return vtkNew < vtkParametricSuperToroid > () ;} -extern "C" void vtkParametricSuperToroid_destructor (vtkNew < vtkParametricSuperToroid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricSuperToroid_get_ptr (vtkNew < vtkParametricSuperToroid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_parametric_super_toroid_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_super_toroid_set_ring_radius(vtkNew sself, double _arg) { sself->SetRingRadius(_arg); } -extern "C" double vtk_parametric_super_toroid_get_ring_radius(vtkNew sself) { return sself->GetRingRadius(); } -extern "C" void vtk_parametric_super_toroid_set_cross_section_radius(vtkNew sself, double _arg) { sself->SetCrossSectionRadius(_arg); } -extern "C" double vtk_parametric_super_toroid_get_cross_section_radius(vtkNew sself) { return sself->GetCrossSectionRadius(); } -extern "C" void vtk_parametric_super_toroid_set_x_radius(vtkNew sself, double _arg) { sself->SetXRadius(_arg); } -extern "C" double vtk_parametric_super_toroid_get_x_radius(vtkNew sself) { return sself->GetXRadius(); } -extern "C" void vtk_parametric_super_toroid_set_y_radius(vtkNew sself, double _arg) { sself->SetYRadius(_arg); } -extern "C" double vtk_parametric_super_toroid_get_y_radius(vtkNew sself) { return sself->GetYRadius(); } -extern "C" void vtk_parametric_super_toroid_set_z_radius(vtkNew sself, double _arg) { sself->SetZRadius(_arg); } -extern "C" double vtk_parametric_super_toroid_get_z_radius(vtkNew sself) { return sself->GetZRadius(); } -extern "C" void vtk_parametric_super_toroid_set_n_1(vtkNew sself, double _arg) { sself->SetN1(_arg); } -extern "C" double vtk_parametric_super_toroid_get_n_1(vtkNew sself) { return sself->GetN1(); } -extern "C" void vtk_parametric_super_toroid_set_n_2(vtkNew sself, double _arg) { sself->SetN2(_arg); } -extern "C" double vtk_parametric_super_toroid_get_n_2(vtkNew sself) { return sself->GetN2(); } -extern "C" void vtk_parametric_super_toroid_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_super_toroid_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } -extern "C" vtkNew < vtkParametricTorus > vtkParametricTorus_new () {return vtkNew < vtkParametricTorus > () ;} -extern "C" void vtkParametricTorus_destructor (vtkNew < vtkParametricTorus > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricTorus_get_ptr (vtkNew < vtkParametricTorus > sself) {return sself . GetPointer () ;} -extern "C" void vtk_parametric_torus_set_ring_radius(vtkNew sself, double _arg) { sself->SetRingRadius(_arg); } -extern "C" double vtk_parametric_torus_get_ring_radius(vtkNew sself) { return sself->GetRingRadius(); } -extern "C" void vtk_parametric_torus_set_cross_section_radius(vtkNew sself, double _arg) { sself->SetCrossSectionRadius(_arg); } -extern "C" double vtk_parametric_torus_get_cross_section_radius(vtkNew sself) { return sself->GetCrossSectionRadius(); } -extern "C" int vtk_parametric_torus_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_parametric_torus_evaluate(vtkNew sself, double uvw, double Pt, double Duvw) { sself->Evaluate(uvw, Pt, Duvw); } -extern "C" double vtk_parametric_torus_evaluate_scalar(vtkNew sself, double uvw, double Pt, double Duvw) { return sself->EvaluateScalar(uvw, Pt, Duvw); } +extern "C" vtkCardinalSpline * vtkCardinalSpline_new () {return vtkCardinalSpline :: New () ;} +extern "C" void vtkCardinalSpline_destructor (vtkCardinalSpline * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCardinalSpline_get_ptr (vtkCardinalSpline * sself) {return sself ;} +extern "C" void vtk_cardinal_spline_compute(vtkCardinalSpline* sself) { sself->Compute(); } +extern "C" double vtk_cardinal_spline_evaluate(vtkCardinalSpline* sself, double t) { return sself->Evaluate(t); } +extern "C" vtkKochanekSpline * vtkKochanekSpline_new () {return vtkKochanekSpline :: New () ;} +extern "C" void vtkKochanekSpline_destructor (vtkKochanekSpline * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkKochanekSpline_get_ptr (vtkKochanekSpline * sself) {return sself ;} +extern "C" void vtk_kochanek_spline_compute(vtkKochanekSpline* sself) { sself->Compute(); } +extern "C" double vtk_kochanek_spline_evaluate(vtkKochanekSpline* sself, double t) { return sself->Evaluate(t); } +extern "C" void vtk_kochanek_spline_set_default_bias(vtkKochanekSpline* sself, double _arg) { sself->SetDefaultBias(_arg); } +extern "C" double vtk_kochanek_spline_get_default_bias(vtkKochanekSpline* sself) { return sself->GetDefaultBias(); } +extern "C" void vtk_kochanek_spline_set_default_tension(vtkKochanekSpline* sself, double _arg) { sself->SetDefaultTension(_arg); } +extern "C" double vtk_kochanek_spline_get_default_tension(vtkKochanekSpline* sself) { return sself->GetDefaultTension(); } +extern "C" void vtk_kochanek_spline_set_default_continuity(vtkKochanekSpline* sself, double _arg) { sself->SetDefaultContinuity(_arg); } +extern "C" double vtk_kochanek_spline_get_default_continuity(vtkKochanekSpline* sself) { return sself->GetDefaultContinuity(); } +extern "C" vtkParametricBohemianDome * vtkParametricBohemianDome_new () {return vtkParametricBohemianDome :: New () ;} +extern "C" void vtkParametricBohemianDome_destructor (vtkParametricBohemianDome * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricBohemianDome_get_ptr (vtkParametricBohemianDome * sself) {return sself ;} +extern "C" double vtk_parametric_bohemian_dome_get_a(vtkParametricBohemianDome* sself) { return sself->GetA(); } +extern "C" void vtk_parametric_bohemian_dome_set_a(vtkParametricBohemianDome* sself, double _arg) { sself->SetA(_arg); } +extern "C" double vtk_parametric_bohemian_dome_get_b(vtkParametricBohemianDome* sself) { return sself->GetB(); } +extern "C" void vtk_parametric_bohemian_dome_set_b(vtkParametricBohemianDome* sself, double _arg) { sself->SetB(_arg); } +extern "C" double vtk_parametric_bohemian_dome_get_c(vtkParametricBohemianDome* sself) { return sself->GetC(); } +extern "C" void vtk_parametric_bohemian_dome_set_c(vtkParametricBohemianDome* sself, double _arg) { sself->SetC(_arg); } +extern "C" int vtk_parametric_bohemian_dome_get_dimension(vtkParametricBohemianDome* sself) { return sself->GetDimension(); } +extern "C" vtkParametricBour * vtkParametricBour_new () {return vtkParametricBour :: New () ;} +extern "C" void vtkParametricBour_destructor (vtkParametricBour * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricBour_get_ptr (vtkParametricBour * sself) {return sself ;} +extern "C" int vtk_parametric_bour_get_dimension(vtkParametricBour* sself) { return sself->GetDimension(); } +extern "C" vtkParametricBoy * vtkParametricBoy_new () {return vtkParametricBoy :: New () ;} +extern "C" void vtkParametricBoy_destructor (vtkParametricBoy * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricBoy_get_ptr (vtkParametricBoy * sself) {return sself ;} +extern "C" int vtk_parametric_boy_get_dimension(vtkParametricBoy* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_boy_set_z_scale(vtkParametricBoy* sself, double _arg) { sself->SetZScale(_arg); } +extern "C" double vtk_parametric_boy_get_z_scale(vtkParametricBoy* sself) { return sself->GetZScale(); } +extern "C" vtkParametricCatalanMinimal * vtkParametricCatalanMinimal_new () {return vtkParametricCatalanMinimal :: New () ;} +extern "C" void vtkParametricCatalanMinimal_destructor (vtkParametricCatalanMinimal * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricCatalanMinimal_get_ptr (vtkParametricCatalanMinimal * sself) {return sself ;} +extern "C" int vtk_parametric_catalan_minimal_get_dimension(vtkParametricCatalanMinimal* sself) { return sself->GetDimension(); } +extern "C" vtkParametricConicSpiral * vtkParametricConicSpiral_new () {return vtkParametricConicSpiral :: New () ;} +extern "C" void vtkParametricConicSpiral_destructor (vtkParametricConicSpiral * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricConicSpiral_get_ptr (vtkParametricConicSpiral * sself) {return sself ;} +extern "C" int vtk_parametric_conic_spiral_get_dimension(vtkParametricConicSpiral* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_conic_spiral_set_a(vtkParametricConicSpiral* sself, double _arg) { sself->SetA(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_a(vtkParametricConicSpiral* sself) { return sself->GetA(); } +extern "C" void vtk_parametric_conic_spiral_set_b(vtkParametricConicSpiral* sself, double _arg) { sself->SetB(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_b(vtkParametricConicSpiral* sself) { return sself->GetB(); } +extern "C" void vtk_parametric_conic_spiral_set_c(vtkParametricConicSpiral* sself, double _arg) { sself->SetC(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_c(vtkParametricConicSpiral* sself) { return sself->GetC(); } +extern "C" void vtk_parametric_conic_spiral_set_n(vtkParametricConicSpiral* sself, double _arg) { sself->SetN(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_n(vtkParametricConicSpiral* sself) { return sself->GetN(); } +extern "C" vtkParametricCrossCap * vtkParametricCrossCap_new () {return vtkParametricCrossCap :: New () ;} +extern "C" void vtkParametricCrossCap_destructor (vtkParametricCrossCap * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricCrossCap_get_ptr (vtkParametricCrossCap * sself) {return sself ;} +extern "C" int vtk_parametric_cross_cap_get_dimension(vtkParametricCrossCap* sself) { return sself->GetDimension(); } +extern "C" vtkParametricDini * vtkParametricDini_new () {return vtkParametricDini :: New () ;} +extern "C" void vtkParametricDini_destructor (vtkParametricDini * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricDini_get_ptr (vtkParametricDini * sself) {return sself ;} +extern "C" int vtk_parametric_dini_get_dimension(vtkParametricDini* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_dini_set_a(vtkParametricDini* sself, double _arg) { sself->SetA(_arg); } +extern "C" double vtk_parametric_dini_get_a(vtkParametricDini* sself) { return sself->GetA(); } +extern "C" void vtk_parametric_dini_set_b(vtkParametricDini* sself, double _arg) { sself->SetB(_arg); } +extern "C" double vtk_parametric_dini_get_b(vtkParametricDini* sself) { return sself->GetB(); } +extern "C" vtkParametricEllipsoid * vtkParametricEllipsoid_new () {return vtkParametricEllipsoid :: New () ;} +extern "C" void vtkParametricEllipsoid_destructor (vtkParametricEllipsoid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricEllipsoid_get_ptr (vtkParametricEllipsoid * sself) {return sself ;} +extern "C" int vtk_parametric_ellipsoid_get_dimension(vtkParametricEllipsoid* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_ellipsoid_set_x_radius(vtkParametricEllipsoid* sself, double _arg) { sself->SetXRadius(_arg); } +extern "C" double vtk_parametric_ellipsoid_get_x_radius(vtkParametricEllipsoid* sself) { return sself->GetXRadius(); } +extern "C" void vtk_parametric_ellipsoid_set_y_radius(vtkParametricEllipsoid* sself, double _arg) { sself->SetYRadius(_arg); } +extern "C" double vtk_parametric_ellipsoid_get_y_radius(vtkParametricEllipsoid* sself) { return sself->GetYRadius(); } +extern "C" void vtk_parametric_ellipsoid_set_z_radius(vtkParametricEllipsoid* sself, double _arg) { sself->SetZRadius(_arg); } +extern "C" double vtk_parametric_ellipsoid_get_z_radius(vtkParametricEllipsoid* sself) { return sself->GetZRadius(); } +extern "C" vtkParametricEnneper * vtkParametricEnneper_new () {return vtkParametricEnneper :: New () ;} +extern "C" void vtkParametricEnneper_destructor (vtkParametricEnneper * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricEnneper_get_ptr (vtkParametricEnneper * sself) {return sself ;} +extern "C" int vtk_parametric_enneper_get_dimension(vtkParametricEnneper* sself) { return sself->GetDimension(); } +extern "C" vtkParametricFigure8Klein * vtkParametricFigure8Klein_new () {return vtkParametricFigure8Klein :: New () ;} +extern "C" void vtkParametricFigure8Klein_destructor (vtkParametricFigure8Klein * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricFigure8Klein_get_ptr (vtkParametricFigure8Klein * sself) {return sself ;} +extern "C" void vtk_parametric_figure_8_klein_set_radius(vtkParametricFigure8Klein* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_parametric_figure_8_klein_get_radius(vtkParametricFigure8Klein* sself) { return sself->GetRadius(); } +extern "C" int vtk_parametric_figure_8_klein_get_dimension(vtkParametricFigure8Klein* sself) { return sself->GetDimension(); } +extern "C" vtkParametricHenneberg * vtkParametricHenneberg_new () {return vtkParametricHenneberg :: New () ;} +extern "C" void vtkParametricHenneberg_destructor (vtkParametricHenneberg * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricHenneberg_get_ptr (vtkParametricHenneberg * sself) {return sself ;} +extern "C" int vtk_parametric_henneberg_get_dimension(vtkParametricHenneberg* sself) { return sself->GetDimension(); } +extern "C" vtkParametricKlein * vtkParametricKlein_new () {return vtkParametricKlein :: New () ;} +extern "C" void vtkParametricKlein_destructor (vtkParametricKlein * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricKlein_get_ptr (vtkParametricKlein * sself) {return sself ;} +extern "C" int vtk_parametric_klein_get_dimension(vtkParametricKlein* sself) { return sself->GetDimension(); } +extern "C" vtkParametricKuen * vtkParametricKuen_new () {return vtkParametricKuen :: New () ;} +extern "C" void vtkParametricKuen_destructor (vtkParametricKuen * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricKuen_get_ptr (vtkParametricKuen * sself) {return sself ;} +extern "C" int vtk_parametric_kuen_get_dimension(vtkParametricKuen* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_kuen_set_delta_v_0(vtkParametricKuen* sself, double _arg) { sself->SetDeltaV0(_arg); } +extern "C" double vtk_parametric_kuen_get_delta_v_0(vtkParametricKuen* sself) { return sself->GetDeltaV0(); } +extern "C" vtkParametricMobius * vtkParametricMobius_new () {return vtkParametricMobius :: New () ;} +extern "C" void vtkParametricMobius_destructor (vtkParametricMobius * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricMobius_get_ptr (vtkParametricMobius * sself) {return sself ;} +extern "C" void vtk_parametric_mobius_set_radius(vtkParametricMobius* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_parametric_mobius_get_radius(vtkParametricMobius* sself) { return sself->GetRadius(); } +extern "C" int vtk_parametric_mobius_get_dimension(vtkParametricMobius* sself) { return sself->GetDimension(); } +extern "C" vtkParametricPluckerConoid * vtkParametricPluckerConoid_new () {return vtkParametricPluckerConoid :: New () ;} +extern "C" void vtkParametricPluckerConoid_destructor (vtkParametricPluckerConoid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricPluckerConoid_get_ptr (vtkParametricPluckerConoid * sself) {return sself ;} +extern "C" int vtk_parametric_plucker_conoid_get_n(vtkParametricPluckerConoid* sself) { return sself->GetN(); } +extern "C" void vtk_parametric_plucker_conoid_set_n(vtkParametricPluckerConoid* sself, int _arg) { sself->SetN(_arg); } +extern "C" int vtk_parametric_plucker_conoid_get_dimension(vtkParametricPluckerConoid* sself) { return sself->GetDimension(); } +extern "C" vtkParametricPseudosphere * vtkParametricPseudosphere_new () {return vtkParametricPseudosphere :: New () ;} +extern "C" void vtkParametricPseudosphere_destructor (vtkParametricPseudosphere * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricPseudosphere_get_ptr (vtkParametricPseudosphere * sself) {return sself ;} +extern "C" int vtk_parametric_pseudosphere_get_dimension(vtkParametricPseudosphere* sself) { return sself->GetDimension(); } +extern "C" vtkParametricRandomHills * vtkParametricRandomHills_new () {return vtkParametricRandomHills :: New () ;} +extern "C" void vtkParametricRandomHills_destructor (vtkParametricRandomHills * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricRandomHills_get_ptr (vtkParametricRandomHills * sself) {return sself ;} +extern "C" int vtk_parametric_random_hills_get_dimension(vtkParametricRandomHills* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_random_hills_set_number_of_hills(vtkParametricRandomHills* sself, int _arg) { sself->SetNumberOfHills(_arg); } +extern "C" int vtk_parametric_random_hills_get_number_of_hills(vtkParametricRandomHills* sself) { return sself->GetNumberOfHills(); } +extern "C" void vtk_parametric_random_hills_set_hill_x_variance(vtkParametricRandomHills* sself, double _arg) { sself->SetHillXVariance(_arg); } +extern "C" double vtk_parametric_random_hills_get_hill_x_variance(vtkParametricRandomHills* sself) { return sself->GetHillXVariance(); } +extern "C" void vtk_parametric_random_hills_set_hill_y_variance(vtkParametricRandomHills* sself, double _arg) { sself->SetHillYVariance(_arg); } +extern "C" double vtk_parametric_random_hills_get_hill_y_variance(vtkParametricRandomHills* sself) { return sself->GetHillYVariance(); } +extern "C" void vtk_parametric_random_hills_set_hill_amplitude(vtkParametricRandomHills* sself, double _arg) { sself->SetHillAmplitude(_arg); } +extern "C" double vtk_parametric_random_hills_get_hill_amplitude(vtkParametricRandomHills* sself) { return sself->GetHillAmplitude(); } +extern "C" void vtk_parametric_random_hills_set_random_seed(vtkParametricRandomHills* sself, int _arg) { sself->SetRandomSeed(_arg); } +extern "C" int vtk_parametric_random_hills_get_random_seed(vtkParametricRandomHills* sself) { return sself->GetRandomSeed(); } +extern "C" void vtk_parametric_random_hills_set_allow_random_generation(vtkParametricRandomHills* sself, int _arg) { sself->SetAllowRandomGeneration(_arg); } +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_min_value(vtkParametricRandomHills* sself) { return sself->GetAllowRandomGenerationMinValue(); } +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_max_value(vtkParametricRandomHills* sself) { return sself->GetAllowRandomGenerationMaxValue(); } +extern "C" int vtk_parametric_random_hills_get_allow_random_generation(vtkParametricRandomHills* sself) { return sself->GetAllowRandomGeneration(); } +extern "C" void vtk_parametric_random_hills_allow_random_generation_on(vtkParametricRandomHills* sself) { sself->AllowRandomGenerationOn(); } +extern "C" void vtk_parametric_random_hills_allow_random_generation_off(vtkParametricRandomHills* sself) { sself->AllowRandomGenerationOff(); } +extern "C" void vtk_parametric_random_hills_set_x_variance_scale_factor(vtkParametricRandomHills* sself, double _arg) { sself->SetXVarianceScaleFactor(_arg); } +extern "C" double vtk_parametric_random_hills_get_x_variance_scale_factor(vtkParametricRandomHills* sself) { return sself->GetXVarianceScaleFactor(); } +extern "C" void vtk_parametric_random_hills_set_y_variance_scale_factor(vtkParametricRandomHills* sself, double _arg) { sself->SetYVarianceScaleFactor(_arg); } +extern "C" double vtk_parametric_random_hills_get_y_variance_scale_factor(vtkParametricRandomHills* sself) { return sself->GetYVarianceScaleFactor(); } +extern "C" void vtk_parametric_random_hills_set_amplitude_scale_factor(vtkParametricRandomHills* sself, double _arg) { sself->SetAmplitudeScaleFactor(_arg); } +extern "C" double vtk_parametric_random_hills_get_amplitude_scale_factor(vtkParametricRandomHills* sself) { return sself->GetAmplitudeScaleFactor(); } +extern "C" vtkParametricRoman * vtkParametricRoman_new () {return vtkParametricRoman :: New () ;} +extern "C" void vtkParametricRoman_destructor (vtkParametricRoman * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricRoman_get_ptr (vtkParametricRoman * sself) {return sself ;} +extern "C" int vtk_parametric_roman_get_dimension(vtkParametricRoman* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_roman_set_radius(vtkParametricRoman* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_parametric_roman_get_radius(vtkParametricRoman* sself) { return sself->GetRadius(); } +extern "C" vtkParametricSpline * vtkParametricSpline_new () {return vtkParametricSpline :: New () ;} +extern "C" void vtkParametricSpline_destructor (vtkParametricSpline * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricSpline_get_ptr (vtkParametricSpline * sself) {return sself ;} +extern "C" int vtk_parametric_spline_get_dimension(vtkParametricSpline* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_spline_set_number_of_points(vtkParametricSpline* sself, long long numPts) { sself->SetNumberOfPoints(numPts); } +extern "C" void vtk_parametric_spline_set_point(vtkParametricSpline* sself, long long index, double x, double y, double z) { sself->SetPoint(index, x, y, z); } +extern "C" void vtk_parametric_spline_set_closed(vtkParametricSpline* sself, int _arg) { sself->SetClosed(_arg); } +extern "C" int vtk_parametric_spline_get_closed(vtkParametricSpline* sself) { return sself->GetClosed(); } +extern "C" void vtk_parametric_spline_closed_on(vtkParametricSpline* sself) { sself->ClosedOn(); } +extern "C" void vtk_parametric_spline_closed_off(vtkParametricSpline* sself) { sself->ClosedOff(); } +extern "C" void vtk_parametric_spline_set_parameterize_by_length(vtkParametricSpline* sself, int _arg) { sself->SetParameterizeByLength(_arg); } +extern "C" int vtk_parametric_spline_get_parameterize_by_length(vtkParametricSpline* sself) { return sself->GetParameterizeByLength(); } +extern "C" void vtk_parametric_spline_parameterize_by_length_on(vtkParametricSpline* sself) { sself->ParameterizeByLengthOn(); } +extern "C" void vtk_parametric_spline_parameterize_by_length_off(vtkParametricSpline* sself) { sself->ParameterizeByLengthOff(); } +extern "C" void vtk_parametric_spline_set_left_constraint(vtkParametricSpline* sself, int _arg) { sself->SetLeftConstraint(_arg); } +extern "C" int vtk_parametric_spline_get_left_constraint_min_value(vtkParametricSpline* sself) { return sself->GetLeftConstraintMinValue(); } +extern "C" int vtk_parametric_spline_get_left_constraint_max_value(vtkParametricSpline* sself) { return sself->GetLeftConstraintMaxValue(); } +extern "C" int vtk_parametric_spline_get_left_constraint(vtkParametricSpline* sself) { return sself->GetLeftConstraint(); } +extern "C" void vtk_parametric_spline_set_right_constraint(vtkParametricSpline* sself, int _arg) { sself->SetRightConstraint(_arg); } +extern "C" int vtk_parametric_spline_get_right_constraint_min_value(vtkParametricSpline* sself) { return sself->GetRightConstraintMinValue(); } +extern "C" int vtk_parametric_spline_get_right_constraint_max_value(vtkParametricSpline* sself) { return sself->GetRightConstraintMaxValue(); } +extern "C" int vtk_parametric_spline_get_right_constraint(vtkParametricSpline* sself) { return sself->GetRightConstraint(); } +extern "C" void vtk_parametric_spline_set_left_value(vtkParametricSpline* sself, double _arg) { sself->SetLeftValue(_arg); } +extern "C" double vtk_parametric_spline_get_left_value(vtkParametricSpline* sself) { return sself->GetLeftValue(); } +extern "C" void vtk_parametric_spline_set_right_value(vtkParametricSpline* sself, double _arg) { sself->SetRightValue(_arg); } +extern "C" double vtk_parametric_spline_get_right_value(vtkParametricSpline* sself) { return sself->GetRightValue(); } +extern "C" vtkParametricSuperEllipsoid * vtkParametricSuperEllipsoid_new () {return vtkParametricSuperEllipsoid :: New () ;} +extern "C" void vtkParametricSuperEllipsoid_destructor (vtkParametricSuperEllipsoid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricSuperEllipsoid_get_ptr (vtkParametricSuperEllipsoid * sself) {return sself ;} +extern "C" int vtk_parametric_super_ellipsoid_get_dimension(vtkParametricSuperEllipsoid* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_super_ellipsoid_set_x_radius(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetXRadius(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_x_radius(vtkParametricSuperEllipsoid* sself) { return sself->GetXRadius(); } +extern "C" void vtk_parametric_super_ellipsoid_set_y_radius(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetYRadius(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_y_radius(vtkParametricSuperEllipsoid* sself) { return sself->GetYRadius(); } +extern "C" void vtk_parametric_super_ellipsoid_set_z_radius(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetZRadius(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_z_radius(vtkParametricSuperEllipsoid* sself) { return sself->GetZRadius(); } +extern "C" void vtk_parametric_super_ellipsoid_set_n_1(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetN1(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_n_1(vtkParametricSuperEllipsoid* sself) { return sself->GetN1(); } +extern "C" void vtk_parametric_super_ellipsoid_set_n_2(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetN2(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_n_2(vtkParametricSuperEllipsoid* sself) { return sself->GetN2(); } +extern "C" vtkParametricSuperToroid * vtkParametricSuperToroid_new () {return vtkParametricSuperToroid :: New () ;} +extern "C" void vtkParametricSuperToroid_destructor (vtkParametricSuperToroid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricSuperToroid_get_ptr (vtkParametricSuperToroid * sself) {return sself ;} +extern "C" int vtk_parametric_super_toroid_get_dimension(vtkParametricSuperToroid* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_super_toroid_set_ring_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetRingRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_ring_radius(vtkParametricSuperToroid* sself) { return sself->GetRingRadius(); } +extern "C" void vtk_parametric_super_toroid_set_cross_section_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetCrossSectionRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_cross_section_radius(vtkParametricSuperToroid* sself) { return sself->GetCrossSectionRadius(); } +extern "C" void vtk_parametric_super_toroid_set_x_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetXRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_x_radius(vtkParametricSuperToroid* sself) { return sself->GetXRadius(); } +extern "C" void vtk_parametric_super_toroid_set_y_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetYRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_y_radius(vtkParametricSuperToroid* sself) { return sself->GetYRadius(); } +extern "C" void vtk_parametric_super_toroid_set_z_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetZRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_z_radius(vtkParametricSuperToroid* sself) { return sself->GetZRadius(); } +extern "C" void vtk_parametric_super_toroid_set_n_1(vtkParametricSuperToroid* sself, double _arg) { sself->SetN1(_arg); } +extern "C" double vtk_parametric_super_toroid_get_n_1(vtkParametricSuperToroid* sself) { return sself->GetN1(); } +extern "C" void vtk_parametric_super_toroid_set_n_2(vtkParametricSuperToroid* sself, double _arg) { sself->SetN2(_arg); } +extern "C" double vtk_parametric_super_toroid_get_n_2(vtkParametricSuperToroid* sself) { return sself->GetN2(); } +extern "C" vtkParametricTorus * vtkParametricTorus_new () {return vtkParametricTorus :: New () ;} +extern "C" void vtkParametricTorus_destructor (vtkParametricTorus * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricTorus_get_ptr (vtkParametricTorus * sself) {return sself ;} +extern "C" void vtk_parametric_torus_set_ring_radius(vtkParametricTorus* sself, double _arg) { sself->SetRingRadius(_arg); } +extern "C" double vtk_parametric_torus_get_ring_radius(vtkParametricTorus* sself) { return sself->GetRingRadius(); } +extern "C" void vtk_parametric_torus_set_cross_section_radius(vtkParametricTorus* sself, double _arg) { sself->SetCrossSectionRadius(_arg); } +extern "C" double vtk_parametric_torus_get_cross_section_radius(vtkParametricTorus* sself) { return sself->GetCrossSectionRadius(); } +extern "C" int vtk_parametric_torus_get_dimension(vtkParametricTorus* sself) { return sself->GetDimension(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp index 82d43f2..ed9a5de 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp @@ -165,1276 +165,811 @@ #include // Implement declared functions -extern "C" vtkNew < vtkAnimationCue > vtkAnimationCue_new () {return vtkNew < vtkAnimationCue > () ;} -extern "C" void vtkAnimationCue_destructor (vtkNew < vtkAnimationCue > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAnimationCue_get_ptr (vtkNew < vtkAnimationCue > sself) {return sself . GetPointer () ;} -extern "C" void vtk_animation_cue_set_time_mode(vtkNew sself, int mode) { sself->SetTimeMode(mode); } -extern "C" int vtk_animation_cue_get_time_mode(vtkNew sself) { return sself->GetTimeMode(); } -extern "C" void vtk_animation_cue_set_time_mode_to_relative(vtkNew sself) { sself->SetTimeModeToRelative(); } -extern "C" void vtk_animation_cue_set_time_mode_to_normalized(vtkNew sself) { sself->SetTimeModeToNormalized(); } -extern "C" void vtk_animation_cue_set_start_time(vtkNew sself, double _arg) { sself->SetStartTime(_arg); } -extern "C" double vtk_animation_cue_get_start_time(vtkNew sself) { return sself->GetStartTime(); } -extern "C" void vtk_animation_cue_set_end_time(vtkNew sself, double _arg) { sself->SetEndTime(_arg); } -extern "C" double vtk_animation_cue_get_end_time(vtkNew sself) { return sself->GetEndTime(); } -extern "C" void vtk_animation_cue_tick(vtkNew sself, double currenttime, double deltatime, double clocktime) { sself->Tick(currenttime, deltatime, clocktime); } -extern "C" void vtk_animation_cue_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_animation_cue_finalize(vtkNew sself) { sself->Finalize(); } -extern "C" double vtk_animation_cue_get_animation_time(vtkNew sself) { return sself->GetAnimationTime(); } -extern "C" double vtk_animation_cue_get_delta_time(vtkNew sself) { return sself->GetDeltaTime(); } -extern "C" double vtk_animation_cue_get_clock_time(vtkNew sself) { return sself->GetClockTime(); } -extern "C" vtkNew < vtkArchiver > vtkArchiver_new () {return vtkNew < vtkArchiver > () ;} -extern "C" void vtkArchiver_destructor (vtkNew < vtkArchiver > sself) {sself . Reset () ; return ;} -extern "C" void * vtkArchiver_get_ptr (vtkNew < vtkArchiver > sself) {return sself . GetPointer () ;} -extern "C" char* vtk_archiver_get_archive_name(vtkNew sself) { return sself->GetArchiveName(); } -extern "C" void vtk_archiver_set_archive_name(vtkNew sself, const char _arg) { sself->SetArchiveName(_arg); } -extern "C" void vtk_archiver_open_archive(vtkNew sself) { sself->OpenArchive(); } -extern "C" void vtk_archiver_close_archive(vtkNew sself) { sself->CloseArchive(); } -extern "C" void vtk_archiver_insert_into_archive(vtkNew sself, const char* relativePath, const char data, size_t size) { sself->InsertIntoArchive(relativePath, data, size); } -extern "C" bool vtk_archiver_contains(vtkNew sself, const char* relativePath) { return sself->Contains(relativePath); } -extern "C" vtkNew < vtkBitArray > vtkBitArray_new () {return vtkNew < vtkBitArray > () ;} -extern "C" void vtkBitArray_destructor (vtkNew < vtkBitArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBitArray_get_ptr (vtkNew < vtkBitArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bit_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } -extern "C" void vtk_bit_array_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_bit_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" int vtk_bit_array_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } -extern "C" void vtk_bit_array_set_number_of_tuples(vtkNew sself, long long number) { sself->SetNumberOfTuples(number); } -extern "C" bool vtk_bit_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" double* vtk_bit_array_get_tuple(vtkNew sself, long long i) { return sself->GetTuple(i); } -extern "C" void vtk_bit_array_get_tuple(vtkNew sself, long long i, double tuple) { sself->GetTuple(i, tuple); } -extern "C" void vtk_bit_array_set_tuple(vtkNew sself, long long i, const float tuple) { sself->SetTuple(i, tuple); } -extern "C" void vtk_bit_array_set_tuple(vtkNew sself, long long i, const double tuple) { sself->SetTuple(i, tuple); } -extern "C" void vtk_bit_array_insert_tuple(vtkNew sself, long long i, const float tuple) { sself->InsertTuple(i, tuple); } -extern "C" void vtk_bit_array_insert_tuple(vtkNew sself, long long i, const double tuple) { sself->InsertTuple(i, tuple); } -extern "C" long long vtk_bit_array_insert_next_tuple(vtkNew sself, const float tuple) { return sself->InsertNextTuple(tuple); } -extern "C" long long vtk_bit_array_insert_next_tuple(vtkNew sself, const double tuple) { return sself->InsertNextTuple(tuple); } -extern "C" void vtk_bit_array_remove_tuple(vtkNew sself, long long id) { sself->RemoveTuple(id); } -extern "C" void vtk_bit_array_set_component(vtkNew sself, long long i, int j, double c) { sself->SetComponent(i, j, c); } -extern "C" void vtk_bit_array_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" int vtk_bit_array_resize(vtkNew sself, long long numTuples) { return sself->Resize(numTuples); } -extern "C" int vtk_bit_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_bit_array_set_value(vtkNew sself, long long id, int value) { sself->SetValue(id, value); } -extern "C" void vtk_bit_array_insert_value(vtkNew sself, long long id, int i) { sself->InsertValue(id, i); } -extern "C" long long vtk_bit_array_insert_next_value(vtkNew sself, int i) { return sself->InsertNextValue(i); } -extern "C" void vtk_bit_array_insert_component(vtkNew sself, long long i, int j, double c) { sself->InsertComponent(i, j, c); } -extern "C" unsigned char* vtk_bit_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" unsigned char* vtk_bit_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" void* vtk_bit_array_write_void_pointer(vtkNew sself, long long id, long long number) { return sself->WriteVoidPointer(id, number); } -extern "C" void* vtk_bit_array_get_void_pointer(vtkNew sself, long long id) { return sself->GetVoidPointer(id); } -extern "C" void vtk_bit_array_set_void_array(vtkNew sself, void array, long long size, int save) { sself->SetVoidArray(array, size, save); } -extern "C" long long vtk_bit_array_lookup_value(vtkNew sself, int value) { return sself->LookupValue(value); } -extern "C" void vtk_bit_array_data_changed(vtkNew sself) { sself->DataChanged(); } -extern "C" void vtk_bit_array_clear_lookup(vtkNew sself) { sself->ClearLookup(); } -extern "C" vtkNew < vtkBitArrayIterator > vtkBitArrayIterator_new () {return vtkNew < vtkBitArrayIterator > () ;} -extern "C" void vtkBitArrayIterator_destructor (vtkNew < vtkBitArrayIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBitArrayIterator_get_ptr (vtkNew < vtkBitArrayIterator > sself) {return sself . GetPointer () ;} -extern "C" int* vtk_bit_array_iterator_get_tuple(vtkNew sself, long long id) { return sself->GetTuple(id); } -extern "C" int vtk_bit_array_iterator_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" long long vtk_bit_array_iterator_get_number_of_tuples(vtkNew sself) { return sself->GetNumberOfTuples(); } -extern "C" long long vtk_bit_array_iterator_get_number_of_values(vtkNew sself) { return sself->GetNumberOfValues(); } -extern "C" int vtk_bit_array_iterator_get_number_of_components(vtkNew sself) { return sself->GetNumberOfComponents(); } -extern "C" int vtk_bit_array_iterator_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" int vtk_bit_array_iterator_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } -extern "C" void vtk_bit_array_iterator_set_value(vtkNew sself, long long id, int value) { sself->SetValue(id, value); } -extern "C" vtkNew < vtkBoxMuellerRandomSequence > vtkBoxMuellerRandomSequence_new () {return vtkNew < vtkBoxMuellerRandomSequence > () ;} -extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkNew < vtkBoxMuellerRandomSequence > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBoxMuellerRandomSequence_get_ptr (vtkNew < vtkBoxMuellerRandomSequence > sself) {return sself . GetPointer () ;} -extern "C" void vtk_box_mueller_random_sequence_initialize(vtkNew sself, unsigned int seed) { sself->Initialize(seed); } -extern "C" double vtk_box_mueller_random_sequence_get_value(vtkNew sself) { return sself->GetValue(); } -extern "C" void vtk_box_mueller_random_sequence_next(vtkNew sself) { sself->Next(); } -extern "C" vtkNew < vtkByteSwap > vtkByteSwap_new () {return vtkNew < vtkByteSwap > () ;} -extern "C" void vtkByteSwap_destructor (vtkNew < vtkByteSwap > sself) {sself . Reset () ; return ;} -extern "C" void * vtkByteSwap_get_ptr (vtkNew < vtkByteSwap > sself) {return sself . GetPointer () ;} -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, float p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, float p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, float p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, float p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, double p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, double p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, double p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, double p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, char p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, char p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, char p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, char p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, short p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, short p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, short p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, short p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, int p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, int p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, int p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, int p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, long p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, long p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, long p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, long p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, long long p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, long long p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, long long p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, long long p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, char p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, char p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, char p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, char p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned char p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned char p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned char p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned char p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned short p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned short p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned short p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned short p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned int p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned int p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned int p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned int p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned long p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned long p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned long p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned long p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_le(vtkNew sself, unsigned long long p) { sself->SwapLE(p); } -extern "C" void vtk_byte_swap_swap_be(vtkNew sself, unsigned long long p) { sself->SwapBE(p); } -extern "C" void vtk_byte_swap_swap_le_range(vtkNew sself, unsigned long long p, size_t num) { sself->SwapLERange(p, num); } -extern "C" void vtk_byte_swap_swap_be_range(vtkNew sself, unsigned long long p, size_t num) { sself->SwapBERange(p, num); } -extern "C" void vtk_byte_swap_swap_2_le(vtkNew sself, void p) { sself->Swap2LE(p); } -extern "C" void vtk_byte_swap_swap_4_le(vtkNew sself, void p) { sself->Swap4LE(p); } -extern "C" void vtk_byte_swap_swap_8_le(vtkNew sself, void p) { sself->Swap8LE(p); } -extern "C" void vtk_byte_swap_swap_2_le_range(vtkNew sself, void p, size_t num) { sself->Swap2LERange(p, num); } -extern "C" void vtk_byte_swap_swap_4_le_range(vtkNew sself, void p, size_t num) { sself->Swap4LERange(p, num); } -extern "C" void vtk_byte_swap_swap_8_le_range(vtkNew sself, void p, size_t num) { sself->Swap8LERange(p, num); } -extern "C" void vtk_byte_swap_swap_2_be(vtkNew sself, void p) { sself->Swap2BE(p); } -extern "C" void vtk_byte_swap_swap_4_be(vtkNew sself, void p) { sself->Swap4BE(p); } -extern "C" void vtk_byte_swap_swap_8_be(vtkNew sself, void p) { sself->Swap8BE(p); } -extern "C" void vtk_byte_swap_swap_2_be_range(vtkNew sself, void p, size_t num) { sself->Swap2BERange(p, num); } -extern "C" void vtk_byte_swap_swap_4_be_range(vtkNew sself, void p, size_t num) { sself->Swap4BERange(p, num); } -extern "C" void vtk_byte_swap_swap_8_be_range(vtkNew sself, void p, size_t num) { sself->Swap8BERange(p, num); } -extern "C" void vtk_byte_swap_swap_void_range(vtkNew sself, void buffer, size_t numWords, size_t wordSize) { sself->SwapVoidRange(buffer, numWords, wordSize); } -extern "C" vtkNew < vtkCallbackCommand > vtkCallbackCommand_new () {return vtkNew < vtkCallbackCommand > () ;} -extern "C" void vtkCallbackCommand_destructor (vtkNew < vtkCallbackCommand > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCallbackCommand_get_ptr (vtkNew < vtkCallbackCommand > sself) {return sself . GetPointer () ;} -extern "C" void vtk_callback_command_set_client_data(vtkNew sself, void cd) { sself->SetClientData(cd); } -extern "C" void* vtk_callback_command_get_client_data(vtkNew sself) { return sself->GetClientData(); } -extern "C" void vtk_callback_command_set_abort_flag_on_execute(vtkNew sself, int f) { sself->SetAbortFlagOnExecute(f); } -extern "C" int vtk_callback_command_get_abort_flag_on_execute(vtkNew sself) { return sself->GetAbortFlagOnExecute(); } -extern "C" void vtk_callback_command_abort_flag_on_execute_on(vtkNew sself) { sself->AbortFlagOnExecuteOn(); } -extern "C" void vtk_callback_command_abort_flag_on_execute_off(vtkNew sself) { sself->AbortFlagOnExecuteOff(); } -extern "C" vtkNew < vtkCharArray > vtkCharArray_new () {return vtkNew < vtkCharArray > () ;} -extern "C" void vtkCharArray_destructor (vtkNew < vtkCharArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCharArray_get_ptr (vtkNew < vtkCharArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_char_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_char_array_get_typed_tuple(vtkNew sself, long long i, char tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_char_array_set_typed_tuple(vtkNew sself, long long i, const char tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_char_array_insert_typed_tuple(vtkNew sself, long long i, const char tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_char_array_insert_next_typed_tuple(vtkNew sself, const char tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" char vtk_char_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_char_array_set_value(vtkNew sself, long long id, char value) { sself->SetValue(id, value); } -extern "C" bool vtk_char_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_char_array_insert_value(vtkNew sself, long long id, char f) { sself->InsertValue(id, f); } -extern "C" long long vtk_char_array_insert_next_value(vtkNew sself, char f) { return sself->InsertNextValue(f); } -extern "C" char* vtk_char_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" char* vtk_char_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" char* vtk_char_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" char* vtk_char_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_char_array_set_array(vtkNew sself, char array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_char_array_set_array(vtkNew sself, char array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" char vtk_char_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" char vtk_char_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkCollection > vtkCollection_new () {return vtkNew < vtkCollection > () ;} -extern "C" void vtkCollection_destructor (vtkNew < vtkCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCollection_get_ptr (vtkNew < vtkCollection > sself) {return sself . GetPointer () ;} -extern "C" void vtk_collection_remove_item(vtkNew sself, int i) { sself->RemoveItem(i); } -extern "C" void vtk_collection_remove_all_items(vtkNew sself) { sself->RemoveAllItems(); } -extern "C" int vtk_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } -extern "C" void vtk_collection_init_traversal(vtkNew sself) { sself->InitTraversal(); } -extern "C" void vtk_collection_init_traversal(vtkNew sself, void cookie) { sself->InitTraversal(cookie); } -extern "C" vtkNew < vtkCollectionIterator > vtkCollectionIterator_new () {return vtkNew < vtkCollectionIterator > () ;} -extern "C" void vtkCollectionIterator_destructor (vtkNew < vtkCollectionIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCollectionIterator_get_ptr (vtkNew < vtkCollectionIterator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_collection_iterator_init_traversal(vtkNew sself) { sself->InitTraversal(); } -extern "C" void vtk_collection_iterator_go_to_first_item(vtkNew sself) { sself->GoToFirstItem(); } -extern "C" void vtk_collection_iterator_go_to_next_item(vtkNew sself) { sself->GoToNextItem(); } -extern "C" int vtk_collection_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } -extern "C" vtkNew < vtkCriticalSection > vtkCriticalSection_new () {return vtkNew < vtkCriticalSection > () ;} -extern "C" void vtkCriticalSection_destructor (vtkNew < vtkCriticalSection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCriticalSection_get_ptr (vtkNew < vtkCriticalSection > sself) {return sself . GetPointer () ;} -extern "C" void vtk_critical_section_lock(vtkNew sself) { sself->Lock(); } -extern "C" void vtk_critical_section_unlock(vtkNew sself) { sself->Unlock(); } -extern "C" vtkNew < vtkDataArrayCollection > vtkDataArrayCollection_new () {return vtkNew < vtkDataArrayCollection > () ;} -extern "C" void vtkDataArrayCollection_destructor (vtkNew < vtkDataArrayCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataArrayCollection_get_ptr (vtkNew < vtkDataArrayCollection > sself) {return sself . GetPointer () ;} -extern "C" int vtk_data_array_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } -extern "C" vtkNew < vtkDataArrayCollectionIterator > vtkDataArrayCollectionIterator_new () {return vtkNew < vtkDataArrayCollectionIterator > () ;} -extern "C" void vtkDataArrayCollectionIterator_destructor (vtkNew < vtkDataArrayCollectionIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataArrayCollectionIterator_get_ptr (vtkNew < vtkDataArrayCollectionIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataArraySelection > vtkDataArraySelection_new () {return vtkNew < vtkDataArraySelection > () ;} -extern "C" void vtkDataArraySelection_destructor (vtkNew < vtkDataArraySelection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataArraySelection_get_ptr (vtkNew < vtkDataArraySelection > sself) {return sself . GetPointer () ;} -extern "C" void vtk_data_array_selection_enable_array(vtkNew sself, const char name) { sself->EnableArray(name); } -extern "C" void vtk_data_array_selection_disable_array(vtkNew sself, const char name) { sself->DisableArray(name); } -extern "C" int vtk_data_array_selection_array_is_enabled(vtkNew sself, const char name) { return sself->ArrayIsEnabled(name); } -extern "C" int vtk_data_array_selection_array_exists(vtkNew sself, const char name) { return sself->ArrayExists(name); } -extern "C" void vtk_data_array_selection_enable_all_arrays(vtkNew sself) { sself->EnableAllArrays(); } -extern "C" void vtk_data_array_selection_disable_all_arrays(vtkNew sself) { sself->DisableAllArrays(); } -extern "C" int vtk_data_array_selection_get_number_of_arrays(vtkNew sself) { return sself->GetNumberOfArrays(); } -extern "C" int vtk_data_array_selection_get_number_of_arrays_enabled(vtkNew sself) { return sself->GetNumberOfArraysEnabled(); } -extern "C" const char* vtk_data_array_selection_get_array_name(vtkNew sself, int index) { return sself->GetArrayName(index); } -extern "C" int vtk_data_array_selection_get_array_index(vtkNew sself, const char name) { return sself->GetArrayIndex(name); } -extern "C" int vtk_data_array_selection_get_enabled_array_index(vtkNew sself, const char name) { return sself->GetEnabledArrayIndex(name); } -extern "C" int vtk_data_array_selection_get_array_setting(vtkNew sself, int index) { return sself->GetArraySetting(index); } -extern "C" int vtk_data_array_selection_get_array_setting(vtkNew sself, const char name) { return sself->GetArraySetting(name); } -extern "C" void vtk_data_array_selection_set_array_setting(vtkNew sself, const char name, int setting) { sself->SetArraySetting(name, setting); } -extern "C" void vtk_data_array_selection_remove_all_arrays(vtkNew sself) { sself->RemoveAllArrays(); } -extern "C" int vtk_data_array_selection_add_array(vtkNew sself, const char name, bool state) { return sself->AddArray(name, state); } -extern "C" void vtk_data_array_selection_remove_array_by_index(vtkNew sself, int index) { sself->RemoveArrayByIndex(index); } -extern "C" void vtk_data_array_selection_remove_array_by_name(vtkNew sself, const char name) { sself->RemoveArrayByName(name); } -extern "C" void vtk_data_array_selection_set_arrays(vtkNew sself, const char names, int numArrays) { sself->SetArrays(names, numArrays); } -extern "C" void vtk_data_array_selection_set_arrays_with_default(vtkNew sself, const char names, int numArrays, int defaultStatus) { sself->SetArraysWithDefault(names, numArrays, defaultStatus); } -extern "C" void vtk_data_array_selection_set_unknown_array_setting(vtkNew sself, int _arg) { sself->SetUnknownArraySetting(_arg); } -extern "C" int vtk_data_array_selection_get_unknown_array_setting(vtkNew sself) { return sself->GetUnknownArraySetting(); } -extern "C" vtkNew < vtkDebugLeaks > vtkDebugLeaks_new () {return vtkNew < vtkDebugLeaks > () ;} -extern "C" void vtkDebugLeaks_destructor (vtkNew < vtkDebugLeaks > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDebugLeaks_get_ptr (vtkNew < vtkDebugLeaks > sself) {return sself . GetPointer () ;} -extern "C" void vtk_debug_leaks_construct_class(vtkNew sself, const char className) { sself->ConstructClass(className); } -extern "C" void vtk_debug_leaks_destruct_class(vtkNew sself, const char className) { sself->DestructClass(className); } -extern "C" int vtk_debug_leaks_print_current_leaks(vtkNew sself) { return sself->PrintCurrentLeaks(); } -extern "C" int vtk_debug_leaks_get_exit_error(vtkNew sself) { return sself->GetExitError(); } -extern "C" void vtk_debug_leaks_set_exit_error(vtkNew sself, int p0) { sself->SetExitError(p0); } -extern "C" vtkNew < vtkDoubleArray > vtkDoubleArray_new () {return vtkNew < vtkDoubleArray > () ;} -extern "C" void vtkDoubleArray_destructor (vtkNew < vtkDoubleArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDoubleArray_get_ptr (vtkNew < vtkDoubleArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_double_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_double_array_get_typed_tuple(vtkNew sself, long long i, double tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_double_array_set_typed_tuple(vtkNew sself, long long i, const double tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_double_array_insert_typed_tuple(vtkNew sself, long long i, const double tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_double_array_insert_next_typed_tuple(vtkNew sself, const double tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" double vtk_double_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_double_array_set_value(vtkNew sself, long long id, double value) { sself->SetValue(id, value); } -extern "C" bool vtk_double_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_double_array_insert_value(vtkNew sself, long long id, double f) { sself->InsertValue(id, f); } -extern "C" long long vtk_double_array_insert_next_value(vtkNew sself, double f) { return sself->InsertNextValue(f); } -extern "C" double* vtk_double_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" double* vtk_double_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" double* vtk_double_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" double* vtk_double_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_double_array_set_array(vtkNew sself, double array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_double_array_set_array(vtkNew sself, double array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" double vtk_double_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" double vtk_double_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkDynamicLoader > vtkDynamicLoader_new () {return vtkNew < vtkDynamicLoader > () ;} -extern "C" void vtkDynamicLoader_destructor (vtkNew < vtkDynamicLoader > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDynamicLoader_get_ptr (vtkNew < vtkDynamicLoader > sself) {return sself . GetPointer () ;} -extern "C" const char* vtk_dynamic_loader_lib_prefix(vtkNew sself) { return sself->LibPrefix(); } -extern "C" const char* vtk_dynamic_loader_lib_extension(vtkNew sself) { return sself->LibExtension(); } -extern "C" const char* vtk_dynamic_loader_last_error(vtkNew sself) { return sself->LastError(); } -extern "C" vtkNew < vtkEventDataDevice3D > vtkEventDataDevice3D_new () {return vtkNew < vtkEventDataDevice3D > () ;} -extern "C" void vtkEventDataDevice3D_destructor (vtkNew < vtkEventDataDevice3D > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEventDataDevice3D_get_ptr (vtkNew < vtkEventDataDevice3D > sself) {return sself . GetPointer () ;} -extern "C" void vtk_event_data_device_3_d_get_world_position(vtkNew sself, double v) { sself->GetWorldPosition(v); } -extern "C" const double* vtk_event_data_device_3_d_get_world_position(vtkNew sself) { return sself->GetWorldPosition(); } -extern "C" void vtk_event_data_device_3_d_set_world_position(vtkNew sself, const double p) { sself->SetWorldPosition(p); } -extern "C" void vtk_event_data_device_3_d_get_world_direction(vtkNew sself, double v) { sself->GetWorldDirection(v); } -extern "C" const double* vtk_event_data_device_3_d_get_world_direction(vtkNew sself) { return sself->GetWorldDirection(); } -extern "C" void vtk_event_data_device_3_d_set_world_direction(vtkNew sself, const double p) { sself->SetWorldDirection(p); } -extern "C" void vtk_event_data_device_3_d_get_world_orientation(vtkNew sself, double v) { sself->GetWorldOrientation(v); } -extern "C" const double* vtk_event_data_device_3_d_get_world_orientation(vtkNew sself) { return sself->GetWorldOrientation(); } -extern "C" void vtk_event_data_device_3_d_set_world_orientation(vtkNew sself, const double p) { sself->SetWorldOrientation(p); } -extern "C" void vtk_event_data_device_3_d_get_track_pad_position(vtkNew sself, double v) { sself->GetTrackPadPosition(v); } -extern "C" const double* vtk_event_data_device_3_d_get_track_pad_position(vtkNew sself) { return sself->GetTrackPadPosition(); } -extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkNew sself, const double p) { sself->SetTrackPadPosition(p); } -extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkNew sself, double x, double y) { sself->SetTrackPadPosition(x, y); } -extern "C" vtkNew < vtkEventDataForDevice > vtkEventDataForDevice_new () {return vtkNew < vtkEventDataForDevice > () ;} -extern "C" void vtkEventDataForDevice_destructor (vtkNew < vtkEventDataForDevice > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEventDataForDevice_get_ptr (vtkNew < vtkEventDataForDevice > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkEventForwarderCommand > vtkEventForwarderCommand_new () {return vtkNew < vtkEventForwarderCommand > () ;} -extern "C" void vtkEventForwarderCommand_destructor (vtkNew < vtkEventForwarderCommand > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEventForwarderCommand_get_ptr (vtkNew < vtkEventForwarderCommand > sself) {return sself . GetPointer () ;} -extern "C" void* vtk_event_forwarder_command_get_target(vtkNew sself) { return sself->GetTarget(); } -extern "C" vtkNew < vtkFileOutputWindow > vtkFileOutputWindow_new () {return vtkNew < vtkFileOutputWindow > () ;} -extern "C" void vtkFileOutputWindow_destructor (vtkNew < vtkFileOutputWindow > sself) {sself . Reset () ; return ;} -extern "C" void * vtkFileOutputWindow_get_ptr (vtkNew < vtkFileOutputWindow > sself) {return sself . GetPointer () ;} -extern "C" void vtk_file_output_window_display_text(vtkNew sself, const char p0) { sself->DisplayText(p0); } -extern "C" void vtk_file_output_window_set_file_name(vtkNew sself, const char _arg) { sself->SetFileName(_arg); } -extern "C" char* vtk_file_output_window_get_file_name(vtkNew sself) { return sself->GetFileName(); } -extern "C" void vtk_file_output_window_set_flush(vtkNew sself, int _arg) { sself->SetFlush(_arg); } -extern "C" int vtk_file_output_window_get_flush(vtkNew sself) { return sself->GetFlush(); } -extern "C" void vtk_file_output_window_flush_on(vtkNew sself) { sself->FlushOn(); } -extern "C" void vtk_file_output_window_flush_off(vtkNew sself) { sself->FlushOff(); } -extern "C" void vtk_file_output_window_set_append(vtkNew sself, int _arg) { sself->SetAppend(_arg); } -extern "C" int vtk_file_output_window_get_append(vtkNew sself) { return sself->GetAppend(); } -extern "C" void vtk_file_output_window_append_on(vtkNew sself) { sself->AppendOn(); } -extern "C" void vtk_file_output_window_append_off(vtkNew sself) { sself->AppendOff(); } -extern "C" vtkNew < vtkFloatArray > vtkFloatArray_new () {return vtkNew < vtkFloatArray > () ;} -extern "C" void vtkFloatArray_destructor (vtkNew < vtkFloatArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkFloatArray_get_ptr (vtkNew < vtkFloatArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_float_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_float_array_get_typed_tuple(vtkNew sself, long long i, float tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_float_array_set_typed_tuple(vtkNew sself, long long i, const float tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_float_array_insert_typed_tuple(vtkNew sself, long long i, const float tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_float_array_insert_next_typed_tuple(vtkNew sself, const float tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" float vtk_float_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_float_array_set_value(vtkNew sself, long long id, float value) { sself->SetValue(id, value); } -extern "C" bool vtk_float_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_float_array_insert_value(vtkNew sself, long long id, float f) { sself->InsertValue(id, f); } -extern "C" long long vtk_float_array_insert_next_value(vtkNew sself, float f) { return sself->InsertNextValue(f); } -extern "C" float* vtk_float_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" float* vtk_float_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" float* vtk_float_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" float* vtk_float_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_float_array_set_array(vtkNew sself, float array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_float_array_set_array(vtkNew sself, float array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" float vtk_float_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" float vtk_float_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkGarbageCollector > vtkGarbageCollector_new () {return vtkNew < vtkGarbageCollector > () ;} -extern "C" void vtkGarbageCollector_destructor (vtkNew < vtkGarbageCollector > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGarbageCollector_get_ptr (vtkNew < vtkGarbageCollector > sself) {return sself . GetPointer () ;} -extern "C" void vtk_garbage_collector_collect(vtkNew sself) { sself->Collect(); } -extern "C" void vtk_garbage_collector_deferred_collection_push(vtkNew sself) { sself->DeferredCollectionPush(); } -extern "C" void vtk_garbage_collector_deferred_collection_pop(vtkNew sself) { sself->DeferredCollectionPop(); } -extern "C" void vtk_garbage_collector_set_global_debug_flag(vtkNew sself, bool flag) { sself->SetGlobalDebugFlag(flag); } -extern "C" bool vtk_garbage_collector_get_global_debug_flag(vtkNew sself) { return sself->GetGlobalDebugFlag(); } -extern "C" vtkNew < vtkIdList > vtkIdList_new () {return vtkNew < vtkIdList > () ;} -extern "C" void vtkIdList_destructor (vtkNew < vtkIdList > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIdList_get_ptr (vtkNew < vtkIdList > sself) {return sself . GetPointer () ;} -extern "C" void vtk_id_list_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_id_list_allocate(vtkNew sself, const long long sz, const int strategy) { return sself->Allocate(sz, strategy); } -extern "C" long long vtk_id_list_get_number_of_ids(vtkNew sself) { return sself->GetNumberOfIds(); } -extern "C" long long vtk_id_list_get_id(vtkNew sself, const long long i) { return sself->GetId(i); } -extern "C" long long vtk_id_list_find_id_location(vtkNew sself, const long long id) { return sself->FindIdLocation(id); } -extern "C" void vtk_id_list_set_number_of_ids(vtkNew sself, const long long number) { sself->SetNumberOfIds(number); } -extern "C" void vtk_id_list_set_id(vtkNew sself, const long long i, const long long vtkid) { sself->SetId(i, vtkid); } -extern "C" void vtk_id_list_insert_id(vtkNew sself, const long long i, const long long vtkid) { sself->InsertId(i, vtkid); } -extern "C" long long vtk_id_list_insert_next_id(vtkNew sself, const long long vtkid) { return sself->InsertNextId(vtkid); } -extern "C" long long vtk_id_list_insert_unique_id(vtkNew sself, const long long vtkid) { return sself->InsertUniqueId(vtkid); } -extern "C" void vtk_id_list_sort(vtkNew sself) { sself->Sort(); } -extern "C" void vtk_id_list_fill(vtkNew sself, long long value) { sself->Fill(value); } -extern "C" long long* vtk_id_list_get_pointer(vtkNew sself, const long long i) { return sself->GetPointer(i); } -extern "C" long long* vtk_id_list_write_pointer(vtkNew sself, const long long i, const long long number) { return sself->WritePointer(i, number); } -extern "C" void vtk_id_list_set_array(vtkNew sself, long long array, long long size) { sself->SetArray(array, size); } -extern "C" void vtk_id_list_reset(vtkNew sself) { sself->Reset(); } -extern "C" void vtk_id_list_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" void vtk_id_list_delete_id(vtkNew sself, long long vtkid) { sself->DeleteId(vtkid); } -extern "C" long long vtk_id_list_is_id(vtkNew sself, long long vtkid) { return sself->IsId(vtkid); } -extern "C" long long* vtk_id_list_resize(vtkNew sself, const long long sz) { return sself->Resize(sz); } -extern "C" long long* vtk_id_list_begin(vtkNew sself) { return sself->begin(); } -extern "C" long long* vtk_id_list_end(vtkNew sself) { return sself->end(); } -extern "C" const long long* vtk_id_list_begin(vtkNew sself) { return sself->begin(); } -extern "C" const long long* vtk_id_list_end(vtkNew sself) { return sself->end(); } -extern "C" vtkNew < vtkIdListCollection > vtkIdListCollection_new () {return vtkNew < vtkIdListCollection > () ;} -extern "C" void vtkIdListCollection_destructor (vtkNew < vtkIdListCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIdListCollection_get_ptr (vtkNew < vtkIdListCollection > sself) {return sself . GetPointer () ;} -extern "C" int vtk_id_list_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } -extern "C" vtkNew < vtkIdTypeArray > vtkIdTypeArray_new () {return vtkNew < vtkIdTypeArray > () ;} -extern "C" void vtkIdTypeArray_destructor (vtkNew < vtkIdTypeArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIdTypeArray_get_ptr (vtkNew < vtkIdTypeArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_id_type_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_id_type_array_get_typed_tuple(vtkNew sself, long long i, long long tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_id_type_array_set_typed_tuple(vtkNew sself, long long i, const long long tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_id_type_array_insert_typed_tuple(vtkNew sself, long long i, const long long tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_id_type_array_insert_next_typed_tuple(vtkNew sself, const long long tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" long long vtk_id_type_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_id_type_array_set_value(vtkNew sself, long long id, long long value) { sself->SetValue(id, value); } -extern "C" bool vtk_id_type_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_id_type_array_insert_value(vtkNew sself, long long id, long long f) { sself->InsertValue(id, f); } -extern "C" long long vtk_id_type_array_insert_next_value(vtkNew sself, long long f) { return sself->InsertNextValue(f); } -extern "C" long long* vtk_id_type_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" long long* vtk_id_type_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" long long* vtk_id_type_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" long long* vtk_id_type_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_id_type_array_set_array(vtkNew sself, long long array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_id_type_array_set_array(vtkNew sself, long long array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" long long vtk_id_type_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" long long vtk_id_type_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkInformation > vtkInformation_new () {return vtkNew < vtkInformation > () ;} -extern "C" void vtkInformation_destructor (vtkNew < vtkInformation > sself) {sself . Reset () ; return ;} -extern "C" void * vtkInformation_get_ptr (vtkNew < vtkInformation > sself) {return sself . GetPointer () ;} -extern "C" void vtk_information_modified(vtkNew sself) { sself->Modified(); } -extern "C" void vtk_information_clear(vtkNew sself) { sself->Clear(); } -extern "C" int vtk_information_get_number_of_keys(vtkNew sself) { return sself->GetNumberOfKeys(); } -extern "C" vtkNew < vtkInformationIterator > vtkInformationIterator_new () {return vtkNew < vtkInformationIterator > () ;} -extern "C" void vtkInformationIterator_destructor (vtkNew < vtkInformationIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkInformationIterator_get_ptr (vtkNew < vtkInformationIterator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_information_iterator_init_traversal(vtkNew sself) { sself->InitTraversal(); } -extern "C" void vtk_information_iterator_go_to_first_item(vtkNew sself) { sself->GoToFirstItem(); } -extern "C" void vtk_information_iterator_go_to_next_item(vtkNew sself) { sself->GoToNextItem(); } -extern "C" int vtk_information_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } -extern "C" vtkNew < vtkInformationKeyLookup > vtkInformationKeyLookup_new () {return vtkNew < vtkInformationKeyLookup > () ;} -extern "C" void vtkInformationKeyLookup_destructor (vtkNew < vtkInformationKeyLookup > sself) {sself . Reset () ; return ;} -extern "C" void * vtkInformationKeyLookup_get_ptr (vtkNew < vtkInformationKeyLookup > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkInformationVector > vtkInformationVector_new () {return vtkNew < vtkInformationVector > () ;} -extern "C" void vtkInformationVector_destructor (vtkNew < vtkInformationVector > sself) {sself . Reset () ; return ;} -extern "C" void * vtkInformationVector_get_ptr (vtkNew < vtkInformationVector > sself) {return sself . GetPointer () ;} -extern "C" int vtk_information_vector_get_number_of_information_objects(vtkNew sself) { return sself->GetNumberOfInformationObjects(); } -extern "C" void vtk_information_vector_set_number_of_information_objects(vtkNew sself, int n) { sself->SetNumberOfInformationObjects(n); } -extern "C" void vtk_information_vector_remove(vtkNew sself, int idx) { sself->Remove(idx); } -extern "C" vtkNew < vtkIntArray > vtkIntArray_new () {return vtkNew < vtkIntArray > () ;} -extern "C" void vtkIntArray_destructor (vtkNew < vtkIntArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIntArray_get_ptr (vtkNew < vtkIntArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_int_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_int_array_get_typed_tuple(vtkNew sself, long long i, int tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_int_array_set_typed_tuple(vtkNew sself, long long i, const int tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_int_array_insert_typed_tuple(vtkNew sself, long long i, const int tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_int_array_insert_next_typed_tuple(vtkNew sself, const int tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" int vtk_int_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_int_array_set_value(vtkNew sself, long long id, int value) { sself->SetValue(id, value); } -extern "C" bool vtk_int_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_int_array_insert_value(vtkNew sself, long long id, int f) { sself->InsertValue(id, f); } -extern "C" long long vtk_int_array_insert_next_value(vtkNew sself, int f) { return sself->InsertNextValue(f); } -extern "C" int* vtk_int_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" int* vtk_int_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" int* vtk_int_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" int* vtk_int_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_int_array_set_array(vtkNew sself, int array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_int_array_set_array(vtkNew sself, int array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" int vtk_int_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" int vtk_int_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkLongArray > vtkLongArray_new () {return vtkNew < vtkLongArray > () ;} -extern "C" void vtkLongArray_destructor (vtkNew < vtkLongArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLongArray_get_ptr (vtkNew < vtkLongArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_long_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_long_array_get_typed_tuple(vtkNew sself, long long i, long tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_long_array_set_typed_tuple(vtkNew sself, long long i, const long tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_long_array_insert_typed_tuple(vtkNew sself, long long i, const long tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_long_array_insert_next_typed_tuple(vtkNew sself, const long tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" long vtk_long_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_long_array_set_value(vtkNew sself, long long id, long value) { sself->SetValue(id, value); } -extern "C" bool vtk_long_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_long_array_insert_value(vtkNew sself, long long id, long f) { sself->InsertValue(id, f); } -extern "C" long long vtk_long_array_insert_next_value(vtkNew sself, long f) { return sself->InsertNextValue(f); } -extern "C" long* vtk_long_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" long* vtk_long_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" long* vtk_long_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" long* vtk_long_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_long_array_set_array(vtkNew sself, long array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_long_array_set_array(vtkNew sself, long array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" long vtk_long_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" long vtk_long_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkLongLongArray > vtkLongLongArray_new () {return vtkNew < vtkLongLongArray > () ;} -extern "C" void vtkLongLongArray_destructor (vtkNew < vtkLongLongArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLongLongArray_get_ptr (vtkNew < vtkLongLongArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_long_long_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_long_long_array_get_typed_tuple(vtkNew sself, long long i, long long tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_long_long_array_set_typed_tuple(vtkNew sself, long long i, const long long tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_long_long_array_insert_typed_tuple(vtkNew sself, long long i, const long long tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_long_long_array_insert_next_typed_tuple(vtkNew sself, const long long tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" long long vtk_long_long_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_long_long_array_set_value(vtkNew sself, long long id, long long value) { sself->SetValue(id, value); } -extern "C" bool vtk_long_long_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_long_long_array_insert_value(vtkNew sself, long long id, long long f) { sself->InsertValue(id, f); } -extern "C" long long vtk_long_long_array_insert_next_value(vtkNew sself, long long f) { return sself->InsertNextValue(f); } -extern "C" long long* vtk_long_long_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" long long* vtk_long_long_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" long long* vtk_long_long_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" long long* vtk_long_long_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_long_long_array_set_array(vtkNew sself, long long array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_long_long_array_set_array(vtkNew sself, long long array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" long long vtk_long_long_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" long long vtk_long_long_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkLookupTable > vtkLookupTable_new () {return vtkNew < vtkLookupTable > () ;} -extern "C" void vtkLookupTable_destructor (vtkNew < vtkLookupTable > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLookupTable_get_ptr (vtkNew < vtkLookupTable > sself) {return sself . GetPointer () ;} -extern "C" int vtk_lookup_table_is_opaque(vtkNew sself) { return sself->IsOpaque(); } -extern "C" int vtk_lookup_table_allocate(vtkNew sself, int sz, int ext) { return sself->Allocate(sz, ext); } -extern "C" void vtk_lookup_table_build(vtkNew sself) { sself->Build(); } -extern "C" void vtk_lookup_table_force_build(vtkNew sself) { sself->ForceBuild(); } -extern "C" void vtk_lookup_table_build_special_colors(vtkNew sself) { sself->BuildSpecialColors(); } -extern "C" void vtk_lookup_table_set_ramp(vtkNew sself, int _arg) { sself->SetRamp(_arg); } -extern "C" void vtk_lookup_table_set_ramp_to_linear(vtkNew sself) { sself->SetRampToLinear(); } -extern "C" void vtk_lookup_table_set_ramp_to_s_curve(vtkNew sself) { sself->SetRampToSCurve(); } -extern "C" void vtk_lookup_table_set_ramp_to_sqrt(vtkNew sself) { sself->SetRampToSQRT(); } -extern "C" int vtk_lookup_table_get_ramp(vtkNew sself) { return sself->GetRamp(); } -extern "C" void vtk_lookup_table_set_scale(vtkNew sself, int scale) { sself->SetScale(scale); } -extern "C" void vtk_lookup_table_set_scale_to_linear(vtkNew sself) { sself->SetScaleToLinear(); } -extern "C" void vtk_lookup_table_set_scale_to_log_10(vtkNew sself) { sself->SetScaleToLog10(); } -extern "C" int vtk_lookup_table_get_scale(vtkNew sself) { return sself->GetScale(); } -extern "C" void vtk_lookup_table_set_table_range(vtkNew sself, const double r) { sself->SetTableRange(r); } -extern "C" void vtk_lookup_table_set_table_range(vtkNew sself, double min, double max) { sself->SetTableRange(min, max); } -extern "C" double* vtk_lookup_table_get_table_range(vtkNew sself) { return sself->GetTableRange(); } -extern "C" void vtk_lookup_table_get_table_range(vtkNew sself, double data) { sself->GetTableRange(data); } -extern "C" void vtk_lookup_table_set_hue_range(vtkNew sself, double _arg1, double _arg2) { sself->SetHueRange(_arg1, _arg2); } -extern "C" void vtk_lookup_table_set_hue_range(vtkNew sself, const double _arg) { sself->SetHueRange(_arg); } -extern "C" double* vtk_lookup_table_get_hue_range(vtkNew sself) { return sself->GetHueRange(); } -extern "C" void vtk_lookup_table_get_hue_range(vtkNew sself, double _arg1, double _arg2) { sself->GetHueRange(_arg1, _arg2); } -extern "C" void vtk_lookup_table_get_hue_range(vtkNew sself, double _arg) { sself->GetHueRange(_arg); } -extern "C" void vtk_lookup_table_set_saturation_range(vtkNew sself, double _arg1, double _arg2) { sself->SetSaturationRange(_arg1, _arg2); } -extern "C" void vtk_lookup_table_set_saturation_range(vtkNew sself, const double _arg) { sself->SetSaturationRange(_arg); } -extern "C" double* vtk_lookup_table_get_saturation_range(vtkNew sself) { return sself->GetSaturationRange(); } -extern "C" void vtk_lookup_table_get_saturation_range(vtkNew sself, double _arg1, double _arg2) { sself->GetSaturationRange(_arg1, _arg2); } -extern "C" void vtk_lookup_table_get_saturation_range(vtkNew sself, double _arg) { sself->GetSaturationRange(_arg); } -extern "C" void vtk_lookup_table_set_value_range(vtkNew sself, double _arg1, double _arg2) { sself->SetValueRange(_arg1, _arg2); } -extern "C" void vtk_lookup_table_set_value_range(vtkNew sself, const double _arg) { sself->SetValueRange(_arg); } -extern "C" double* vtk_lookup_table_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" void vtk_lookup_table_get_value_range(vtkNew sself, double _arg1, double _arg2) { sself->GetValueRange(_arg1, _arg2); } -extern "C" void vtk_lookup_table_get_value_range(vtkNew sself, double _arg) { sself->GetValueRange(_arg); } -extern "C" void vtk_lookup_table_set_alpha_range(vtkNew sself, double _arg1, double _arg2) { sself->SetAlphaRange(_arg1, _arg2); } -extern "C" void vtk_lookup_table_set_alpha_range(vtkNew sself, const double _arg) { sself->SetAlphaRange(_arg); } -extern "C" double* vtk_lookup_table_get_alpha_range(vtkNew sself) { return sself->GetAlphaRange(); } -extern "C" void vtk_lookup_table_get_alpha_range(vtkNew sself, double _arg1, double _arg2) { sself->GetAlphaRange(_arg1, _arg2); } -extern "C" void vtk_lookup_table_get_alpha_range(vtkNew sself, double _arg) { sself->GetAlphaRange(_arg); } -extern "C" void vtk_lookup_table_set_nan_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetNanColor(_arg1, _arg2, _arg3, _arg4); } -extern "C" void vtk_lookup_table_set_nan_color(vtkNew sself, const double _arg) { sself->SetNanColor(_arg); } -extern "C" double* vtk_lookup_table_get_nan_color(vtkNew sself) { return sself->GetNanColor(); } -extern "C" void vtk_lookup_table_get_nan_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->GetNanColor(_arg1, _arg2, _arg3, _arg4); } -extern "C" void vtk_lookup_table_get_nan_color(vtkNew sself, double _arg) { sself->GetNanColor(_arg); } -extern "C" unsigned char* vtk_lookup_table_get_nan_color_as_unsigned_chars(vtkNew sself) { return sself->GetNanColorAsUnsignedChars(); } -extern "C" void vtk_lookup_table_get_color_as_unsigned_chars(vtkNew sself, const double colorIn, unsigned char colorOut) { sself->GetColorAsUnsignedChars(colorIn, colorOut); } -extern "C" void vtk_lookup_table_set_below_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetBelowRangeColor(_arg1, _arg2, _arg3, _arg4); } -extern "C" void vtk_lookup_table_set_below_range_color(vtkNew sself, const double _arg) { sself->SetBelowRangeColor(_arg); } -extern "C" double* vtk_lookup_table_get_below_range_color(vtkNew sself) { return sself->GetBelowRangeColor(); } -extern "C" void vtk_lookup_table_get_below_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->GetBelowRangeColor(_arg1, _arg2, _arg3, _arg4); } -extern "C" void vtk_lookup_table_get_below_range_color(vtkNew sself, double _arg) { sself->GetBelowRangeColor(_arg); } -extern "C" void vtk_lookup_table_set_use_below_range_color(vtkNew sself, int _arg) { sself->SetUseBelowRangeColor(_arg); } -extern "C" int vtk_lookup_table_get_use_below_range_color(vtkNew sself) { return sself->GetUseBelowRangeColor(); } -extern "C" void vtk_lookup_table_use_below_range_color_on(vtkNew sself) { sself->UseBelowRangeColorOn(); } -extern "C" void vtk_lookup_table_use_below_range_color_off(vtkNew sself) { sself->UseBelowRangeColorOff(); } -extern "C" void vtk_lookup_table_set_above_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetAboveRangeColor(_arg1, _arg2, _arg3, _arg4); } -extern "C" void vtk_lookup_table_set_above_range_color(vtkNew sself, const double _arg) { sself->SetAboveRangeColor(_arg); } -extern "C" double* vtk_lookup_table_get_above_range_color(vtkNew sself) { return sself->GetAboveRangeColor(); } -extern "C" void vtk_lookup_table_get_above_range_color(vtkNew sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->GetAboveRangeColor(_arg1, _arg2, _arg3, _arg4); } -extern "C" void vtk_lookup_table_get_above_range_color(vtkNew sself, double _arg) { sself->GetAboveRangeColor(_arg); } -extern "C" void vtk_lookup_table_set_use_above_range_color(vtkNew sself, int _arg) { sself->SetUseAboveRangeColor(_arg); } -extern "C" int vtk_lookup_table_get_use_above_range_color(vtkNew sself) { return sself->GetUseAboveRangeColor(); } -extern "C" void vtk_lookup_table_use_above_range_color_on(vtkNew sself) { sself->UseAboveRangeColorOn(); } -extern "C" void vtk_lookup_table_use_above_range_color_off(vtkNew sself) { sself->UseAboveRangeColorOff(); } -extern "C" const unsigned char* vtk_lookup_table_map_value(vtkNew sself, double v) { return sself->MapValue(v); } -extern "C" void vtk_lookup_table_get_color(vtkNew sself, double v, double rgb) { sself->GetColor(v, rgb); } -extern "C" double vtk_lookup_table_get_opacity(vtkNew sself, double v) { return sself->GetOpacity(v); } -extern "C" long long vtk_lookup_table_get_index(vtkNew sself, double v) { return sself->GetIndex(v); } -extern "C" void vtk_lookup_table_set_number_of_table_values(vtkNew sself, long long number) { sself->SetNumberOfTableValues(number); } -extern "C" long long vtk_lookup_table_get_number_of_table_values(vtkNew sself) { return sself->GetNumberOfTableValues(); } -extern "C" void vtk_lookup_table_set_table_value(vtkNew sself, long long indx, const double rgba) { sself->SetTableValue(indx, rgba); } -extern "C" void vtk_lookup_table_set_table_value(vtkNew sself, long long indx, double r, double g, double b, double a) { sself->SetTableValue(indx, r, g, b, a); } -extern "C" double* vtk_lookup_table_get_table_value(vtkNew sself, long long indx) { return sself->GetTableValue(indx); } -extern "C" void vtk_lookup_table_get_table_value(vtkNew sself, long long indx, double rgba) { sself->GetTableValue(indx, rgba); } -extern "C" unsigned char* vtk_lookup_table_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" unsigned char* vtk_lookup_table_write_pointer(vtkNew sself, long long id, int number) { return sself->WritePointer(id, number); } -extern "C" double* vtk_lookup_table_get_range(vtkNew sself) { return sself->GetRange(); } -extern "C" void vtk_lookup_table_get_log_range(vtkNew sself, const double range, double log_range) { sself->GetLogRange(range, log_range); } -extern "C" double vtk_lookup_table_apply_log_scale(vtkNew sself, double v, const double range, const double log_range) { return sself->ApplyLogScale(v, range, log_range); } -extern "C" void vtk_lookup_table_set_number_of_colors(vtkNew sself, long long _arg) { sself->SetNumberOfColors(_arg); } -extern "C" long long vtk_lookup_table_get_number_of_colors_min_value(vtkNew sself) { return sself->GetNumberOfColorsMinValue(); } -extern "C" long long vtk_lookup_table_get_number_of_colors_max_value(vtkNew sself) { return sself->GetNumberOfColorsMaxValue(); } -extern "C" long long vtk_lookup_table_get_number_of_colors(vtkNew sself) { return sself->GetNumberOfColors(); } -extern "C" void vtk_lookup_table_map_scalars_through_table_2(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat) { sself->MapScalarsThroughTable2(input, output, inputDataType, numberOfValues, inputIncrement, outputFormat); } -extern "C" int vtk_lookup_table_using_log_scale(vtkNew sself) { return sself->UsingLogScale(); } -extern "C" void vtk_lookup_table_get_indexed_color(vtkNew sself, long long idx, double rgba) { sself->GetIndexedColor(idx, rgba); } -extern "C" vtkNew < vtkMath > vtkMath_new () {return vtkNew < vtkMath > () ;} -extern "C" void vtkMath_destructor (vtkNew < vtkMath > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMath_get_ptr (vtkNew < vtkMath > sself) {return sself . GetPointer () ;} -extern "C" double vtk_math_pi(vtkNew sself) { return sself->Pi(); } -extern "C" float vtk_math_radians_from_degrees(vtkNew sself, float degrees) { return sself->RadiansFromDegrees(degrees); } -extern "C" double vtk_math_radians_from_degrees(vtkNew sself, double degrees) { return sself->RadiansFromDegrees(degrees); } -extern "C" float vtk_math_degrees_from_radians(vtkNew sself, float radians) { return sself->DegreesFromRadians(radians); } -extern "C" double vtk_math_degrees_from_radians(vtkNew sself, double radians) { return sself->DegreesFromRadians(radians); } -extern "C" int vtk_math_round(vtkNew sself, float f) { return sself->Round(f); } -extern "C" int vtk_math_round(vtkNew sself, double f) { return sself->Round(f); } -extern "C" int vtk_math_floor(vtkNew sself, double x) { return sself->Floor(x); } -extern "C" int vtk_math_ceil(vtkNew sself, double x) { return sself->Ceil(x); } -extern "C" int vtk_math_ceil_log_2(vtkNew sself, unsigned long long x) { return sself->CeilLog2(x); } -extern "C" bool vtk_math_is_power_of_two(vtkNew sself, unsigned long long x) { return sself->IsPowerOfTwo(x); } -extern "C" int vtk_math_nearest_power_of_two(vtkNew sself, int x) { return sself->NearestPowerOfTwo(x); } -extern "C" long long vtk_math_factorial(vtkNew sself, int N) { return sself->Factorial(N); } -extern "C" long long vtk_math_binomial(vtkNew sself, int m, int n) { return sself->Binomial(m, n); } -extern "C" int* vtk_math_begin_combination(vtkNew sself, int m, int n) { return sself->BeginCombination(m, n); } -extern "C" int vtk_math_next_combination(vtkNew sself, int m, int n, int combination) { return sself->NextCombination(m, n, combination); } -extern "C" void vtk_math_free_combination(vtkNew sself, int combination) { sself->FreeCombination(combination); } -extern "C" void vtk_math_random_seed(vtkNew sself, int s) { sself->RandomSeed(s); } -extern "C" int vtk_math_get_seed(vtkNew sself) { return sself->GetSeed(); } -extern "C" double vtk_math_random(vtkNew sself) { return sself->Random(); } -extern "C" double vtk_math_random(vtkNew sself, double min, double max) { return sself->Random(min, max); } -extern "C" double vtk_math_gaussian(vtkNew sself) { return sself->Gaussian(); } -extern "C" double vtk_math_gaussian(vtkNew sself, double mean, double std) { return sself->Gaussian(mean, std); } -extern "C" void vtk_math_assign(vtkNew sself, const double a, double b) { sself->Assign(a, b); } -extern "C" void vtk_math_add(vtkNew sself, const float a, const float b, float c) { sself->Add(a, b, c); } -extern "C" void vtk_math_add(vtkNew sself, const double a, const double b, double c) { sself->Add(a, b, c); } -extern "C" void vtk_math_subtract(vtkNew sself, const float a, const float b, float c) { sself->Subtract(a, b, c); } -extern "C" void vtk_math_subtract(vtkNew sself, const double a, const double b, double c) { sself->Subtract(a, b, c); } -extern "C" void vtk_math_multiply_scalar(vtkNew sself, float a, float s) { sself->MultiplyScalar(a, s); } -extern "C" void vtk_math_multiply_scalar_2_d(vtkNew sself, float a, float s) { sself->MultiplyScalar2D(a, s); } -extern "C" void vtk_math_multiply_scalar(vtkNew sself, double a, double s) { sself->MultiplyScalar(a, s); } -extern "C" void vtk_math_multiply_scalar_2_d(vtkNew sself, double a, double s) { sself->MultiplyScalar2D(a, s); } -extern "C" float vtk_math_dot(vtkNew sself, const float a, const float b) { return sself->Dot(a, b); } -extern "C" double vtk_math_dot(vtkNew sself, const double a, const double b) { return sself->Dot(a, b); } -extern "C" void vtk_math_outer(vtkNew sself, const float a, const float b, float c) { sself->Outer(a, b, c); } -extern "C" void vtk_math_outer(vtkNew sself, const double a, const double b, double c) { sself->Outer(a, b, c); } -extern "C" void vtk_math_cross(vtkNew sself, const float a, const float b, float c) { sself->Cross(a, b, c); } -extern "C" void vtk_math_cross(vtkNew sself, const double a, const double b, double c) { sself->Cross(a, b, c); } -extern "C" float vtk_math_norm(vtkNew sself, const float x, int n) { return sself->Norm(x, n); } -extern "C" double vtk_math_norm(vtkNew sself, const double x, int n) { return sself->Norm(x, n); } -extern "C" float vtk_math_norm(vtkNew sself, const float v) { return sself->Norm(v); } -extern "C" double vtk_math_norm(vtkNew sself, const double v) { return sself->Norm(v); } -extern "C" float vtk_math_normalize(vtkNew sself, float v) { return sself->Normalize(v); } -extern "C" double vtk_math_normalize(vtkNew sself, double v) { return sself->Normalize(v); } -extern "C" void vtk_math_perpendiculars(vtkNew sself, const double v1, double v2, double v3, double theta) { sself->Perpendiculars(v1, v2, v3, theta); } -extern "C" void vtk_math_perpendiculars(vtkNew sself, const float v1, float v2, float v3, double theta) { sself->Perpendiculars(v1, v2, v3, theta); } -extern "C" bool vtk_math_project_vector(vtkNew sself, const float a, const float b, float projection) { return sself->ProjectVector(a, b, projection); } -extern "C" bool vtk_math_project_vector(vtkNew sself, const double a, const double b, double projection) { return sself->ProjectVector(a, b, projection); } -extern "C" bool vtk_math_project_vector_2_d(vtkNew sself, const float a, const float b, float projection) { return sself->ProjectVector2D(a, b, projection); } -extern "C" bool vtk_math_project_vector_2_d(vtkNew sself, const double a, const double b, double projection) { return sself->ProjectVector2D(a, b, projection); } -extern "C" float vtk_math_distance_2_between_points(vtkNew sself, const float p1, const float p2) { return sself->Distance2BetweenPoints(p1, p2); } -extern "C" double vtk_math_distance_2_between_points(vtkNew sself, const double p1, const double p2) { return sself->Distance2BetweenPoints(p1, p2); } -extern "C" double vtk_math_angle_between_vectors(vtkNew sself, const double v1, const double v2) { return sself->AngleBetweenVectors(v1, v2); } -extern "C" double vtk_math_signed_angle_between_vectors(vtkNew sself, const double v1, const double v2, const double vn) { return sself->SignedAngleBetweenVectors(v1, v2, vn); } -extern "C" double vtk_math_gaussian_amplitude(vtkNew sself, const double variance, const double distanceFromMean) { return sself->GaussianAmplitude(variance, distanceFromMean); } -extern "C" double vtk_math_gaussian_amplitude(vtkNew sself, const double mean, const double variance, const double position) { return sself->GaussianAmplitude(mean, variance, position); } -extern "C" double vtk_math_gaussian_weight(vtkNew sself, const double variance, const double distanceFromMean) { return sself->GaussianWeight(variance, distanceFromMean); } -extern "C" double vtk_math_gaussian_weight(vtkNew sself, const double mean, const double variance, const double position) { return sself->GaussianWeight(mean, variance, position); } -extern "C" float vtk_math_dot_2_d(vtkNew sself, const float x, const float y) { return sself->Dot2D(x, y); } -extern "C" double vtk_math_dot_2_d(vtkNew sself, const double x, const double y) { return sself->Dot2D(x, y); } -extern "C" void vtk_math_outer_2_d(vtkNew sself, const float x, const float y, float A) { sself->Outer2D(x, y, A); } -extern "C" void vtk_math_outer_2_d(vtkNew sself, const double x, const double y, double A) { sself->Outer2D(x, y, A); } -extern "C" float vtk_math_norm_2_d(vtkNew sself, const float x) { return sself->Norm2D(x); } -extern "C" double vtk_math_norm_2_d(vtkNew sself, const double x) { return sself->Norm2D(x); } -extern "C" float vtk_math_normalize_2_d(vtkNew sself, float v) { return sself->Normalize2D(v); } -extern "C" double vtk_math_normalize_2_d(vtkNew sself, double v) { return sself->Normalize2D(v); } -extern "C" float vtk_math_determinant_2_x_2(vtkNew sself, const float c1, const float c2) { return sself->Determinant2x2(c1, c2); } -extern "C" double vtk_math_determinant_2_x_2(vtkNew sself, double a, double b, double c, double d) { return sself->Determinant2x2(a, b, c, d); } -extern "C" double vtk_math_determinant_2_x_2(vtkNew sself, const double c1, const double c2) { return sself->Determinant2x2(c1, c2); } -extern "C" void vtk_math_lu_factor_3_x_3(vtkNew sself, float A, int index) { sself->LUFactor3x3(A, index); } -extern "C" void vtk_math_lu_factor_3_x_3(vtkNew sself, double A, int index) { sself->LUFactor3x3(A, index); } -extern "C" void vtk_math_lu_solve_3_x_3(vtkNew sself, const float A, const int index, float x) { sself->LUSolve3x3(A, index, x); } -extern "C" void vtk_math_lu_solve_3_x_3(vtkNew sself, const double A, const int index, double x) { sself->LUSolve3x3(A, index, x); } -extern "C" void vtk_math_linear_solve_3_x_3(vtkNew sself, const float A, const float x, float y) { sself->LinearSolve3x3(A, x, y); } -extern "C" void vtk_math_linear_solve_3_x_3(vtkNew sself, const double A, const double x, double y) { sself->LinearSolve3x3(A, x, y); } -extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const float A, const float v, float u) { sself->Multiply3x3(A, v, u); } -extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const double A, const double v, double u) { sself->Multiply3x3(A, v, u); } -extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const float A, const float B, float C) { sself->Multiply3x3(A, B, C); } -extern "C" void vtk_math_multiply_3_x_3(vtkNew sself, const double A, const double B, double C) { sself->Multiply3x3(A, B, C); } -extern "C" void vtk_math_multiply_matrix(vtkNew sself, const double A, const double B, unsigned int rowA, unsigned int colA, unsigned int rowB, unsigned int colB, double C) { sself->MultiplyMatrix(A, B, rowA, colA, rowB, colB, C); } -extern "C" void vtk_math_transpose_3_x_3(vtkNew sself, const float A, float AT) { sself->Transpose3x3(A, AT); } -extern "C" void vtk_math_transpose_3_x_3(vtkNew sself, const double A, double AT) { sself->Transpose3x3(A, AT); } -extern "C" void vtk_math_invert_3_x_3(vtkNew sself, const float A, float AI) { sself->Invert3x3(A, AI); } -extern "C" void vtk_math_invert_3_x_3(vtkNew sself, const double A, double AI) { sself->Invert3x3(A, AI); } -extern "C" void vtk_math_identity_3_x_3(vtkNew sself, float A) { sself->Identity3x3(A); } -extern "C" void vtk_math_identity_3_x_3(vtkNew sself, double A) { sself->Identity3x3(A); } -extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const float A) { return sself->Determinant3x3(A); } -extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const double A) { return sself->Determinant3x3(A); } -extern "C" float vtk_math_determinant_3_x_3(vtkNew sself, const float c1, const float c2, const float c3) { return sself->Determinant3x3(c1, c2, c3); } -extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, const double c1, const double c2, const double c3) { return sself->Determinant3x3(c1, c2, c3); } -extern "C" double vtk_math_determinant_3_x_3(vtkNew sself, double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3) { return sself->Determinant3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3); } -extern "C" void vtk_math_quaternion_to_matrix_3_x_3(vtkNew sself, const float quat, float A) { sself->QuaternionToMatrix3x3(quat, A); } -extern "C" void vtk_math_quaternion_to_matrix_3_x_3(vtkNew sself, const double quat, double A) { sself->QuaternionToMatrix3x3(quat, A); } -extern "C" void vtk_math_matrix_3_x_3_to_quaternion(vtkNew sself, const float A, float quat) { sself->Matrix3x3ToQuaternion(A, quat); } -extern "C" void vtk_math_matrix_3_x_3_to_quaternion(vtkNew sself, const double A, double quat) { sself->Matrix3x3ToQuaternion(A, quat); } -extern "C" void vtk_math_multiply_quaternion(vtkNew sself, const float q1, const float q2, float q) { sself->MultiplyQuaternion(q1, q2, q); } -extern "C" void vtk_math_multiply_quaternion(vtkNew sself, const double q1, const double q2, double q) { sself->MultiplyQuaternion(q1, q2, q); } -extern "C" void vtk_math_rotate_vector_by_normalized_quaternion(vtkNew sself, const float v, const float q, float r) { sself->RotateVectorByNormalizedQuaternion(v, q, r); } -extern "C" void vtk_math_rotate_vector_by_normalized_quaternion(vtkNew sself, const double v, const double q, double r) { sself->RotateVectorByNormalizedQuaternion(v, q, r); } -extern "C" void vtk_math_rotate_vector_by_wxyz(vtkNew sself, const float v, const float q, float r) { sself->RotateVectorByWXYZ(v, q, r); } -extern "C" void vtk_math_rotate_vector_by_wxyz(vtkNew sself, const double v, const double q, double r) { sself->RotateVectorByWXYZ(v, q, r); } -extern "C" void vtk_math_orthogonalize_3_x_3(vtkNew sself, const float A, float B) { sself->Orthogonalize3x3(A, B); } -extern "C" void vtk_math_orthogonalize_3_x_3(vtkNew sself, const double A, double B) { sself->Orthogonalize3x3(A, B); } -extern "C" void vtk_math_diagonalize_3_x_3(vtkNew sself, const float A, float w, float V) { sself->Diagonalize3x3(A, w, V); } -extern "C" void vtk_math_diagonalize_3_x_3(vtkNew sself, const double A, double w, double V) { sself->Diagonalize3x3(A, w, V); } -extern "C" void vtk_math_singular_value_decomposition_3_x_3(vtkNew sself, const float A, float U, float w, float VT) { sself->SingularValueDecomposition3x3(A, U, w, VT); } -extern "C" void vtk_math_singular_value_decomposition_3_x_3(vtkNew sself, const double A, double U, double w, double VT) { sself->SingularValueDecomposition3x3(A, U, w, VT); } -extern "C" int vtk_math_solve_linear_system_gepp_2_x_2(vtkNew sself, double a00, double a01, double a10, double a11, double b0, double b1, double x0, double x1) { return sself->SolveLinearSystemGEPP2x2(a00, a01, a10, a11, b0, b1, x0, x1); } -extern "C" int vtk_math_solve_linear_system(vtkNew sself, double A, double x, int size) { return sself->SolveLinearSystem(A, x, size); } -extern "C" int vtk_math_invert_matrix(vtkNew sself, double A, double AI, int size) { return sself->InvertMatrix(A, AI, size); } -extern "C" int vtk_math_invert_matrix(vtkNew sself, double A, double AI, int size, int tmp1Size, double tmp2Size) { return sself->InvertMatrix(A, AI, size, tmp1Size, tmp2Size); } -extern "C" int vtk_math_lu_factor_linear_system(vtkNew sself, double A, int index, int size) { return sself->LUFactorLinearSystem(A, index, size); } -extern "C" int vtk_math_lu_factor_linear_system(vtkNew sself, double A, int index, int size, double tmpSize) { return sself->LUFactorLinearSystem(A, index, size, tmpSize); } -extern "C" void vtk_math_lu_solve_linear_system(vtkNew sself, double A, int index, double x, int size) { sself->LUSolveLinearSystem(A, index, x, size); } -extern "C" double vtk_math_estimate_matrix_condition(vtkNew sself, const double A, int size) { return sself->EstimateMatrixCondition(A, size); } -extern "C" int vtk_math_jacobi(vtkNew sself, float a, float w, float v) { return sself->Jacobi(a, w, v); } -extern "C" int vtk_math_jacobi(vtkNew sself, double a, double w, double v) { return sself->Jacobi(a, w, v); } -extern "C" int vtk_math_jacobi_n(vtkNew sself, float a, int n, float w, float v) { return sself->JacobiN(a, n, w, v); } -extern "C" int vtk_math_jacobi_n(vtkNew sself, double a, int n, double w, double v) { return sself->JacobiN(a, n, w, v); } -extern "C" int vtk_math_solve_homogeneous_least_squares(vtkNew sself, int numberOfSamples, double xt, int xOrder, double mt) { return sself->SolveHomogeneousLeastSquares(numberOfSamples, xt, xOrder, mt); } -extern "C" int vtk_math_solve_least_squares(vtkNew sself, int numberOfSamples, double xt, int xOrder, double yt, int yOrder, double mt, int checkHomogeneous) { return sself->SolveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt, checkHomogeneous); } -extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, const float rgb, float hsv) { sself->RGBToHSV(rgb, hsv); } -extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, float r, float g, float b, float h, float s, float v) { sself->RGBToHSV(r, g, b, h, s, v); } -extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, const double rgb, double hsv) { sself->RGBToHSV(rgb, hsv); } -extern "C" void vtk_math_rgb_to_hsv(vtkNew sself, double r, double g, double b, double h, double s, double v) { sself->RGBToHSV(r, g, b, h, s, v); } -extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, const float hsv, float rgb) { sself->HSVToRGB(hsv, rgb); } -extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, float h, float s, float v, float r, float g, float b) { sself->HSVToRGB(h, s, v, r, g, b); } -extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, const double hsv, double rgb) { sself->HSVToRGB(hsv, rgb); } -extern "C" void vtk_math_hsv_to_rgb(vtkNew sself, double h, double s, double v, double r, double g, double b) { sself->HSVToRGB(h, s, v, r, g, b); } -extern "C" void vtk_math_lab_to_xyz(vtkNew sself, const double lab, double xyz) { sself->LabToXYZ(lab, xyz); } -extern "C" void vtk_math_lab_to_xyz(vtkNew sself, double L, double a, double b, double x, double y, double z) { sself->LabToXYZ(L, a, b, x, y, z); } -extern "C" void vtk_math_xyz_to_lab(vtkNew sself, const double xyz, double lab) { sself->XYZToLab(xyz, lab); } -extern "C" void vtk_math_xyz_to_lab(vtkNew sself, double x, double y, double z, double L, double a, double b) { sself->XYZToLab(x, y, z, L, a, b); } -extern "C" void vtk_math_xyz_to_rgb(vtkNew sself, const double xyz, double rgb) { sself->XYZToRGB(xyz, rgb); } -extern "C" void vtk_math_xyz_to_rgb(vtkNew sself, double x, double y, double z, double r, double g, double b) { sself->XYZToRGB(x, y, z, r, g, b); } -extern "C" void vtk_math_rgb_to_xyz(vtkNew sself, const double rgb, double xyz) { sself->RGBToXYZ(rgb, xyz); } -extern "C" void vtk_math_rgb_to_xyz(vtkNew sself, double r, double g, double b, double x, double y, double z) { sself->RGBToXYZ(r, g, b, x, y, z); } -extern "C" void vtk_math_rgb_to_lab(vtkNew sself, const double rgb, double lab) { sself->RGBToLab(rgb, lab); } -extern "C" void vtk_math_rgb_to_lab(vtkNew sself, double red, double green, double blue, double L, double a, double b) { sself->RGBToLab(red, green, blue, L, a, b); } -extern "C" void vtk_math_lab_to_rgb(vtkNew sself, const double lab, double rgb) { sself->LabToRGB(lab, rgb); } -extern "C" void vtk_math_lab_to_rgb(vtkNew sself, double L, double a, double b, double red, double green, double blue) { sself->LabToRGB(L, a, b, red, green, blue); } -extern "C" void vtk_math_uninitialize_bounds(vtkNew sself, double bounds) { sself->UninitializeBounds(bounds); } -extern "C" int vtk_math_are_bounds_initialized(vtkNew sself, const double bounds) { return sself->AreBoundsInitialized(bounds); } -extern "C" void vtk_math_clamp_value(vtkNew sself, double value, const double range) { sself->ClampValue(value, range); } -extern "C" void vtk_math_clamp_value(vtkNew sself, double value, const double range, double clamped_value) { sself->ClampValue(value, range, clamped_value); } -extern "C" void vtk_math_clamp_values(vtkNew sself, double values, int nb_values, const double range) { sself->ClampValues(values, nb_values, range); } -extern "C" void vtk_math_clamp_values(vtkNew sself, const double values, int nb_values, const double range, double clamped_values) { sself->ClampValues(values, nb_values, range, clamped_values); } -extern "C" double vtk_math_clamp_and_normalize_value(vtkNew sself, double value, const double range) { return sself->ClampAndNormalizeValue(value, range); } -extern "C" int vtk_math_get_scalar_type_fitting_range(vtkNew sself, double range_min, double range_max, double scale, double shift) { return sself->GetScalarTypeFittingRange(range_min, range_max, scale, shift); } -extern "C" int vtk_math_extent_is_within_other_extent(vtkNew sself, const int extent1, const int extent2) { return sself->ExtentIsWithinOtherExtent(extent1, extent2); } -extern "C" int vtk_math_bounds_is_within_other_bounds(vtkNew sself, const double bounds1, const double bounds2, const double delta) { return sself->BoundsIsWithinOtherBounds(bounds1, bounds2, delta); } -extern "C" int vtk_math_point_is_within_bounds(vtkNew sself, const double point, const double bounds, const double delta) { return sself->PointIsWithinBounds(point, bounds, delta); } -extern "C" int vtk_math_plane_intersects_aabb(vtkNew sself, const double bounds, const double normal, const double point) { return sself->PlaneIntersectsAABB(bounds, normal, point); } -extern "C" double vtk_math_solve_3_point_circle(vtkNew sself, const double p1, const double p2, const double p3, double center) { return sself->Solve3PointCircle(p1, p2, p3, center); } -extern "C" double vtk_math_inf(vtkNew sself) { return sself->Inf(); } -extern "C" double vtk_math_neg_inf(vtkNew sself) { return sself->NegInf(); } -extern "C" double vtk_math_nan(vtkNew sself) { return sself->Nan(); } -extern "C" int vtk_math_is_inf(vtkNew sself, double x) { return sself->IsInf(x); } -extern "C" int vtk_math_is_nan(vtkNew sself, double x) { return sself->IsNan(x); } -extern "C" bool vtk_math_is_finite(vtkNew sself, double x) { return sself->IsFinite(x); } -extern "C" int vtk_math_quadratic_root(vtkNew sself, double a, double b, double c, double min, double max, double u) { return sself->QuadraticRoot(a, b, c, min, max, u); } -extern "C" vtkNew < vtkMersenneTwister > vtkMersenneTwister_new () {return vtkNew < vtkMersenneTwister > () ;} -extern "C" void vtkMersenneTwister_destructor (vtkNew < vtkMersenneTwister > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMersenneTwister_get_ptr (vtkNew < vtkMersenneTwister > sself) {return sself . GetPointer () ;} -extern "C" void vtk_mersenne_twister_initialize(vtkNew sself, unsigned int seed) { sself->Initialize(seed); } -extern "C" unsigned int vtk_mersenne_twister_initialize_new_sequence(vtkNew sself, unsigned int seed, int p) { return sself->InitializeNewSequence(seed, p); } -extern "C" void vtk_mersenne_twister_initialize_sequence(vtkNew sself, unsigned int id, unsigned int seed, int p) { sself->InitializeSequence(id, seed, p); } -extern "C" double vtk_mersenne_twister_get_value(vtkNew sself, unsigned int id) { return sself->GetValue(id); } -extern "C" double vtk_mersenne_twister_get_value(vtkNew sself) { return sself->GetValue(); } -extern "C" void vtk_mersenne_twister_next(vtkNew sself, unsigned int id) { sself->Next(id); } -extern "C" void vtk_mersenne_twister_next(vtkNew sself) { sself->Next(); } -extern "C" vtkNew < vtkMinimalStandardRandomSequence > vtkMinimalStandardRandomSequence_new () {return vtkNew < vtkMinimalStandardRandomSequence > () ;} -extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkNew < vtkMinimalStandardRandomSequence > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMinimalStandardRandomSequence_get_ptr (vtkNew < vtkMinimalStandardRandomSequence > sself) {return sself . GetPointer () ;} -extern "C" void vtk_minimal_standard_random_sequence_initialize(vtkNew sself, unsigned int seed) { sself->Initialize(seed); } -extern "C" void vtk_minimal_standard_random_sequence_set_seed(vtkNew sself, int value) { sself->SetSeed(value); } -extern "C" void vtk_minimal_standard_random_sequence_set_seed_only(vtkNew sself, int value) { sself->SetSeedOnly(value); } -extern "C" int vtk_minimal_standard_random_sequence_get_seed(vtkNew sself) { return sself->GetSeed(); } -extern "C" double vtk_minimal_standard_random_sequence_get_value(vtkNew sself) { return sself->GetValue(); } -extern "C" void vtk_minimal_standard_random_sequence_next(vtkNew sself) { sself->Next(); } -extern "C" double vtk_minimal_standard_random_sequence_get_range_value(vtkNew sself, double rangeMin, double rangeMax) { return sself->GetRangeValue(rangeMin, rangeMax); } -extern "C" double vtk_minimal_standard_random_sequence_get_next_range_value(vtkNew sself, double rangeMin, double rangeMax) { return sself->GetNextRangeValue(rangeMin, rangeMax); } -extern "C" vtkNew < vtkMultiThreader > vtkMultiThreader_new () {return vtkNew < vtkMultiThreader > () ;} -extern "C" void vtkMultiThreader_destructor (vtkNew < vtkMultiThreader > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMultiThreader_get_ptr (vtkNew < vtkMultiThreader > sself) {return sself . GetPointer () ;} -extern "C" void vtk_multi_threader_set_number_of_threads(vtkNew sself, int _arg) { sself->SetNumberOfThreads(_arg); } -extern "C" int vtk_multi_threader_get_number_of_threads_min_value(vtkNew sself) { return sself->GetNumberOfThreadsMinValue(); } -extern "C" int vtk_multi_threader_get_number_of_threads_max_value(vtkNew sself) { return sself->GetNumberOfThreadsMaxValue(); } -extern "C" int vtk_multi_threader_get_number_of_threads(vtkNew sself) { return sself->GetNumberOfThreads(); } -extern "C" int vtk_multi_threader_get_global_static_maximum_number_of_threads(vtkNew sself) { return sself->GetGlobalStaticMaximumNumberOfThreads(); } -extern "C" void vtk_multi_threader_set_global_maximum_number_of_threads(vtkNew sself, int val) { sself->SetGlobalMaximumNumberOfThreads(val); } -extern "C" int vtk_multi_threader_get_global_maximum_number_of_threads(vtkNew sself) { return sself->GetGlobalMaximumNumberOfThreads(); } -extern "C" void vtk_multi_threader_set_global_default_number_of_threads(vtkNew sself, int val) { sself->SetGlobalDefaultNumberOfThreads(val); } -extern "C" int vtk_multi_threader_get_global_default_number_of_threads(vtkNew sself) { return sself->GetGlobalDefaultNumberOfThreads(); } -extern "C" void vtk_multi_threader_single_method_execute(vtkNew sself) { sself->SingleMethodExecute(); } -extern "C" void vtk_multi_threader_multiple_method_execute(vtkNew sself) { sself->MultipleMethodExecute(); } -extern "C" void vtk_multi_threader_terminate_thread(vtkNew sself, int threadId) { sself->TerminateThread(threadId); } -extern "C" int vtk_multi_threader_is_thread_active(vtkNew sself, int threadId) { return sself->IsThreadActive(threadId); } -extern "C" vtkNew < vtkObject > vtkObject_new () {return vtkNew < vtkObject > () ;} -extern "C" void vtkObject_destructor (vtkNew < vtkObject > sself) {sself . Reset () ; return ;} -extern "C" void * vtkObject_get_ptr (vtkNew < vtkObject > sself) {return sself . GetPointer () ;} -extern "C" int vtk_object_is_type_of(vtkNew sself, const char type) { return sself->IsTypeOf(type); } -extern "C" int vtk_object_is_a(vtkNew sself, const char type) { return sself->IsA(type); } -extern "C" long long vtk_object_get_number_of_generations_from_base_type(vtkNew sself, const char type) { return sself->GetNumberOfGenerationsFromBaseType(type); } -extern "C" long long vtk_object_get_number_of_generations_from_base(vtkNew sself, const char type) { return sself->GetNumberOfGenerationsFromBase(type); } -extern "C" void vtk_object_debug_on(vtkNew sself) { sself->DebugOn(); } -extern "C" void vtk_object_debug_off(vtkNew sself) { sself->DebugOff(); } -extern "C" bool vtk_object_get_debug(vtkNew sself) { return sself->GetDebug(); } -extern "C" void vtk_object_set_debug(vtkNew sself, bool debugFlag) { sself->SetDebug(debugFlag); } -extern "C" void vtk_object_break_on_error(vtkNew sself) { sself->BreakOnError(); } -extern "C" void vtk_object_modified(vtkNew sself) { sself->Modified(); } -extern "C" unsigned long vtk_object_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_object_set_global_warning_display(vtkNew sself, int val) { sself->SetGlobalWarningDisplay(val); } -extern "C" void vtk_object_global_warning_display_on(vtkNew sself) { sself->GlobalWarningDisplayOn(); } -extern "C" void vtk_object_global_warning_display_off(vtkNew sself) { sself->GlobalWarningDisplayOff(); } -extern "C" int vtk_object_get_global_warning_display(vtkNew sself) { return sself->GetGlobalWarningDisplay(); } -extern "C" void vtk_object_remove_observer(vtkNew sself, unsigned long tag) { sself->RemoveObserver(tag); } -extern "C" void vtk_object_remove_observers(vtkNew sself, unsigned long event) { sself->RemoveObservers(event); } -extern "C" void vtk_object_remove_observers(vtkNew sself, const char event) { sself->RemoveObservers(event); } -extern "C" void vtk_object_remove_all_observers(vtkNew sself) { sself->RemoveAllObservers(); } -extern "C" int vtk_object_has_observer(vtkNew sself, unsigned long event) { return sself->HasObserver(event); } -extern "C" int vtk_object_has_observer(vtkNew sself, const char event) { return sself->HasObserver(event); } -extern "C" int vtk_object_invoke_event(vtkNew sself, unsigned long event, void callData) { return sself->InvokeEvent(event, callData); } -extern "C" int vtk_object_invoke_event(vtkNew sself, const char event, void callData) { return sself->InvokeEvent(event, callData); } -extern "C" int vtk_object_invoke_event(vtkNew sself, unsigned long event) { return sself->InvokeEvent(event); } -extern "C" int vtk_object_invoke_event(vtkNew sself, const char event) { return sself->InvokeEvent(event); } -extern "C" vtkNew < vtkObjectFactoryCollection > vtkObjectFactoryCollection_new () {return vtkNew < vtkObjectFactoryCollection > () ;} -extern "C" void vtkObjectFactoryCollection_destructor (vtkNew < vtkObjectFactoryCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkObjectFactoryCollection_get_ptr (vtkNew < vtkObjectFactoryCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOldStyleCallbackCommand > vtkOldStyleCallbackCommand_new () {return vtkNew < vtkOldStyleCallbackCommand > () ;} -extern "C" void vtkOldStyleCallbackCommand_destructor (vtkNew < vtkOldStyleCallbackCommand > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOldStyleCallbackCommand_get_ptr (vtkNew < vtkOldStyleCallbackCommand > sself) {return sself . GetPointer () ;} -extern "C" void vtk_old_style_callback_command_set_client_data(vtkNew sself, void cd) { sself->SetClientData(cd); } -extern "C" vtkNew < vtkOutputWindow > vtkOutputWindow_new () {return vtkNew < vtkOutputWindow > () ;} -extern "C" void vtkOutputWindow_destructor (vtkNew < vtkOutputWindow > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOutputWindow_get_ptr (vtkNew < vtkOutputWindow > sself) {return sself . GetPointer () ;} -extern "C" void vtk_output_window_display_text(vtkNew sself, const char p0) { sself->DisplayText(p0); } -extern "C" void vtk_output_window_display_error_text(vtkNew sself, const char p0) { sself->DisplayErrorText(p0); } -extern "C" void vtk_output_window_display_warning_text(vtkNew sself, const char p0) { sself->DisplayWarningText(p0); } -extern "C" void vtk_output_window_display_generic_warning_text(vtkNew sself, const char p0) { sself->DisplayGenericWarningText(p0); } -extern "C" void vtk_output_window_display_debug_text(vtkNew sself, const char p0) { sself->DisplayDebugText(p0); } -extern "C" void vtk_output_window_prompt_user_on(vtkNew sself) { sself->PromptUserOn(); } -extern "C" void vtk_output_window_prompt_user_off(vtkNew sself) { sself->PromptUserOff(); } -extern "C" void vtk_output_window_set_prompt_user(vtkNew sself, bool _arg) { sself->SetPromptUser(_arg); } -extern "C" void vtk_output_window_set_use_std_error_for_all_messages(vtkNew sself, bool p0) { sself->SetUseStdErrorForAllMessages(p0); } -extern "C" bool vtk_output_window_get_use_std_error_for_all_messages(vtkNew sself) { return sself->GetUseStdErrorForAllMessages(); } -extern "C" void vtk_output_window_use_std_error_for_all_messages_on(vtkNew sself) { sself->UseStdErrorForAllMessagesOn(); } -extern "C" void vtk_output_window_use_std_error_for_all_messages_off(vtkNew sself) { sself->UseStdErrorForAllMessagesOff(); } -extern "C" void vtk_output_window_set_display_mode(vtkNew sself, int _arg) { sself->SetDisplayMode(_arg); } -extern "C" int vtk_output_window_get_display_mode_min_value(vtkNew sself) { return sself->GetDisplayModeMinValue(); } -extern "C" int vtk_output_window_get_display_mode_max_value(vtkNew sself) { return sself->GetDisplayModeMaxValue(); } -extern "C" int vtk_output_window_get_display_mode(vtkNew sself) { return sself->GetDisplayMode(); } -extern "C" void vtk_output_window_set_display_mode_to_default(vtkNew sself) { sself->SetDisplayModeToDefault(); } -extern "C" void vtk_output_window_set_display_mode_to_never(vtkNew sself) { sself->SetDisplayModeToNever(); } -extern "C" void vtk_output_window_set_display_mode_to_always(vtkNew sself) { sself->SetDisplayModeToAlways(); } -extern "C" void vtk_output_window_set_display_mode_to_always_std_err(vtkNew sself) { sself->SetDisplayModeToAlwaysStdErr(); } -extern "C" vtkNew < vtkOverrideInformationCollection > vtkOverrideInformationCollection_new () {return vtkNew < vtkOverrideInformationCollection > () ;} -extern "C" void vtkOverrideInformationCollection_destructor (vtkNew < vtkOverrideInformationCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOverrideInformationCollection_get_ptr (vtkNew < vtkOverrideInformationCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPoints > vtkPoints_new () {return vtkNew < vtkPoints > () ;} -extern "C" void vtkPoints_destructor (vtkNew < vtkPoints > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPoints_get_ptr (vtkNew < vtkPoints > sself) {return sself . GetPointer () ;} -extern "C" int vtk_points_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } -extern "C" void vtk_points_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_points_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_points_set_data_type(vtkNew sself, int dataType) { sself->SetDataType(dataType); } -extern "C" void vtk_points_set_data_type_to_bit(vtkNew sself) { sself->SetDataTypeToBit(); } -extern "C" void vtk_points_set_data_type_to_char(vtkNew sself) { sself->SetDataTypeToChar(); } -extern "C" void vtk_points_set_data_type_to_unsigned_char(vtkNew sself) { sself->SetDataTypeToUnsignedChar(); } -extern "C" void vtk_points_set_data_type_to_short(vtkNew sself) { sself->SetDataTypeToShort(); } -extern "C" void vtk_points_set_data_type_to_unsigned_short(vtkNew sself) { sself->SetDataTypeToUnsignedShort(); } -extern "C" void vtk_points_set_data_type_to_int(vtkNew sself) { sself->SetDataTypeToInt(); } -extern "C" void vtk_points_set_data_type_to_unsigned_int(vtkNew sself) { sself->SetDataTypeToUnsignedInt(); } -extern "C" void vtk_points_set_data_type_to_long(vtkNew sself) { sself->SetDataTypeToLong(); } -extern "C" void vtk_points_set_data_type_to_unsigned_long(vtkNew sself) { sself->SetDataTypeToUnsignedLong(); } -extern "C" void vtk_points_set_data_type_to_float(vtkNew sself) { sself->SetDataTypeToFloat(); } -extern "C" void vtk_points_set_data_type_to_double(vtkNew sself) { sself->SetDataTypeToDouble(); } -extern "C" void* vtk_points_get_void_pointer(vtkNew sself, const int id) { return sself->GetVoidPointer(id); } -extern "C" void vtk_points_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" void vtk_points_reset(vtkNew sself) { sself->Reset(); } -extern "C" unsigned long vtk_points_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" long long vtk_points_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" double* vtk_points_get_point(vtkNew sself, long long id) { return sself->GetPoint(id); } -extern "C" void vtk_points_get_point(vtkNew sself, long long id, double x) { sself->GetPoint(id, x); } -extern "C" void vtk_points_set_point(vtkNew sself, long long id, const float x) { sself->SetPoint(id, x); } -extern "C" void vtk_points_set_point(vtkNew sself, long long id, const double x) { sself->SetPoint(id, x); } -extern "C" void vtk_points_set_point(vtkNew sself, long long id, double x, double y, double z) { sself->SetPoint(id, x, y, z); } -extern "C" void vtk_points_insert_point(vtkNew sself, long long id, const float x) { sself->InsertPoint(id, x); } -extern "C" void vtk_points_insert_point(vtkNew sself, long long id, const double x) { sself->InsertPoint(id, x); } -extern "C" void vtk_points_insert_point(vtkNew sself, long long id, double x, double y, double z) { sself->InsertPoint(id, x, y, z); } -extern "C" long long vtk_points_insert_next_point(vtkNew sself, const float x) { return sself->InsertNextPoint(x); } -extern "C" long long vtk_points_insert_next_point(vtkNew sself, const double x) { return sself->InsertNextPoint(x); } -extern "C" long long vtk_points_insert_next_point(vtkNew sself, double x, double y, double z) { return sself->InsertNextPoint(x, y, z); } -extern "C" void vtk_points_set_number_of_points(vtkNew sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } -extern "C" int vtk_points_resize(vtkNew sself, long long numPoints) { return sself->Resize(numPoints); } -extern "C" void vtk_points_compute_bounds(vtkNew sself) { sself->ComputeBounds(); } -extern "C" double* vtk_points_get_bounds(vtkNew sself) { return sself->GetBounds(); } -extern "C" void vtk_points_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" unsigned long vtk_points_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_points_modified(vtkNew sself) { sself->Modified(); } -extern "C" vtkNew < vtkPoints2D > vtkPoints2D_new () {return vtkNew < vtkPoints2D > () ;} -extern "C" void vtkPoints2D_destructor (vtkNew < vtkPoints2D > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPoints2D_get_ptr (vtkNew < vtkPoints2D > sself) {return sself . GetPointer () ;} -extern "C" int vtk_points_2_d_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } -extern "C" void vtk_points_2_d_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_points_2_d_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_points_2_d_set_data_type(vtkNew sself, int dataType) { sself->SetDataType(dataType); } -extern "C" void vtk_points_2_d_set_data_type_to_bit(vtkNew sself) { sself->SetDataTypeToBit(); } -extern "C" void vtk_points_2_d_set_data_type_to_char(vtkNew sself) { sself->SetDataTypeToChar(); } -extern "C" void vtk_points_2_d_set_data_type_to_unsigned_char(vtkNew sself) { sself->SetDataTypeToUnsignedChar(); } -extern "C" void vtk_points_2_d_set_data_type_to_short(vtkNew sself) { sself->SetDataTypeToShort(); } -extern "C" void vtk_points_2_d_set_data_type_to_unsigned_short(vtkNew sself) { sself->SetDataTypeToUnsignedShort(); } -extern "C" void vtk_points_2_d_set_data_type_to_int(vtkNew sself) { sself->SetDataTypeToInt(); } -extern "C" void vtk_points_2_d_set_data_type_to_unsigned_int(vtkNew sself) { sself->SetDataTypeToUnsignedInt(); } -extern "C" void vtk_points_2_d_set_data_type_to_long(vtkNew sself) { sself->SetDataTypeToLong(); } -extern "C" void vtk_points_2_d_set_data_type_to_unsigned_long(vtkNew sself) { sself->SetDataTypeToUnsignedLong(); } -extern "C" void vtk_points_2_d_set_data_type_to_float(vtkNew sself) { sself->SetDataTypeToFloat(); } -extern "C" void vtk_points_2_d_set_data_type_to_double(vtkNew sself) { sself->SetDataTypeToDouble(); } -extern "C" void* vtk_points_2_d_get_void_pointer(vtkNew sself, const int id) { return sself->GetVoidPointer(id); } -extern "C" void vtk_points_2_d_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" void vtk_points_2_d_reset(vtkNew sself) { sself->Reset(); } -extern "C" unsigned long vtk_points_2_d_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" long long vtk_points_2_d_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" double* vtk_points_2_d_get_point(vtkNew sself, long long id) { return sself->GetPoint(id); } -extern "C" void vtk_points_2_d_get_point(vtkNew sself, long long id, double x) { sself->GetPoint(id, x); } -extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, const float x) { sself->SetPoint(id, x); } -extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, const double x) { sself->SetPoint(id, x); } -extern "C" void vtk_points_2_d_set_point(vtkNew sself, long long id, double x, double y) { sself->SetPoint(id, x, y); } -extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, const float x) { sself->InsertPoint(id, x); } -extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, const double x) { sself->InsertPoint(id, x); } -extern "C" void vtk_points_2_d_insert_point(vtkNew sself, long long id, double x, double y) { sself->InsertPoint(id, x, y); } -extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, const float x) { return sself->InsertNextPoint(x); } -extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, const double x) { return sself->InsertNextPoint(x); } -extern "C" long long vtk_points_2_d_insert_next_point(vtkNew sself, double x, double y) { return sself->InsertNextPoint(x, y); } -extern "C" void vtk_points_2_d_remove_point(vtkNew sself, long long id) { sself->RemovePoint(id); } -extern "C" void vtk_points_2_d_set_number_of_points(vtkNew sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } -extern "C" int vtk_points_2_d_resize(vtkNew sself, long long numPoints) { return sself->Resize(numPoints); } -extern "C" void vtk_points_2_d_compute_bounds(vtkNew sself) { sself->ComputeBounds(); } -extern "C" double* vtk_points_2_d_get_bounds(vtkNew sself) { return sself->GetBounds(); } -extern "C" void vtk_points_2_d_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" vtkNew < vtkPriorityQueue > vtkPriorityQueue_new () {return vtkNew < vtkPriorityQueue > () ;} -extern "C" void vtkPriorityQueue_destructor (vtkNew < vtkPriorityQueue > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPriorityQueue_get_ptr (vtkNew < vtkPriorityQueue > sself) {return sself . GetPointer () ;} -extern "C" void vtk_priority_queue_allocate(vtkNew sself, long long sz, long long ext) { sself->Allocate(sz, ext); } -extern "C" void vtk_priority_queue_insert(vtkNew sself, double priority, long long id) { sself->Insert(priority, id); } -extern "C" long long vtk_priority_queue_pop(vtkNew sself, long long location, double priority) { return sself->Pop(location, priority); } -extern "C" long long vtk_priority_queue_pop(vtkNew sself, long long location) { return sself->Pop(location); } -extern "C" long long vtk_priority_queue_peek(vtkNew sself, long long location, double priority) { return sself->Peek(location, priority); } -extern "C" long long vtk_priority_queue_peek(vtkNew sself, long long location) { return sself->Peek(location); } -extern "C" double vtk_priority_queue_delete_id(vtkNew sself, long long id) { return sself->DeleteId(id); } -extern "C" double vtk_priority_queue_get_priority(vtkNew sself, long long id) { return sself->GetPriority(id); } -extern "C" long long vtk_priority_queue_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } -extern "C" void vtk_priority_queue_reset(vtkNew sself) { sself->Reset(); } -extern "C" vtkNew < vtkRandomPool > vtkRandomPool_new () {return vtkNew < vtkRandomPool > () ;} -extern "C" void vtkRandomPool_destructor (vtkNew < vtkRandomPool > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRandomPool_get_ptr (vtkNew < vtkRandomPool > sself) {return sself . GetPointer () ;} -extern "C" void vtk_random_pool_set_size(vtkNew sself, long long _arg) { sself->SetSize(_arg); } -extern "C" long long vtk_random_pool_get_size_min_value(vtkNew sself) { return sself->GetSizeMinValue(); } -extern "C" long long vtk_random_pool_get_size_max_value(vtkNew sself) { return sself->GetSizeMaxValue(); } -extern "C" long long vtk_random_pool_get_size(vtkNew sself) { return sself->GetSize(); } -extern "C" void vtk_random_pool_set_number_of_components(vtkNew sself, long long _arg) { sself->SetNumberOfComponents(_arg); } -extern "C" long long vtk_random_pool_get_number_of_components_min_value(vtkNew sself) { return sself->GetNumberOfComponentsMinValue(); } -extern "C" long long vtk_random_pool_get_number_of_components_max_value(vtkNew sself) { return sself->GetNumberOfComponentsMaxValue(); } -extern "C" long long vtk_random_pool_get_number_of_components(vtkNew sself) { return sself->GetNumberOfComponents(); } -extern "C" long long vtk_random_pool_get_total_size(vtkNew sself) { return sself->GetTotalSize(); } -extern "C" const double* vtk_random_pool_generate_pool(vtkNew sself) { return sself->GeneratePool(); } -extern "C" const double* vtk_random_pool_get_pool(vtkNew sself) { return sself->GetPool(); } -extern "C" double vtk_random_pool_get_value(vtkNew sself, long long i) { return sself->GetValue(i); } -extern "C" double vtk_random_pool_get_value(vtkNew sself, long long i, int compNum) { return sself->GetValue(i, compNum); } -extern "C" void vtk_random_pool_set_chunk_size(vtkNew sself, long long _arg) { sself->SetChunkSize(_arg); } -extern "C" long long vtk_random_pool_get_chunk_size_min_value(vtkNew sself) { return sself->GetChunkSizeMinValue(); } -extern "C" long long vtk_random_pool_get_chunk_size_max_value(vtkNew sself) { return sself->GetChunkSizeMaxValue(); } -extern "C" long long vtk_random_pool_get_chunk_size(vtkNew sself) { return sself->GetChunkSize(); } -extern "C" vtkNew < vtkReferenceCount > vtkReferenceCount_new () {return vtkNew < vtkReferenceCount > () ;} -extern "C" void vtkReferenceCount_destructor (vtkNew < vtkReferenceCount > sself) {sself . Reset () ; return ;} -extern "C" void * vtkReferenceCount_get_ptr (vtkNew < vtkReferenceCount > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkScalarsToColors > vtkScalarsToColors_new () {return vtkNew < vtkScalarsToColors > () ;} -extern "C" void vtkScalarsToColors_destructor (vtkNew < vtkScalarsToColors > sself) {sself . Reset () ; return ;} -extern "C" void * vtkScalarsToColors_get_ptr (vtkNew < vtkScalarsToColors > sself) {return sself . GetPointer () ;} -extern "C" int vtk_scalars_to_colors_is_opaque(vtkNew sself) { return sself->IsOpaque(); } -extern "C" void vtk_scalars_to_colors_build(vtkNew sself) { sself->Build(); } -extern "C" double* vtk_scalars_to_colors_get_range(vtkNew sself) { return sself->GetRange(); } -extern "C" void vtk_scalars_to_colors_set_range(vtkNew sself, double min, double max) { sself->SetRange(min, max); } -extern "C" void vtk_scalars_to_colors_set_range(vtkNew sself, const double rng) { sself->SetRange(rng); } -extern "C" const unsigned char* vtk_scalars_to_colors_map_value(vtkNew sself, double v) { return sself->MapValue(v); } -extern "C" void vtk_scalars_to_colors_get_color(vtkNew sself, double v, double rgb) { sself->GetColor(v, rgb); } -extern "C" double* vtk_scalars_to_colors_get_color(vtkNew sself, double v) { return sself->GetColor(v); } -extern "C" double vtk_scalars_to_colors_get_opacity(vtkNew sself, double v) { return sself->GetOpacity(v); } -extern "C" double vtk_scalars_to_colors_get_luminance(vtkNew sself, double x) { return sself->GetLuminance(x); } -extern "C" void vtk_scalars_to_colors_set_alpha(vtkNew sself, double alpha) { sself->SetAlpha(alpha); } -extern "C" double vtk_scalars_to_colors_get_alpha(vtkNew sself) { return sself->GetAlpha(); } -extern "C" void vtk_scalars_to_colors_set_vector_mode(vtkNew sself, int _arg) { sself->SetVectorMode(_arg); } -extern "C" int vtk_scalars_to_colors_get_vector_mode(vtkNew sself) { return sself->GetVectorMode(); } -extern "C" void vtk_scalars_to_colors_set_vector_mode_to_magnitude(vtkNew sself) { sself->SetVectorModeToMagnitude(); } -extern "C" void vtk_scalars_to_colors_set_vector_mode_to_component(vtkNew sself) { sself->SetVectorModeToComponent(); } -extern "C" void vtk_scalars_to_colors_set_vector_mode_to_rgb_colors(vtkNew sself) { sself->SetVectorModeToRGBColors(); } -extern "C" void vtk_scalars_to_colors_set_vector_component(vtkNew sself, int _arg) { sself->SetVectorComponent(_arg); } -extern "C" int vtk_scalars_to_colors_get_vector_component(vtkNew sself) { return sself->GetVectorComponent(); } -extern "C" void vtk_scalars_to_colors_set_vector_size(vtkNew sself, int _arg) { sself->SetVectorSize(_arg); } -extern "C" int vtk_scalars_to_colors_get_vector_size(vtkNew sself) { return sself->GetVectorSize(); } -extern "C" void vtk_scalars_to_colors_map_vectors_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat, int vectorComponent, int vectorSize) { sself->MapVectorsThroughTable(input, output, inputDataType, numberOfValues, inputIncrement, outputFormat, vectorComponent, vectorSize); } -extern "C" void vtk_scalars_to_colors_map_vectors_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat) { sself->MapVectorsThroughTable(input, output, inputDataType, numberOfValues, inputIncrement, outputFormat); } -extern "C" void vtk_scalars_to_colors_map_scalars_through_table(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat) { sself->MapScalarsThroughTable(input, output, inputDataType, numberOfValues, inputIncrement, outputFormat); } -extern "C" void vtk_scalars_to_colors_map_scalars_through_table_2(vtkNew sself, void input, unsigned char output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat) { sself->MapScalarsThroughTable2(input, output, inputDataType, numberOfValues, inputIncrement, outputFormat); } -extern "C" int vtk_scalars_to_colors_using_log_scale(vtkNew sself) { return sself->UsingLogScale(); } -extern "C" long long vtk_scalars_to_colors_get_number_of_available_colors(vtkNew sself) { return sself->GetNumberOfAvailableColors(); } -extern "C" long long vtk_scalars_to_colors_get_number_of_annotated_values(vtkNew sself) { return sself->GetNumberOfAnnotatedValues(); } -extern "C" void vtk_scalars_to_colors_get_indexed_color(vtkNew sself, long long i, double rgba) { sself->GetIndexedColor(i, rgba); } -extern "C" void vtk_scalars_to_colors_reset_annotations(vtkNew sself) { sself->ResetAnnotations(); } -extern "C" void vtk_scalars_to_colors_set_indexed_lookup(vtkNew sself, int _arg) { sself->SetIndexedLookup(_arg); } -extern "C" int vtk_scalars_to_colors_get_indexed_lookup(vtkNew sself) { return sself->GetIndexedLookup(); } -extern "C" void vtk_scalars_to_colors_indexed_lookup_on(vtkNew sself) { sself->IndexedLookupOn(); } -extern "C" void vtk_scalars_to_colors_indexed_lookup_off(vtkNew sself) { sself->IndexedLookupOff(); } -extern "C" vtkNew < vtkShortArray > vtkShortArray_new () {return vtkNew < vtkShortArray > () ;} -extern "C" void vtkShortArray_destructor (vtkNew < vtkShortArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkShortArray_get_ptr (vtkNew < vtkShortArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_short_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_short_array_get_typed_tuple(vtkNew sself, long long i, short tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_short_array_set_typed_tuple(vtkNew sself, long long i, const short tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_short_array_insert_typed_tuple(vtkNew sself, long long i, const short tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_short_array_insert_next_typed_tuple(vtkNew sself, const short tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" short vtk_short_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_short_array_set_value(vtkNew sself, long long id, short value) { sself->SetValue(id, value); } -extern "C" bool vtk_short_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_short_array_insert_value(vtkNew sself, long long id, short f) { sself->InsertValue(id, f); } -extern "C" long long vtk_short_array_insert_next_value(vtkNew sself, short f) { return sself->InsertNextValue(f); } -extern "C" short* vtk_short_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" short* vtk_short_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" short* vtk_short_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" short* vtk_short_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_short_array_set_array(vtkNew sself, short array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_short_array_set_array(vtkNew sself, short array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" short vtk_short_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" short vtk_short_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkSignedCharArray > vtkSignedCharArray_new () {return vtkNew < vtkSignedCharArray > () ;} -extern "C" void vtkSignedCharArray_destructor (vtkNew < vtkSignedCharArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSignedCharArray_get_ptr (vtkNew < vtkSignedCharArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_signed_char_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_signed_char_array_get_typed_tuple(vtkNew sself, long long i, char tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_signed_char_array_set_typed_tuple(vtkNew sself, long long i, const char tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_signed_char_array_insert_typed_tuple(vtkNew sself, long long i, const char tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_signed_char_array_insert_next_typed_tuple(vtkNew sself, const char tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" char vtk_signed_char_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_signed_char_array_set_value(vtkNew sself, long long id, char value) { sself->SetValue(id, value); } -extern "C" bool vtk_signed_char_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_signed_char_array_insert_value(vtkNew sself, long long id, char f) { sself->InsertValue(id, f); } -extern "C" long long vtk_signed_char_array_insert_next_value(vtkNew sself, char f) { return sself->InsertNextValue(f); } -extern "C" char* vtk_signed_char_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" char* vtk_signed_char_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" char* vtk_signed_char_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" char* vtk_signed_char_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_signed_char_array_set_array(vtkNew sself, char array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_signed_char_array_set_array(vtkNew sself, char array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" char vtk_signed_char_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" char vtk_signed_char_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkSortDataArray > vtkSortDataArray_new () {return vtkNew < vtkSortDataArray > () ;} -extern "C" void vtkSortDataArray_destructor (vtkNew < vtkSortDataArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSortDataArray_get_ptr (vtkNew < vtkSortDataArray > sself) {return sself . GetPointer () ;} -extern "C" long long* vtk_sort_data_array_initialize_sort_indices(vtkNew sself, long long numKeys) { return sself->InitializeSortIndices(numKeys); } -extern "C" void vtk_sort_data_array_generate_sort_indices(vtkNew sself, int dataType, void dataIn, long long numKeys, int numComp, int k, long long idx) { sself->GenerateSortIndices(dataType, dataIn, numKeys, numComp, k, idx); } -extern "C" vtkNew < vtkStringArray > vtkStringArray_new () {return vtkNew < vtkStringArray > () ;} -extern "C" void vtkStringArray_destructor (vtkNew < vtkStringArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStringArray_get_ptr (vtkNew < vtkStringArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_string_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" int vtk_string_array_is_numeric(vtkNew sself) { return sself->IsNumeric(); } -extern "C" void vtk_string_array_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_string_array_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } -extern "C" void vtk_string_array_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" int vtk_string_array_resize(vtkNew sself, long long numTuples) { return sself->Resize(numTuples); } -extern "C" int vtk_string_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } -extern "C" void vtk_string_array_set_value(vtkNew sself, long long id, const char value) { sself->SetValue(id, value); } -extern "C" void vtk_string_array_set_number_of_tuples(vtkNew sself, long long number) { sself->SetNumberOfTuples(number); } -extern "C" long long vtk_string_array_get_number_of_values(vtkNew sself) { return sself->GetNumberOfValues(); } -extern "C" int vtk_string_array_get_number_of_element_components(vtkNew sself) { return sself->GetNumberOfElementComponents(); } -extern "C" int vtk_string_array_get_element_component_size(vtkNew sself) { return sself->GetElementComponentSize(); } -extern "C" void vtk_string_array_insert_value(vtkNew sself, long long id, const char val) { sself->InsertValue(id, val); } -extern "C" long long vtk_string_array_insert_next_value(vtkNew sself, const char f) { return sself->InsertNextValue(f); } -extern "C" void* vtk_string_array_get_void_pointer(vtkNew sself, long long id) { return sself->GetVoidPointer(id); } -extern "C" void vtk_string_array_set_void_array(vtkNew sself, void array, long long size, int save) { sself->SetVoidArray(array, size, save); } -extern "C" unsigned long vtk_string_array_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" long long vtk_string_array_get_data_size(vtkNew sself) { return sself->GetDataSize(); } -extern "C" long long vtk_string_array_lookup_value(vtkNew sself, const char value) { return sself->LookupValue(value); } -extern "C" void vtk_string_array_data_changed(vtkNew sself) { sself->DataChanged(); } -extern "C" void vtk_string_array_data_element_changed(vtkNew sself, long long id) { sself->DataElementChanged(id); } -extern "C" void vtk_string_array_clear_lookup(vtkNew sself) { sself->ClearLookup(); } -extern "C" vtkNew < vtkStringOutputWindow > vtkStringOutputWindow_new () {return vtkNew < vtkStringOutputWindow > () ;} -extern "C" void vtkStringOutputWindow_destructor (vtkNew < vtkStringOutputWindow > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStringOutputWindow_get_ptr (vtkNew < vtkStringOutputWindow > sself) {return sself . GetPointer () ;} -extern "C" void vtk_string_output_window_display_text(vtkNew sself, const char p0) { sself->DisplayText(p0); } -extern "C" const char* vtk_string_output_window_get_output(vtkNew sself) { return sself->GetOutput(); } -extern "C" vtkNew < vtkTimePointUtility > vtkTimePointUtility_new () {return vtkNew < vtkTimePointUtility > () ;} -extern "C" void vtkTimePointUtility_destructor (vtkNew < vtkTimePointUtility > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTimePointUtility_get_ptr (vtkNew < vtkTimePointUtility > sself) {return sself . GetPointer () ;} -extern "C" unsigned long long vtk_time_point_utility_date_to_time_point(vtkNew sself, int year, int month, int day) { return sself->DateToTimePoint(year, month, day); } -extern "C" unsigned long long vtk_time_point_utility_time_to_time_point(vtkNew sself, int hour, int minute, int second, int millis) { return sself->TimeToTimePoint(hour, minute, second, millis); } -extern "C" unsigned long long vtk_time_point_utility_date_time_to_time_point(vtkNew sself, int year, int month, int day, int hour, int minute, int sec, int millis) { return sself->DateTimeToTimePoint(year, month, day, hour, minute, sec, millis); } -extern "C" void vtk_time_point_utility_get_date(vtkNew sself, unsigned long long time, int year, int month, int day) { sself->GetDate(time, year, month, day); } -extern "C" void vtk_time_point_utility_get_time(vtkNew sself, unsigned long long time, int hour, int minute, int second, int millis) { sself->GetTime(time, hour, minute, second, millis); } -extern "C" void vtk_time_point_utility_get_date_time(vtkNew sself, unsigned long long time, int year, int month, int day, int hour, int minute, int second, int millis) { sself->GetDateTime(time, year, month, day, hour, minute, second, millis); } -extern "C" int vtk_time_point_utility_get_year(vtkNew sself, unsigned long long time) { return sself->GetYear(time); } -extern "C" int vtk_time_point_utility_get_month(vtkNew sself, unsigned long long time) { return sself->GetMonth(time); } -extern "C" int vtk_time_point_utility_get_day(vtkNew sself, unsigned long long time) { return sself->GetDay(time); } -extern "C" int vtk_time_point_utility_get_hour(vtkNew sself, unsigned long long time) { return sself->GetHour(time); } -extern "C" int vtk_time_point_utility_get_minute(vtkNew sself, unsigned long long time) { return sself->GetMinute(time); } -extern "C" int vtk_time_point_utility_get_second(vtkNew sself, unsigned long long time) { return sself->GetSecond(time); } -extern "C" int vtk_time_point_utility_get_millisecond(vtkNew sself, unsigned long long time) { return sself->GetMillisecond(time); } -extern "C" unsigned long long vtk_time_point_utility_iso_8601_to_time_point(vtkNew sself, const char str, bool ok) { return sself->ISO8601ToTimePoint(str, ok); } -extern "C" const char* vtk_time_point_utility_time_point_to_iso_8601(vtkNew sself, unsigned long long p0, int format) { return sself->TimePointToISO8601(p0, format); } -extern "C" vtkNew < vtkTypeFloat32Array > vtkTypeFloat32Array_new () {return vtkNew < vtkTypeFloat32Array > () ;} -extern "C" void vtkTypeFloat32Array_destructor (vtkNew < vtkTypeFloat32Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeFloat32Array_get_ptr (vtkNew < vtkTypeFloat32Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeFloat64Array > vtkTypeFloat64Array_new () {return vtkNew < vtkTypeFloat64Array > () ;} -extern "C" void vtkTypeFloat64Array_destructor (vtkNew < vtkTypeFloat64Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeFloat64Array_get_ptr (vtkNew < vtkTypeFloat64Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeInt16Array > vtkTypeInt16Array_new () {return vtkNew < vtkTypeInt16Array > () ;} -extern "C" void vtkTypeInt16Array_destructor (vtkNew < vtkTypeInt16Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeInt16Array_get_ptr (vtkNew < vtkTypeInt16Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeInt32Array > vtkTypeInt32Array_new () {return vtkNew < vtkTypeInt32Array > () ;} -extern "C" void vtkTypeInt32Array_destructor (vtkNew < vtkTypeInt32Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeInt32Array_get_ptr (vtkNew < vtkTypeInt32Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeInt64Array > vtkTypeInt64Array_new () {return vtkNew < vtkTypeInt64Array > () ;} -extern "C" void vtkTypeInt64Array_destructor (vtkNew < vtkTypeInt64Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeInt64Array_get_ptr (vtkNew < vtkTypeInt64Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeInt8Array > vtkTypeInt8Array_new () {return vtkNew < vtkTypeInt8Array > () ;} -extern "C" void vtkTypeInt8Array_destructor (vtkNew < vtkTypeInt8Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeInt8Array_get_ptr (vtkNew < vtkTypeInt8Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeUInt16Array > vtkTypeUInt16Array_new () {return vtkNew < vtkTypeUInt16Array > () ;} -extern "C" void vtkTypeUInt16Array_destructor (vtkNew < vtkTypeUInt16Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeUInt16Array_get_ptr (vtkNew < vtkTypeUInt16Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeUInt32Array > vtkTypeUInt32Array_new () {return vtkNew < vtkTypeUInt32Array > () ;} -extern "C" void vtkTypeUInt32Array_destructor (vtkNew < vtkTypeUInt32Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeUInt32Array_get_ptr (vtkNew < vtkTypeUInt32Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeUInt64Array > vtkTypeUInt64Array_new () {return vtkNew < vtkTypeUInt64Array > () ;} -extern "C" void vtkTypeUInt64Array_destructor (vtkNew < vtkTypeUInt64Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeUInt64Array_get_ptr (vtkNew < vtkTypeUInt64Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeUInt8Array > vtkTypeUInt8Array_new () {return vtkNew < vtkTypeUInt8Array > () ;} -extern "C" void vtkTypeUInt8Array_destructor (vtkNew < vtkTypeUInt8Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeUInt8Array_get_ptr (vtkNew < vtkTypeUInt8Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnicodeStringArray > vtkUnicodeStringArray_new () {return vtkNew < vtkUnicodeStringArray > () ;} -extern "C" void vtkUnicodeStringArray_destructor (vtkNew < vtkUnicodeStringArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnicodeStringArray_get_ptr (vtkNew < vtkUnicodeStringArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_unicode_string_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } -extern "C" void vtk_unicode_string_array_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_unicode_string_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" int vtk_unicode_string_array_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } -extern "C" int vtk_unicode_string_array_get_element_component_size(vtkNew sself) { return sself->GetElementComponentSize(); } -extern "C" void vtk_unicode_string_array_set_number_of_tuples(vtkNew sself, long long number) { sself->SetNumberOfTuples(number); } -extern "C" void* vtk_unicode_string_array_get_void_pointer(vtkNew sself, long long id) { return sself->GetVoidPointer(id); } -extern "C" void vtk_unicode_string_array_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" int vtk_unicode_string_array_resize(vtkNew sself, long long numTuples) { return sself->Resize(numTuples); } -extern "C" void vtk_unicode_string_array_set_void_array(vtkNew sself, void array, long long size, int save) { sself->SetVoidArray(array, size, save); } -extern "C" unsigned long vtk_unicode_string_array_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" int vtk_unicode_string_array_is_numeric(vtkNew sself) { return sself->IsNumeric(); } -extern "C" void vtk_unicode_string_array_data_changed(vtkNew sself) { sself->DataChanged(); } -extern "C" void vtk_unicode_string_array_clear_lookup(vtkNew sself) { sself->ClearLookup(); } -extern "C" void vtk_unicode_string_array_insert_next_utf_8_value(vtkNew sself, const char p0) { sself->InsertNextUTF8Value(p0); } -extern "C" void vtk_unicode_string_array_set_utf_8_value(vtkNew sself, long long i, const char p1) { sself->SetUTF8Value(i, p1); } -extern "C" const char* vtk_unicode_string_array_get_utf_8_value(vtkNew sself, long long i) { return sself->GetUTF8Value(i); } -extern "C" vtkNew < vtkUnsignedCharArray > vtkUnsignedCharArray_new () {return vtkNew < vtkUnsignedCharArray > () ;} -extern "C" void vtkUnsignedCharArray_destructor (vtkNew < vtkUnsignedCharArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnsignedCharArray_get_ptr (vtkNew < vtkUnsignedCharArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_unsigned_char_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_unsigned_char_array_get_typed_tuple(vtkNew sself, long long i, unsigned char tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_unsigned_char_array_set_typed_tuple(vtkNew sself, long long i, const unsigned char tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_unsigned_char_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned char tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_unsigned_char_array_insert_next_typed_tuple(vtkNew sself, const unsigned char tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" unsigned char vtk_unsigned_char_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_unsigned_char_array_set_value(vtkNew sself, long long id, unsigned char value) { sself->SetValue(id, value); } -extern "C" bool vtk_unsigned_char_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_unsigned_char_array_insert_value(vtkNew sself, long long id, unsigned char f) { sself->InsertValue(id, f); } -extern "C" long long vtk_unsigned_char_array_insert_next_value(vtkNew sself, unsigned char f) { return sself->InsertNextValue(f); } -extern "C" unsigned char* vtk_unsigned_char_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" unsigned char* vtk_unsigned_char_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" unsigned char* vtk_unsigned_char_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" unsigned char* vtk_unsigned_char_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_unsigned_char_array_set_array(vtkNew sself, unsigned char array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_unsigned_char_array_set_array(vtkNew sself, unsigned char array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkUnsignedIntArray > vtkUnsignedIntArray_new () {return vtkNew < vtkUnsignedIntArray > () ;} -extern "C" void vtkUnsignedIntArray_destructor (vtkNew < vtkUnsignedIntArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnsignedIntArray_get_ptr (vtkNew < vtkUnsignedIntArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_unsigned_int_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_unsigned_int_array_get_typed_tuple(vtkNew sself, long long i, unsigned int tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_unsigned_int_array_set_typed_tuple(vtkNew sself, long long i, const unsigned int tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_unsigned_int_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned int tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_unsigned_int_array_insert_next_typed_tuple(vtkNew sself, const unsigned int tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" unsigned int vtk_unsigned_int_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_unsigned_int_array_set_value(vtkNew sself, long long id, unsigned int value) { sself->SetValue(id, value); } -extern "C" bool vtk_unsigned_int_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_unsigned_int_array_insert_value(vtkNew sself, long long id, unsigned int f) { sself->InsertValue(id, f); } -extern "C" long long vtk_unsigned_int_array_insert_next_value(vtkNew sself, unsigned int f) { return sself->InsertNextValue(f); } -extern "C" unsigned int* vtk_unsigned_int_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" unsigned int* vtk_unsigned_int_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" unsigned int* vtk_unsigned_int_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" unsigned int* vtk_unsigned_int_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_unsigned_int_array_set_array(vtkNew sself, unsigned int array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_unsigned_int_array_set_array(vtkNew sself, unsigned int array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkUnsignedLongArray > vtkUnsignedLongArray_new () {return vtkNew < vtkUnsignedLongArray > () ;} -extern "C" void vtkUnsignedLongArray_destructor (vtkNew < vtkUnsignedLongArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnsignedLongArray_get_ptr (vtkNew < vtkUnsignedLongArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_unsigned_long_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_unsigned_long_array_get_typed_tuple(vtkNew sself, long long i, unsigned long tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_unsigned_long_array_set_typed_tuple(vtkNew sself, long long i, const unsigned long tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_unsigned_long_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned long tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_unsigned_long_array_insert_next_typed_tuple(vtkNew sself, const unsigned long tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" unsigned long vtk_unsigned_long_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_unsigned_long_array_set_value(vtkNew sself, long long id, unsigned long value) { sself->SetValue(id, value); } -extern "C" bool vtk_unsigned_long_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_unsigned_long_array_insert_value(vtkNew sself, long long id, unsigned long f) { sself->InsertValue(id, f); } -extern "C" long long vtk_unsigned_long_array_insert_next_value(vtkNew sself, unsigned long f) { return sself->InsertNextValue(f); } -extern "C" unsigned long* vtk_unsigned_long_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" unsigned long* vtk_unsigned_long_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" unsigned long* vtk_unsigned_long_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" unsigned long* vtk_unsigned_long_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_unsigned_long_array_set_array(vtkNew sself, unsigned long array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_unsigned_long_array_set_array(vtkNew sself, unsigned long array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkUnsignedLongLongArray > vtkUnsignedLongLongArray_new () {return vtkNew < vtkUnsignedLongLongArray > () ;} -extern "C" void vtkUnsignedLongLongArray_destructor (vtkNew < vtkUnsignedLongLongArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnsignedLongLongArray_get_ptr (vtkNew < vtkUnsignedLongLongArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_unsigned_long_long_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_unsigned_long_long_array_get_typed_tuple(vtkNew sself, long long i, unsigned long long tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_unsigned_long_long_array_set_typed_tuple(vtkNew sself, long long i, const unsigned long long tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_unsigned_long_long_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned long long tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_unsigned_long_long_array_insert_next_typed_tuple(vtkNew sself, const unsigned long long tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" unsigned long long vtk_unsigned_long_long_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_unsigned_long_long_array_set_value(vtkNew sself, long long id, unsigned long long value) { sself->SetValue(id, value); } -extern "C" bool vtk_unsigned_long_long_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_unsigned_long_long_array_insert_value(vtkNew sself, long long id, unsigned long long f) { sself->InsertValue(id, f); } -extern "C" long long vtk_unsigned_long_long_array_insert_next_value(vtkNew sself, unsigned long long f) { return sself->InsertNextValue(f); } -extern "C" unsigned long long* vtk_unsigned_long_long_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" unsigned long long* vtk_unsigned_long_long_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" unsigned long long* vtk_unsigned_long_long_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" unsigned long long* vtk_unsigned_long_long_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_unsigned_long_long_array_set_array(vtkNew sself, unsigned long long array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_unsigned_long_long_array_set_array(vtkNew sself, unsigned long long array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkUnsignedShortArray > vtkUnsignedShortArray_new () {return vtkNew < vtkUnsignedShortArray > () ;} -extern "C" void vtkUnsignedShortArray_destructor (vtkNew < vtkUnsignedShortArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnsignedShortArray_get_ptr (vtkNew < vtkUnsignedShortArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_unsigned_short_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" void vtk_unsigned_short_array_get_typed_tuple(vtkNew sself, long long i, unsigned short tuple) { sself->GetTypedTuple(i, tuple); } -extern "C" void vtk_unsigned_short_array_set_typed_tuple(vtkNew sself, long long i, const unsigned short tuple) { sself->SetTypedTuple(i, tuple); } -extern "C" void vtk_unsigned_short_array_insert_typed_tuple(vtkNew sself, long long i, const unsigned short tuple) { sself->InsertTypedTuple(i, tuple); } -extern "C" long long vtk_unsigned_short_array_insert_next_typed_tuple(vtkNew sself, const unsigned short tuple) { return sself->InsertNextTypedTuple(tuple); } -extern "C" unsigned short vtk_unsigned_short_array_get_value(vtkNew sself, long long id) { return sself->GetValue(id); } -extern "C" void vtk_unsigned_short_array_set_value(vtkNew sself, long long id, unsigned short value) { sself->SetValue(id, value); } -extern "C" bool vtk_unsigned_short_array_set_number_of_values(vtkNew sself, long long number) { return sself->SetNumberOfValues(number); } -extern "C" void vtk_unsigned_short_array_insert_value(vtkNew sself, long long id, unsigned short f) { sself->InsertValue(id, f); } -extern "C" long long vtk_unsigned_short_array_insert_next_value(vtkNew sself, unsigned short f) { return sself->InsertNextValue(f); } -extern "C" unsigned short* vtk_unsigned_short_array_get_value_range(vtkNew sself, int comp) { return sself->GetValueRange(comp); } -extern "C" unsigned short* vtk_unsigned_short_array_get_value_range(vtkNew sself) { return sself->GetValueRange(); } -extern "C" unsigned short* vtk_unsigned_short_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" unsigned short* vtk_unsigned_short_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void vtk_unsigned_short_array_set_array(vtkNew sself, unsigned short array, long long size, int save) { sself->SetArray(array, size, save); } -extern "C" void vtk_unsigned_short_array_set_array(vtkNew sself, unsigned short array, long long size, int save, int deleteMethod) { sself->SetArray(array, size, save, deleteMethod); } -extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_min(vtkNew sself) { return sself->GetDataTypeValueMin(); } -extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_max(vtkNew sself) { return sself->GetDataTypeValueMax(); } -extern "C" vtkNew < vtkVariantArray > vtkVariantArray_new () {return vtkNew < vtkVariantArray > () ;} -extern "C" void vtkVariantArray_destructor (vtkNew < vtkVariantArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVariantArray_get_ptr (vtkNew < vtkVariantArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_variant_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } -extern "C" void vtk_variant_array_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_variant_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" int vtk_variant_array_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } -extern "C" int vtk_variant_array_get_element_component_size(vtkNew sself) { return sself->GetElementComponentSize(); } -extern "C" void vtk_variant_array_set_number_of_tuples(vtkNew sself, long long number) { sself->SetNumberOfTuples(number); } -extern "C" void* vtk_variant_array_get_void_pointer(vtkNew sself, long long id) { return sself->GetVoidPointer(id); } -extern "C" void vtk_variant_array_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" int vtk_variant_array_resize(vtkNew sself, long long numTuples) { return sself->Resize(numTuples); } -extern "C" void vtk_variant_array_set_void_array(vtkNew sself, void arr, long long size, int save) { sself->SetVoidArray(arr, size, save); } -extern "C" void vtk_variant_array_set_void_array(vtkNew sself, void arr, long long size, int save, int deleteM) { sself->SetVoidArray(arr, size, save, deleteM); } -extern "C" unsigned long vtk_variant_array_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" int vtk_variant_array_is_numeric(vtkNew sself) { return sself->IsNumeric(); } -extern "C" long long vtk_variant_array_get_number_of_values(vtkNew sself) { return sself->GetNumberOfValues(); } -extern "C" void vtk_variant_array_data_changed(vtkNew sself) { sself->DataChanged(); } -extern "C" void vtk_variant_array_data_element_changed(vtkNew sself, long long id) { sself->DataElementChanged(id); } -extern "C" void vtk_variant_array_clear_lookup(vtkNew sself) { sself->ClearLookup(); } -extern "C" vtkNew < vtkVersion > vtkVersion_new () {return vtkNew < vtkVersion > () ;} -extern "C" void vtkVersion_destructor (vtkNew < vtkVersion > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVersion_get_ptr (vtkNew < vtkVersion > sself) {return sself . GetPointer () ;} -extern "C" const char* vtk_version_get_vtk_version(vtkNew sself) { return sself->GetVTKVersion(); } -extern "C" const char* vtk_version_get_vtk_version_full(vtkNew sself) { return sself->GetVTKVersionFull(); } -extern "C" int vtk_version_get_vtk_major_version(vtkNew sself) { return sself->GetVTKMajorVersion(); } -extern "C" int vtk_version_get_vtk_minor_version(vtkNew sself) { return sself->GetVTKMinorVersion(); } -extern "C" int vtk_version_get_vtk_build_version(vtkNew sself) { return sself->GetVTKBuildVersion(); } -extern "C" const char* vtk_version_get_vtk_source_version(vtkNew sself) { return sself->GetVTKSourceVersion(); } -extern "C" vtkNew < vtkVoidArray > vtkVoidArray_new () {return vtkNew < vtkVoidArray > () ;} -extern "C" void vtkVoidArray_destructor (vtkNew < vtkVoidArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVoidArray_get_ptr (vtkNew < vtkVoidArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_void_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } -extern "C" void vtk_void_array_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_void_array_get_data_type(vtkNew sself) { return sself->GetDataType(); } -extern "C" int vtk_void_array_get_data_type_size(vtkNew sself) { return sself->GetDataTypeSize(); } -extern "C" void vtk_void_array_set_number_of_pointers(vtkNew sself, long long number) { sself->SetNumberOfPointers(number); } -extern "C" long long vtk_void_array_get_number_of_pointers(vtkNew sself) { return sself->GetNumberOfPointers(); } -extern "C" void* vtk_void_array_get_void_pointer(vtkNew sself, long long id) { return sself->GetVoidPointer(id); } -extern "C" void vtk_void_array_set_void_pointer(vtkNew sself, long long id, void ptr) { sself->SetVoidPointer(id, ptr); } -extern "C" void vtk_void_array_insert_void_pointer(vtkNew sself, long long i, void ptr) { sself->InsertVoidPointer(i, ptr); } -extern "C" long long vtk_void_array_insert_next_void_pointer(vtkNew sself, void tuple) { return sself->InsertNextVoidPointer(tuple); } -extern "C" void vtk_void_array_reset(vtkNew sself) { sself->Reset(); } -extern "C" void vtk_void_array_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" void&* vtk_void_array_get_pointer(vtkNew sself, long long id) { return sself->GetPointer(id); } -extern "C" void&* vtk_void_array_write_pointer(vtkNew sself, long long id, long long number) { return sself->WritePointer(id, number); } -extern "C" vtkNew < vtkWeakReference > vtkWeakReference_new () {return vtkNew < vtkWeakReference > () ;} -extern "C" void vtkWeakReference_destructor (vtkNew < vtkWeakReference > sself) {sself . Reset () ; return ;} -extern "C" void * vtkWeakReference_get_ptr (vtkNew < vtkWeakReference > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkXMLFileOutputWindow > vtkXMLFileOutputWindow_new () {return vtkNew < vtkXMLFileOutputWindow > () ;} -extern "C" void vtkXMLFileOutputWindow_destructor (vtkNew < vtkXMLFileOutputWindow > sself) {sself . Reset () ; return ;} -extern "C" void * vtkXMLFileOutputWindow_get_ptr (vtkNew < vtkXMLFileOutputWindow > sself) {return sself . GetPointer () ;} -extern "C" void vtk_xml_file_output_window_display_text(vtkNew sself, const char p0) { sself->DisplayText(p0); } -extern "C" void vtk_xml_file_output_window_display_tag(vtkNew sself, const char p0) { sself->DisplayTag(p0); } +extern "C" vtkAnimationCue * vtkAnimationCue_new () {return vtkAnimationCue :: New () ;} +extern "C" void vtkAnimationCue_destructor (vtkAnimationCue * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAnimationCue_get_ptr (vtkAnimationCue * sself) {return sself ;} +extern "C" void vtk_animation_cue_set_time_mode(vtkAnimationCue* sself, int mode) { sself->SetTimeMode(mode); } +extern "C" int vtk_animation_cue_get_time_mode(vtkAnimationCue* sself) { return sself->GetTimeMode(); } +extern "C" void vtk_animation_cue_set_time_mode_to_relative(vtkAnimationCue* sself) { sself->SetTimeModeToRelative(); } +extern "C" void vtk_animation_cue_set_time_mode_to_normalized(vtkAnimationCue* sself) { sself->SetTimeModeToNormalized(); } +extern "C" void vtk_animation_cue_set_start_time(vtkAnimationCue* sself, double _arg) { sself->SetStartTime(_arg); } +extern "C" double vtk_animation_cue_get_start_time(vtkAnimationCue* sself) { return sself->GetStartTime(); } +extern "C" void vtk_animation_cue_set_end_time(vtkAnimationCue* sself, double _arg) { sself->SetEndTime(_arg); } +extern "C" double vtk_animation_cue_get_end_time(vtkAnimationCue* sself) { return sself->GetEndTime(); } +extern "C" void vtk_animation_cue_tick(vtkAnimationCue* sself, double currenttime, double deltatime, double clocktime) { sself->Tick(currenttime, deltatime, clocktime); } +extern "C" void vtk_animation_cue_initialize(vtkAnimationCue* sself) { sself->Initialize(); } +extern "C" void vtk_animation_cue_finalize(vtkAnimationCue* sself) { sself->Finalize(); } +extern "C" double vtk_animation_cue_get_animation_time(vtkAnimationCue* sself) { return sself->GetAnimationTime(); } +extern "C" double vtk_animation_cue_get_delta_time(vtkAnimationCue* sself) { return sself->GetDeltaTime(); } +extern "C" double vtk_animation_cue_get_clock_time(vtkAnimationCue* sself) { return sself->GetClockTime(); } +extern "C" vtkArchiver * vtkArchiver_new () {return vtkArchiver :: New () ;} +extern "C" void vtkArchiver_destructor (vtkArchiver * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkArchiver_get_ptr (vtkArchiver * sself) {return sself ;} +extern "C" void vtk_archiver_set_archive_name(vtkArchiver* sself, const char* _arg) { sself->SetArchiveName(_arg); } +extern "C" void vtk_archiver_open_archive(vtkArchiver* sself) { sself->OpenArchive(); } +extern "C" void vtk_archiver_close_archive(vtkArchiver* sself) { sself->CloseArchive(); } +extern "C" void vtk_archiver_insert_into_archive(vtkArchiver* sself, const char*& relativePath, const char* data, size_t size) { sself->InsertIntoArchive(relativePath, data, size); } +extern "C" bool vtk_archiver_contains(vtkArchiver* sself, const char*& relativePath) { return sself->Contains(relativePath); } +extern "C" vtkBitArray * vtkBitArray_new () {return vtkBitArray :: New () ;} +extern "C" void vtkBitArray_destructor (vtkBitArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBitArray_get_ptr (vtkBitArray * sself) {return sself ;} +extern "C" int vtk_bit_array_allocate(vtkBitArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_bit_array_initialize(vtkBitArray* sself) { sself->Initialize(); } +extern "C" int vtk_bit_array_get_data_type(vtkBitArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_bit_array_get_data_type_size(vtkBitArray* sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_bit_array_set_number_of_tuples(vtkBitArray* sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" bool vtk_bit_array_set_number_of_values(vtkBitArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_bit_array_remove_tuple(vtkBitArray* sself, long long id) { sself->RemoveTuple(id); } +extern "C" void vtk_bit_array_set_component(vtkBitArray* sself, long long i, int j, double c) { sself->SetComponent(i, j, c); } +extern "C" void vtk_bit_array_squeeze(vtkBitArray* sself) { sself->Squeeze(); } +extern "C" int vtk_bit_array_resize(vtkBitArray* sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" int vtk_bit_array_get_value(vtkBitArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_bit_array_set_value(vtkBitArray* sself, long long id, int value) { sself->SetValue(id, value); } +extern "C" void vtk_bit_array_insert_value(vtkBitArray* sself, long long id, int i) { sself->InsertValue(id, i); } +extern "C" long long vtk_bit_array_insert_next_value(vtkBitArray* sself, int i) { return sself->InsertNextValue(i); } +extern "C" void vtk_bit_array_insert_component(vtkBitArray* sself, long long i, int j, double c) { sself->InsertComponent(i, j, c); } +extern "C" void* vtk_bit_array_write_void_pointer(vtkBitArray* sself, long long id, long long number) { return sself->WriteVoidPointer(id, number); } +extern "C" void* vtk_bit_array_get_void_pointer(vtkBitArray* sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_bit_array_set_void_array(vtkBitArray* sself, void* array, long long size, int save) { sself->SetVoidArray(array, size, save); } +extern "C" void vtk_bit_array_data_changed(vtkBitArray* sself) { sself->DataChanged(); } +extern "C" void vtk_bit_array_clear_lookup(vtkBitArray* sself) { sself->ClearLookup(); } +extern "C" vtkBitArrayIterator * vtkBitArrayIterator_new () {return vtkBitArrayIterator :: New () ;} +extern "C" void vtkBitArrayIterator_destructor (vtkBitArrayIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBitArrayIterator_get_ptr (vtkBitArrayIterator * sself) {return sself ;} +extern "C" int vtk_bit_array_iterator_get_value(vtkBitArrayIterator* sself, long long id) { return sself->GetValue(id); } +extern "C" long long vtk_bit_array_iterator_get_number_of_tuples(vtkBitArrayIterator* sself) { return sself->GetNumberOfTuples(); } +extern "C" long long vtk_bit_array_iterator_get_number_of_values(vtkBitArrayIterator* sself) { return sself->GetNumberOfValues(); } +extern "C" int vtk_bit_array_iterator_get_number_of_components(vtkBitArrayIterator* sself) { return sself->GetNumberOfComponents(); } +extern "C" int vtk_bit_array_iterator_get_data_type(vtkBitArrayIterator* sself) { return sself->GetDataType(); } +extern "C" int vtk_bit_array_iterator_get_data_type_size(vtkBitArrayIterator* sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_bit_array_iterator_set_value(vtkBitArrayIterator* sself, long long id, int value) { sself->SetValue(id, value); } +extern "C" vtkBoxMuellerRandomSequence * vtkBoxMuellerRandomSequence_new () {return vtkBoxMuellerRandomSequence :: New () ;} +extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkBoxMuellerRandomSequence * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBoxMuellerRandomSequence_get_ptr (vtkBoxMuellerRandomSequence * sself) {return sself ;} +extern "C" void vtk_box_mueller_random_sequence_initialize(vtkBoxMuellerRandomSequence* sself, unsigned int seed) { sself->Initialize(seed); } +extern "C" double vtk_box_mueller_random_sequence_get_value(vtkBoxMuellerRandomSequence* sself) { return sself->GetValue(); } +extern "C" void vtk_box_mueller_random_sequence_next(vtkBoxMuellerRandomSequence* sself) { sself->Next(); } +extern "C" vtkByteSwap * vtkByteSwap_new () {return vtkByteSwap :: New () ;} +extern "C" void vtkByteSwap_destructor (vtkByteSwap * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkByteSwap_get_ptr (vtkByteSwap * sself) {return sself ;} +extern "C" void vtk_byte_swap_swap_2_le(vtkByteSwap* sself, void* p) { sself->Swap2LE(p); } +extern "C" void vtk_byte_swap_swap_4_le(vtkByteSwap* sself, void* p) { sself->Swap4LE(p); } +extern "C" void vtk_byte_swap_swap_8_le(vtkByteSwap* sself, void* p) { sself->Swap8LE(p); } +extern "C" void vtk_byte_swap_swap_2_le_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap2LERange(p, num); } +extern "C" void vtk_byte_swap_swap_4_le_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap4LERange(p, num); } +extern "C" void vtk_byte_swap_swap_8_le_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap8LERange(p, num); } +extern "C" void vtk_byte_swap_swap_2_be(vtkByteSwap* sself, void* p) { sself->Swap2BE(p); } +extern "C" void vtk_byte_swap_swap_4_be(vtkByteSwap* sself, void* p) { sself->Swap4BE(p); } +extern "C" void vtk_byte_swap_swap_8_be(vtkByteSwap* sself, void* p) { sself->Swap8BE(p); } +extern "C" void vtk_byte_swap_swap_2_be_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap2BERange(p, num); } +extern "C" void vtk_byte_swap_swap_4_be_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap4BERange(p, num); } +extern "C" void vtk_byte_swap_swap_8_be_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap8BERange(p, num); } +extern "C" void vtk_byte_swap_swap_void_range(vtkByteSwap* sself, void* buffer, size_t numWords, size_t wordSize) { sself->SwapVoidRange(buffer, numWords, wordSize); } +extern "C" vtkCallbackCommand * vtkCallbackCommand_new () {return vtkCallbackCommand :: New () ;} +extern "C" void vtkCallbackCommand_destructor (vtkCallbackCommand * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCallbackCommand_get_ptr (vtkCallbackCommand * sself) {return sself ;} +extern "C" void vtk_callback_command_set_client_data(vtkCallbackCommand* sself, void* cd) { sself->SetClientData(cd); } +extern "C" void* vtk_callback_command_get_client_data(vtkCallbackCommand* sself) { return sself->GetClientData(); } +extern "C" void vtk_callback_command_set_abort_flag_on_execute(vtkCallbackCommand* sself, int f) { sself->SetAbortFlagOnExecute(f); } +extern "C" int vtk_callback_command_get_abort_flag_on_execute(vtkCallbackCommand* sself) { return sself->GetAbortFlagOnExecute(); } +extern "C" void vtk_callback_command_abort_flag_on_execute_on(vtkCallbackCommand* sself) { sself->AbortFlagOnExecuteOn(); } +extern "C" void vtk_callback_command_abort_flag_on_execute_off(vtkCallbackCommand* sself) { sself->AbortFlagOnExecuteOff(); } +extern "C" vtkCharArray * vtkCharArray_new () {return vtkCharArray :: New () ;} +extern "C" void vtkCharArray_destructor (vtkCharArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCharArray_get_ptr (vtkCharArray * sself) {return sself ;} +extern "C" int vtk_char_array_get_data_type(vtkCharArray* sself) { return sself->GetDataType(); } +extern "C" void vtk_char_array_set_typed_tuple(vtkCharArray* sself, long long i, const char* tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_char_array_insert_typed_tuple(vtkCharArray* sself, long long i, const char* tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_char_array_insert_next_typed_tuple(vtkCharArray* sself, const char* tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" char vtk_char_array_get_value(vtkCharArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_char_array_set_value(vtkCharArray* sself, long long id, char value) { sself->SetValue(id, value); } +extern "C" bool vtk_char_array_set_number_of_values(vtkCharArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_char_array_insert_value(vtkCharArray* sself, long long id, char f) { sself->InsertValue(id, f); } +extern "C" long long vtk_char_array_insert_next_value(vtkCharArray* sself, char f) { return sself->InsertNextValue(f); } +extern "C" char vtk_char_array_get_data_type_value_min(vtkCharArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" char vtk_char_array_get_data_type_value_max(vtkCharArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkCollection * vtkCollection_new () {return vtkCollection :: New () ;} +extern "C" void vtkCollection_destructor (vtkCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCollection_get_ptr (vtkCollection * sself) {return sself ;} +extern "C" void vtk_collection_remove_item(vtkCollection* sself, int i) { sself->RemoveItem(i); } +extern "C" void vtk_collection_remove_all_items(vtkCollection* sself) { sself->RemoveAllItems(); } +extern "C" int vtk_collection_get_number_of_items(vtkCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" void vtk_collection_init_traversal(vtkCollection* sself) { sself->InitTraversal(); } +extern "C" vtkCollectionIterator * vtkCollectionIterator_new () {return vtkCollectionIterator :: New () ;} +extern "C" void vtkCollectionIterator_destructor (vtkCollectionIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCollectionIterator_get_ptr (vtkCollectionIterator * sself) {return sself ;} +extern "C" void vtk_collection_iterator_init_traversal(vtkCollectionIterator* sself) { sself->InitTraversal(); } +extern "C" void vtk_collection_iterator_go_to_first_item(vtkCollectionIterator* sself) { sself->GoToFirstItem(); } +extern "C" void vtk_collection_iterator_go_to_next_item(vtkCollectionIterator* sself) { sself->GoToNextItem(); } +extern "C" int vtk_collection_iterator_is_done_with_traversal(vtkCollectionIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" vtkCriticalSection * vtkCriticalSection_new () {return vtkCriticalSection :: New () ;} +extern "C" void vtkCriticalSection_destructor (vtkCriticalSection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCriticalSection_get_ptr (vtkCriticalSection * sself) {return sself ;} +extern "C" void vtk_critical_section_lock(vtkCriticalSection* sself) { sself->Lock(); } +extern "C" void vtk_critical_section_unlock(vtkCriticalSection* sself) { sself->Unlock(); } +extern "C" vtkDataArrayCollection * vtkDataArrayCollection_new () {return vtkDataArrayCollection :: New () ;} +extern "C" void vtkDataArrayCollection_destructor (vtkDataArrayCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataArrayCollection_get_ptr (vtkDataArrayCollection * sself) {return sself ;} +extern "C" int vtk_data_array_collection_get_number_of_items(vtkDataArrayCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" vtkDataArrayCollectionIterator * vtkDataArrayCollectionIterator_new () {return vtkDataArrayCollectionIterator :: New () ;} +extern "C" void vtkDataArrayCollectionIterator_destructor (vtkDataArrayCollectionIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataArrayCollectionIterator_get_ptr (vtkDataArrayCollectionIterator * sself) {return sself ;} +extern "C" vtkDataArraySelection * vtkDataArraySelection_new () {return vtkDataArraySelection :: New () ;} +extern "C" void vtkDataArraySelection_destructor (vtkDataArraySelection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataArraySelection_get_ptr (vtkDataArraySelection * sself) {return sself ;} +extern "C" void vtk_data_array_selection_enable_array(vtkDataArraySelection* sself, const char* name) { sself->EnableArray(name); } +extern "C" void vtk_data_array_selection_disable_array(vtkDataArraySelection* sself, const char* name) { sself->DisableArray(name); } +extern "C" int vtk_data_array_selection_array_is_enabled(vtkDataArraySelection* sself, const char* name) { return sself->ArrayIsEnabled(name); } +extern "C" int vtk_data_array_selection_array_exists(vtkDataArraySelection* sself, const char* name) { return sself->ArrayExists(name); } +extern "C" void vtk_data_array_selection_enable_all_arrays(vtkDataArraySelection* sself) { sself->EnableAllArrays(); } +extern "C" void vtk_data_array_selection_disable_all_arrays(vtkDataArraySelection* sself) { sself->DisableAllArrays(); } +extern "C" int vtk_data_array_selection_get_number_of_arrays(vtkDataArraySelection* sself) { return sself->GetNumberOfArrays(); } +extern "C" int vtk_data_array_selection_get_number_of_arrays_enabled(vtkDataArraySelection* sself) { return sself->GetNumberOfArraysEnabled(); } +extern "C" const char* vtk_data_array_selection_get_array_name(vtkDataArraySelection* sself, int index) { return sself->GetArrayName(index); } +extern "C" int vtk_data_array_selection_get_array_index(vtkDataArraySelection* sself, const char* name) { return sself->GetArrayIndex(name); } +extern "C" int vtk_data_array_selection_get_enabled_array_index(vtkDataArraySelection* sself, const char* name) { return sself->GetEnabledArrayIndex(name); } +extern "C" int vtk_data_array_selection_get_array_setting(vtkDataArraySelection* sself, int index) { return sself->GetArraySetting(index); } +extern "C" void vtk_data_array_selection_set_array_setting(vtkDataArraySelection* sself, const char* name, int setting) { sself->SetArraySetting(name, setting); } +extern "C" void vtk_data_array_selection_remove_all_arrays(vtkDataArraySelection* sself) { sself->RemoveAllArrays(); } +extern "C" int vtk_data_array_selection_add_array(vtkDataArraySelection* sself, const char* name, bool state) { return sself->AddArray(name, state); } +extern "C" void vtk_data_array_selection_remove_array_by_index(vtkDataArraySelection* sself, int index) { sself->RemoveArrayByIndex(index); } +extern "C" void vtk_data_array_selection_remove_array_by_name(vtkDataArraySelection* sself, const char* name) { sself->RemoveArrayByName(name); } +extern "C" void vtk_data_array_selection_set_unknown_array_setting(vtkDataArraySelection* sself, int _arg) { sself->SetUnknownArraySetting(_arg); } +extern "C" int vtk_data_array_selection_get_unknown_array_setting(vtkDataArraySelection* sself) { return sself->GetUnknownArraySetting(); } +extern "C" vtkDebugLeaks * vtkDebugLeaks_new () {return vtkDebugLeaks :: New () ;} +extern "C" void vtkDebugLeaks_destructor (vtkDebugLeaks * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDebugLeaks_get_ptr (vtkDebugLeaks * sself) {return sself ;} +extern "C" int vtk_debug_leaks_print_current_leaks(vtkDebugLeaks* sself) { return sself->PrintCurrentLeaks(); } +extern "C" int vtk_debug_leaks_get_exit_error(vtkDebugLeaks* sself) { return sself->GetExitError(); } +extern "C" void vtk_debug_leaks_set_exit_error(vtkDebugLeaks* sself, int p0) { sself->SetExitError(p0); } +extern "C" vtkDoubleArray * vtkDoubleArray_new () {return vtkDoubleArray :: New () ;} +extern "C" void vtkDoubleArray_destructor (vtkDoubleArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDoubleArray_get_ptr (vtkDoubleArray * sself) {return sself ;} +extern "C" int vtk_double_array_get_data_type(vtkDoubleArray* sself) { return sself->GetDataType(); } +extern "C" double vtk_double_array_get_value(vtkDoubleArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_double_array_set_value(vtkDoubleArray* sself, long long id, double value) { sself->SetValue(id, value); } +extern "C" bool vtk_double_array_set_number_of_values(vtkDoubleArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_double_array_insert_value(vtkDoubleArray* sself, long long id, double f) { sself->InsertValue(id, f); } +extern "C" long long vtk_double_array_insert_next_value(vtkDoubleArray* sself, double f) { return sself->InsertNextValue(f); } +extern "C" double vtk_double_array_get_data_type_value_min(vtkDoubleArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" double vtk_double_array_get_data_type_value_max(vtkDoubleArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkDynamicLoader * vtkDynamicLoader_new () {return vtkDynamicLoader :: New () ;} +extern "C" void vtkDynamicLoader_destructor (vtkDynamicLoader * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDynamicLoader_get_ptr (vtkDynamicLoader * sself) {return sself ;} +extern "C" const char* vtk_dynamic_loader_lib_prefix(vtkDynamicLoader* sself) { return sself->LibPrefix(); } +extern "C" const char* vtk_dynamic_loader_lib_extension(vtkDynamicLoader* sself) { return sself->LibExtension(); } +extern "C" const char* vtk_dynamic_loader_last_error(vtkDynamicLoader* sself) { return sself->LastError(); } +extern "C" vtkEventDataDevice3D * vtkEventDataDevice3D_new () {return vtkEventDataDevice3D :: New () ;} +extern "C" void vtkEventDataDevice3D_destructor (vtkEventDataDevice3D * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkEventDataDevice3D_get_ptr (vtkEventDataDevice3D * sself) {return sself ;} +extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkEventDataDevice3D* sself, double x, double y) { sself->SetTrackPadPosition(x, y); } +extern "C" vtkEventDataForDevice * vtkEventDataForDevice_new () {return vtkEventDataForDevice :: New () ;} +extern "C" void vtkEventDataForDevice_destructor (vtkEventDataForDevice * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkEventDataForDevice_get_ptr (vtkEventDataForDevice * sself) {return sself ;} +extern "C" vtkEventForwarderCommand * vtkEventForwarderCommand_new () {return vtkEventForwarderCommand :: New () ;} +extern "C" void vtkEventForwarderCommand_destructor (vtkEventForwarderCommand * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkEventForwarderCommand_get_ptr (vtkEventForwarderCommand * sself) {return sself ;} +extern "C" void* vtk_event_forwarder_command_get_target(vtkEventForwarderCommand* sself) { return sself->GetTarget(); } +extern "C" vtkFileOutputWindow * vtkFileOutputWindow_new () {return vtkFileOutputWindow :: New () ;} +extern "C" void vtkFileOutputWindow_destructor (vtkFileOutputWindow * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkFileOutputWindow_get_ptr (vtkFileOutputWindow * sself) {return sself ;} +extern "C" void vtk_file_output_window_display_text(vtkFileOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } +extern "C" void vtk_file_output_window_set_file_name(vtkFileOutputWindow* sself, const char* _arg) { sself->SetFileName(_arg); } +extern "C" void vtk_file_output_window_set_flush(vtkFileOutputWindow* sself, int _arg) { sself->SetFlush(_arg); } +extern "C" int vtk_file_output_window_get_flush(vtkFileOutputWindow* sself) { return sself->GetFlush(); } +extern "C" void vtk_file_output_window_flush_on(vtkFileOutputWindow* sself) { sself->FlushOn(); } +extern "C" void vtk_file_output_window_flush_off(vtkFileOutputWindow* sself) { sself->FlushOff(); } +extern "C" void vtk_file_output_window_set_append(vtkFileOutputWindow* sself, int _arg) { sself->SetAppend(_arg); } +extern "C" int vtk_file_output_window_get_append(vtkFileOutputWindow* sself) { return sself->GetAppend(); } +extern "C" void vtk_file_output_window_append_on(vtkFileOutputWindow* sself) { sself->AppendOn(); } +extern "C" void vtk_file_output_window_append_off(vtkFileOutputWindow* sself) { sself->AppendOff(); } +extern "C" vtkFloatArray * vtkFloatArray_new () {return vtkFloatArray :: New () ;} +extern "C" void vtkFloatArray_destructor (vtkFloatArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkFloatArray_get_ptr (vtkFloatArray * sself) {return sself ;} +extern "C" int vtk_float_array_get_data_type(vtkFloatArray* sself) { return sself->GetDataType(); } +extern "C" float vtk_float_array_get_value(vtkFloatArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_float_array_set_value(vtkFloatArray* sself, long long id, float value) { sself->SetValue(id, value); } +extern "C" bool vtk_float_array_set_number_of_values(vtkFloatArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_float_array_insert_value(vtkFloatArray* sself, long long id, float f) { sself->InsertValue(id, f); } +extern "C" long long vtk_float_array_insert_next_value(vtkFloatArray* sself, float f) { return sself->InsertNextValue(f); } +extern "C" float vtk_float_array_get_data_type_value_min(vtkFloatArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" float vtk_float_array_get_data_type_value_max(vtkFloatArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkGarbageCollector * vtkGarbageCollector_new () {return vtkGarbageCollector :: New () ;} +extern "C" void vtkGarbageCollector_destructor (vtkGarbageCollector * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGarbageCollector_get_ptr (vtkGarbageCollector * sself) {return sself ;} +extern "C" void vtk_garbage_collector_collect(vtkGarbageCollector* sself) { sself->Collect(); } +extern "C" void vtk_garbage_collector_deferred_collection_push(vtkGarbageCollector* sself) { sself->DeferredCollectionPush(); } +extern "C" void vtk_garbage_collector_deferred_collection_pop(vtkGarbageCollector* sself) { sself->DeferredCollectionPop(); } +extern "C" void vtk_garbage_collector_set_global_debug_flag(vtkGarbageCollector* sself, bool flag) { sself->SetGlobalDebugFlag(flag); } +extern "C" bool vtk_garbage_collector_get_global_debug_flag(vtkGarbageCollector* sself) { return sself->GetGlobalDebugFlag(); } +extern "C" vtkIdList * vtkIdList_new () {return vtkIdList :: New () ;} +extern "C" void vtkIdList_destructor (vtkIdList * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkIdList_get_ptr (vtkIdList * sself) {return sself ;} +extern "C" void vtk_id_list_initialize(vtkIdList* sself) { sself->Initialize(); } +extern "C" int vtk_id_list_allocate(vtkIdList* sself, const long long sz, const int strategy) { return sself->Allocate(sz, strategy); } +extern "C" long long vtk_id_list_get_number_of_ids(vtkIdList* sself) { return sself->GetNumberOfIds(); } +extern "C" long long vtk_id_list_get_id(vtkIdList* sself, const long long i) { return sself->GetId(i); } +extern "C" long long vtk_id_list_find_id_location(vtkIdList* sself, const long long id) { return sself->FindIdLocation(id); } +extern "C" void vtk_id_list_set_number_of_ids(vtkIdList* sself, const long long number) { sself->SetNumberOfIds(number); } +extern "C" void vtk_id_list_set_id(vtkIdList* sself, const long long i, const long long vtkid) { sself->SetId(i, vtkid); } +extern "C" void vtk_id_list_insert_id(vtkIdList* sself, const long long i, const long long vtkid) { sself->InsertId(i, vtkid); } +extern "C" long long vtk_id_list_insert_next_id(vtkIdList* sself, const long long vtkid) { return sself->InsertNextId(vtkid); } +extern "C" long long vtk_id_list_insert_unique_id(vtkIdList* sself, const long long vtkid) { return sself->InsertUniqueId(vtkid); } +extern "C" void vtk_id_list_sort(vtkIdList* sself) { sself->Sort(); } +extern "C" void vtk_id_list_fill(vtkIdList* sself, long long value) { sself->Fill(value); } +extern "C" void vtk_id_list_reset(vtkIdList* sself) { sself->Reset(); } +extern "C" void vtk_id_list_squeeze(vtkIdList* sself) { sself->Squeeze(); } +extern "C" void vtk_id_list_delete_id(vtkIdList* sself, long long vtkid) { sself->DeleteId(vtkid); } +extern "C" long long vtk_id_list_is_id(vtkIdList* sself, long long vtkid) { return sself->IsId(vtkid); } +extern "C" vtkIdListCollection * vtkIdListCollection_new () {return vtkIdListCollection :: New () ;} +extern "C" void vtkIdListCollection_destructor (vtkIdListCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkIdListCollection_get_ptr (vtkIdListCollection * sself) {return sself ;} +extern "C" int vtk_id_list_collection_get_number_of_items(vtkIdListCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" vtkIdTypeArray * vtkIdTypeArray_new () {return vtkIdTypeArray :: New () ;} +extern "C" void vtkIdTypeArray_destructor (vtkIdTypeArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkIdTypeArray_get_ptr (vtkIdTypeArray * sself) {return sself ;} +extern "C" int vtk_id_type_array_get_data_type(vtkIdTypeArray* sself) { return sself->GetDataType(); } +extern "C" long long vtk_id_type_array_get_value(vtkIdTypeArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_id_type_array_set_value(vtkIdTypeArray* sself, long long id, long long value) { sself->SetValue(id, value); } +extern "C" bool vtk_id_type_array_set_number_of_values(vtkIdTypeArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_id_type_array_insert_value(vtkIdTypeArray* sself, long long id, long long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_id_type_array_insert_next_value(vtkIdTypeArray* sself, long long f) { return sself->InsertNextValue(f); } +extern "C" long long vtk_id_type_array_get_data_type_value_min(vtkIdTypeArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" long long vtk_id_type_array_get_data_type_value_max(vtkIdTypeArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkInformation * vtkInformation_new () {return vtkInformation :: New () ;} +extern "C" void vtkInformation_destructor (vtkInformation * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkInformation_get_ptr (vtkInformation * sself) {return sself ;} +extern "C" void vtk_information_modified(vtkInformation* sself) { sself->Modified(); } +extern "C" void vtk_information_clear(vtkInformation* sself) { sself->Clear(); } +extern "C" int vtk_information_get_number_of_keys(vtkInformation* sself) { return sself->GetNumberOfKeys(); } +extern "C" vtkInformationIterator * vtkInformationIterator_new () {return vtkInformationIterator :: New () ;} +extern "C" void vtkInformationIterator_destructor (vtkInformationIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkInformationIterator_get_ptr (vtkInformationIterator * sself) {return sself ;} +extern "C" void vtk_information_iterator_init_traversal(vtkInformationIterator* sself) { sself->InitTraversal(); } +extern "C" void vtk_information_iterator_go_to_first_item(vtkInformationIterator* sself) { sself->GoToFirstItem(); } +extern "C" void vtk_information_iterator_go_to_next_item(vtkInformationIterator* sself) { sself->GoToNextItem(); } +extern "C" int vtk_information_iterator_is_done_with_traversal(vtkInformationIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" vtkInformationKeyLookup * vtkInformationKeyLookup_new () {return vtkInformationKeyLookup :: New () ;} +extern "C" void vtkInformationKeyLookup_destructor (vtkInformationKeyLookup * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkInformationKeyLookup_get_ptr (vtkInformationKeyLookup * sself) {return sself ;} +extern "C" vtkInformationVector * vtkInformationVector_new () {return vtkInformationVector :: New () ;} +extern "C" void vtkInformationVector_destructor (vtkInformationVector * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkInformationVector_get_ptr (vtkInformationVector * sself) {return sself ;} +extern "C" int vtk_information_vector_get_number_of_information_objects(vtkInformationVector* sself) { return sself->GetNumberOfInformationObjects(); } +extern "C" void vtk_information_vector_set_number_of_information_objects(vtkInformationVector* sself, int n) { sself->SetNumberOfInformationObjects(n); } +extern "C" vtkIntArray * vtkIntArray_new () {return vtkIntArray :: New () ;} +extern "C" void vtkIntArray_destructor (vtkIntArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkIntArray_get_ptr (vtkIntArray * sself) {return sself ;} +extern "C" int vtk_int_array_get_data_type(vtkIntArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_int_array_get_value(vtkIntArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_int_array_set_value(vtkIntArray* sself, long long id, int value) { sself->SetValue(id, value); } +extern "C" bool vtk_int_array_set_number_of_values(vtkIntArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_int_array_insert_value(vtkIntArray* sself, long long id, int f) { sself->InsertValue(id, f); } +extern "C" long long vtk_int_array_insert_next_value(vtkIntArray* sself, int f) { return sself->InsertNextValue(f); } +extern "C" int vtk_int_array_get_data_type_value_min(vtkIntArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" int vtk_int_array_get_data_type_value_max(vtkIntArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkLongArray * vtkLongArray_new () {return vtkLongArray :: New () ;} +extern "C" void vtkLongArray_destructor (vtkLongArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLongArray_get_ptr (vtkLongArray * sself) {return sself ;} +extern "C" int vtk_long_array_get_data_type(vtkLongArray* sself) { return sself->GetDataType(); } +extern "C" long vtk_long_array_get_value(vtkLongArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_long_array_set_value(vtkLongArray* sself, long long id, long value) { sself->SetValue(id, value); } +extern "C" bool vtk_long_array_set_number_of_values(vtkLongArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_long_array_insert_value(vtkLongArray* sself, long long id, long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_long_array_insert_next_value(vtkLongArray* sself, long f) { return sself->InsertNextValue(f); } +extern "C" long vtk_long_array_get_data_type_value_min(vtkLongArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" long vtk_long_array_get_data_type_value_max(vtkLongArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkLongLongArray * vtkLongLongArray_new () {return vtkLongLongArray :: New () ;} +extern "C" void vtkLongLongArray_destructor (vtkLongLongArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLongLongArray_get_ptr (vtkLongLongArray * sself) {return sself ;} +extern "C" int vtk_long_long_array_get_data_type(vtkLongLongArray* sself) { return sself->GetDataType(); } +extern "C" long long vtk_long_long_array_get_value(vtkLongLongArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_long_long_array_set_value(vtkLongLongArray* sself, long long id, long long value) { sself->SetValue(id, value); } +extern "C" bool vtk_long_long_array_set_number_of_values(vtkLongLongArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_long_long_array_insert_value(vtkLongLongArray* sself, long long id, long long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_long_long_array_insert_next_value(vtkLongLongArray* sself, long long f) { return sself->InsertNextValue(f); } +extern "C" long long vtk_long_long_array_get_data_type_value_min(vtkLongLongArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" long long vtk_long_long_array_get_data_type_value_max(vtkLongLongArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkLookupTable * vtkLookupTable_new () {return vtkLookupTable :: New () ;} +extern "C" void vtkLookupTable_destructor (vtkLookupTable * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLookupTable_get_ptr (vtkLookupTable * sself) {return sself ;} +extern "C" int vtk_lookup_table_is_opaque(vtkLookupTable* sself) { return sself->IsOpaque(); } +extern "C" int vtk_lookup_table_allocate(vtkLookupTable* sself, int sz, int ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_lookup_table_build(vtkLookupTable* sself) { sself->Build(); } +extern "C" void vtk_lookup_table_force_build(vtkLookupTable* sself) { sself->ForceBuild(); } +extern "C" void vtk_lookup_table_build_special_colors(vtkLookupTable* sself) { sself->BuildSpecialColors(); } +extern "C" void vtk_lookup_table_set_ramp(vtkLookupTable* sself, int _arg) { sself->SetRamp(_arg); } +extern "C" void vtk_lookup_table_set_ramp_to_linear(vtkLookupTable* sself) { sself->SetRampToLinear(); } +extern "C" void vtk_lookup_table_set_ramp_to_s_curve(vtkLookupTable* sself) { sself->SetRampToSCurve(); } +extern "C" void vtk_lookup_table_set_ramp_to_sqrt(vtkLookupTable* sself) { sself->SetRampToSQRT(); } +extern "C" int vtk_lookup_table_get_ramp(vtkLookupTable* sself) { return sself->GetRamp(); } +extern "C" void vtk_lookup_table_set_scale(vtkLookupTable* sself, int scale) { sself->SetScale(scale); } +extern "C" void vtk_lookup_table_set_scale_to_linear(vtkLookupTable* sself) { sself->SetScaleToLinear(); } +extern "C" void vtk_lookup_table_set_scale_to_log_10(vtkLookupTable* sself) { sself->SetScaleToLog10(); } +extern "C" int vtk_lookup_table_get_scale(vtkLookupTable* sself) { return sself->GetScale(); } +extern "C" void vtk_lookup_table_set_table_range(vtkLookupTable* sself, double min, double max) { sself->SetTableRange(min, max); } +extern "C" void vtk_lookup_table_set_hue_range(vtkLookupTable* sself, double _arg1, double _arg2) { sself->SetHueRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_saturation_range(vtkLookupTable* sself, double _arg1, double _arg2) { sself->SetSaturationRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_value_range(vtkLookupTable* sself, double _arg1, double _arg2) { sself->SetValueRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_alpha_range(vtkLookupTable* sself, double _arg1, double _arg2) { sself->SetAlphaRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_nan_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetNanColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_set_below_range_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetBelowRangeColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_set_use_below_range_color(vtkLookupTable* sself, int _arg) { sself->SetUseBelowRangeColor(_arg); } +extern "C" int vtk_lookup_table_get_use_below_range_color(vtkLookupTable* sself) { return sself->GetUseBelowRangeColor(); } +extern "C" void vtk_lookup_table_use_below_range_color_on(vtkLookupTable* sself) { sself->UseBelowRangeColorOn(); } +extern "C" void vtk_lookup_table_use_below_range_color_off(vtkLookupTable* sself) { sself->UseBelowRangeColorOff(); } +extern "C" void vtk_lookup_table_set_above_range_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetAboveRangeColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_set_use_above_range_color(vtkLookupTable* sself, int _arg) { sself->SetUseAboveRangeColor(_arg); } +extern "C" int vtk_lookup_table_get_use_above_range_color(vtkLookupTable* sself) { return sself->GetUseAboveRangeColor(); } +extern "C" void vtk_lookup_table_use_above_range_color_on(vtkLookupTable* sself) { sself->UseAboveRangeColorOn(); } +extern "C" void vtk_lookup_table_use_above_range_color_off(vtkLookupTable* sself) { sself->UseAboveRangeColorOff(); } +extern "C" double vtk_lookup_table_get_opacity(vtkLookupTable* sself, double v) { return sself->GetOpacity(v); } +extern "C" long long vtk_lookup_table_get_index(vtkLookupTable* sself, double v) { return sself->GetIndex(v); } +extern "C" void vtk_lookup_table_set_number_of_table_values(vtkLookupTable* sself, long long number) { sself->SetNumberOfTableValues(number); } +extern "C" long long vtk_lookup_table_get_number_of_table_values(vtkLookupTable* sself) { return sself->GetNumberOfTableValues(); } +extern "C" void vtk_lookup_table_set_table_value(vtkLookupTable* sself, long long indx, double r, double g, double b, double a) { sself->SetTableValue(indx, r, g, b, a); } +extern "C" void vtk_lookup_table_set_number_of_colors(vtkLookupTable* sself, long long _arg) { sself->SetNumberOfColors(_arg); } +extern "C" long long vtk_lookup_table_get_number_of_colors_min_value(vtkLookupTable* sself) { return sself->GetNumberOfColorsMinValue(); } +extern "C" long long vtk_lookup_table_get_number_of_colors_max_value(vtkLookupTable* sself) { return sself->GetNumberOfColorsMaxValue(); } +extern "C" long long vtk_lookup_table_get_number_of_colors(vtkLookupTable* sself) { return sself->GetNumberOfColors(); } +extern "C" int vtk_lookup_table_using_log_scale(vtkLookupTable* sself) { return sself->UsingLogScale(); } +extern "C" vtkMath * vtkMath_new () {return vtkMath :: New () ;} +extern "C" void vtkMath_destructor (vtkMath * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMath_get_ptr (vtkMath * sself) {return sself ;} +extern "C" double vtk_math_pi(vtkMath* sself) { return sself->Pi(); } +extern "C" float vtk_math_radians_from_degrees(vtkMath* sself, float degrees) { return sself->RadiansFromDegrees(degrees); } +extern "C" float vtk_math_degrees_from_radians(vtkMath* sself, float radians) { return sself->DegreesFromRadians(radians); } +extern "C" int vtk_math_round(vtkMath* sself, float f) { return sself->Round(f); } +extern "C" int vtk_math_floor(vtkMath* sself, double x) { return sself->Floor(x); } +extern "C" int vtk_math_ceil(vtkMath* sself, double x) { return sself->Ceil(x); } +extern "C" int vtk_math_ceil_log_2(vtkMath* sself, unsigned long long x) { return sself->CeilLog2(x); } +extern "C" bool vtk_math_is_power_of_two(vtkMath* sself, unsigned long long x) { return sself->IsPowerOfTwo(x); } +extern "C" int vtk_math_nearest_power_of_two(vtkMath* sself, int x) { return sself->NearestPowerOfTwo(x); } +extern "C" long long vtk_math_factorial(vtkMath* sself, int N) { return sself->Factorial(N); } +extern "C" long long vtk_math_binomial(vtkMath* sself, int m, int n) { return sself->Binomial(m, n); } +extern "C" void vtk_math_random_seed(vtkMath* sself, int s) { sself->RandomSeed(s); } +extern "C" int vtk_math_get_seed(vtkMath* sself) { return sself->GetSeed(); } +extern "C" double vtk_math_random(vtkMath* sself) { return sself->Random(); } +extern "C" double vtk_math_gaussian(vtkMath* sself) { return sself->Gaussian(); } +extern "C" double vtk_math_gaussian_amplitude(vtkMath* sself, const double variance, const double distanceFromMean) { return sself->GaussianAmplitude(variance, distanceFromMean); } +extern "C" double vtk_math_gaussian_weight(vtkMath* sself, const double variance, const double distanceFromMean) { return sself->GaussianWeight(variance, distanceFromMean); } +extern "C" double vtk_math_determinant_2_x_2(vtkMath* sself, double a, double b, double c, double d) { return sself->Determinant2x2(a, b, c, d); } +extern "C" double vtk_math_determinant_3_x_3(vtkMath* sself, double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3) { return sself->Determinant3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3); } +extern "C" int vtk_math_solve_linear_system_gepp_2_x_2(vtkMath* sself, double a00, double a01, double a10, double a11, double b0, double b1, double& x0, double& x1) { return sself->SolveLinearSystemGEPP2x2(a00, a01, a10, a11, b0, b1, x0, x1); } +extern "C" int vtk_math_get_scalar_type_fitting_range(vtkMath* sself, double range_min, double range_max, double scale, double shift) { return sself->GetScalarTypeFittingRange(range_min, range_max, scale, shift); } +extern "C" double vtk_math_inf(vtkMath* sself) { return sself->Inf(); } +extern "C" double vtk_math_neg_inf(vtkMath* sself) { return sself->NegInf(); } +extern "C" double vtk_math_nan(vtkMath* sself) { return sself->Nan(); } +extern "C" int vtk_math_is_inf(vtkMath* sself, double x) { return sself->IsInf(x); } +extern "C" int vtk_math_is_nan(vtkMath* sself, double x) { return sself->IsNan(x); } +extern "C" bool vtk_math_is_finite(vtkMath* sself, double x) { return sself->IsFinite(x); } +extern "C" vtkMersenneTwister * vtkMersenneTwister_new () {return vtkMersenneTwister :: New () ;} +extern "C" void vtkMersenneTwister_destructor (vtkMersenneTwister * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMersenneTwister_get_ptr (vtkMersenneTwister * sself) {return sself ;} +extern "C" void vtk_mersenne_twister_initialize(vtkMersenneTwister* sself, unsigned int seed) { sself->Initialize(seed); } +extern "C" unsigned int vtk_mersenne_twister_initialize_new_sequence(vtkMersenneTwister* sself, unsigned int seed, int p) { return sself->InitializeNewSequence(seed, p); } +extern "C" void vtk_mersenne_twister_initialize_sequence(vtkMersenneTwister* sself, unsigned int id, unsigned int seed, int p) { sself->InitializeSequence(id, seed, p); } +extern "C" double vtk_mersenne_twister_get_value(vtkMersenneTwister* sself, unsigned int id) { return sself->GetValue(id); } +extern "C" void vtk_mersenne_twister_next(vtkMersenneTwister* sself, unsigned int id) { sself->Next(id); } +extern "C" vtkMinimalStandardRandomSequence * vtkMinimalStandardRandomSequence_new () {return vtkMinimalStandardRandomSequence :: New () ;} +extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkMinimalStandardRandomSequence * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMinimalStandardRandomSequence_get_ptr (vtkMinimalStandardRandomSequence * sself) {return sself ;} +extern "C" void vtk_minimal_standard_random_sequence_initialize(vtkMinimalStandardRandomSequence* sself, unsigned int seed) { sself->Initialize(seed); } +extern "C" void vtk_minimal_standard_random_sequence_set_seed(vtkMinimalStandardRandomSequence* sself, int value) { sself->SetSeed(value); } +extern "C" void vtk_minimal_standard_random_sequence_set_seed_only(vtkMinimalStandardRandomSequence* sself, int value) { sself->SetSeedOnly(value); } +extern "C" int vtk_minimal_standard_random_sequence_get_seed(vtkMinimalStandardRandomSequence* sself) { return sself->GetSeed(); } +extern "C" double vtk_minimal_standard_random_sequence_get_value(vtkMinimalStandardRandomSequence* sself) { return sself->GetValue(); } +extern "C" void vtk_minimal_standard_random_sequence_next(vtkMinimalStandardRandomSequence* sself) { sself->Next(); } +extern "C" double vtk_minimal_standard_random_sequence_get_range_value(vtkMinimalStandardRandomSequence* sself, double rangeMin, double rangeMax) { return sself->GetRangeValue(rangeMin, rangeMax); } +extern "C" double vtk_minimal_standard_random_sequence_get_next_range_value(vtkMinimalStandardRandomSequence* sself, double rangeMin, double rangeMax) { return sself->GetNextRangeValue(rangeMin, rangeMax); } +extern "C" vtkMultiThreader * vtkMultiThreader_new () {return vtkMultiThreader :: New () ;} +extern "C" void vtkMultiThreader_destructor (vtkMultiThreader * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMultiThreader_get_ptr (vtkMultiThreader * sself) {return sself ;} +extern "C" void vtk_multi_threader_set_number_of_threads(vtkMultiThreader* sself, int _arg) { sself->SetNumberOfThreads(_arg); } +extern "C" int vtk_multi_threader_get_number_of_threads_min_value(vtkMultiThreader* sself) { return sself->GetNumberOfThreadsMinValue(); } +extern "C" int vtk_multi_threader_get_number_of_threads_max_value(vtkMultiThreader* sself) { return sself->GetNumberOfThreadsMaxValue(); } +extern "C" int vtk_multi_threader_get_number_of_threads(vtkMultiThreader* sself) { return sself->GetNumberOfThreads(); } +extern "C" int vtk_multi_threader_get_global_static_maximum_number_of_threads(vtkMultiThreader* sself) { return sself->GetGlobalStaticMaximumNumberOfThreads(); } +extern "C" void vtk_multi_threader_set_global_maximum_number_of_threads(vtkMultiThreader* sself, int val) { sself->SetGlobalMaximumNumberOfThreads(val); } +extern "C" int vtk_multi_threader_get_global_maximum_number_of_threads(vtkMultiThreader* sself) { return sself->GetGlobalMaximumNumberOfThreads(); } +extern "C" void vtk_multi_threader_set_global_default_number_of_threads(vtkMultiThreader* sself, int val) { sself->SetGlobalDefaultNumberOfThreads(val); } +extern "C" int vtk_multi_threader_get_global_default_number_of_threads(vtkMultiThreader* sself) { return sself->GetGlobalDefaultNumberOfThreads(); } +extern "C" void vtk_multi_threader_single_method_execute(vtkMultiThreader* sself) { sself->SingleMethodExecute(); } +extern "C" void vtk_multi_threader_multiple_method_execute(vtkMultiThreader* sself) { sself->MultipleMethodExecute(); } +extern "C" void vtk_multi_threader_terminate_thread(vtkMultiThreader* sself, int threadId) { sself->TerminateThread(threadId); } +extern "C" int vtk_multi_threader_is_thread_active(vtkMultiThreader* sself, int threadId) { return sself->IsThreadActive(threadId); } +extern "C" vtkObject * vtkObject_new () {return vtkObject :: New () ;} +extern "C" void vtkObject_destructor (vtkObject * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkObject_get_ptr (vtkObject * sself) {return sself ;} +extern "C" int vtk_object_is_type_of(vtkObject* sself, const char* type) { return sself->IsTypeOf(type); } +extern "C" int vtk_object_is_a(vtkObject* sself, const char* type) { return sself->IsA(type); } +extern "C" long long vtk_object_get_number_of_generations_from_base_type(vtkObject* sself, const char* type) { return sself->GetNumberOfGenerationsFromBaseType(type); } +extern "C" long long vtk_object_get_number_of_generations_from_base(vtkObject* sself, const char* type) { return sself->GetNumberOfGenerationsFromBase(type); } +extern "C" void vtk_object_debug_on(vtkObject* sself) { sself->DebugOn(); } +extern "C" void vtk_object_debug_off(vtkObject* sself) { sself->DebugOff(); } +extern "C" bool vtk_object_get_debug(vtkObject* sself) { return sself->GetDebug(); } +extern "C" void vtk_object_set_debug(vtkObject* sself, bool debugFlag) { sself->SetDebug(debugFlag); } +extern "C" void vtk_object_break_on_error(vtkObject* sself) { sself->BreakOnError(); } +extern "C" void vtk_object_modified(vtkObject* sself) { sself->Modified(); } +extern "C" unsigned long vtk_object_get_m_time(vtkObject* sself) { return sself->GetMTime(); } +extern "C" void vtk_object_set_global_warning_display(vtkObject* sself, int val) { sself->SetGlobalWarningDisplay(val); } +extern "C" void vtk_object_global_warning_display_on(vtkObject* sself) { sself->GlobalWarningDisplayOn(); } +extern "C" void vtk_object_global_warning_display_off(vtkObject* sself) { sself->GlobalWarningDisplayOff(); } +extern "C" int vtk_object_get_global_warning_display(vtkObject* sself) { return sself->GetGlobalWarningDisplay(); } +extern "C" void vtk_object_remove_all_observers(vtkObject* sself) { sself->RemoveAllObservers(); } +extern "C" int vtk_object_invoke_event(vtkObject* sself, unsigned long event, void* callData) { return sself->InvokeEvent(event, callData); } +extern "C" vtkObjectFactoryCollection * vtkObjectFactoryCollection_new () {return vtkObjectFactoryCollection :: New () ;} +extern "C" void vtkObjectFactoryCollection_destructor (vtkObjectFactoryCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkObjectFactoryCollection_get_ptr (vtkObjectFactoryCollection * sself) {return sself ;} +extern "C" vtkOldStyleCallbackCommand * vtkOldStyleCallbackCommand_new () {return vtkOldStyleCallbackCommand :: New () ;} +extern "C" void vtkOldStyleCallbackCommand_destructor (vtkOldStyleCallbackCommand * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOldStyleCallbackCommand_get_ptr (vtkOldStyleCallbackCommand * sself) {return sself ;} +extern "C" void vtk_old_style_callback_command_set_client_data(vtkOldStyleCallbackCommand* sself, void* cd) { sself->SetClientData(cd); } +extern "C" vtkOutputWindow * vtkOutputWindow_new () {return vtkOutputWindow :: New () ;} +extern "C" void vtkOutputWindow_destructor (vtkOutputWindow * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOutputWindow_get_ptr (vtkOutputWindow * sself) {return sself ;} +extern "C" void vtk_output_window_display_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } +extern "C" void vtk_output_window_display_error_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayErrorText(p0); } +extern "C" void vtk_output_window_display_warning_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayWarningText(p0); } +extern "C" void vtk_output_window_display_generic_warning_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayGenericWarningText(p0); } +extern "C" void vtk_output_window_display_debug_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayDebugText(p0); } +extern "C" void vtk_output_window_prompt_user_on(vtkOutputWindow* sself) { sself->PromptUserOn(); } +extern "C" void vtk_output_window_prompt_user_off(vtkOutputWindow* sself) { sself->PromptUserOff(); } +extern "C" void vtk_output_window_set_prompt_user(vtkOutputWindow* sself, bool _arg) { sself->SetPromptUser(_arg); } +extern "C" void vtk_output_window_set_use_std_error_for_all_messages(vtkOutputWindow* sself, bool p0) { sself->SetUseStdErrorForAllMessages(p0); } +extern "C" bool vtk_output_window_get_use_std_error_for_all_messages(vtkOutputWindow* sself) { return sself->GetUseStdErrorForAllMessages(); } +extern "C" void vtk_output_window_use_std_error_for_all_messages_on(vtkOutputWindow* sself) { sself->UseStdErrorForAllMessagesOn(); } +extern "C" void vtk_output_window_use_std_error_for_all_messages_off(vtkOutputWindow* sself) { sself->UseStdErrorForAllMessagesOff(); } +extern "C" void vtk_output_window_set_display_mode(vtkOutputWindow* sself, int _arg) { sself->SetDisplayMode(_arg); } +extern "C" int vtk_output_window_get_display_mode_min_value(vtkOutputWindow* sself) { return sself->GetDisplayModeMinValue(); } +extern "C" int vtk_output_window_get_display_mode_max_value(vtkOutputWindow* sself) { return sself->GetDisplayModeMaxValue(); } +extern "C" int vtk_output_window_get_display_mode(vtkOutputWindow* sself) { return sself->GetDisplayMode(); } +extern "C" void vtk_output_window_set_display_mode_to_default(vtkOutputWindow* sself) { sself->SetDisplayModeToDefault(); } +extern "C" void vtk_output_window_set_display_mode_to_never(vtkOutputWindow* sself) { sself->SetDisplayModeToNever(); } +extern "C" void vtk_output_window_set_display_mode_to_always(vtkOutputWindow* sself) { sself->SetDisplayModeToAlways(); } +extern "C" void vtk_output_window_set_display_mode_to_always_std_err(vtkOutputWindow* sself) { sself->SetDisplayModeToAlwaysStdErr(); } +extern "C" vtkOverrideInformationCollection * vtkOverrideInformationCollection_new () {return vtkOverrideInformationCollection :: New () ;} +extern "C" void vtkOverrideInformationCollection_destructor (vtkOverrideInformationCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOverrideInformationCollection_get_ptr (vtkOverrideInformationCollection * sself) {return sself ;} +extern "C" vtkPoints * vtkPoints_new () {return vtkPoints :: New () ;} +extern "C" void vtkPoints_destructor (vtkPoints * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPoints_get_ptr (vtkPoints * sself) {return sself ;} +extern "C" int vtk_points_allocate(vtkPoints* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_points_initialize(vtkPoints* sself) { sself->Initialize(); } +extern "C" int vtk_points_get_data_type(vtkPoints* sself) { return sself->GetDataType(); } +extern "C" void vtk_points_set_data_type(vtkPoints* sself, int dataType) { sself->SetDataType(dataType); } +extern "C" void vtk_points_set_data_type_to_bit(vtkPoints* sself) { sself->SetDataTypeToBit(); } +extern "C" void vtk_points_set_data_type_to_char(vtkPoints* sself) { sself->SetDataTypeToChar(); } +extern "C" void vtk_points_set_data_type_to_unsigned_char(vtkPoints* sself) { sself->SetDataTypeToUnsignedChar(); } +extern "C" void vtk_points_set_data_type_to_short(vtkPoints* sself) { sself->SetDataTypeToShort(); } +extern "C" void vtk_points_set_data_type_to_unsigned_short(vtkPoints* sself) { sself->SetDataTypeToUnsignedShort(); } +extern "C" void vtk_points_set_data_type_to_int(vtkPoints* sself) { sself->SetDataTypeToInt(); } +extern "C" void vtk_points_set_data_type_to_unsigned_int(vtkPoints* sself) { sself->SetDataTypeToUnsignedInt(); } +extern "C" void vtk_points_set_data_type_to_long(vtkPoints* sself) { sself->SetDataTypeToLong(); } +extern "C" void vtk_points_set_data_type_to_unsigned_long(vtkPoints* sself) { sself->SetDataTypeToUnsignedLong(); } +extern "C" void vtk_points_set_data_type_to_float(vtkPoints* sself) { sself->SetDataTypeToFloat(); } +extern "C" void vtk_points_set_data_type_to_double(vtkPoints* sself) { sself->SetDataTypeToDouble(); } +extern "C" void* vtk_points_get_void_pointer(vtkPoints* sself, const int id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_points_squeeze(vtkPoints* sself) { sself->Squeeze(); } +extern "C" void vtk_points_reset(vtkPoints* sself) { sself->Reset(); } +extern "C" unsigned long vtk_points_get_actual_memory_size(vtkPoints* sself) { return sself->GetActualMemorySize(); } +extern "C" long long vtk_points_get_number_of_points(vtkPoints* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_points_set_point(vtkPoints* sself, long long id, double x, double y, double z) { sself->SetPoint(id, x, y, z); } +extern "C" void vtk_points_insert_point(vtkPoints* sself, long long id, double x, double y, double z) { sself->InsertPoint(id, x, y, z); } +extern "C" long long vtk_points_insert_next_point(vtkPoints* sself, double x, double y, double z) { return sself->InsertNextPoint(x, y, z); } +extern "C" void vtk_points_set_number_of_points(vtkPoints* sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } +extern "C" int vtk_points_resize(vtkPoints* sself, long long numPoints) { return sself->Resize(numPoints); } +extern "C" void vtk_points_compute_bounds(vtkPoints* sself) { sself->ComputeBounds(); } +extern "C" unsigned long vtk_points_get_m_time(vtkPoints* sself) { return sself->GetMTime(); } +extern "C" void vtk_points_modified(vtkPoints* sself) { sself->Modified(); } +extern "C" vtkPoints2D * vtkPoints2D_new () {return vtkPoints2D :: New () ;} +extern "C" void vtkPoints2D_destructor (vtkPoints2D * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPoints2D_get_ptr (vtkPoints2D * sself) {return sself ;} +extern "C" int vtk_points_2_d_allocate(vtkPoints2D* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_points_2_d_initialize(vtkPoints2D* sself) { sself->Initialize(); } +extern "C" int vtk_points_2_d_get_data_type(vtkPoints2D* sself) { return sself->GetDataType(); } +extern "C" void vtk_points_2_d_set_data_type(vtkPoints2D* sself, int dataType) { sself->SetDataType(dataType); } +extern "C" void vtk_points_2_d_set_data_type_to_bit(vtkPoints2D* sself) { sself->SetDataTypeToBit(); } +extern "C" void vtk_points_2_d_set_data_type_to_char(vtkPoints2D* sself) { sself->SetDataTypeToChar(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_char(vtkPoints2D* sself) { sself->SetDataTypeToUnsignedChar(); } +extern "C" void vtk_points_2_d_set_data_type_to_short(vtkPoints2D* sself) { sself->SetDataTypeToShort(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_short(vtkPoints2D* sself) { sself->SetDataTypeToUnsignedShort(); } +extern "C" void vtk_points_2_d_set_data_type_to_int(vtkPoints2D* sself) { sself->SetDataTypeToInt(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_int(vtkPoints2D* sself) { sself->SetDataTypeToUnsignedInt(); } +extern "C" void vtk_points_2_d_set_data_type_to_long(vtkPoints2D* sself) { sself->SetDataTypeToLong(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_long(vtkPoints2D* sself) { sself->SetDataTypeToUnsignedLong(); } +extern "C" void vtk_points_2_d_set_data_type_to_float(vtkPoints2D* sself) { sself->SetDataTypeToFloat(); } +extern "C" void vtk_points_2_d_set_data_type_to_double(vtkPoints2D* sself) { sself->SetDataTypeToDouble(); } +extern "C" void* vtk_points_2_d_get_void_pointer(vtkPoints2D* sself, const int id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_points_2_d_squeeze(vtkPoints2D* sself) { sself->Squeeze(); } +extern "C" void vtk_points_2_d_reset(vtkPoints2D* sself) { sself->Reset(); } +extern "C" unsigned long vtk_points_2_d_get_actual_memory_size(vtkPoints2D* sself) { return sself->GetActualMemorySize(); } +extern "C" long long vtk_points_2_d_get_number_of_points(vtkPoints2D* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_points_2_d_set_point(vtkPoints2D* sself, long long id, double x, double y) { sself->SetPoint(id, x, y); } +extern "C" void vtk_points_2_d_insert_point(vtkPoints2D* sself, long long id, double x, double y) { sself->InsertPoint(id, x, y); } +extern "C" long long vtk_points_2_d_insert_next_point(vtkPoints2D* sself, double x, double y) { return sself->InsertNextPoint(x, y); } +extern "C" void vtk_points_2_d_remove_point(vtkPoints2D* sself, long long id) { sself->RemovePoint(id); } +extern "C" void vtk_points_2_d_set_number_of_points(vtkPoints2D* sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } +extern "C" int vtk_points_2_d_resize(vtkPoints2D* sself, long long numPoints) { return sself->Resize(numPoints); } +extern "C" void vtk_points_2_d_compute_bounds(vtkPoints2D* sself) { sself->ComputeBounds(); } +extern "C" vtkPriorityQueue * vtkPriorityQueue_new () {return vtkPriorityQueue :: New () ;} +extern "C" void vtkPriorityQueue_destructor (vtkPriorityQueue * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPriorityQueue_get_ptr (vtkPriorityQueue * sself) {return sself ;} +extern "C" void vtk_priority_queue_allocate(vtkPriorityQueue* sself, long long sz, long long ext) { sself->Allocate(sz, ext); } +extern "C" void vtk_priority_queue_insert(vtkPriorityQueue* sself, double priority, long long id) { sself->Insert(priority, id); } +extern "C" long long vtk_priority_queue_pop(vtkPriorityQueue* sself, long long location, double& priority) { return sself->Pop(location, priority); } +extern "C" long long vtk_priority_queue_peek(vtkPriorityQueue* sself, long long location, double& priority) { return sself->Peek(location, priority); } +extern "C" double vtk_priority_queue_delete_id(vtkPriorityQueue* sself, long long id) { return sself->DeleteId(id); } +extern "C" double vtk_priority_queue_get_priority(vtkPriorityQueue* sself, long long id) { return sself->GetPriority(id); } +extern "C" long long vtk_priority_queue_get_number_of_items(vtkPriorityQueue* sself) { return sself->GetNumberOfItems(); } +extern "C" void vtk_priority_queue_reset(vtkPriorityQueue* sself) { sself->Reset(); } +extern "C" vtkRandomPool * vtkRandomPool_new () {return vtkRandomPool :: New () ;} +extern "C" void vtkRandomPool_destructor (vtkRandomPool * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkRandomPool_get_ptr (vtkRandomPool * sself) {return sself ;} +extern "C" void vtk_random_pool_set_size(vtkRandomPool* sself, long long _arg) { sself->SetSize(_arg); } +extern "C" long long vtk_random_pool_get_size_min_value(vtkRandomPool* sself) { return sself->GetSizeMinValue(); } +extern "C" long long vtk_random_pool_get_size_max_value(vtkRandomPool* sself) { return sself->GetSizeMaxValue(); } +extern "C" long long vtk_random_pool_get_size(vtkRandomPool* sself) { return sself->GetSize(); } +extern "C" void vtk_random_pool_set_number_of_components(vtkRandomPool* sself, long long _arg) { sself->SetNumberOfComponents(_arg); } +extern "C" long long vtk_random_pool_get_number_of_components_min_value(vtkRandomPool* sself) { return sself->GetNumberOfComponentsMinValue(); } +extern "C" long long vtk_random_pool_get_number_of_components_max_value(vtkRandomPool* sself) { return sself->GetNumberOfComponentsMaxValue(); } +extern "C" long long vtk_random_pool_get_number_of_components(vtkRandomPool* sself) { return sself->GetNumberOfComponents(); } +extern "C" long long vtk_random_pool_get_total_size(vtkRandomPool* sself) { return sself->GetTotalSize(); } +extern "C" double vtk_random_pool_get_value(vtkRandomPool* sself, long long i) { return sself->GetValue(i); } +extern "C" void vtk_random_pool_set_chunk_size(vtkRandomPool* sself, long long _arg) { sself->SetChunkSize(_arg); } +extern "C" long long vtk_random_pool_get_chunk_size_min_value(vtkRandomPool* sself) { return sself->GetChunkSizeMinValue(); } +extern "C" long long vtk_random_pool_get_chunk_size_max_value(vtkRandomPool* sself) { return sself->GetChunkSizeMaxValue(); } +extern "C" long long vtk_random_pool_get_chunk_size(vtkRandomPool* sself) { return sself->GetChunkSize(); } +extern "C" vtkReferenceCount * vtkReferenceCount_new () {return vtkReferenceCount :: New () ;} +extern "C" void vtkReferenceCount_destructor (vtkReferenceCount * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkReferenceCount_get_ptr (vtkReferenceCount * sself) {return sself ;} +extern "C" vtkScalarsToColors * vtkScalarsToColors_new () {return vtkScalarsToColors :: New () ;} +extern "C" void vtkScalarsToColors_destructor (vtkScalarsToColors * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkScalarsToColors_get_ptr (vtkScalarsToColors * sself) {return sself ;} +extern "C" int vtk_scalars_to_colors_is_opaque(vtkScalarsToColors* sself) { return sself->IsOpaque(); } +extern "C" void vtk_scalars_to_colors_build(vtkScalarsToColors* sself) { sself->Build(); } +extern "C" void vtk_scalars_to_colors_set_range(vtkScalarsToColors* sself, double min, double max) { sself->SetRange(min, max); } +extern "C" double vtk_scalars_to_colors_get_opacity(vtkScalarsToColors* sself, double v) { return sself->GetOpacity(v); } +extern "C" double vtk_scalars_to_colors_get_luminance(vtkScalarsToColors* sself, double x) { return sself->GetLuminance(x); } +extern "C" void vtk_scalars_to_colors_set_alpha(vtkScalarsToColors* sself, double alpha) { sself->SetAlpha(alpha); } +extern "C" double vtk_scalars_to_colors_get_alpha(vtkScalarsToColors* sself) { return sself->GetAlpha(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode(vtkScalarsToColors* sself, int _arg) { sself->SetVectorMode(_arg); } +extern "C" int vtk_scalars_to_colors_get_vector_mode(vtkScalarsToColors* sself) { return sself->GetVectorMode(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_magnitude(vtkScalarsToColors* sself) { sself->SetVectorModeToMagnitude(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_component(vtkScalarsToColors* sself) { sself->SetVectorModeToComponent(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_rgb_colors(vtkScalarsToColors* sself) { sself->SetVectorModeToRGBColors(); } +extern "C" void vtk_scalars_to_colors_set_vector_component(vtkScalarsToColors* sself, int _arg) { sself->SetVectorComponent(_arg); } +extern "C" int vtk_scalars_to_colors_get_vector_component(vtkScalarsToColors* sself) { return sself->GetVectorComponent(); } +extern "C" void vtk_scalars_to_colors_set_vector_size(vtkScalarsToColors* sself, int _arg) { sself->SetVectorSize(_arg); } +extern "C" int vtk_scalars_to_colors_get_vector_size(vtkScalarsToColors* sself) { return sself->GetVectorSize(); } +extern "C" int vtk_scalars_to_colors_using_log_scale(vtkScalarsToColors* sself) { return sself->UsingLogScale(); } +extern "C" long long vtk_scalars_to_colors_get_number_of_available_colors(vtkScalarsToColors* sself) { return sself->GetNumberOfAvailableColors(); } +extern "C" long long vtk_scalars_to_colors_get_number_of_annotated_values(vtkScalarsToColors* sself) { return sself->GetNumberOfAnnotatedValues(); } +extern "C" void vtk_scalars_to_colors_reset_annotations(vtkScalarsToColors* sself) { sself->ResetAnnotations(); } +extern "C" void vtk_scalars_to_colors_set_indexed_lookup(vtkScalarsToColors* sself, int _arg) { sself->SetIndexedLookup(_arg); } +extern "C" int vtk_scalars_to_colors_get_indexed_lookup(vtkScalarsToColors* sself) { return sself->GetIndexedLookup(); } +extern "C" void vtk_scalars_to_colors_indexed_lookup_on(vtkScalarsToColors* sself) { sself->IndexedLookupOn(); } +extern "C" void vtk_scalars_to_colors_indexed_lookup_off(vtkScalarsToColors* sself) { sself->IndexedLookupOff(); } +extern "C" vtkShortArray * vtkShortArray_new () {return vtkShortArray :: New () ;} +extern "C" void vtkShortArray_destructor (vtkShortArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkShortArray_get_ptr (vtkShortArray * sself) {return sself ;} +extern "C" int vtk_short_array_get_data_type(vtkShortArray* sself) { return sself->GetDataType(); } +extern "C" short vtk_short_array_get_value(vtkShortArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_short_array_set_value(vtkShortArray* sself, long long id, short value) { sself->SetValue(id, value); } +extern "C" bool vtk_short_array_set_number_of_values(vtkShortArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_short_array_insert_value(vtkShortArray* sself, long long id, short f) { sself->InsertValue(id, f); } +extern "C" long long vtk_short_array_insert_next_value(vtkShortArray* sself, short f) { return sself->InsertNextValue(f); } +extern "C" short vtk_short_array_get_data_type_value_min(vtkShortArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" short vtk_short_array_get_data_type_value_max(vtkShortArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkSignedCharArray * vtkSignedCharArray_new () {return vtkSignedCharArray :: New () ;} +extern "C" void vtkSignedCharArray_destructor (vtkSignedCharArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSignedCharArray_get_ptr (vtkSignedCharArray * sself) {return sself ;} +extern "C" int vtk_signed_char_array_get_data_type(vtkSignedCharArray* sself) { return sself->GetDataType(); } +extern "C" signed char vtk_signed_char_array_get_value(vtkSignedCharArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_signed_char_array_set_value(vtkSignedCharArray* sself, long long id, signed char value) { sself->SetValue(id, value); } +extern "C" bool vtk_signed_char_array_set_number_of_values(vtkSignedCharArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_signed_char_array_insert_value(vtkSignedCharArray* sself, long long id, signed char f) { sself->InsertValue(id, f); } +extern "C" long long vtk_signed_char_array_insert_next_value(vtkSignedCharArray* sself, signed char f) { return sself->InsertNextValue(f); } +extern "C" signed char vtk_signed_char_array_get_data_type_value_min(vtkSignedCharArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" signed char vtk_signed_char_array_get_data_type_value_max(vtkSignedCharArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkSortDataArray * vtkSortDataArray_new () {return vtkSortDataArray :: New () ;} +extern "C" void vtkSortDataArray_destructor (vtkSortDataArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSortDataArray_get_ptr (vtkSortDataArray * sself) {return sself ;} +extern "C" vtkStringArray * vtkStringArray_new () {return vtkStringArray :: New () ;} +extern "C" void vtkStringArray_destructor (vtkStringArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStringArray_get_ptr (vtkStringArray * sself) {return sself ;} +extern "C" int vtk_string_array_get_data_type(vtkStringArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_string_array_is_numeric(vtkStringArray* sself) { return sself->IsNumeric(); } +extern "C" void vtk_string_array_initialize(vtkStringArray* sself) { sself->Initialize(); } +extern "C" int vtk_string_array_get_data_type_size(vtkStringArray* sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_string_array_squeeze(vtkStringArray* sself) { sself->Squeeze(); } +extern "C" int vtk_string_array_resize(vtkStringArray* sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" int vtk_string_array_allocate(vtkStringArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_string_array_set_number_of_tuples(vtkStringArray* sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" long long vtk_string_array_get_number_of_values(vtkStringArray* sself) { return sself->GetNumberOfValues(); } +extern "C" int vtk_string_array_get_number_of_element_components(vtkStringArray* sself) { return sself->GetNumberOfElementComponents(); } +extern "C" int vtk_string_array_get_element_component_size(vtkStringArray* sself) { return sself->GetElementComponentSize(); } +extern "C" void* vtk_string_array_get_void_pointer(vtkStringArray* sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_string_array_set_void_array(vtkStringArray* sself, void* array, long long size, int save) { sself->SetVoidArray(array, size, save); } +extern "C" unsigned long vtk_string_array_get_actual_memory_size(vtkStringArray* sself) { return sself->GetActualMemorySize(); } +extern "C" long long vtk_string_array_get_data_size(vtkStringArray* sself) { return sself->GetDataSize(); } +extern "C" void vtk_string_array_data_changed(vtkStringArray* sself) { sself->DataChanged(); } +extern "C" void vtk_string_array_data_element_changed(vtkStringArray* sself, long long id) { sself->DataElementChanged(id); } +extern "C" void vtk_string_array_clear_lookup(vtkStringArray* sself) { sself->ClearLookup(); } +extern "C" vtkStringOutputWindow * vtkStringOutputWindow_new () {return vtkStringOutputWindow :: New () ;} +extern "C" void vtkStringOutputWindow_destructor (vtkStringOutputWindow * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStringOutputWindow_get_ptr (vtkStringOutputWindow * sself) {return sself ;} +extern "C" void vtk_string_output_window_display_text(vtkStringOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } +extern "C" vtkTimePointUtility * vtkTimePointUtility_new () {return vtkTimePointUtility :: New () ;} +extern "C" void vtkTimePointUtility_destructor (vtkTimePointUtility * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTimePointUtility_get_ptr (vtkTimePointUtility * sself) {return sself ;} +extern "C" unsigned long long vtk_time_point_utility_date_to_time_point(vtkTimePointUtility* sself, int year, int month, int day) { return sself->DateToTimePoint(year, month, day); } +extern "C" unsigned long long vtk_time_point_utility_time_to_time_point(vtkTimePointUtility* sself, int hour, int minute, int second, int millis) { return sself->TimeToTimePoint(hour, minute, second, millis); } +extern "C" unsigned long long vtk_time_point_utility_date_time_to_time_point(vtkTimePointUtility* sself, int year, int month, int day, int hour, int minute, int sec, int millis) { return sself->DateTimeToTimePoint(year, month, day, hour, minute, sec, millis); } +extern "C" void vtk_time_point_utility_get_date(vtkTimePointUtility* sself, unsigned long long time, int& year, int& month, int& day) { sself->GetDate(time, year, month, day); } +extern "C" void vtk_time_point_utility_get_time(vtkTimePointUtility* sself, unsigned long long time, int& hour, int& minute, int& second, int& millis) { sself->GetTime(time, hour, minute, second, millis); } +extern "C" void vtk_time_point_utility_get_date_time(vtkTimePointUtility* sself, unsigned long long time, int& year, int& month, int& day, int& hour, int& minute, int& second, int& millis) { sself->GetDateTime(time, year, month, day, hour, minute, second, millis); } +extern "C" int vtk_time_point_utility_get_year(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetYear(time); } +extern "C" int vtk_time_point_utility_get_month(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetMonth(time); } +extern "C" int vtk_time_point_utility_get_day(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetDay(time); } +extern "C" int vtk_time_point_utility_get_hour(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetHour(time); } +extern "C" int vtk_time_point_utility_get_minute(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetMinute(time); } +extern "C" int vtk_time_point_utility_get_second(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetSecond(time); } +extern "C" int vtk_time_point_utility_get_millisecond(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetMillisecond(time); } +extern "C" const char* vtk_time_point_utility_time_point_to_iso_8601(vtkTimePointUtility* sself, unsigned long long p0, int format) { return sself->TimePointToISO8601(p0, format); } +extern "C" vtkTypeFloat32Array * vtkTypeFloat32Array_new () {return vtkTypeFloat32Array :: New () ;} +extern "C" void vtkTypeFloat32Array_destructor (vtkTypeFloat32Array * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTypeFloat32Array_get_ptr (vtkTypeFloat32Array * sself) {return sself ;} +extern "C" vtkTypeFloat64Array * vtkTypeFloat64Array_new () {return vtkTypeFloat64Array :: New () ;} +extern "C" void vtkTypeFloat64Array_destructor (vtkTypeFloat64Array * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTypeFloat64Array_get_ptr (vtkTypeFloat64Array * sself) {return sself ;} +extern "C" vtkTypeInt16Array * vtkTypeInt16Array_new () {return vtkTypeInt16Array :: New () ;} +extern "C" void vtkTypeInt16Array_destructor (vtkTypeInt16Array * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTypeInt16Array_get_ptr (vtkTypeInt16Array * sself) {return sself ;} +extern "C" vtkTypeInt32Array * vtkTypeInt32Array_new () {return vtkTypeInt32Array :: New () ;} +extern "C" void vtkTypeInt32Array_destructor (vtkTypeInt32Array * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTypeInt32Array_get_ptr (vtkTypeInt32Array * sself) {return sself ;} +extern "C" vtkTypeInt64Array * vtkTypeInt64Array_new () {return vtkTypeInt64Array :: New () ;} +extern "C" void vtkTypeInt64Array_destructor (vtkTypeInt64Array * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTypeInt64Array_get_ptr (vtkTypeInt64Array * sself) {return sself ;} +extern "C" vtkTypeInt8Array * vtkTypeInt8Array_new () {return vtkTypeInt8Array :: New () ;} +extern "C" void vtkTypeInt8Array_destructor (vtkTypeInt8Array * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTypeInt8Array_get_ptr (vtkTypeInt8Array * sself) {return sself ;} +extern "C" vtkTypeUInt16Array * vtkTypeUInt16Array_new () {return vtkTypeUInt16Array :: New () ;} +extern "C" void vtkTypeUInt16Array_destructor (vtkTypeUInt16Array * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTypeUInt16Array_get_ptr (vtkTypeUInt16Array * sself) {return sself ;} +extern "C" vtkTypeUInt32Array * vtkTypeUInt32Array_new () {return vtkTypeUInt32Array :: New () ;} +extern "C" void vtkTypeUInt32Array_destructor (vtkTypeUInt32Array * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTypeUInt32Array_get_ptr (vtkTypeUInt32Array * sself) {return sself ;} +extern "C" vtkTypeUInt64Array * vtkTypeUInt64Array_new () {return vtkTypeUInt64Array :: New () ;} +extern "C" void vtkTypeUInt64Array_destructor (vtkTypeUInt64Array * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTypeUInt64Array_get_ptr (vtkTypeUInt64Array * sself) {return sself ;} +extern "C" vtkTypeUInt8Array * vtkTypeUInt8Array_new () {return vtkTypeUInt8Array :: New () ;} +extern "C" void vtkTypeUInt8Array_destructor (vtkTypeUInt8Array * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTypeUInt8Array_get_ptr (vtkTypeUInt8Array * sself) {return sself ;} +extern "C" vtkUnicodeStringArray * vtkUnicodeStringArray_new () {return vtkUnicodeStringArray :: New () ;} +extern "C" void vtkUnicodeStringArray_destructor (vtkUnicodeStringArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUnicodeStringArray_get_ptr (vtkUnicodeStringArray * sself) {return sself ;} +extern "C" int vtk_unicode_string_array_allocate(vtkUnicodeStringArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_unicode_string_array_initialize(vtkUnicodeStringArray* sself) { sself->Initialize(); } +extern "C" int vtk_unicode_string_array_get_data_type(vtkUnicodeStringArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_unicode_string_array_get_data_type_size(vtkUnicodeStringArray* sself) { return sself->GetDataTypeSize(); } +extern "C" int vtk_unicode_string_array_get_element_component_size(vtkUnicodeStringArray* sself) { return sself->GetElementComponentSize(); } +extern "C" void vtk_unicode_string_array_set_number_of_tuples(vtkUnicodeStringArray* sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" void* vtk_unicode_string_array_get_void_pointer(vtkUnicodeStringArray* sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_unicode_string_array_squeeze(vtkUnicodeStringArray* sself) { sself->Squeeze(); } +extern "C" int vtk_unicode_string_array_resize(vtkUnicodeStringArray* sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" void vtk_unicode_string_array_set_void_array(vtkUnicodeStringArray* sself, void* array, long long size, int save) { sself->SetVoidArray(array, size, save); } +extern "C" unsigned long vtk_unicode_string_array_get_actual_memory_size(vtkUnicodeStringArray* sself) { return sself->GetActualMemorySize(); } +extern "C" int vtk_unicode_string_array_is_numeric(vtkUnicodeStringArray* sself) { return sself->IsNumeric(); } +extern "C" void vtk_unicode_string_array_data_changed(vtkUnicodeStringArray* sself) { sself->DataChanged(); } +extern "C" void vtk_unicode_string_array_clear_lookup(vtkUnicodeStringArray* sself) { sself->ClearLookup(); } +extern "C" void vtk_unicode_string_array_insert_next_utf_8_value(vtkUnicodeStringArray* sself, const char* p0) { sself->InsertNextUTF8Value(p0); } +extern "C" void vtk_unicode_string_array_set_utf_8_value(vtkUnicodeStringArray* sself, long long i, const char* p1) { sself->SetUTF8Value(i, p1); } +extern "C" const char* vtk_unicode_string_array_get_utf_8_value(vtkUnicodeStringArray* sself, long long i) { return sself->GetUTF8Value(i); } +extern "C" vtkUnsignedCharArray * vtkUnsignedCharArray_new () {return vtkUnsignedCharArray :: New () ;} +extern "C" void vtkUnsignedCharArray_destructor (vtkUnsignedCharArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUnsignedCharArray_get_ptr (vtkUnsignedCharArray * sself) {return sself ;} +extern "C" int vtk_unsigned_char_array_get_data_type(vtkUnsignedCharArray* sself) { return sself->GetDataType(); } +extern "C" unsigned char vtk_unsigned_char_array_get_value(vtkUnsignedCharArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_char_array_set_value(vtkUnsignedCharArray* sself, long long id, unsigned char value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_char_array_set_number_of_values(vtkUnsignedCharArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_char_array_insert_value(vtkUnsignedCharArray* sself, long long id, unsigned char f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_char_array_insert_next_value(vtkUnsignedCharArray* sself, unsigned char f) { return sself->InsertNextValue(f); } +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_min(vtkUnsignedCharArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_max(vtkUnsignedCharArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkUnsignedIntArray * vtkUnsignedIntArray_new () {return vtkUnsignedIntArray :: New () ;} +extern "C" void vtkUnsignedIntArray_destructor (vtkUnsignedIntArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUnsignedIntArray_get_ptr (vtkUnsignedIntArray * sself) {return sself ;} +extern "C" int vtk_unsigned_int_array_get_data_type(vtkUnsignedIntArray* sself) { return sself->GetDataType(); } +extern "C" unsigned int vtk_unsigned_int_array_get_value(vtkUnsignedIntArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_int_array_set_value(vtkUnsignedIntArray* sself, long long id, unsigned int value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_int_array_set_number_of_values(vtkUnsignedIntArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_int_array_insert_value(vtkUnsignedIntArray* sself, long long id, unsigned int f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_int_array_insert_next_value(vtkUnsignedIntArray* sself, unsigned int f) { return sself->InsertNextValue(f); } +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_min(vtkUnsignedIntArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_max(vtkUnsignedIntArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkUnsignedLongArray * vtkUnsignedLongArray_new () {return vtkUnsignedLongArray :: New () ;} +extern "C" void vtkUnsignedLongArray_destructor (vtkUnsignedLongArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUnsignedLongArray_get_ptr (vtkUnsignedLongArray * sself) {return sself ;} +extern "C" int vtk_unsigned_long_array_get_data_type(vtkUnsignedLongArray* sself) { return sself->GetDataType(); } +extern "C" unsigned long vtk_unsigned_long_array_get_value(vtkUnsignedLongArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_long_array_set_value(vtkUnsignedLongArray* sself, long long id, unsigned long value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_long_array_set_number_of_values(vtkUnsignedLongArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_long_array_insert_value(vtkUnsignedLongArray* sself, long long id, unsigned long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_long_array_insert_next_value(vtkUnsignedLongArray* sself, unsigned long f) { return sself->InsertNextValue(f); } +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_min(vtkUnsignedLongArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_max(vtkUnsignedLongArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkUnsignedLongLongArray * vtkUnsignedLongLongArray_new () {return vtkUnsignedLongLongArray :: New () ;} +extern "C" void vtkUnsignedLongLongArray_destructor (vtkUnsignedLongLongArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUnsignedLongLongArray_get_ptr (vtkUnsignedLongLongArray * sself) {return sself ;} +extern "C" int vtk_unsigned_long_long_array_get_data_type(vtkUnsignedLongLongArray* sself) { return sself->GetDataType(); } +extern "C" unsigned long long vtk_unsigned_long_long_array_get_value(vtkUnsignedLongLongArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_long_long_array_set_value(vtkUnsignedLongLongArray* sself, long long id, unsigned long long value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_long_long_array_set_number_of_values(vtkUnsignedLongLongArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_long_long_array_insert_value(vtkUnsignedLongLongArray* sself, long long id, unsigned long long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_long_long_array_insert_next_value(vtkUnsignedLongLongArray* sself, unsigned long long f) { return sself->InsertNextValue(f); } +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_min(vtkUnsignedLongLongArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_max(vtkUnsignedLongLongArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkUnsignedShortArray * vtkUnsignedShortArray_new () {return vtkUnsignedShortArray :: New () ;} +extern "C" void vtkUnsignedShortArray_destructor (vtkUnsignedShortArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUnsignedShortArray_get_ptr (vtkUnsignedShortArray * sself) {return sself ;} +extern "C" int vtk_unsigned_short_array_get_data_type(vtkUnsignedShortArray* sself) { return sself->GetDataType(); } +extern "C" unsigned short vtk_unsigned_short_array_get_value(vtkUnsignedShortArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_short_array_set_value(vtkUnsignedShortArray* sself, long long id, unsigned short value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_short_array_set_number_of_values(vtkUnsignedShortArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_short_array_insert_value(vtkUnsignedShortArray* sself, long long id, unsigned short f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_short_array_insert_next_value(vtkUnsignedShortArray* sself, unsigned short f) { return sself->InsertNextValue(f); } +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_min(vtkUnsignedShortArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_max(vtkUnsignedShortArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkVariantArray * vtkVariantArray_new () {return vtkVariantArray :: New () ;} +extern "C" void vtkVariantArray_destructor (vtkVariantArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkVariantArray_get_ptr (vtkVariantArray * sself) {return sself ;} +extern "C" int vtk_variant_array_allocate(vtkVariantArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_variant_array_initialize(vtkVariantArray* sself) { sself->Initialize(); } +extern "C" int vtk_variant_array_get_data_type(vtkVariantArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_variant_array_get_data_type_size(vtkVariantArray* sself) { return sself->GetDataTypeSize(); } +extern "C" int vtk_variant_array_get_element_component_size(vtkVariantArray* sself) { return sself->GetElementComponentSize(); } +extern "C" void vtk_variant_array_set_number_of_tuples(vtkVariantArray* sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" void* vtk_variant_array_get_void_pointer(vtkVariantArray* sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_variant_array_squeeze(vtkVariantArray* sself) { sself->Squeeze(); } +extern "C" int vtk_variant_array_resize(vtkVariantArray* sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" void vtk_variant_array_set_void_array(vtkVariantArray* sself, void* arr, long long size, int save) { sself->SetVoidArray(arr, size, save); } +extern "C" unsigned long vtk_variant_array_get_actual_memory_size(vtkVariantArray* sself) { return sself->GetActualMemorySize(); } +extern "C" int vtk_variant_array_is_numeric(vtkVariantArray* sself) { return sself->IsNumeric(); } +extern "C" long long vtk_variant_array_get_number_of_values(vtkVariantArray* sself) { return sself->GetNumberOfValues(); } +extern "C" void vtk_variant_array_data_changed(vtkVariantArray* sself) { sself->DataChanged(); } +extern "C" void vtk_variant_array_data_element_changed(vtkVariantArray* sself, long long id) { sself->DataElementChanged(id); } +extern "C" void vtk_variant_array_clear_lookup(vtkVariantArray* sself) { sself->ClearLookup(); } +extern "C" vtkVersion * vtkVersion_new () {return vtkVersion :: New () ;} +extern "C" void vtkVersion_destructor (vtkVersion * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkVersion_get_ptr (vtkVersion * sself) {return sself ;} +extern "C" const char* vtk_version_get_vtk_version(vtkVersion* sself) { return sself->GetVTKVersion(); } +extern "C" const char* vtk_version_get_vtk_version_full(vtkVersion* sself) { return sself->GetVTKVersionFull(); } +extern "C" int vtk_version_get_vtk_major_version(vtkVersion* sself) { return sself->GetVTKMajorVersion(); } +extern "C" int vtk_version_get_vtk_minor_version(vtkVersion* sself) { return sself->GetVTKMinorVersion(); } +extern "C" int vtk_version_get_vtk_build_version(vtkVersion* sself) { return sself->GetVTKBuildVersion(); } +extern "C" const char* vtk_version_get_vtk_source_version(vtkVersion* sself) { return sself->GetVTKSourceVersion(); } +extern "C" vtkVoidArray * vtkVoidArray_new () {return vtkVoidArray :: New () ;} +extern "C" void vtkVoidArray_destructor (vtkVoidArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkVoidArray_get_ptr (vtkVoidArray * sself) {return sself ;} +extern "C" int vtk_void_array_allocate(vtkVoidArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_void_array_initialize(vtkVoidArray* sself) { sself->Initialize(); } +extern "C" int vtk_void_array_get_data_type(vtkVoidArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_void_array_get_data_type_size(vtkVoidArray* sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_void_array_set_number_of_pointers(vtkVoidArray* sself, long long number) { sself->SetNumberOfPointers(number); } +extern "C" long long vtk_void_array_get_number_of_pointers(vtkVoidArray* sself) { return sself->GetNumberOfPointers(); } +extern "C" void* vtk_void_array_get_void_pointer(vtkVoidArray* sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_void_array_set_void_pointer(vtkVoidArray* sself, long long id, void* ptr) { sself->SetVoidPointer(id, ptr); } +extern "C" void vtk_void_array_insert_void_pointer(vtkVoidArray* sself, long long i, void* ptr) { sself->InsertVoidPointer(i, ptr); } +extern "C" long long vtk_void_array_insert_next_void_pointer(vtkVoidArray* sself, void* tuple) { return sself->InsertNextVoidPointer(tuple); } +extern "C" void vtk_void_array_reset(vtkVoidArray* sself) { sself->Reset(); } +extern "C" void vtk_void_array_squeeze(vtkVoidArray* sself) { sself->Squeeze(); } +extern "C" vtkWeakReference * vtkWeakReference_new () {return vtkWeakReference :: New () ;} +extern "C" void vtkWeakReference_destructor (vtkWeakReference * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkWeakReference_get_ptr (vtkWeakReference * sself) {return sself ;} +extern "C" vtkXMLFileOutputWindow * vtkXMLFileOutputWindow_new () {return vtkXMLFileOutputWindow :: New () ;} +extern "C" void vtkXMLFileOutputWindow_destructor (vtkXMLFileOutputWindow * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkXMLFileOutputWindow_get_ptr (vtkXMLFileOutputWindow * sself) {return sself ;} +extern "C" void vtk_xml_file_output_window_display_text(vtkXMLFileOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } +extern "C" void vtk_xml_file_output_window_display_tag(vtkXMLFileOutputWindow* sself, const char* p0) { sself->DisplayTag(p0); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp index 6edbd39..6dad674 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp @@ -282,3022 +282,1889 @@ #include // Implement declared functions -extern "C" vtkNew < vtkAMRDataInternals > vtkAMRDataInternals_new () {return vtkNew < vtkAMRDataInternals > () ;} -extern "C" void vtkAMRDataInternals_destructor (vtkNew < vtkAMRDataInternals > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAMRDataInternals_get_ptr (vtkNew < vtkAMRDataInternals > sself) {return sself . GetPointer () ;} -extern "C" void vtk_amr_data_internals_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" bool vtk_amr_data_internals_empty(vtkNew sself) { return sself->Empty(); } -extern "C" unsigned int vtk_amr_data_internals_get_number_of_blocks(vtkNew sself) { return sself->GetNumberOfBlocks(); } -extern "C" vtkNew < vtkAdjacentVertexIterator > vtkAdjacentVertexIterator_new () {return vtkNew < vtkAdjacentVertexIterator > () ;} -extern "C" void vtkAdjacentVertexIterator_destructor (vtkNew < vtkAdjacentVertexIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAdjacentVertexIterator_get_ptr (vtkNew < vtkAdjacentVertexIterator > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_adjacent_vertex_iterator_get_vertex(vtkNew sself) { return sself->GetVertex(); } -extern "C" long long vtk_adjacent_vertex_iterator_next(vtkNew sself) { return sself->Next(); } -extern "C" bool vtk_adjacent_vertex_iterator_has_next(vtkNew sself) { return sself->HasNext(); } -extern "C" vtkNew < vtkAnimationScene > vtkAnimationScene_new () {return vtkNew < vtkAnimationScene > () ;} -extern "C" void vtkAnimationScene_destructor (vtkNew < vtkAnimationScene > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAnimationScene_get_ptr (vtkNew < vtkAnimationScene > sself) {return sself . GetPointer () ;} -extern "C" void vtk_animation_scene_set_play_mode(vtkNew sself, int _arg) { sself->SetPlayMode(_arg); } -extern "C" void vtk_animation_scene_set_mode_to_sequence(vtkNew sself) { sself->SetModeToSequence(); } -extern "C" void vtk_animation_scene_set_mode_to_real_time(vtkNew sself) { sself->SetModeToRealTime(); } -extern "C" int vtk_animation_scene_get_play_mode(vtkNew sself) { return sself->GetPlayMode(); } -extern "C" void vtk_animation_scene_set_frame_rate(vtkNew sself, double _arg) { sself->SetFrameRate(_arg); } -extern "C" double vtk_animation_scene_get_frame_rate(vtkNew sself) { return sself->GetFrameRate(); } -extern "C" void vtk_animation_scene_remove_all_cues(vtkNew sself) { sself->RemoveAllCues(); } -extern "C" int vtk_animation_scene_get_number_of_cues(vtkNew sself) { return sself->GetNumberOfCues(); } -extern "C" void vtk_animation_scene_play(vtkNew sself) { sself->Play(); } -extern "C" void vtk_animation_scene_stop(vtkNew sself) { sself->Stop(); } -extern "C" void vtk_animation_scene_set_loop(vtkNew sself, int _arg) { sself->SetLoop(_arg); } -extern "C" int vtk_animation_scene_get_loop(vtkNew sself) { return sself->GetLoop(); } -extern "C" void vtk_animation_scene_set_animation_time(vtkNew sself, double time) { sself->SetAnimationTime(time); } -extern "C" void vtk_animation_scene_set_time_mode(vtkNew sself, int mode) { sself->SetTimeMode(mode); } -extern "C" int vtk_animation_scene_is_in_play(vtkNew sself) { return sself->IsInPlay(); } -extern "C" vtkNew < vtkAnnotation > vtkAnnotation_new () {return vtkNew < vtkAnnotation > () ;} -extern "C" void vtkAnnotation_destructor (vtkNew < vtkAnnotation > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAnnotation_get_ptr (vtkNew < vtkAnnotation > sself) {return sself . GetPointer () ;} -extern "C" int vtk_annotation_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" void vtk_annotation_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" unsigned long vtk_annotation_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkAnnotationLayers > vtkAnnotationLayers_new () {return vtkNew < vtkAnnotationLayers > () ;} -extern "C" void vtkAnnotationLayers_destructor (vtkNew < vtkAnnotationLayers > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAnnotationLayers_get_ptr (vtkNew < vtkAnnotationLayers > sself) {return sself . GetPointer () ;} -extern "C" int vtk_annotation_layers_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" unsigned int vtk_annotation_layers_get_number_of_annotations(vtkNew sself) { return sself->GetNumberOfAnnotations(); } -extern "C" void vtk_annotation_layers_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" unsigned long vtk_annotation_layers_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkArrayData > vtkArrayData_new () {return vtkNew < vtkArrayData > () ;} -extern "C" void vtkArrayData_destructor (vtkNew < vtkArrayData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkArrayData_get_ptr (vtkNew < vtkArrayData > sself) {return sself . GetPointer () ;} -extern "C" void vtk_array_data_clear_arrays(vtkNew sself) { sself->ClearArrays(); } -extern "C" long long vtk_array_data_get_number_of_arrays(vtkNew sself) { return sself->GetNumberOfArrays(); } -extern "C" int vtk_array_data_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" vtkNew < vtkAttributesErrorMetric > vtkAttributesErrorMetric_new () {return vtkNew < vtkAttributesErrorMetric > () ;} -extern "C" void vtkAttributesErrorMetric_destructor (vtkNew < vtkAttributesErrorMetric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAttributesErrorMetric_get_ptr (vtkNew < vtkAttributesErrorMetric > sself) {return sself . GetPointer () ;} -extern "C" double vtk_attributes_error_metric_get_absolute_attribute_tolerance(vtkNew sself) { return sself->GetAbsoluteAttributeTolerance(); } -extern "C" void vtk_attributes_error_metric_set_absolute_attribute_tolerance(vtkNew sself, double value) { sself->SetAbsoluteAttributeTolerance(value); } -extern "C" double vtk_attributes_error_metric_get_attribute_tolerance(vtkNew sself) { return sself->GetAttributeTolerance(); } -extern "C" void vtk_attributes_error_metric_set_attribute_tolerance(vtkNew sself, double value) { sself->SetAttributeTolerance(value); } -extern "C" int vtk_attributes_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->RequiresEdgeSubdivision(leftPoint, midPoint, rightPoint, alpha); } -extern "C" double vtk_attributes_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->GetError(leftPoint, midPoint, rightPoint, alpha); } -extern "C" vtkNew < vtkBSPCuts > vtkBSPCuts_new () {return vtkNew < vtkBSPCuts > () ;} -extern "C" void vtkBSPCuts_destructor (vtkNew < vtkBSPCuts > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBSPCuts_get_ptr (vtkNew < vtkBSPCuts > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bsp_cuts_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" void vtk_bsp_cuts_create_cuts(vtkNew sself, double bounds, int ncuts, int dim, double coord, int lower, int upper, double lowerDataCoord, double upperDataCoord, int npoints) { sself->CreateCuts(bounds, ncuts, dim, coord, lower, upper, lowerDataCoord, upperDataCoord, npoints); } -extern "C" int vtk_bsp_cuts_get_number_of_cuts(vtkNew sself) { return sself->GetNumberOfCuts(); } -extern "C" int vtk_bsp_cuts_get_arrays(vtkNew sself, int len, int dim, double coord, int lower, int upper, double lowerDataCoord, double upperDataCoord, int npoints) { return sself->GetArrays(len, dim, coord, lower, upper, lowerDataCoord, upperDataCoord, npoints); } -extern "C" void vtk_bsp_cuts_print_tree(vtkNew sself) { sself->PrintTree(); } -extern "C" void vtk_bsp_cuts_print_arrays(vtkNew sself) { sself->PrintArrays(); } -extern "C" vtkNew < vtkBSPIntersections > vtkBSPIntersections_new () {return vtkNew < vtkBSPIntersections > () ;} -extern "C" void vtkBSPIntersections_destructor (vtkNew < vtkBSPIntersections > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBSPIntersections_get_ptr (vtkNew < vtkBSPIntersections > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bsp_intersections_get_bounds(vtkNew sself, double bounds) { return sself->GetBounds(bounds); } -extern "C" int vtk_bsp_intersections_get_number_of_regions(vtkNew sself) { return sself->GetNumberOfRegions(); } -extern "C" int vtk_bsp_intersections_get_region_bounds(vtkNew sself, int regionID, double bounds) { return sself->GetRegionBounds(regionID, bounds); } -extern "C" int vtk_bsp_intersections_get_region_data_bounds(vtkNew sself, int regionID, double bounds) { return sself->GetRegionDataBounds(regionID, bounds); } -extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int regionId, double x) { return sself->IntersectsBox(regionId, x); } -extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int regionId, double x0, double x1, double y0, double y1, double z0, double z1) { return sself->IntersectsBox(regionId, x0, x1, y0, y1, z0, z1); } -extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int ids, int len, double x) { return sself->IntersectsBox(ids, len, x); } -extern "C" int vtk_bsp_intersections_intersects_box(vtkNew sself, int ids, int len, double x0, double x1, double y0, double y1, double z0, double z1) { return sself->IntersectsBox(ids, len, x0, x1, y0, y1, z0, z1); } -extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkNew sself, int regionId, double x, double y, double z, double rSquared) { return sself->IntersectsSphere2(regionId, x, y, z, rSquared); } -extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkNew sself, int ids, int len, double x, double y, double z, double rSquared) { return sself->IntersectsSphere2(ids, len, x, y, z, rSquared); } -extern "C" int vtk_bsp_intersections_get_compute_intersections_using_data_bounds(vtkNew sself) { return sself->GetComputeIntersectionsUsingDataBounds(); } -extern "C" void vtk_bsp_intersections_set_compute_intersections_using_data_bounds(vtkNew sself, int c) { sself->SetComputeIntersectionsUsingDataBounds(c); } -extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_on(vtkNew sself) { sself->ComputeIntersectionsUsingDataBoundsOn(); } -extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_off(vtkNew sself) { sself->ComputeIntersectionsUsingDataBoundsOff(); } -extern "C" vtkNew < vtkBezierCurve > vtkBezierCurve_new () {return vtkNew < vtkBezierCurve > () ;} -extern "C" void vtkBezierCurve_destructor (vtkNew < vtkBezierCurve > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierCurve_get_ptr (vtkNew < vtkBezierCurve > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bezier_curve_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_bezier_curve_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } -extern "C" void vtk_bezier_curve_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkBezierHexahedron > vtkBezierHexahedron_new () {return vtkNew < vtkBezierHexahedron > () ;} -extern "C" void vtkBezierHexahedron_destructor (vtkNew < vtkBezierHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierHexahedron_get_ptr (vtkNew < vtkBezierHexahedron > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bezier_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_bezier_hexahedron_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } -extern "C" void vtk_bezier_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkBezierInterpolation > vtkBezierInterpolation_new () {return vtkNew < vtkBezierInterpolation > () ;} -extern "C" void vtkBezierInterpolation_destructor (vtkNew < vtkBezierInterpolation > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierInterpolation_get_ptr (vtkNew < vtkBezierInterpolation > sself) {return sself . GetPointer () ;} -extern "C" void vtk_bezier_interpolation_de_casteljau_simplex(vtkNew sself, const int dim, const int deg, const double pcoords, double weights) { sself->deCasteljauSimplex(dim, deg, pcoords, weights); } -extern "C" void vtk_bezier_interpolation_de_casteljau_simplex(vtkNew sself, const int dim, const int deg, const double pcoords, double weights) { sself->DeCasteljauSimplex(dim, deg, pcoords, weights); } -extern "C" void vtk_bezier_interpolation_de_casteljau_simplex_deriv(vtkNew sself, const int dim, const int deg, const double pcoords, double weights) { sself->deCasteljauSimplexDeriv(dim, deg, pcoords, weights); } -extern "C" void vtk_bezier_interpolation_de_casteljau_simplex_deriv(vtkNew sself, const int dim, const int deg, const double pcoords, double weights) { sself->DeCasteljauSimplexDeriv(dim, deg, pcoords, weights); } -extern "C" void vtk_bezier_interpolation_evaluate_shape_functions(vtkNew sself, int order, double pcoord, double shape) { sself->EvaluateShapeFunctions(order, pcoord, shape); } -extern "C" void vtk_bezier_interpolation_evaluate_shape_and_gradient(vtkNew sself, int order, double pcoord, double shape, double grad) { sself->EvaluateShapeAndGradient(order, pcoord, shape, grad); } -extern "C" int vtk_bezier_interpolation_tensor_1_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor1ShapeFunctions(order, pcoords, shape); } -extern "C" int vtk_bezier_interpolation_tensor_1_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor1ShapeDerivatives(order, pcoords, derivs); } -extern "C" int vtk_bezier_interpolation_tensor_2_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor2ShapeFunctions(order, pcoords, shape); } -extern "C" int vtk_bezier_interpolation_tensor_2_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor2ShapeDerivatives(order, pcoords, derivs); } -extern "C" int vtk_bezier_interpolation_tensor_3_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor3ShapeFunctions(order, pcoords, shape); } -extern "C" int vtk_bezier_interpolation_tensor_3_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor3ShapeDerivatives(order, pcoords, derivs); } -extern "C" void vtk_bezier_interpolation_wedge_shape_functions(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double shape) { sself->WedgeShapeFunctions(order, numberOfPoints, pcoords, shape); } -extern "C" void vtk_bezier_interpolation_wedge_shape_derivatives(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double derivs) { sself->WedgeShapeDerivatives(order, numberOfPoints, pcoords, derivs); } -extern "C" void vtk_bezier_interpolation_wedge_evaluate(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double fieldVals, int fieldDim, double fieldAtPCoords) { sself->WedgeEvaluate(order, numberOfPoints, pcoords, fieldVals, fieldDim, fieldAtPCoords); } -extern "C" vtkNew < vtkBezierQuadrilateral > vtkBezierQuadrilateral_new () {return vtkNew < vtkBezierQuadrilateral > () ;} -extern "C" void vtkBezierQuadrilateral_destructor (vtkNew < vtkBezierQuadrilateral > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierQuadrilateral_get_ptr (vtkNew < vtkBezierQuadrilateral > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bezier_quadrilateral_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_bezier_quadrilateral_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } -extern "C" void vtk_bezier_quadrilateral_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkBezierTetra > vtkBezierTetra_new () {return vtkNew < vtkBezierTetra > () ;} -extern "C" void vtkBezierTetra_destructor (vtkNew < vtkBezierTetra > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierTetra_get_ptr (vtkNew < vtkBezierTetra > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bezier_tetra_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_bezier_tetra_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } -extern "C" void vtk_bezier_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkBezierTriangle > vtkBezierTriangle_new () {return vtkNew < vtkBezierTriangle > () ;} -extern "C" void vtkBezierTriangle_destructor (vtkNew < vtkBezierTriangle > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierTriangle_get_ptr (vtkNew < vtkBezierTriangle > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bezier_triangle_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_bezier_triangle_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } -extern "C" void vtk_bezier_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkBezierWedge > vtkBezierWedge_new () {return vtkNew < vtkBezierWedge > () ;} -extern "C" void vtkBezierWedge_destructor (vtkNew < vtkBezierWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierWedge_get_ptr (vtkNew < vtkBezierWedge > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bezier_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_bezier_wedge_evaluate_location_projected_node(vtkNew sself, int subId, const long long point_id, double x, double weights) { sself->EvaluateLocationProjectedNode(subId, point_id, x, weights); } -extern "C" void vtk_bezier_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkBiQuadraticQuad > vtkBiQuadraticQuad_new () {return vtkNew < vtkBiQuadraticQuad > () ;} -extern "C" void vtkBiQuadraticQuad_destructor (vtkNew < vtkBiQuadraticQuad > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBiQuadraticQuad_get_ptr (vtkNew < vtkBiQuadraticQuad > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bi_quadratic_quad_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_bi_quadratic_quad_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_bi_quadratic_quad_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_bi_quadratic_quad_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_bi_quadratic_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_bi_quadratic_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_bi_quadratic_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_bi_quadratic_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_bi_quadratic_quad_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_bi_quadratic_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_bi_quadratic_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" vtkNew < vtkBiQuadraticQuadraticHexahedron > vtkBiQuadraticQuadraticHexahedron_new () {return vtkNew < vtkBiQuadraticQuadraticHexahedron > () ;} -extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBiQuadraticQuadraticHexahedron_get_ptr (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_bi_quadratic_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_bi_quadratic_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_bi_quadratic_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" void vtk_bi_quadratic_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkBiQuadraticQuadraticWedge > vtkBiQuadraticQuadraticWedge_new () {return vtkNew < vtkBiQuadraticQuadraticWedge > () ;} -extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkNew < vtkBiQuadraticQuadraticWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBiQuadraticQuadraticWedge_get_ptr (vtkNew < vtkBiQuadraticQuadraticWedge > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_bi_quadratic_quadratic_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_bi_quadratic_quadratic_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_bi_quadratic_quadratic_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_bi_quadratic_quadratic_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_bi_quadratic_quadratic_wedge_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_bi_quadratic_quadratic_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_bi_quadratic_quadratic_wedge_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_bi_quadratic_quadratic_wedge_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" void vtk_bi_quadratic_quadratic_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkBiQuadraticTriangle > vtkBiQuadraticTriangle_new () {return vtkNew < vtkBiQuadraticTriangle > () ;} -extern "C" void vtkBiQuadraticTriangle_destructor (vtkNew < vtkBiQuadraticTriangle > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBiQuadraticTriangle_get_ptr (vtkNew < vtkBiQuadraticTriangle > sself) {return sself . GetPointer () ;} -extern "C" int vtk_bi_quadratic_triangle_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_bi_quadratic_triangle_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_bi_quadratic_triangle_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_bi_quadratic_triangle_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_bi_quadratic_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_bi_quadratic_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_bi_quadratic_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_bi_quadratic_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_bi_quadratic_triangle_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" double vtk_bi_quadratic_triangle_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } -extern "C" void vtk_bi_quadratic_triangle_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_bi_quadratic_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_bi_quadratic_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_bi_quadratic_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" vtkNew < vtkBox > vtkBox_new () {return vtkNew < vtkBox > () ;} -extern "C" void vtkBox_destructor (vtkNew < vtkBox > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBox_get_ptr (vtkNew < vtkBox > sself) {return sself . GetPointer () ;} -extern "C" double vtk_box_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_box_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } -extern "C" void vtk_box_set_x_min(vtkNew sself, double p) { sself->SetXMin(p); } -extern "C" void vtk_box_set_x_min(vtkNew sself, double x, double y, double z) { sself->SetXMin(x, y, z); } -extern "C" void vtk_box_get_x_min(vtkNew sself, double p) { sself->GetXMin(p); } -extern "C" void vtk_box_get_x_min(vtkNew sself, double x, double y, double z) { sself->GetXMin(x, y, z); } -extern "C" void vtk_box_set_x_max(vtkNew sself, double p) { sself->SetXMax(p); } -extern "C" void vtk_box_set_x_max(vtkNew sself, double x, double y, double z) { sself->SetXMax(x, y, z); } -extern "C" void vtk_box_get_x_max(vtkNew sself, double p) { sself->GetXMax(p); } -extern "C" void vtk_box_get_x_max(vtkNew sself, double x, double y, double z) { sself->GetXMax(x, y, z); } -extern "C" void vtk_box_set_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } -extern "C" void vtk_box_set_bounds(vtkNew sself, const double bounds) { sself->SetBounds(bounds); } -extern "C" void vtk_box_get_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->GetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } -extern "C" void vtk_box_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" double* vtk_box_get_bounds(vtkNew sself) { return sself->GetBounds(); } -extern "C" void vtk_box_add_bounds(vtkNew sself, const double bounds) { sself->AddBounds(bounds); } -extern "C" char vtk_box_intersect_box(vtkNew sself, const double bounds, const double origin, const double dir, double coord, double t, const double tolerance) { return sself->IntersectBox(bounds, origin, dir, coord, t, tolerance); } -extern "C" int vtk_box_intersect_with_line(vtkNew sself, const double bounds, const double p1, const double p2, double t1, double t2, double x1, double x2, int plane1, int plane2) { return sself->IntersectWithLine(bounds, p1, p2, t1, t2, x1, x2, plane1, plane2); } -extern "C" bool vtk_box_intersect_with_infinite_line(vtkNew sself, const double bounds, const double p1, const double p2, double t1, double t2, double x1, double x2, int plane1, int plane2) { return sself->IntersectWithInfiniteLine(bounds, p1, p2, t1, t2, x1, x2, plane1, plane2); } -extern "C" int vtk_box_intersect_with_plane(vtkNew sself, double bounds, double origin, double normal) { return sself->IntersectWithPlane(bounds, origin, normal); } -extern "C" int vtk_box_intersect_with_plane(vtkNew sself, double bounds, double origin, double normal, double xout) { return sself->IntersectWithPlane(bounds, origin, normal, xout); } -extern "C" int vtk_box_is_box_in_frustum(vtkNew sself, double planes, double bounds) { return sself->IsBoxInFrustum(planes, bounds); } -extern "C" vtkNew < vtkCellArray > vtkCellArray_new () {return vtkNew < vtkCellArray > () ;} -extern "C" void vtkCellArray_destructor (vtkNew < vtkCellArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellArray_get_ptr (vtkNew < vtkCellArray > sself) {return sself . GetPointer () ;} -extern "C" int vtk_cell_array_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } -extern "C" bool vtk_cell_array_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } -extern "C" bool vtk_cell_array_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } -extern "C" bool vtk_cell_array_resize_exact(vtkNew sself, long long numCells, long long connectivitySize) { return sself->ResizeExact(numCells, connectivitySize); } -extern "C" void vtk_cell_array_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_cell_array_reset(vtkNew sself) { sself->Reset(); } -extern "C" void vtk_cell_array_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" bool vtk_cell_array_is_valid(vtkNew sself) { return sself->IsValid(); } -extern "C" long long vtk_cell_array_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } -extern "C" long long vtk_cell_array_get_number_of_offsets(vtkNew sself) { return sself->GetNumberOfOffsets(); } -extern "C" long long vtk_cell_array_get_number_of_connectivity_ids(vtkNew sself) { return sself->GetNumberOfConnectivityIds(); } -extern "C" bool vtk_cell_array_is_storage_64_bit(vtkNew sself) { return sself->IsStorage64Bit(); } -extern "C" bool vtk_cell_array_is_storage_shareable(vtkNew sself) { return sself->IsStorageShareable(); } -extern "C" void vtk_cell_array_use_32_bit_storage(vtkNew sself) { sself->Use32BitStorage(); } -extern "C" void vtk_cell_array_use_64_bit_storage(vtkNew sself) { sself->Use64BitStorage(); } -extern "C" void vtk_cell_array_use_default_storage(vtkNew sself) { sself->UseDefaultStorage(); } -extern "C" bool vtk_cell_array_can_convert_to_32_bit_storage(vtkNew sself) { return sself->CanConvertTo32BitStorage(); } -extern "C" bool vtk_cell_array_can_convert_to_64_bit_storage(vtkNew sself) { return sself->CanConvertTo64BitStorage(); } -extern "C" bool vtk_cell_array_can_convert_to_default_storage(vtkNew sself) { return sself->CanConvertToDefaultStorage(); } -extern "C" bool vtk_cell_array_convert_to_32_bit_storage(vtkNew sself) { return sself->ConvertTo32BitStorage(); } -extern "C" bool vtk_cell_array_convert_to_64_bit_storage(vtkNew sself) { return sself->ConvertTo64BitStorage(); } -extern "C" bool vtk_cell_array_convert_to_default_storage(vtkNew sself) { return sself->ConvertToDefaultStorage(); } -extern "C" bool vtk_cell_array_convert_to_smallest_storage(vtkNew sself) { return sself->ConvertToSmallestStorage(); } -extern "C" long long vtk_cell_array_is_homogeneous(vtkNew sself) { return sself->IsHomogeneous(); } -extern "C" void vtk_cell_array_init_traversal(vtkNew sself) { sself->InitTraversal(); } -extern "C" int vtk_cell_array_get_next_cell(vtkNew sself, long long npts, const long long pts) { return sself->GetNextCell(npts, pts); } -extern "C" void vtk_cell_array_get_cell_at_id(vtkNew sself, long long cellId, long long cellSize, const long long cellPoints) { sself->GetCellAtId(cellId, cellSize, cellPoints); } -extern "C" long long vtk_cell_array_get_cell_size(vtkNew sself, const long long cellId) { return sself->GetCellSize(cellId); } -extern "C" long long vtk_cell_array_insert_next_cell(vtkNew sself, long long npts, const long long pts) { return sself->InsertNextCell(npts, pts); } -extern "C" long long vtk_cell_array_insert_next_cell(vtkNew sself, int npts) { return sself->InsertNextCell(npts); } -extern "C" void vtk_cell_array_insert_cell_point(vtkNew sself, long long id) { sself->InsertCellPoint(id); } -extern "C" void vtk_cell_array_update_cell_count(vtkNew sself, int npts) { sself->UpdateCellCount(npts); } -extern "C" long long vtk_cell_array_get_traversal_cell_id(vtkNew sself) { return sself->GetTraversalCellId(); } -extern "C" void vtk_cell_array_set_traversal_cell_id(vtkNew sself, long long cellId) { sself->SetTraversalCellId(cellId); } -extern "C" void vtk_cell_array_reverse_cell_at_id(vtkNew sself, long long cellId) { sself->ReverseCellAtId(cellId); } -extern "C" void vtk_cell_array_replace_cell_at_id(vtkNew sself, long long cellId, long long cellSize, const long long cellPoints) { sself->ReplaceCellAtId(cellId, cellSize, cellPoints); } -extern "C" int vtk_cell_array_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } -extern "C" void vtk_cell_array_import_legacy_format(vtkNew sself, const long long data, long long len) { sself->ImportLegacyFormat(data, len); } -extern "C" void vtk_cell_array_append_legacy_format(vtkNew sself, const long long data, long long len, long long ptOffset) { sself->AppendLegacyFormat(data, len, ptOffset); } -extern "C" unsigned long vtk_cell_array_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" void vtk_cell_array_set_number_of_cells(vtkNew sself, long long p0) { sself->SetNumberOfCells(p0); } -extern "C" long long vtk_cell_array_estimate_size(vtkNew sself, long long numCells, int maxPtsPerCell) { return sself->EstimateSize(numCells, maxPtsPerCell); } -extern "C" long long vtk_cell_array_get_size(vtkNew sself) { return sself->GetSize(); } -extern "C" long long vtk_cell_array_get_number_of_connectivity_entries(vtkNew sself) { return sself->GetNumberOfConnectivityEntries(); } -extern "C" void vtk_cell_array_get_cell(vtkNew sself, long long loc, long long npts, const long long pts) { sself->GetCell(loc, npts, pts); } -extern "C" long long vtk_cell_array_get_insert_location(vtkNew sself, int npts) { return sself->GetInsertLocation(npts); } -extern "C" long long vtk_cell_array_get_traversal_location(vtkNew sself) { return sself->GetTraversalLocation(); } -extern "C" long long vtk_cell_array_get_traversal_location(vtkNew sself, long long npts) { return sself->GetTraversalLocation(npts); } -extern "C" void vtk_cell_array_set_traversal_location(vtkNew sself, long long loc) { sself->SetTraversalLocation(loc); } -extern "C" void vtk_cell_array_reverse_cell(vtkNew sself, long long loc) { sself->ReverseCell(loc); } -extern "C" void vtk_cell_array_replace_cell(vtkNew sself, long long loc, int npts, const long long pts) { sself->ReplaceCell(loc, npts, pts); } -extern "C" vtkNew < vtkCellArrayIterator > vtkCellArrayIterator_new () {return vtkNew < vtkCellArrayIterator > () ;} -extern "C" void vtkCellArrayIterator_destructor (vtkNew < vtkCellArrayIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellArrayIterator_get_ptr (vtkNew < vtkCellArrayIterator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_cell_array_iterator_go_to_cell(vtkNew sself, long long cellId) { sself->GoToCell(cellId); } -extern "C" void vtk_cell_array_iterator_get_cell_at_id(vtkNew sself, long long cellId, long long numCellPts, const long long cellPts) { sself->GetCellAtId(cellId, numCellPts, cellPts); } -extern "C" void vtk_cell_array_iterator_go_to_first_cell(vtkNew sself) { sself->GoToFirstCell(); } -extern "C" void vtk_cell_array_iterator_go_to_next_cell(vtkNew sself) { sself->GoToNextCell(); } -extern "C" bool vtk_cell_array_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } -extern "C" long long vtk_cell_array_iterator_get_current_cell_id(vtkNew sself) { return sself->GetCurrentCellId(); } -extern "C" void vtk_cell_array_iterator_get_current_cell(vtkNew sself, long long cellSize, const long long cellPoints) { sself->GetCurrentCell(cellSize, cellPoints); } -extern "C" void vtk_cell_array_iterator_replace_current_cell(vtkNew sself, long long npts, const long long pts) { sself->ReplaceCurrentCell(npts, pts); } -extern "C" void vtk_cell_array_iterator_reverse_current_cell(vtkNew sself) { sself->ReverseCurrentCell(); } -extern "C" vtkNew < vtkCellData > vtkCellData_new () {return vtkNew < vtkCellData > () ;} -extern "C" void vtkCellData_destructor (vtkNew < vtkCellData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellData_get_ptr (vtkNew < vtkCellData > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellLinks > vtkCellLinks_new () {return vtkNew < vtkCellLinks > () ;} -extern "C" void vtkCellLinks_destructor (vtkNew < vtkCellLinks > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellLinks_get_ptr (vtkNew < vtkCellLinks > sself) {return sself . GetPointer () ;} -extern "C" void vtk_cell_links_allocate(vtkNew sself, long long numLinks, long long ext) { sself->Allocate(numLinks, ext); } -extern "C" void vtk_cell_links_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" long long vtk_cell_links_get_ncells(vtkNew sself, long long ptId) { return sself->GetNcells(ptId); } -extern "C" long long* vtk_cell_links_get_cells(vtkNew sself, long long ptId) { return sself->GetCells(ptId); } -extern "C" void vtk_cell_links_select_cells(vtkNew sself, long long minMaxDegree, unsigned char cellSelection) { sself->SelectCells(minMaxDegree, cellSelection); } -extern "C" long long vtk_cell_links_insert_next_point(vtkNew sself, int numLinks) { return sself->InsertNextPoint(numLinks); } -extern "C" void vtk_cell_links_insert_next_cell_reference(vtkNew sself, long long ptId, long long cellId) { sself->InsertNextCellReference(ptId, cellId); } -extern "C" void vtk_cell_links_delete_point(vtkNew sself, long long ptId) { sself->DeletePoint(ptId); } -extern "C" void vtk_cell_links_remove_cell_reference(vtkNew sself, long long cellId, long long ptId) { sself->RemoveCellReference(cellId, ptId); } -extern "C" void vtk_cell_links_add_cell_reference(vtkNew sself, long long cellId, long long ptId) { sself->AddCellReference(cellId, ptId); } -extern "C" void vtk_cell_links_resize_cell_list(vtkNew sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } -extern "C" void vtk_cell_links_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" void vtk_cell_links_reset(vtkNew sself) { sself->Reset(); } -extern "C" unsigned long vtk_cell_links_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" vtkNew < vtkCellLocator > vtkCellLocator_new () {return vtkNew < vtkCellLocator > () ;} -extern "C" void vtkCellLocator_destructor (vtkNew < vtkCellLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellLocator_get_ptr (vtkNew < vtkCellLocator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_cell_locator_set_number_of_cells_per_bucket(vtkNew sself, int N) { sself->SetNumberOfCellsPerBucket(N); } -extern "C" int vtk_cell_locator_get_number_of_cells_per_bucket(vtkNew sself) { return sself->GetNumberOfCellsPerBucket(); } -extern "C" int vtk_cell_locator_get_number_of_buckets(vtkNew sself) { return sself->GetNumberOfBuckets(); } -extern "C" void vtk_cell_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } -extern "C" void vtk_cell_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } -extern "C" void vtk_cell_locator_build_locator_if_needed(vtkNew sself) { sself->BuildLocatorIfNeeded(); } -extern "C" void vtk_cell_locator_force_build_locator(vtkNew sself) { sself->ForceBuildLocator(); } -extern "C" void vtk_cell_locator_build_locator_internal(vtkNew sself) { sself->BuildLocatorInternal(); } -extern "C" vtkNew < vtkCellLocatorStrategy > vtkCellLocatorStrategy_new () {return vtkNew < vtkCellLocatorStrategy > () ;} -extern "C" void vtkCellLocatorStrategy_destructor (vtkNew < vtkCellLocatorStrategy > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellLocatorStrategy_get_ptr (vtkNew < vtkCellLocatorStrategy > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellTypes > vtkCellTypes_new () {return vtkNew < vtkCellTypes > () ;} -extern "C" void vtkCellTypes_destructor (vtkNew < vtkCellTypes > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellTypes_get_ptr (vtkNew < vtkCellTypes > sself) {return sself . GetPointer () ;} -extern "C" int vtk_cell_types_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } -extern "C" void vtk_cell_types_insert_cell(vtkNew sself, long long id, unsigned char type, long long loc) { sself->InsertCell(id, type, loc); } -extern "C" long long vtk_cell_types_insert_next_cell(vtkNew sself, unsigned char type, long long loc) { return sself->InsertNextCell(type, loc); } -extern "C" long long vtk_cell_types_get_cell_location(vtkNew sself, long long cellId) { return sself->GetCellLocation(cellId); } -extern "C" void vtk_cell_types_delete_cell(vtkNew sself, long long cellId) { sself->DeleteCell(cellId); } -extern "C" long long vtk_cell_types_get_number_of_types(vtkNew sself) { return sself->GetNumberOfTypes(); } -extern "C" int vtk_cell_types_is_type(vtkNew sself, unsigned char type) { return sself->IsType(type); } -extern "C" long long vtk_cell_types_insert_next_type(vtkNew sself, unsigned char type) { return sself->InsertNextType(type); } -extern "C" unsigned char vtk_cell_types_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } -extern "C" void vtk_cell_types_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" void vtk_cell_types_reset(vtkNew sself) { sself->Reset(); } -extern "C" unsigned long vtk_cell_types_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" const char* vtk_cell_types_get_class_name_from_type_id(vtkNew sself, int typeId) { return sself->GetClassNameFromTypeId(typeId); } -extern "C" int vtk_cell_types_get_type_id_from_class_name(vtkNew sself, const char classname) { return sself->GetTypeIdFromClassName(classname); } -extern "C" int vtk_cell_types_is_linear(vtkNew sself, unsigned char type) { return sself->IsLinear(type); } -extern "C" vtkNew < vtkClosestNPointsStrategy > vtkClosestNPointsStrategy_new () {return vtkNew < vtkClosestNPointsStrategy > () ;} -extern "C" void vtkClosestNPointsStrategy_destructor (vtkNew < vtkClosestNPointsStrategy > sself) {sself . Reset () ; return ;} -extern "C" void * vtkClosestNPointsStrategy_get_ptr (vtkNew < vtkClosestNPointsStrategy > sself) {return sself . GetPointer () ;} -extern "C" void vtk_closest_n_points_strategy_set_closest_n_points(vtkNew sself, int _arg) { sself->SetClosestNPoints(_arg); } -extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_min_value(vtkNew sself) { return sself->GetClosestNPointsMinValue(); } -extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_max_value(vtkNew sself) { return sself->GetClosestNPointsMaxValue(); } -extern "C" int vtk_closest_n_points_strategy_get_closest_n_points(vtkNew sself) { return sself->GetClosestNPoints(); } -extern "C" vtkNew < vtkClosestPointStrategy > vtkClosestPointStrategy_new () {return vtkNew < vtkClosestPointStrategy > () ;} -extern "C" void vtkClosestPointStrategy_destructor (vtkNew < vtkClosestPointStrategy > sself) {sself . Reset () ; return ;} -extern "C" void * vtkClosestPointStrategy_get_ptr (vtkNew < vtkClosestPointStrategy > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCone > vtkCone_new () {return vtkNew < vtkCone > () ;} -extern "C" void vtkCone_destructor (vtkNew < vtkCone > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCone_get_ptr (vtkNew < vtkCone > sself) {return sself . GetPointer () ;} -extern "C" double vtk_cone_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_cone_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } -extern "C" void vtk_cone_set_angle(vtkNew sself, double _arg) { sself->SetAngle(_arg); } -extern "C" double vtk_cone_get_angle_min_value(vtkNew sself) { return sself->GetAngleMinValue(); } -extern "C" double vtk_cone_get_angle_max_value(vtkNew sself) { return sself->GetAngleMaxValue(); } -extern "C" double vtk_cone_get_angle(vtkNew sself) { return sself->GetAngle(); } -extern "C" vtkNew < vtkConvexPointSet > vtkConvexPointSet_new () {return vtkNew < vtkConvexPointSet > () ;} -extern "C" void vtkConvexPointSet_destructor (vtkNew < vtkConvexPointSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkConvexPointSet_get_ptr (vtkNew < vtkConvexPointSet > sself) {return sself . GetPointer () ;} -extern "C" int vtk_convex_point_set_has_fixed_topology(vtkNew sself) { return sself->HasFixedTopology(); } -extern "C" void vtk_convex_point_set_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" void vtk_convex_point_set_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" long long vtk_convex_point_set_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_convex_point_set_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_convex_point_set_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } -extern "C" long long vtk_convex_point_set_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } -extern "C" long long vtk_convex_point_set_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } -extern "C" long long vtk_convex_point_set_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } -extern "C" long long vtk_convex_point_set_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } -extern "C" bool vtk_convex_point_set_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } -extern "C" double* vtk_convex_point_set_get_parametric_coords(vtkNew sself) { return sself->GetParametricCoords(); } -extern "C" int vtk_convex_point_set_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_convex_point_set_requires_initialization(vtkNew sself) { return sself->RequiresInitialization(); } -extern "C" int vtk_convex_point_set_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_convex_point_set_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_convex_point_set_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_convex_point_set_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_convex_point_set_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_convex_point_set_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_convex_point_set_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" int vtk_convex_point_set_is_primary_cell(vtkNew sself) { return sself->IsPrimaryCell(); } -extern "C" void vtk_convex_point_set_interpolate_functions(vtkNew sself, const double pcoords, double sf) { sself->InterpolateFunctions(pcoords, sf); } -extern "C" vtkNew < vtkCubicLine > vtkCubicLine_new () {return vtkNew < vtkCubicLine > () ;} -extern "C" void vtkCubicLine_destructor (vtkNew < vtkCubicLine > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCubicLine_get_ptr (vtkNew < vtkCubicLine > sself) {return sself . GetPointer () ;} -extern "C" int vtk_cubic_line_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_cubic_line_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_cubic_line_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_cubic_line_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_cubic_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_cubic_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_cubic_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" double vtk_cubic_line_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } -extern "C" int vtk_cubic_line_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" int vtk_cubic_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_cubic_line_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_cubic_line_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_cubic_line_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_cubic_line_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" vtkNew < vtkCylinder > vtkCylinder_new () {return vtkNew < vtkCylinder > () ;} -extern "C" void vtkCylinder_destructor (vtkNew < vtkCylinder > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCylinder_get_ptr (vtkNew < vtkCylinder > sself) {return sself . GetPointer () ;} -extern "C" double vtk_cylinder_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_cylinder_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } -extern "C" void vtk_cylinder_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } -extern "C" double vtk_cylinder_get_radius(vtkNew sself) { return sself->GetRadius(); } -extern "C" void vtk_cylinder_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } -extern "C" void vtk_cylinder_set_center(vtkNew sself, const double _arg) { sself->SetCenter(_arg); } -extern "C" double* vtk_cylinder_get_center(vtkNew sself) { return sself->GetCenter(); } -extern "C" void vtk_cylinder_get_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetCenter(_arg1, _arg2, _arg3); } -extern "C" void vtk_cylinder_get_center(vtkNew sself, double _arg) { sself->GetCenter(_arg); } -extern "C" void vtk_cylinder_set_axis(vtkNew sself, double ax, double ay, double az) { sself->SetAxis(ax, ay, az); } -extern "C" void vtk_cylinder_set_axis(vtkNew sself, double a) { sself->SetAxis(a); } -extern "C" double* vtk_cylinder_get_axis(vtkNew sself) { return sself->GetAxis(); } -extern "C" void vtk_cylinder_get_axis(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetAxis(_arg1, _arg2, _arg3); } -extern "C" void vtk_cylinder_get_axis(vtkNew sself, double _arg) { sself->GetAxis(_arg); } -extern "C" vtkNew < vtkDataAssembly > vtkDataAssembly_new () {return vtkNew < vtkDataAssembly > () ;} -extern "C" void vtkDataAssembly_destructor (vtkNew < vtkDataAssembly > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataAssembly_get_ptr (vtkNew < vtkDataAssembly > sself) {return sself . GetPointer () ;} -extern "C" void vtk_data_assembly_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" bool vtk_data_assembly_initialize_from_xml(vtkNew sself, const char xmlcontents) { return sself->InitializeFromXML(xmlcontents); } -extern "C" int vtk_data_assembly_get_root_node(vtkNew sself) { return sself->GetRootNode(); } -extern "C" void vtk_data_assembly_set_root_node_name(vtkNew sself, const char name) { sself->SetRootNodeName(name); } -extern "C" const char* vtk_data_assembly_get_root_node_name(vtkNew sself) { return sself->GetRootNodeName(); } -extern "C" int vtk_data_assembly_add_node(vtkNew sself, const char name, int parent) { return sself->AddNode(name, parent); } -extern "C" bool vtk_data_assembly_remove_node(vtkNew sself, int id) { return sself->RemoveNode(id); } -extern "C" void vtk_data_assembly_set_node_name(vtkNew sself, int id, const char name) { sself->SetNodeName(id, name); } -extern "C" const char* vtk_data_assembly_get_node_name(vtkNew sself, int id) { return sself->GetNodeName(id); } -extern "C" const char* vtk_data_assembly_get_node_path(vtkNew sself, int id) { return sself->GetNodePath(id); } -extern "C" int vtk_data_assembly_get_first_node_by_path(vtkNew sself, const char path) { return sself->GetFirstNodeByPath(path); } -extern "C" bool vtk_data_assembly_add_data_set_index(vtkNew sself, int id, unsigned int dataset_index) { return sself->AddDataSetIndex(id, dataset_index); } -extern "C" bool vtk_data_assembly_add_data_set_index_range(vtkNew sself, int id, unsigned int index_start, int count) { return sself->AddDataSetIndexRange(id, index_start, count); } -extern "C" bool vtk_data_assembly_remove_data_set_index(vtkNew sself, int id, unsigned int dataset_index) { return sself->RemoveDataSetIndex(id, dataset_index); } -extern "C" bool vtk_data_assembly_remove_all_data_set_indices(vtkNew sself, int id, bool traverse_subtree) { return sself->RemoveAllDataSetIndices(id, traverse_subtree); } -extern "C" int vtk_data_assembly_find_first_node_with_name(vtkNew sself, const char name, int traversal_order) { return sself->FindFirstNodeWithName(name, traversal_order); } -extern "C" int vtk_data_assembly_get_number_of_children(vtkNew sself, int parent) { return sself->GetNumberOfChildren(parent); } -extern "C" int vtk_data_assembly_get_child(vtkNew sself, int parent, int index) { return sself->GetChild(parent, index); } -extern "C" int vtk_data_assembly_get_child_index(vtkNew sself, int parent, int child) { return sself->GetChildIndex(parent, child); } -extern "C" int vtk_data_assembly_get_parent(vtkNew sself, int id) { return sself->GetParent(id); } -extern "C" bool vtk_data_assembly_has_attribute(vtkNew sself, int id, const char name) { return sself->HasAttribute(id, name); } -extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, const char value) { sself->SetAttribute(id, name, value); } -extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, int value) { sself->SetAttribute(id, name, value); } -extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, unsigned int value) { sself->SetAttribute(id, name, value); } -extern "C" void vtk_data_assembly_set_attribute(vtkNew sself, int id, const char name, long long value) { sself->SetAttribute(id, name, value); } -extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, const char value) { return sself->GetAttribute(id, name, value); } -extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, int value) { return sself->GetAttribute(id, name, value); } -extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, unsigned int value) { return sself->GetAttribute(id, name, value); } -extern "C" bool vtk_data_assembly_get_attribute(vtkNew sself, int id, const char name, long long value) { return sself->GetAttribute(id, name, value); } -extern "C" const char* vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, const char default_value) { return sself->GetAttributeOrDefault(id, name, default_value); } -extern "C" int vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, int default_value) { return sself->GetAttributeOrDefault(id, name, default_value); } -extern "C" unsigned int vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, unsigned int default_value) { return sself->GetAttributeOrDefault(id, name, default_value); } -extern "C" long long vtk_data_assembly_get_attribute_or_default(vtkNew sself, int id, const char name, long long default_value) { return sself->GetAttributeOrDefault(id, name, default_value); } -extern "C" bool vtk_data_assembly_is_node_name_valid(vtkNew sself, const char name) { return sself->IsNodeNameValid(name); } -extern "C" const char* vtk_data_assembly_make_valid_node_name(vtkNew sself, const char name) { return sself->MakeValidNodeName(name); } -extern "C" bool vtk_data_assembly_is_node_name_reserved(vtkNew sself, const char name) { return sself->IsNodeNameReserved(name); } -extern "C" vtkNew < vtkDataAssemblyUtilities > vtkDataAssemblyUtilities_new () {return vtkNew < vtkDataAssemblyUtilities > () ;} -extern "C" void vtkDataAssemblyUtilities_destructor (vtkNew < vtkDataAssemblyUtilities > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataAssemblyUtilities_get_ptr (vtkNew < vtkDataAssemblyUtilities > sself) {return sself . GetPointer () ;} -extern "C" const char* vtk_data_assembly_utilities_hierarchy_name(vtkNew sself) { return sself->HierarchyName(); } -extern "C" vtkNew < vtkDataObject > vtkDataObject_new () {return vtkNew < vtkDataObject > () ;} -extern "C" void vtkDataObject_destructor (vtkNew < vtkDataObject > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataObject_get_ptr (vtkNew < vtkDataObject > sself) {return sself . GetPointer () ;} -extern "C" unsigned long vtk_data_object_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_data_object_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_data_object_release_data(vtkNew sself) { sself->ReleaseData(); } -extern "C" int vtk_data_object_get_data_released(vtkNew sself) { return sself->GetDataReleased(); } -extern "C" void vtk_data_object_set_global_release_data_flag(vtkNew sself, int val) { sself->SetGlobalReleaseDataFlag(val); } -extern "C" void vtk_data_object_global_release_data_flag_on(vtkNew sself) { sself->GlobalReleaseDataFlagOn(); } -extern "C" void vtk_data_object_global_release_data_flag_off(vtkNew sself) { sself->GlobalReleaseDataFlagOff(); } -extern "C" int vtk_data_object_get_global_release_data_flag(vtkNew sself) { return sself->GetGlobalReleaseDataFlag(); } -extern "C" int vtk_data_object_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" unsigned long vtk_data_object_get_update_time(vtkNew sself) { return sself->GetUpdateTime(); } -extern "C" unsigned long vtk_data_object_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" void vtk_data_object_data_has_been_generated(vtkNew sself) { sself->DataHasBeenGenerated(); } -extern "C" void vtk_data_object_prepare_for_new_data(vtkNew sself) { sself->PrepareForNewData(); } -extern "C" int vtk_data_object_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } -extern "C" void vtk_data_object_crop(vtkNew sself, const int updateExtent) { sself->Crop(updateExtent); } -extern "C" long long vtk_data_object_get_number_of_elements(vtkNew sself, int type) { return sself->GetNumberOfElements(type); } -extern "C" const char* vtk_data_object_get_association_type_as_string(vtkNew sself, int associationType) { return sself->GetAssociationTypeAsString(associationType); } -extern "C" int vtk_data_object_get_association_type_from_string(vtkNew sself, const char associationName) { return sself->GetAssociationTypeFromString(associationName); } -extern "C" vtkNew < vtkDataObjectCollection > vtkDataObjectCollection_new () {return vtkNew < vtkDataObjectCollection > () ;} -extern "C" void vtkDataObjectCollection_destructor (vtkNew < vtkDataObjectCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataObjectCollection_get_ptr (vtkNew < vtkDataObjectCollection > sself) {return sself . GetPointer () ;} -extern "C" int vtk_data_object_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } -extern "C" vtkNew < vtkDataObjectTreeIterator > vtkDataObjectTreeIterator_new () {return vtkNew < vtkDataObjectTreeIterator > () ;} -extern "C" void vtkDataObjectTreeIterator_destructor (vtkNew < vtkDataObjectTreeIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataObjectTreeIterator_get_ptr (vtkNew < vtkDataObjectTreeIterator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_data_object_tree_iterator_go_to_first_item(vtkNew sself) { sself->GoToFirstItem(); } -extern "C" void vtk_data_object_tree_iterator_go_to_next_item(vtkNew sself) { sself->GoToNextItem(); } -extern "C" int vtk_data_object_tree_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } -extern "C" int vtk_data_object_tree_iterator_has_current_meta_data(vtkNew sself) { return sself->HasCurrentMetaData(); } -extern "C" unsigned int vtk_data_object_tree_iterator_get_current_flat_index(vtkNew sself) { return sself->GetCurrentFlatIndex(); } -extern "C" void vtk_data_object_tree_iterator_set_visit_only_leaves(vtkNew sself, int _arg) { sself->SetVisitOnlyLeaves(_arg); } -extern "C" int vtk_data_object_tree_iterator_get_visit_only_leaves(vtkNew sself) { return sself->GetVisitOnlyLeaves(); } -extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_on(vtkNew sself) { sself->VisitOnlyLeavesOn(); } -extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_off(vtkNew sself) { sself->VisitOnlyLeavesOff(); } -extern "C" void vtk_data_object_tree_iterator_set_traverse_sub_tree(vtkNew sself, int _arg) { sself->SetTraverseSubTree(_arg); } -extern "C" int vtk_data_object_tree_iterator_get_traverse_sub_tree(vtkNew sself) { return sself->GetTraverseSubTree(); } -extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_on(vtkNew sself) { sself->TraverseSubTreeOn(); } -extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_off(vtkNew sself) { sself->TraverseSubTreeOff(); } -extern "C" vtkNew < vtkDataObjectTypes > vtkDataObjectTypes_new () {return vtkNew < vtkDataObjectTypes > () ;} -extern "C" void vtkDataObjectTypes_destructor (vtkNew < vtkDataObjectTypes > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataObjectTypes_get_ptr (vtkNew < vtkDataObjectTypes > sself) {return sself . GetPointer () ;} -extern "C" const char* vtk_data_object_types_get_class_name_from_type_id(vtkNew sself, int typeId) { return sself->GetClassNameFromTypeId(typeId); } -extern "C" int vtk_data_object_types_get_type_id_from_class_name(vtkNew sself, const char classname) { return sself->GetTypeIdFromClassName(classname); } -extern "C" bool vtk_data_object_types_type_id_is_a(vtkNew sself, int typeId, int targetTypeId) { return sself->TypeIdIsA(typeId, targetTypeId); } -extern "C" int vtk_data_object_types_get_common_base_type_id(vtkNew sself, int typeA, int typeB) { return sself->GetCommonBaseTypeId(typeA, typeB); } -extern "C" vtkNew < vtkDataSetAttributes > vtkDataSetAttributes_new () {return vtkNew < vtkDataSetAttributes > () ;} -extern "C" void vtkDataSetAttributes_destructor (vtkNew < vtkDataSetAttributes > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataSetAttributes_get_ptr (vtkNew < vtkDataSetAttributes > sself) {return sself . GetPointer () ;} -extern "C" void vtk_data_set_attributes_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_data_set_attributes_update(vtkNew sself) { sself->Update(); } -extern "C" const char* vtk_data_set_attributes_ghost_array_name(vtkNew sself) { return sself->GhostArrayName(); } -extern "C" int vtk_data_set_attributes_set_active_scalars(vtkNew sself, const char name) { return sself->SetActiveScalars(name); } -extern "C" int vtk_data_set_attributes_set_active_vectors(vtkNew sself, const char name) { return sself->SetActiveVectors(name); } -extern "C" int vtk_data_set_attributes_set_active_normals(vtkNew sself, const char name) { return sself->SetActiveNormals(name); } -extern "C" int vtk_data_set_attributes_set_active_tangents(vtkNew sself, const char name) { return sself->SetActiveTangents(name); } -extern "C" int vtk_data_set_attributes_set_active_t_coords(vtkNew sself, const char name) { return sself->SetActiveTCoords(name); } -extern "C" int vtk_data_set_attributes_set_active_tensors(vtkNew sself, const char name) { return sself->SetActiveTensors(name); } -extern "C" int vtk_data_set_attributes_set_active_global_ids(vtkNew sself, const char name) { return sself->SetActiveGlobalIds(name); } -extern "C" int vtk_data_set_attributes_set_active_pedigree_ids(vtkNew sself, const char name) { return sself->SetActivePedigreeIds(name); } -extern "C" int vtk_data_set_attributes_set_active_rational_weights(vtkNew sself, const char name) { return sself->SetActiveRationalWeights(name); } -extern "C" int vtk_data_set_attributes_set_active_higher_order_degrees(vtkNew sself, const char name) { return sself->SetActiveHigherOrderDegrees(name); } -extern "C" int vtk_data_set_attributes_set_active_attribute(vtkNew sself, const char name, int attributeType) { return sself->SetActiveAttribute(name, attributeType); } -extern "C" int vtk_data_set_attributes_set_active_attribute(vtkNew sself, int index, int attributeType) { return sself->SetActiveAttribute(index, attributeType); } -extern "C" void vtk_data_set_attributes_get_attribute_indices(vtkNew sself, int indexArray) { sself->GetAttributeIndices(indexArray); } -extern "C" int vtk_data_set_attributes_is_array_an_attribute(vtkNew sself, int idx) { return sself->IsArrayAnAttribute(idx); } -extern "C" const char* vtk_data_set_attributes_get_attribute_type_as_string(vtkNew sself, int attributeType) { return sself->GetAttributeTypeAsString(attributeType); } -extern "C" const char* vtk_data_set_attributes_get_long_attribute_type_as_string(vtkNew sself, int attributeType) { return sself->GetLongAttributeTypeAsString(attributeType); } -extern "C" void vtk_data_set_attributes_set_copy_attribute(vtkNew sself, int index, int value, int ctype) { sself->SetCopyAttribute(index, value, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_attribute(vtkNew sself, int index, int ctype) { return sself->GetCopyAttribute(index, ctype); } -extern "C" void vtk_data_set_attributes_set_copy_scalars(vtkNew sself, int i, int ctype) { sself->SetCopyScalars(i, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_scalars(vtkNew sself, int ctype) { return sself->GetCopyScalars(ctype); } -extern "C" void vtk_data_set_attributes_copy_scalars_on(vtkNew sself) { sself->CopyScalarsOn(); } -extern "C" void vtk_data_set_attributes_copy_scalars_off(vtkNew sself) { sself->CopyScalarsOff(); } -extern "C" void vtk_data_set_attributes_set_copy_vectors(vtkNew sself, int i, int ctype) { sself->SetCopyVectors(i, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_vectors(vtkNew sself, int ctype) { return sself->GetCopyVectors(ctype); } -extern "C" void vtk_data_set_attributes_copy_vectors_on(vtkNew sself) { sself->CopyVectorsOn(); } -extern "C" void vtk_data_set_attributes_copy_vectors_off(vtkNew sself) { sself->CopyVectorsOff(); } -extern "C" void vtk_data_set_attributes_set_copy_normals(vtkNew sself, int i, int ctype) { sself->SetCopyNormals(i, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_normals(vtkNew sself, int ctype) { return sself->GetCopyNormals(ctype); } -extern "C" void vtk_data_set_attributes_copy_normals_on(vtkNew sself) { sself->CopyNormalsOn(); } -extern "C" void vtk_data_set_attributes_copy_normals_off(vtkNew sself) { sself->CopyNormalsOff(); } -extern "C" void vtk_data_set_attributes_set_copy_tangents(vtkNew sself, int i, int ctype) { sself->SetCopyTangents(i, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_tangents(vtkNew sself, int ctype) { return sself->GetCopyTangents(ctype); } -extern "C" void vtk_data_set_attributes_copy_tangents_on(vtkNew sself) { sself->CopyTangentsOn(); } -extern "C" void vtk_data_set_attributes_copy_tangents_off(vtkNew sself) { sself->CopyTangentsOff(); } -extern "C" void vtk_data_set_attributes_set_copy_t_coords(vtkNew sself, int i, int ctype) { sself->SetCopyTCoords(i, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_t_coords(vtkNew sself, int ctype) { return sself->GetCopyTCoords(ctype); } -extern "C" void vtk_data_set_attributes_copy_t_coords_on(vtkNew sself) { sself->CopyTCoordsOn(); } -extern "C" void vtk_data_set_attributes_copy_t_coords_off(vtkNew sself) { sself->CopyTCoordsOff(); } -extern "C" void vtk_data_set_attributes_set_copy_tensors(vtkNew sself, int i, int ctype) { sself->SetCopyTensors(i, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_tensors(vtkNew sself, int ctype) { return sself->GetCopyTensors(ctype); } -extern "C" void vtk_data_set_attributes_copy_tensors_on(vtkNew sself) { sself->CopyTensorsOn(); } -extern "C" void vtk_data_set_attributes_copy_tensors_off(vtkNew sself) { sself->CopyTensorsOff(); } -extern "C" void vtk_data_set_attributes_set_copy_global_ids(vtkNew sself, int i, int ctype) { sself->SetCopyGlobalIds(i, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_global_ids(vtkNew sself, int ctype) { return sself->GetCopyGlobalIds(ctype); } -extern "C" void vtk_data_set_attributes_copy_global_ids_on(vtkNew sself) { sself->CopyGlobalIdsOn(); } -extern "C" void vtk_data_set_attributes_copy_global_ids_off(vtkNew sself) { sself->CopyGlobalIdsOff(); } -extern "C" void vtk_data_set_attributes_set_copy_pedigree_ids(vtkNew sself, int i, int ctype) { sself->SetCopyPedigreeIds(i, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_pedigree_ids(vtkNew sself, int ctype) { return sself->GetCopyPedigreeIds(ctype); } -extern "C" void vtk_data_set_attributes_copy_pedigree_ids_on(vtkNew sself) { sself->CopyPedigreeIdsOn(); } -extern "C" void vtk_data_set_attributes_copy_pedigree_ids_off(vtkNew sself) { sself->CopyPedigreeIdsOff(); } -extern "C" void vtk_data_set_attributes_set_copy_rational_weights(vtkNew sself, int i, int ctype) { sself->SetCopyRationalWeights(i, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_rational_weights(vtkNew sself, int ctype) { return sself->GetCopyRationalWeights(ctype); } -extern "C" void vtk_data_set_attributes_copy_rational_weights_on(vtkNew sself) { sself->CopyRationalWeightsOn(); } -extern "C" void vtk_data_set_attributes_copy_rational_weights_off(vtkNew sself) { sself->CopyRationalWeightsOff(); } -extern "C" void vtk_data_set_attributes_set_copy_higher_order_degrees(vtkNew sself, int i, int ctype) { sself->SetCopyHigherOrderDegrees(i, ctype); } -extern "C" int vtk_data_set_attributes_get_copy_higher_order_degrees(vtkNew sself, int ctype) { return sself->GetCopyHigherOrderDegrees(ctype); } -extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_on(vtkNew sself) { sself->CopyHigherOrderDegreesOn(); } -extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_off(vtkNew sself) { sself->CopyHigherOrderDegreesOff(); } -extern "C" void vtk_data_set_attributes_copy_all_on(vtkNew sself, int ctype) { sself->CopyAllOn(ctype); } -extern "C" void vtk_data_set_attributes_copy_all_off(vtkNew sself, int ctype) { sself->CopyAllOff(ctype); } -extern "C" vtkNew < vtkDataSetCellIterator > vtkDataSetCellIterator_new () {return vtkNew < vtkDataSetCellIterator > () ;} -extern "C" void vtkDataSetCellIterator_destructor (vtkNew < vtkDataSetCellIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataSetCellIterator_get_ptr (vtkNew < vtkDataSetCellIterator > sself) {return sself . GetPointer () ;} -extern "C" bool vtk_data_set_cell_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } -extern "C" long long vtk_data_set_cell_iterator_get_cell_id(vtkNew sself) { return sself->GetCellId(); } -extern "C" vtkNew < vtkDataSetCollection > vtkDataSetCollection_new () {return vtkNew < vtkDataSetCollection > () ;} -extern "C" void vtkDataSetCollection_destructor (vtkNew < vtkDataSetCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataSetCollection_get_ptr (vtkNew < vtkDataSetCollection > sself) {return sself . GetPointer () ;} -extern "C" int vtk_data_set_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } -extern "C" vtkNew < vtkDirectedAcyclicGraph > vtkDirectedAcyclicGraph_new () {return vtkNew < vtkDirectedAcyclicGraph > () ;} -extern "C" void vtkDirectedAcyclicGraph_destructor (vtkNew < vtkDirectedAcyclicGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDirectedAcyclicGraph_get_ptr (vtkNew < vtkDirectedAcyclicGraph > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDirectedGraph > vtkDirectedGraph_new () {return vtkNew < vtkDirectedGraph > () ;} -extern "C" void vtkDirectedGraph_destructor (vtkNew < vtkDirectedGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDirectedGraph_get_ptr (vtkNew < vtkDirectedGraph > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkEdgeListIterator > vtkEdgeListIterator_new () {return vtkNew < vtkEdgeListIterator > () ;} -extern "C" void vtkEdgeListIterator_destructor (vtkNew < vtkEdgeListIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEdgeListIterator_get_ptr (vtkNew < vtkEdgeListIterator > sself) {return sself . GetPointer () ;} -extern "C" bool vtk_edge_list_iterator_has_next(vtkNew sself) { return sself->HasNext(); } -extern "C" vtkNew < vtkEdgeTable > vtkEdgeTable_new () {return vtkNew < vtkEdgeTable > () ;} -extern "C" void vtkEdgeTable_destructor (vtkNew < vtkEdgeTable > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEdgeTable_get_ptr (vtkNew < vtkEdgeTable > sself) {return sself . GetPointer () ;} -extern "C" void vtk_edge_table_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_edge_table_init_edge_insertion(vtkNew sself, long long numPoints, int storeAttributes) { return sself->InitEdgeInsertion(numPoints, storeAttributes); } -extern "C" long long vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2) { return sself->InsertEdge(p1, p2); } -extern "C" void vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2, long long attributeId) { sself->InsertEdge(p1, p2, attributeId); } -extern "C" void vtk_edge_table_insert_edge(vtkNew sself, long long p1, long long p2, void ptr) { sself->InsertEdge(p1, p2, ptr); } -extern "C" long long vtk_edge_table_is_edge(vtkNew sself, long long p1, long long p2) { return sself->IsEdge(p1, p2); } -extern "C" void vtk_edge_table_is_edge(vtkNew sself, long long p1, long long p2, void ptr) { sself->IsEdge(p1, p2, ptr); } -extern "C" int vtk_edge_table_insert_unique_point(vtkNew sself, long long p1, long long p2, double x, long long ptId) { return sself->InsertUniquePoint(p1, p2, x, ptId); } -extern "C" long long vtk_edge_table_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" void vtk_edge_table_init_traversal(vtkNew sself) { sself->InitTraversal(); } -extern "C" long long vtk_edge_table_get_next_edge(vtkNew sself, long long p1, long long p2) { return sself->GetNextEdge(p1, p2); } -extern "C" int vtk_edge_table_get_next_edge(vtkNew sself, long long p1, long long p2, void ptr) { return sself->GetNextEdge(p1, p2, ptr); } -extern "C" void vtk_edge_table_reset(vtkNew sself) { sself->Reset(); } -extern "C" vtkNew < vtkEmptyCell > vtkEmptyCell_new () {return vtkNew < vtkEmptyCell > () ;} -extern "C" void vtkEmptyCell_destructor (vtkNew < vtkEmptyCell > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEmptyCell_get_ptr (vtkNew < vtkEmptyCell > sself) {return sself . GetPointer () ;} -extern "C" int vtk_empty_cell_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_empty_cell_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_empty_cell_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_empty_cell_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_empty_cell_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_empty_cell_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_empty_cell_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_empty_cell_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" vtkNew < vtkExplicitStructuredGrid > vtkExplicitStructuredGrid_new () {return vtkNew < vtkExplicitStructuredGrid > () ;} -extern "C" void vtkExplicitStructuredGrid_destructor (vtkNew < vtkExplicitStructuredGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExplicitStructuredGrid_get_ptr (vtkNew < vtkExplicitStructuredGrid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_explicit_structured_grid_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" void vtk_explicit_structured_grid_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_explicit_structured_grid_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } -extern "C" int vtk_explicit_structured_grid_get_data_dimension(vtkNew sself) { return sself->GetDataDimension(); } -extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkNew sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } -extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkNew sself, int dim) { sself->SetDimensions(dim); } -extern "C" void vtk_explicit_structured_grid_get_dimensions(vtkNew sself, int dim) { sself->GetDimensions(dim); } -extern "C" void vtk_explicit_structured_grid_get_cell_dims(vtkNew sself, int cellDims) { sself->GetCellDims(cellDims); } -extern "C" int vtk_explicit_structured_grid_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } -extern "C" void vtk_explicit_structured_grid_set_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1) { sself->SetExtent(x0, x1, y0, y1, z0, z1); } -extern "C" void vtk_explicit_structured_grid_set_extent(vtkNew sself, int extent) { sself->SetExtent(extent); } -extern "C" int* vtk_explicit_structured_grid_get_extent(vtkNew sself) { return sself->GetExtent(); } -extern "C" void vtk_explicit_structured_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_explicit_structured_grid_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } -extern "C" void vtk_explicit_structured_grid_build_links(vtkNew sself) { sself->BuildLinks(); } -extern "C" long long* vtk_explicit_structured_grid_get_cell_points(vtkNew sself, long long cellId) { return sself->GetCellPoints(cellId); } -extern "C" void vtk_explicit_structured_grid_get_cell_points(vtkNew sself, long long cellId, long long npts, long long pts) { sself->GetCellPoints(cellId, npts, pts); } -extern "C" void vtk_explicit_structured_grid_get_cell_neighbors(vtkNew sself, long long cellId, long long neighbors, int wholeExtent) { sself->GetCellNeighbors(cellId, neighbors, wholeExtent); } -extern "C" void vtk_explicit_structured_grid_compute_cell_structured_coords(vtkNew sself, long long cellId, int i, int j, int k, bool adjustForExtent) { sself->ComputeCellStructuredCoords(cellId, i, j, k, adjustForExtent); } -extern "C" long long vtk_explicit_structured_grid_compute_cell_id(vtkNew sself, int i, int j, int k, bool adjustForExtent) { return sself->ComputeCellId(i, j, k, adjustForExtent); } -extern "C" void vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(vtkNew sself) { sself->ComputeFacesConnectivityFlagsArray(); } -extern "C" void vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name(vtkNew sself, const char _arg) { sself->SetFacesConnectivityFlagsArrayName(_arg); } -extern "C" char* vtk_explicit_structured_grid_get_faces_connectivity_flags_array_name(vtkNew sself) { return sself->GetFacesConnectivityFlagsArrayName(); } -extern "C" void vtk_explicit_structured_grid_blank_cell(vtkNew sself, long long cellId) { sself->BlankCell(cellId); } -extern "C" void vtk_explicit_structured_grid_un_blank_cell(vtkNew sself, long long cellId) { sself->UnBlankCell(cellId); } -extern "C" bool vtk_explicit_structured_grid_has_any_blank_cells(vtkNew sself) { return sself->HasAnyBlankCells(); } -extern "C" unsigned char vtk_explicit_structured_grid_is_cell_visible(vtkNew sself, long long cellId) { return sself->IsCellVisible(cellId); } -extern "C" unsigned char vtk_explicit_structured_grid_is_cell_ghost(vtkNew sself, long long cellId) { return sself->IsCellGhost(cellId); } -extern "C" bool vtk_explicit_structured_grid_has_any_ghost_cells(vtkNew sself) { return sself->HasAnyGhostCells(); } -extern "C" void vtk_explicit_structured_grid_crop(vtkNew sself, const int updateExtent) { sself->Crop(updateExtent); } -extern "C" unsigned long vtk_explicit_structured_grid_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" void vtk_explicit_structured_grid_check_and_reorder_faces(vtkNew sself) { sself->CheckAndReorderFaces(); } -extern "C" vtkNew < vtkExtractStructuredGridHelper > vtkExtractStructuredGridHelper_new () {return vtkNew < vtkExtractStructuredGridHelper > () ;} -extern "C" void vtkExtractStructuredGridHelper_destructor (vtkNew < vtkExtractStructuredGridHelper > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExtractStructuredGridHelper_get_ptr (vtkNew < vtkExtractStructuredGridHelper > sself) {return sself . GetPointer () ;} -extern "C" int* vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself) { return sself->GetOutputWholeExtent(); } -extern "C" void vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetOutputWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_extract_structured_grid_helper_get_output_whole_extent(vtkNew sself, int _arg) { sself->GetOutputWholeExtent(_arg); } -extern "C" void vtk_extract_structured_grid_helper_initialize(vtkNew sself, int voi, int wholeExt, int sampleRate, bool includeBoundary) { sself->Initialize(voi, wholeExt, sampleRate, includeBoundary); } -extern "C" bool vtk_extract_structured_grid_helper_is_valid(vtkNew sself) { return sself->IsValid(); } -extern "C" int vtk_extract_structured_grid_helper_get_size(vtkNew sself, const int dim) { return sself->GetSize(dim); } -extern "C" int vtk_extract_structured_grid_helper_get_mapped_index(vtkNew sself, int dim, int outIdx) { return sself->GetMappedIndex(dim, outIdx); } -extern "C" int vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value(vtkNew sself, int dim, int outExtVal) { return sself->GetMappedIndexFromExtentValue(dim, outExtVal); } -extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value(vtkNew sself, int dim, int outExtVal) { return sself->GetMappedExtentValue(dim, outExtVal); } -extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index(vtkNew sself, int dim, int outIdx) { return sself->GetMappedExtentValueFromIndex(dim, outIdx); } -extern "C" void vtk_extract_structured_grid_helper_compute_begin_and_end(vtkNew sself, int inExt, int voi, int begin, int end) { sself->ComputeBeginAndEnd(inExt, voi, begin, end); } -extern "C" void vtk_extract_structured_grid_helper_get_partitioned_voi(vtkNew sself, const int globalVOI, const int partitionedExtent, const int sampleRate, bool includeBoundary, int partitionedVOI) { sself->GetPartitionedVOI(globalVOI, partitionedExtent, sampleRate, includeBoundary, partitionedVOI); } -extern "C" void vtk_extract_structured_grid_helper_get_partitioned_output_extent(vtkNew sself, const int globalVOI, const int partitionedVOI, const int outputWholeExtent, const int sampleRate, bool includeBoundary, int partitionedOutputExtent) { sself->GetPartitionedOutputExtent(globalVOI, partitionedVOI, outputWholeExtent, sampleRate, includeBoundary, partitionedOutputExtent); } -extern "C" vtkNew < vtkFieldData > vtkFieldData_new () {return vtkNew < vtkFieldData > () ;} -extern "C" void vtkFieldData_destructor (vtkNew < vtkFieldData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkFieldData_get_ptr (vtkNew < vtkFieldData > sself) {return sself . GetPointer () ;} -extern "C" void vtk_field_data_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_field_data_allocate(vtkNew sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } -extern "C" void vtk_field_data_allocate_arrays(vtkNew sself, int num) { sself->AllocateArrays(num); } -extern "C" int vtk_field_data_get_number_of_arrays(vtkNew sself) { return sself->GetNumberOfArrays(); } -extern "C" void vtk_field_data_null_data(vtkNew sself, long long id) { sself->NullData(id); } -extern "C" void vtk_field_data_remove_array(vtkNew sself, const char name) { sself->RemoveArray(name); } -extern "C" void vtk_field_data_remove_array(vtkNew sself, int index) { sself->RemoveArray(index); } -extern "C" int vtk_field_data_has_array(vtkNew sself, const char name) { return sself->HasArray(name); } -extern "C" const char* vtk_field_data_get_array_name(vtkNew sself, int i) { return sself->GetArrayName(i); } -extern "C" void vtk_field_data_copy_field_on(vtkNew sself, const char name) { sself->CopyFieldOn(name); } -extern "C" void vtk_field_data_copy_field_off(vtkNew sself, const char name) { sself->CopyFieldOff(name); } -extern "C" void vtk_field_data_copy_all_on(vtkNew sself, int unused) { sself->CopyAllOn(unused); } -extern "C" void vtk_field_data_copy_all_off(vtkNew sself, int unused) { sself->CopyAllOff(unused); } -extern "C" void vtk_field_data_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" void vtk_field_data_reset(vtkNew sself) { sself->Reset(); } -extern "C" unsigned long vtk_field_data_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" unsigned long vtk_field_data_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" int vtk_field_data_get_array_containing_component(vtkNew sself, int i, int arrayComp) { return sself->GetArrayContainingComponent(i, arrayComp); } -extern "C" int vtk_field_data_get_number_of_components(vtkNew sself) { return sself->GetNumberOfComponents(); } -extern "C" long long vtk_field_data_get_number_of_tuples(vtkNew sself) { return sself->GetNumberOfTuples(); } -extern "C" void vtk_field_data_set_number_of_tuples(vtkNew sself, const long long number) { sself->SetNumberOfTuples(number); } -extern "C" vtkNew < vtkGenericAttributeCollection > vtkGenericAttributeCollection_new () {return vtkNew < vtkGenericAttributeCollection > () ;} -extern "C" void vtkGenericAttributeCollection_destructor (vtkNew < vtkGenericAttributeCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGenericAttributeCollection_get_ptr (vtkNew < vtkGenericAttributeCollection > sself) {return sself . GetPointer () ;} -extern "C" int vtk_generic_attribute_collection_get_number_of_attributes(vtkNew sself) { return sself->GetNumberOfAttributes(); } -extern "C" int vtk_generic_attribute_collection_get_number_of_components(vtkNew sself) { return sself->GetNumberOfComponents(); } -extern "C" int vtk_generic_attribute_collection_get_number_of_point_centered_components(vtkNew sself) { return sself->GetNumberOfPointCenteredComponents(); } -extern "C" int vtk_generic_attribute_collection_get_max_number_of_components(vtkNew sself) { return sself->GetMaxNumberOfComponents(); } -extern "C" unsigned long vtk_generic_attribute_collection_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" int vtk_generic_attribute_collection_is_empty(vtkNew sself) { return sself->IsEmpty(); } -extern "C" int vtk_generic_attribute_collection_find_attribute(vtkNew sself, const char name) { return sself->FindAttribute(name); } -extern "C" int vtk_generic_attribute_collection_get_attribute_index(vtkNew sself, int i) { return sself->GetAttributeIndex(i); } -extern "C" void vtk_generic_attribute_collection_remove_attribute(vtkNew sself, int i) { sself->RemoveAttribute(i); } -extern "C" void vtk_generic_attribute_collection_reset(vtkNew sself) { sself->Reset(); } -extern "C" unsigned long vtk_generic_attribute_collection_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" int vtk_generic_attribute_collection_get_active_attribute(vtkNew sself) { return sself->GetActiveAttribute(); } -extern "C" int vtk_generic_attribute_collection_get_active_component(vtkNew sself) { return sself->GetActiveComponent(); } -extern "C" void vtk_generic_attribute_collection_set_active_attribute(vtkNew sself, int attribute, int component) { sself->SetActiveAttribute(attribute, component); } -extern "C" int vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate(vtkNew sself) { return sself->GetNumberOfAttributesToInterpolate(); } -extern "C" int* vtk_generic_attribute_collection_get_attributes_to_interpolate(vtkNew sself) { return sself->GetAttributesToInterpolate(); } -extern "C" int vtk_generic_attribute_collection_has_attribute(vtkNew sself, int size, int attributes, int attribute) { return sself->HasAttribute(size, attributes, attribute); } -extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate(vtkNew sself, int size, int attributes) { sself->SetAttributesToInterpolate(size, attributes); } -extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(vtkNew sself) { sself->SetAttributesToInterpolateToAll(); } -extern "C" vtkNew < vtkGenericCell > vtkGenericCell_new () {return vtkNew < vtkGenericCell > () ;} -extern "C" void vtkGenericCell_destructor (vtkNew < vtkGenericCell > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGenericCell_get_ptr (vtkNew < vtkGenericCell > sself) {return sself . GetPointer () ;} -extern "C" int vtk_generic_cell_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_generic_cell_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_generic_cell_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_generic_cell_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_generic_cell_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_generic_cell_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_generic_cell_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_generic_cell_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" void vtk_generic_cell_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_generic_cell_set_cell_type(vtkNew sself, int cellType) { sself->SetCellType(cellType); } -extern "C" void vtk_generic_cell_set_cell_type_to_empty_cell(vtkNew sself) { sself->SetCellTypeToEmptyCell(); } -extern "C" void vtk_generic_cell_set_cell_type_to_vertex(vtkNew sself) { sself->SetCellTypeToVertex(); } -extern "C" void vtk_generic_cell_set_cell_type_to_poly_vertex(vtkNew sself) { sself->SetCellTypeToPolyVertex(); } -extern "C" void vtk_generic_cell_set_cell_type_to_line(vtkNew sself) { sself->SetCellTypeToLine(); } -extern "C" void vtk_generic_cell_set_cell_type_to_poly_line(vtkNew sself) { sself->SetCellTypeToPolyLine(); } -extern "C" void vtk_generic_cell_set_cell_type_to_triangle(vtkNew sself) { sself->SetCellTypeToTriangle(); } -extern "C" void vtk_generic_cell_set_cell_type_to_triangle_strip(vtkNew sself) { sself->SetCellTypeToTriangleStrip(); } -extern "C" void vtk_generic_cell_set_cell_type_to_polygon(vtkNew sself) { sself->SetCellTypeToPolygon(); } -extern "C" void vtk_generic_cell_set_cell_type_to_pixel(vtkNew sself) { sself->SetCellTypeToPixel(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quad(vtkNew sself) { sself->SetCellTypeToQuad(); } -extern "C" void vtk_generic_cell_set_cell_type_to_tetra(vtkNew sself) { sself->SetCellTypeToTetra(); } -extern "C" void vtk_generic_cell_set_cell_type_to_voxel(vtkNew sself) { sself->SetCellTypeToVoxel(); } -extern "C" void vtk_generic_cell_set_cell_type_to_hexahedron(vtkNew sself) { sself->SetCellTypeToHexahedron(); } -extern "C" void vtk_generic_cell_set_cell_type_to_wedge(vtkNew sself) { sself->SetCellTypeToWedge(); } -extern "C" void vtk_generic_cell_set_cell_type_to_pyramid(vtkNew sself) { sself->SetCellTypeToPyramid(); } -extern "C" void vtk_generic_cell_set_cell_type_to_pentagonal_prism(vtkNew sself) { sself->SetCellTypeToPentagonalPrism(); } -extern "C" void vtk_generic_cell_set_cell_type_to_hexagonal_prism(vtkNew sself) { sself->SetCellTypeToHexagonalPrism(); } -extern "C" void vtk_generic_cell_set_cell_type_to_polyhedron(vtkNew sself) { sself->SetCellTypeToPolyhedron(); } -extern "C" void vtk_generic_cell_set_cell_type_to_convex_point_set(vtkNew sself) { sself->SetCellTypeToConvexPointSet(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_edge(vtkNew sself) { sself->SetCellTypeToQuadraticEdge(); } -extern "C" void vtk_generic_cell_set_cell_type_to_cubic_line(vtkNew sself) { sself->SetCellTypeToCubicLine(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_triangle(vtkNew sself) { sself->SetCellTypeToQuadraticTriangle(); } -extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle(vtkNew sself) { sself->SetCellTypeToBiQuadraticTriangle(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_quad(vtkNew sself) { sself->SetCellTypeToQuadraticQuad(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_polygon(vtkNew sself) { sself->SetCellTypeToQuadraticPolygon(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_tetra(vtkNew sself) { sself->SetCellTypeToQuadraticTetra(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_hexahedron(vtkNew sself) { sself->SetCellTypeToQuadraticHexahedron(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_wedge(vtkNew sself) { sself->SetCellTypeToQuadraticWedge(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_pyramid(vtkNew sself) { sself->SetCellTypeToQuadraticPyramid(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_quad(vtkNew sself) { sself->SetCellTypeToQuadraticLinearQuad(); } -extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quad(vtkNew sself) { sself->SetCellTypeToBiQuadraticQuad(); } -extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge(vtkNew sself) { sself->SetCellTypeToQuadraticLinearWedge(); } -extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge(vtkNew sself) { sself->SetCellTypeToBiQuadraticQuadraticWedge(); } -extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron(vtkNew sself) { sself->SetCellTypeToTriQuadraticHexahedron(); } -extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid(vtkNew sself) { sself->SetCellTypeToTriQuadraticPyramid(); } -extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron(vtkNew sself) { sself->SetCellTypeToBiQuadraticQuadraticHexahedron(); } -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_triangle(vtkNew sself) { sself->SetCellTypeToLagrangeTriangle(); } -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_tetra(vtkNew sself) { sself->SetCellTypeToLagrangeTetra(); } -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_curve(vtkNew sself) { sself->SetCellTypeToLagrangeCurve(); } -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral(vtkNew sself) { sself->SetCellTypeToLagrangeQuadrilateral(); } -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_hexahedron(vtkNew sself) { sself->SetCellTypeToLagrangeHexahedron(); } -extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_wedge(vtkNew sself) { sself->SetCellTypeToLagrangeWedge(); } -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_triangle(vtkNew sself) { sself->SetCellTypeToBezierTriangle(); } -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_tetra(vtkNew sself) { sself->SetCellTypeToBezierTetra(); } -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_curve(vtkNew sself) { sself->SetCellTypeToBezierCurve(); } -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_quadrilateral(vtkNew sself) { sself->SetCellTypeToBezierQuadrilateral(); } -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_hexahedron(vtkNew sself) { sself->SetCellTypeToBezierHexahedron(); } -extern "C" void vtk_generic_cell_set_cell_type_to_bezier_wedge(vtkNew sself) { sself->SetCellTypeToBezierWedge(); } -extern "C" vtkNew < vtkGenericEdgeTable > vtkGenericEdgeTable_new () {return vtkNew < vtkGenericEdgeTable > () ;} -extern "C" void vtkGenericEdgeTable_destructor (vtkNew < vtkGenericEdgeTable > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGenericEdgeTable_get_ptr (vtkNew < vtkGenericEdgeTable > sself) {return sself . GetPointer () ;} -extern "C" void vtk_generic_edge_table_insert_edge(vtkNew sself, long long e1, long long e2, long long cellId, int ref, long long ptId) { sself->InsertEdge(e1, e2, cellId, ref, ptId); } -extern "C" void vtk_generic_edge_table_insert_edge(vtkNew sself, long long e1, long long e2, long long cellId, int ref) { sself->InsertEdge(e1, e2, cellId, ref); } -extern "C" int vtk_generic_edge_table_remove_edge(vtkNew sself, long long e1, long long e2) { return sself->RemoveEdge(e1, e2); } -extern "C" int vtk_generic_edge_table_check_edge(vtkNew sself, long long e1, long long e2, long long ptId) { return sself->CheckEdge(e1, e2, ptId); } -extern "C" int vtk_generic_edge_table_increment_edge_reference_count(vtkNew sself, long long e1, long long e2, long long cellId) { return sself->IncrementEdgeReferenceCount(e1, e2, cellId); } -extern "C" int vtk_generic_edge_table_check_edge_reference_count(vtkNew sself, long long e1, long long e2) { return sself->CheckEdgeReferenceCount(e1, e2); } -extern "C" void vtk_generic_edge_table_initialize(vtkNew sself, long long start) { sself->Initialize(start); } -extern "C" int vtk_generic_edge_table_get_number_of_components(vtkNew sself) { return sself->GetNumberOfComponents(); } -extern "C" void vtk_generic_edge_table_set_number_of_components(vtkNew sself, int count) { sself->SetNumberOfComponents(count); } -extern "C" int vtk_generic_edge_table_check_point(vtkNew sself, long long ptId) { return sself->CheckPoint(ptId); } -extern "C" int vtk_generic_edge_table_check_point(vtkNew sself, long long ptId, double point, double scalar) { return sself->CheckPoint(ptId, point, scalar); } -extern "C" void vtk_generic_edge_table_insert_point(vtkNew sself, long long ptId, double point) { sself->InsertPoint(ptId, point); } -extern "C" void vtk_generic_edge_table_insert_point_and_scalar(vtkNew sself, long long ptId, double pt, double s) { sself->InsertPointAndScalar(ptId, pt, s); } -extern "C" void vtk_generic_edge_table_remove_point(vtkNew sself, long long ptId) { sself->RemovePoint(ptId); } -extern "C" void vtk_generic_edge_table_increment_point_reference_count(vtkNew sself, long long ptId) { sself->IncrementPointReferenceCount(ptId); } -extern "C" void vtk_generic_edge_table_dump_table(vtkNew sself) { sself->DumpTable(); } -extern "C" void vtk_generic_edge_table_load_factor(vtkNew sself) { sself->LoadFactor(); } -extern "C" vtkNew < vtkGenericInterpolatedVelocityField > vtkGenericInterpolatedVelocityField_new () {return vtkNew < vtkGenericInterpolatedVelocityField > () ;} -extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkNew < vtkGenericInterpolatedVelocityField > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGenericInterpolatedVelocityField_get_ptr (vtkNew < vtkGenericInterpolatedVelocityField > sself) {return sself . GetPointer () ;} -extern "C" int vtk_generic_interpolated_velocity_field_function_values(vtkNew sself, double x, double f) { return sself->FunctionValues(x, f); } -extern "C" void vtk_generic_interpolated_velocity_field_clear_last_cell(vtkNew sself) { sself->ClearLastCell(); } -extern "C" int vtk_generic_interpolated_velocity_field_get_last_local_coordinates(vtkNew sself, double pcoords) { return sself->GetLastLocalCoordinates(pcoords); } -extern "C" int vtk_generic_interpolated_velocity_field_get_caching(vtkNew sself) { return sself->GetCaching(); } -extern "C" void vtk_generic_interpolated_velocity_field_set_caching(vtkNew sself, int _arg) { sself->SetCaching(_arg); } -extern "C" void vtk_generic_interpolated_velocity_field_caching_on(vtkNew sself) { sself->CachingOn(); } -extern "C" void vtk_generic_interpolated_velocity_field_caching_off(vtkNew sself) { sself->CachingOff(); } -extern "C" int vtk_generic_interpolated_velocity_field_get_cache_hit(vtkNew sself) { return sself->GetCacheHit(); } -extern "C" int vtk_generic_interpolated_velocity_field_get_cache_miss(vtkNew sself) { return sself->GetCacheMiss(); } -extern "C" char* vtk_generic_interpolated_velocity_field_get_vectors_selection(vtkNew sself) { return sself->GetVectorsSelection(); } -extern "C" void vtk_generic_interpolated_velocity_field_select_vectors(vtkNew sself, const char fieldName) { sself->SelectVectors(fieldName); } -extern "C" vtkNew < vtkGeometricErrorMetric > vtkGeometricErrorMetric_new () {return vtkNew < vtkGeometricErrorMetric > () ;} -extern "C" void vtkGeometricErrorMetric_destructor (vtkNew < vtkGeometricErrorMetric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGeometricErrorMetric_get_ptr (vtkNew < vtkGeometricErrorMetric > sself) {return sself . GetPointer () ;} -extern "C" double vtk_geometric_error_metric_get_absolute_geometric_tolerance(vtkNew sself) { return sself->GetAbsoluteGeometricTolerance(); } -extern "C" void vtk_geometric_error_metric_set_absolute_geometric_tolerance(vtkNew sself, double value) { sself->SetAbsoluteGeometricTolerance(value); } -extern "C" int vtk_geometric_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->RequiresEdgeSubdivision(leftPoint, midPoint, rightPoint, alpha); } -extern "C" double vtk_geometric_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->GetError(leftPoint, midPoint, rightPoint, alpha); } -extern "C" int vtk_geometric_error_metric_get_relative(vtkNew sself) { return sself->GetRelative(); } -extern "C" vtkNew < vtkGraphEdge > vtkGraphEdge_new () {return vtkNew < vtkGraphEdge > () ;} -extern "C" void vtkGraphEdge_destructor (vtkNew < vtkGraphEdge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGraphEdge_get_ptr (vtkNew < vtkGraphEdge > sself) {return sself . GetPointer () ;} -extern "C" void vtk_graph_edge_set_source(vtkNew sself, long long _arg) { sself->SetSource(_arg); } -extern "C" long long vtk_graph_edge_get_source(vtkNew sself) { return sself->GetSource(); } -extern "C" void vtk_graph_edge_set_target(vtkNew sself, long long _arg) { sself->SetTarget(_arg); } -extern "C" long long vtk_graph_edge_get_target(vtkNew sself) { return sself->GetTarget(); } -extern "C" void vtk_graph_edge_set_id(vtkNew sself, long long _arg) { sself->SetId(_arg); } -extern "C" long long vtk_graph_edge_get_id(vtkNew sself) { return sself->GetId(); } -extern "C" vtkNew < vtkGraphInternals > vtkGraphInternals_new () {return vtkNew < vtkGraphInternals > () ;} -extern "C" void vtkGraphInternals_destructor (vtkNew < vtkGraphInternals > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGraphInternals_get_ptr (vtkNew < vtkGraphInternals > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHexagonalPrism > vtkHexagonalPrism_new () {return vtkNew < vtkHexagonalPrism > () ;} -extern "C" void vtkHexagonalPrism_destructor (vtkNew < vtkHexagonalPrism > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHexagonalPrism_get_ptr (vtkNew < vtkHexagonalPrism > sself) {return sself . GetPointer () ;} -extern "C" void vtk_hexagonal_prism_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" void vtk_hexagonal_prism_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" long long vtk_hexagonal_prism_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_hexagonal_prism_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_hexagonal_prism_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } -extern "C" long long vtk_hexagonal_prism_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } -extern "C" long long vtk_hexagonal_prism_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } -extern "C" long long vtk_hexagonal_prism_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } -extern "C" long long vtk_hexagonal_prism_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } -extern "C" bool vtk_hexagonal_prism_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } -extern "C" int vtk_hexagonal_prism_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_hexagonal_prism_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_hexagonal_prism_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_hexagonal_prism_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_hexagonal_prism_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_hexagonal_prism_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_hexagonal_prism_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_hexagonal_prism_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_hexagonal_prism_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_hexagonal_prism_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_hexagonal_prism_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_hexagonal_prism_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_hexagonal_prism_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_hexagonal_prism_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" const long long* vtk_hexagonal_prism_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } -extern "C" const long long* vtk_hexagonal_prism_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } -extern "C" const long long* vtk_hexagonal_prism_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } -extern "C" const long long* vtk_hexagonal_prism_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } -extern "C" const long long* vtk_hexagonal_prism_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } -extern "C" void vtk_hexagonal_prism_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkHexahedron > vtkHexahedron_new () {return vtkNew < vtkHexahedron > () ;} -extern "C" void vtkHexahedron_destructor (vtkNew < vtkHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHexahedron_get_ptr (vtkNew < vtkHexahedron > sself) {return sself . GetPointer () ;} -extern "C" void vtk_hexahedron_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" void vtk_hexahedron_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" long long vtk_hexahedron_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_hexahedron_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_hexahedron_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } -extern "C" long long vtk_hexahedron_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } -extern "C" long long vtk_hexahedron_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } -extern "C" long long vtk_hexahedron_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } -extern "C" long long vtk_hexahedron_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } -extern "C" bool vtk_hexahedron_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } -extern "C" int vtk_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_hexahedron_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_hexahedron_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int* vtk_hexahedron_get_triangle_cases(vtkNew sself, int caseId) { return sself->GetTriangleCases(caseId); } -extern "C" void vtk_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_hexahedron_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_hexahedron_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" const long long* vtk_hexahedron_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } -extern "C" const long long* vtk_hexahedron_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } -extern "C" const long long* vtk_hexahedron_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } -extern "C" const long long* vtk_hexahedron_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } -extern "C" const long long* vtk_hexahedron_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } -extern "C" void vtk_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkHierarchicalBoxDataIterator > vtkHierarchicalBoxDataIterator_new () {return vtkNew < vtkHierarchicalBoxDataIterator > () ;} -extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkNew < vtkHierarchicalBoxDataIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHierarchicalBoxDataIterator_get_ptr (vtkNew < vtkHierarchicalBoxDataIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHierarchicalBoxDataSet > vtkHierarchicalBoxDataSet_new () {return vtkNew < vtkHierarchicalBoxDataSet > () ;} -extern "C" void vtkHierarchicalBoxDataSet_destructor (vtkNew < vtkHierarchicalBoxDataSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHierarchicalBoxDataSet_get_ptr (vtkNew < vtkHierarchicalBoxDataSet > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGrid > vtkHyperTreeGrid_new () {return vtkNew < vtkHyperTreeGrid > () ;} -extern "C" void vtkHyperTreeGrid_destructor (vtkNew < vtkHyperTreeGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGrid_get_ptr (vtkNew < vtkHyperTreeGrid > sself) {return sself . GetPointer () ;} -extern "C" void vtk_hyper_tree_grid_set_mode_squeeze(vtkNew sself, const char _arg) { sself->SetModeSqueeze(_arg); } -extern "C" char* vtk_hyper_tree_grid_get_mode_squeeze(vtkNew sself) { return sself->GetModeSqueeze(); } -extern "C" void vtk_hyper_tree_grid_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" int vtk_hyper_tree_grid_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, const unsigned int dims) { sself->SetDimensions(dims); } -extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, const int dims) { sself->SetDimensions(dims); } -extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, unsigned int i, unsigned int j, unsigned int k) { sself->SetDimensions(i, j, k); } -extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkNew sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } -extern "C" const unsigned int* vtk_hyper_tree_grid_get_dimensions(vtkNew sself) { return sself->GetDimensions(); } -extern "C" void vtk_hyper_tree_grid_get_dimensions(vtkNew sself, int dim) { sself->GetDimensions(dim); } -extern "C" void vtk_hyper_tree_grid_get_dimensions(vtkNew sself, unsigned int dim) { sself->GetDimensions(dim); } -extern "C" void vtk_hyper_tree_grid_set_extent(vtkNew sself, const int extent) { sself->SetExtent(extent); } -extern "C" void vtk_hyper_tree_grid_set_extent(vtkNew sself, int x1, int x2, int y1, int y2, int z1, int z2) { sself->SetExtent(x1, x2, y1, y2, z1, z2); } -extern "C" int* vtk_hyper_tree_grid_get_extent(vtkNew sself) { return sself->GetExtent(); } -extern "C" void vtk_hyper_tree_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_hyper_tree_grid_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } -extern "C" const unsigned int* vtk_hyper_tree_grid_get_cell_dims(vtkNew sself) { return sself->GetCellDims(); } -extern "C" void vtk_hyper_tree_grid_get_cell_dims(vtkNew sself, int cellDims) { sself->GetCellDims(cellDims); } -extern "C" void vtk_hyper_tree_grid_get_cell_dims(vtkNew sself, unsigned int cellDims) { sself->GetCellDims(cellDims); } -extern "C" unsigned int vtk_hyper_tree_grid_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" void vtk_hyper_tree_grid_get_1_d_axis(vtkNew sself, unsigned int axis) { sself->Get1DAxis(axis); } -extern "C" void vtk_hyper_tree_grid_get_2_d_axes(vtkNew sself, unsigned int axis1, unsigned int axis2) { sself->Get2DAxes(axis1, axis2); } -extern "C" const unsigned int* vtk_hyper_tree_grid_get_axes(vtkNew sself) { return sself->GetAxes(); } -extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_children(vtkNew sself) { return sself->GetNumberOfChildren(); } -extern "C" void vtk_hyper_tree_grid_set_transposed_root_indexing(vtkNew sself, bool _arg) { sself->SetTransposedRootIndexing(_arg); } -extern "C" bool vtk_hyper_tree_grid_get_transposed_root_indexing(vtkNew sself) { return sself->GetTransposedRootIndexing(); } -extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_kji(vtkNew sself) { sself->SetIndexingModeToKJI(); } -extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_ijk(vtkNew sself) { sself->SetIndexingModeToIJK(); } -extern "C" unsigned int vtk_hyper_tree_grid_get_orientation(vtkNew sself) { return sself->GetOrientation(); } -extern "C" bool vtk_hyper_tree_grid_get_freeze_state(vtkNew sself) { return sself->GetFreezeState(); } -extern "C" void vtk_hyper_tree_grid_set_branch_factor(vtkNew sself, unsigned int p0) { sself->SetBranchFactor(p0); } -extern "C" unsigned int vtk_hyper_tree_grid_get_branch_factor(vtkNew sself) { return sself->GetBranchFactor(); } -extern "C" long long vtk_hyper_tree_grid_get_max_number_of_trees(vtkNew sself) { return sself->GetMaxNumberOfTrees(); } -extern "C" long long vtk_hyper_tree_grid_get_number_of_vertices(vtkNew sself) { return sself->GetNumberOfVertices(); } -extern "C" long long vtk_hyper_tree_grid_get_number_of_non_empty_trees(vtkNew sself) { return sself->GetNumberOfNonEmptyTrees(); } -extern "C" long long vtk_hyper_tree_grid_get_number_of_leaves(vtkNew sself) { return sself->GetNumberOfLeaves(); } -extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkNew sself, long long p0) { return sself->GetNumberOfLevels(p0); } -extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkNew sself) { return sself->GetNumberOfLevels(); } -extern "C" void vtk_hyper_tree_grid_set_fixed_coordinates(vtkNew sself, unsigned int axis, double value) { sself->SetFixedCoordinates(axis, value); } -extern "C" bool vtk_hyper_tree_grid_has_mask(vtkNew sself) { return sself->HasMask(); } -extern "C" void vtk_hyper_tree_grid_set_has_interface(vtkNew sself, bool _arg) { sself->SetHasInterface(_arg); } -extern "C" bool vtk_hyper_tree_grid_get_has_interface(vtkNew sself) { return sself->GetHasInterface(); } -extern "C" void vtk_hyper_tree_grid_has_interface_on(vtkNew sself) { sself->HasInterfaceOn(); } -extern "C" void vtk_hyper_tree_grid_has_interface_off(vtkNew sself) { sself->HasInterfaceOff(); } -extern "C" void vtk_hyper_tree_grid_set_interface_normals_name(vtkNew sself, const char _arg) { sself->SetInterfaceNormalsName(_arg); } -extern "C" char* vtk_hyper_tree_grid_get_interface_normals_name(vtkNew sself) { return sself->GetInterfaceNormalsName(); } -extern "C" void vtk_hyper_tree_grid_set_interface_intercepts_name(vtkNew sself, const char _arg) { sself->SetInterfaceInterceptsName(_arg); } -extern "C" char* vtk_hyper_tree_grid_get_interface_intercepts_name(vtkNew sself) { return sself->GetInterfaceInterceptsName(); } -extern "C" void vtk_hyper_tree_grid_set_depth_limiter(vtkNew sself, unsigned int _arg) { sself->SetDepthLimiter(_arg); } -extern "C" unsigned int vtk_hyper_tree_grid_get_depth_limiter(vtkNew sself) { return sself->GetDepthLimiter(); } -extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_x(vtkNew sself, double value) { return sself->FindDichotomicX(value); } -extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_y(vtkNew sself, double value) { return sself->FindDichotomicY(value); } -extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_z(vtkNew sself, double value) { return sself->FindDichotomicZ(value); } -extern "C" void vtk_hyper_tree_grid_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_hyper_tree_grid_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } -extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size_bytes(vtkNew sself) { return sself->GetActualMemorySizeBytes(); } -extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" unsigned int vtk_hyper_tree_grid_get_child_mask(vtkNew sself, unsigned int p0) { return sself->GetChildMask(p0); } -extern "C" void vtk_hyper_tree_grid_get_index_from_level_zero_coordinates(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3) { sself->GetIndexFromLevelZeroCoordinates(p0, p1, p2, p3); } -extern "C" long long vtk_hyper_tree_grid_get_shifted_level_zero_index(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3) { return sself->GetShiftedLevelZeroIndex(p0, p1, p2, p3); } -extern "C" void vtk_hyper_tree_grid_get_level_zero_coordinates_from_index(vtkNew sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3) { sself->GetLevelZeroCoordinatesFromIndex(p0, p1, p2, p3); } -extern "C" void vtk_hyper_tree_grid_get_level_zero_origin_and_size_from_index(vtkNew sself, long long p0, double p1, double p2) { sself->GetLevelZeroOriginAndSizeFromIndex(p0, p1, p2); } -extern "C" void vtk_hyper_tree_grid_get_level_zero_origin_from_index(vtkNew sself, long long p0, double p1) { sself->GetLevelZeroOriginFromIndex(p0, p1); } -extern "C" long long vtk_hyper_tree_grid_get_global_node_index_max(vtkNew sself) { return sself->GetGlobalNodeIndexMax(); } -extern "C" void vtk_hyper_tree_grid_initialize_local_index_node(vtkNew sself) { sself->InitializeLocalIndexNode(); } -extern "C" bool vtk_hyper_tree_grid_has_any_ghost_cells(vtkNew sself) { return sself->HasAnyGhostCells(); } -extern "C" double* vtk_hyper_tree_grid_get_bounds(vtkNew sself) { return sself->GetBounds(); } -extern "C" void vtk_hyper_tree_grid_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" double* vtk_hyper_tree_grid_get_center(vtkNew sself) { return sself->GetCenter(); } -extern "C" void vtk_hyper_tree_grid_get_center(vtkNew sself, double center) { sself->GetCenter(center); } -extern "C" long long vtk_hyper_tree_grid_get_number_of_elements(vtkNew sself, int type) { return sself->GetNumberOfElements(type); } -extern "C" vtkNew < vtkHyperTreeGridNonOrientedCursor > vtkHyperTreeGridNonOrientedCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedCursor > () ;} -extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) {return sself . GetPointer () ;} -extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_has_tree(vtkNew sself) { return sself->HasTree(); } -extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(vtkNew sself) { return sself->GetVertexId(); } -extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(vtkNew sself) { return sself->GetGlobalNodeIndex(); } -extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(vtkNew sself) { return sself->GetNumberOfChildren(); } -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(vtkNew sself, long long index) { sself->SetGlobalIndexStart(index); } -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local(vtkNew sself, long long index) { sself->SetGlobalIndexFromLocal(index); } -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_mask(vtkNew sself, bool state) { sself->SetMask(state); } -extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_masked(vtkNew sself) { return sself->IsMasked(); } -extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_leaf(vtkNew sself) { return sself->IsLeaf(); } -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf(vtkNew sself) { sself->SubdivideLeaf(); } -extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_root(vtkNew sself) { return sself->IsRoot(); } -extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_cursor_get_level(vtkNew sself) { return sself->GetLevel(); } -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_child(vtkNew sself, unsigned char ichild) { sself->ToChild(ichild); } -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_root(vtkNew sself) { sself->ToRoot(); } -extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_parent(vtkNew sself) { sself->ToParent(); } -extern "C" vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > vtkHyperTreeGridNonOrientedGeometryCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > () ;} -extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) {return sself . GetPointer () ;} -extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(vtkNew sself) { return sself->HasTree(); } -extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(vtkNew sself) { return sself->GetVertexId(); } -extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index(vtkNew sself) { return sself->GetGlobalNodeIndex(); } -extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children(vtkNew sself) { return sself->GetNumberOfChildren(); } -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start(vtkNew sself, long long index) { sself->SetGlobalIndexStart(index); } -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local(vtkNew sself, long long index) { sself->SetGlobalIndexFromLocal(index); } -extern "C" double* vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_origin(vtkNew sself) { return sself->GetOrigin(); } -extern "C" double* vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_size(vtkNew sself) { return sself->GetSize(); } -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_point(vtkNew sself, double point) { sself->GetPoint(point); } -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask(vtkNew sself, bool state) { sself->SetMask(state); } -extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked(vtkNew sself) { return sself->IsMasked(); } -extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf(vtkNew sself) { return sself->IsLeaf(); } -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf(vtkNew sself) { sself->SubdivideLeaf(); } -extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root(vtkNew sself) { return sself->IsRoot(); } -extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level(vtkNew sself) { return sself->GetLevel(); } -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child(vtkNew sself, unsigned char ichild) { sself->ToChild(ichild); } -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(vtkNew sself) { sself->ToRoot(); } -extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(vtkNew sself) { sself->ToParent(); } -extern "C" vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > vtkHyperTreeGridNonOrientedMooreSuperCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > () ;} -extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new () {return vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > () ;} -extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursorLight_destructor (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > () ;} -extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new () {return vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > () ;} -extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_destructor (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridOrientedCursor > vtkHyperTreeGridOrientedCursor_new () {return vtkNew < vtkHyperTreeGridOrientedCursor > () ;} -extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkNew < vtkHyperTreeGridOrientedCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedCursor > sself) {return sself . GetPointer () ;} -extern "C" bool vtk_hyper_tree_grid_oriented_cursor_has_tree(vtkNew sself) { return sself->HasTree(); } -extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(vtkNew sself) { return sself->GetVertexId(); } -extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(vtkNew sself) { return sself->GetGlobalNodeIndex(); } -extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(vtkNew sself) { return sself->GetNumberOfChildren(); } -extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(vtkNew sself, long long index) { sself->SetGlobalIndexStart(index); } -extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local(vtkNew sself, long long index) { sself->SetGlobalIndexFromLocal(index); } -extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_mask(vtkNew sself, bool state) { sself->SetMask(state); } -extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_masked(vtkNew sself) { return sself->IsMasked(); } -extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_leaf(vtkNew sself) { return sself->IsLeaf(); } -extern "C" void vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf(vtkNew sself) { sself->SubdivideLeaf(); } -extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_root(vtkNew sself) { return sself->IsRoot(); } -extern "C" unsigned int vtk_hyper_tree_grid_oriented_cursor_get_level(vtkNew sself) { return sself->GetLevel(); } -extern "C" void vtk_hyper_tree_grid_oriented_cursor_to_child(vtkNew sself, unsigned char ichild) { sself->ToChild(ichild); } -extern "C" vtkNew < vtkHyperTreeGridOrientedGeometryCursor > vtkHyperTreeGridOrientedGeometryCursor_new () {return vtkNew < vtkHyperTreeGridOrientedGeometryCursor > () ;} -extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) {return sself . GetPointer () ;} -extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(vtkNew sself) { return sself->HasTree(); } -extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(vtkNew sself) { return sself->GetVertexId(); } -extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(vtkNew sself) { return sself->GetGlobalNodeIndex(); } -extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension(vtkNew sself) { return sself->GetDimension(); } -extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(vtkNew sself) { return sself->GetNumberOfChildren(); } -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start(vtkNew sself, long long index) { sself->SetGlobalIndexStart(index); } -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local(vtkNew sself, long long index) { sself->SetGlobalIndexFromLocal(index); } -extern "C" double* vtk_hyper_tree_grid_oriented_geometry_cursor_get_origin(vtkNew sself) { return sself->GetOrigin(); } -extern "C" double* vtk_hyper_tree_grid_oriented_geometry_cursor_get_size(vtkNew sself) { return sself->GetSize(); } -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_get_point(vtkNew sself, double point) { sself->GetPoint(point); } -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask(vtkNew sself, bool state) { sself->SetMask(state); } -extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked(vtkNew sself) { return sself->IsMasked(); } -extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf(vtkNew sself) { return sself->IsLeaf(); } -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf(vtkNew sself) { sself->SubdivideLeaf(); } -extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_root(vtkNew sself) { return sself->IsRoot(); } -extern "C" unsigned int vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(vtkNew sself) { return sself->GetLevel(); } -extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(vtkNew sself, unsigned char ichild) { sself->ToChild(ichild); } -extern "C" vtkNew < vtkImageData > vtkImageData_new () {return vtkNew < vtkImageData > () ;} -extern "C" void vtkImageData_destructor (vtkNew < vtkImageData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImageData_get_ptr (vtkNew < vtkImageData > sself) {return sself . GetPointer () ;} -extern "C" int vtk_image_data_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" long long vtk_image_data_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } -extern "C" long long vtk_image_data_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" double* vtk_image_data_get_point(vtkNew sself, long long ptId) { return sself->GetPoint(ptId); } -extern "C" long long vtk_image_data_find_point(vtkNew sself, double x, double y, double z) { return sself->FindPoint(x, y, z); } -extern "C" long long vtk_image_data_find_point(vtkNew sself, double x) { return sself->FindPoint(x); } -extern "C" int vtk_image_data_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } -extern "C" int vtk_image_data_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } -extern "C" void vtk_image_data_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" unsigned char vtk_image_data_is_point_visible(vtkNew sself, long long ptId) { return sself->IsPointVisible(ptId); } -extern "C" unsigned char vtk_image_data_is_cell_visible(vtkNew sself, long long cellId) { return sself->IsCellVisible(cellId); } -extern "C" bool vtk_image_data_has_any_blank_points(vtkNew sself) { return sself->HasAnyBlankPoints(); } -extern "C" bool vtk_image_data_has_any_blank_cells(vtkNew sself) { return sself->HasAnyBlankCells(); } -extern "C" void vtk_image_data_get_cell_dims(vtkNew sself, int cellDims) { sself->GetCellDims(cellDims); } -extern "C" void vtk_image_data_set_dimensions(vtkNew sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } -extern "C" void vtk_image_data_set_dimensions(vtkNew sself, const int dims) { sself->SetDimensions(dims); } -extern "C" int* vtk_image_data_get_dimensions(vtkNew sself) { return sself->GetDimensions(); } -extern "C" void vtk_image_data_get_dimensions(vtkNew sself, int dims) { sself->GetDimensions(dims); } -extern "C" void vtk_image_data_get_dimensions(vtkNew sself, long long dims) { sself->GetDimensions(dims); } -extern "C" int vtk_image_data_compute_structured_coordinates(vtkNew sself, const double x, int ijk, double pcoords) { return sself->ComputeStructuredCoordinates(x, ijk, pcoords); } -extern "C" int vtk_image_data_get_data_dimension(vtkNew sself) { return sself->GetDataDimension(); } -extern "C" long long vtk_image_data_compute_point_id(vtkNew sself, int ijk) { return sself->ComputePointId(ijk); } -extern "C" long long vtk_image_data_compute_cell_id(vtkNew sself, int ijk) { return sself->ComputeCellId(ijk); } -extern "C" void vtk_image_data_set_axis_update_extent(vtkNew sself, int axis, int min, int max, const int updateExtent, int axisUpdateExtent) { sself->SetAxisUpdateExtent(axis, min, max, updateExtent, axisUpdateExtent); } -extern "C" void vtk_image_data_get_axis_update_extent(vtkNew sself, int axis, int min, int max, const int updateExtent) { sself->GetAxisUpdateExtent(axis, min, max, updateExtent); } -extern "C" void vtk_image_data_set_extent(vtkNew sself, int extent) { sself->SetExtent(extent); } -extern "C" void vtk_image_data_set_extent(vtkNew sself, int x1, int x2, int y1, int y2, int z1, int z2) { sself->SetExtent(x1, x2, y1, y2, z1, z2); } -extern "C" int* vtk_image_data_get_extent(vtkNew sself) { return sself->GetExtent(); } -extern "C" void vtk_image_data_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_image_data_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } -extern "C" double vtk_image_data_get_scalar_type_min(vtkNew sself) { return sself->GetScalarTypeMin(); } -extern "C" double vtk_image_data_get_scalar_type_max(vtkNew sself) { return sself->GetScalarTypeMax(); } -extern "C" int vtk_image_data_get_scalar_size(vtkNew sself) { return sself->GetScalarSize(); } -extern "C" long long* vtk_image_data_get_increments(vtkNew sself) { return sself->GetIncrements(); } -extern "C" void vtk_image_data_get_increments(vtkNew sself, long long incX, long long incY, long long incZ) { sself->GetIncrements(incX, incY, incZ); } -extern "C" void vtk_image_data_get_increments(vtkNew sself, long long inc) { sself->GetIncrements(inc); } -extern "C" void vtk_image_data_get_continuous_increments(vtkNew sself, int extent, long long incX, long long incY, long long incZ) { sself->GetContinuousIncrements(extent, incX, incY, incZ); } -extern "C" void* vtk_image_data_get_scalar_pointer_for_extent(vtkNew sself, int extent) { return sself->GetScalarPointerForExtent(extent); } -extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself, int coordinates) { return sself->GetScalarPointer(coordinates); } -extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself, int x, int y, int z) { return sself->GetScalarPointer(x, y, z); } -extern "C" void* vtk_image_data_get_scalar_pointer(vtkNew sself) { return sself->GetScalarPointer(); } -extern "C" long long vtk_image_data_get_scalar_index_for_extent(vtkNew sself, int extent) { return sself->GetScalarIndexForExtent(extent); } -extern "C" long long vtk_image_data_get_scalar_index(vtkNew sself, int coordinates) { return sself->GetScalarIndex(coordinates); } -extern "C" long long vtk_image_data_get_scalar_index(vtkNew sself, int x, int y, int z) { return sself->GetScalarIndex(x, y, z); } -extern "C" float vtk_image_data_get_scalar_component_as_float(vtkNew sself, int x, int y, int z, int component) { return sself->GetScalarComponentAsFloat(x, y, z, component); } -extern "C" void vtk_image_data_set_scalar_component_from_float(vtkNew sself, int x, int y, int z, int component, float v) { sself->SetScalarComponentFromFloat(x, y, z, component, v); } -extern "C" double vtk_image_data_get_scalar_component_as_double(vtkNew sself, int x, int y, int z, int component) { return sself->GetScalarComponentAsDouble(x, y, z, component); } -extern "C" void vtk_image_data_set_scalar_component_from_double(vtkNew sself, int x, int y, int z, int component, double v) { sself->SetScalarComponentFromDouble(x, y, z, component, v); } -extern "C" void vtk_image_data_allocate_scalars(vtkNew sself, int dataType, int numComponents) { sself->AllocateScalars(dataType, numComponents); } -extern "C" void vtk_image_data_crop(vtkNew sself, const int updateExtent) { sself->Crop(updateExtent); } -extern "C" double* vtk_image_data_get_spacing(vtkNew sself) { return sself->GetSpacing(); } -extern "C" void vtk_image_data_get_spacing(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetSpacing(_arg1, _arg2, _arg3); } -extern "C" void vtk_image_data_get_spacing(vtkNew sself, double _arg) { sself->GetSpacing(_arg); } -extern "C" void vtk_image_data_set_spacing(vtkNew sself, double i, double j, double k) { sself->SetSpacing(i, j, k); } -extern "C" void vtk_image_data_set_spacing(vtkNew sself, const double ijk) { sself->SetSpacing(ijk); } -extern "C" double* vtk_image_data_get_origin(vtkNew sself) { return sself->GetOrigin(); } -extern "C" void vtk_image_data_get_origin(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetOrigin(_arg1, _arg2, _arg3); } -extern "C" void vtk_image_data_get_origin(vtkNew sself, double _arg) { sself->GetOrigin(_arg); } -extern "C" void vtk_image_data_set_origin(vtkNew sself, double i, double j, double k) { sself->SetOrigin(i, j, k); } -extern "C" void vtk_image_data_set_origin(vtkNew sself, const double ijk) { sself->SetOrigin(ijk); } -extern "C" void vtk_image_data_set_direction_matrix(vtkNew sself, const double elements) { sself->SetDirectionMatrix(elements); } -extern "C" void vtk_image_data_set_direction_matrix(vtkNew sself, double e00, double e01, double e02, double e10, double e11, double e12, double e20, double e21, double e22) { sself->SetDirectionMatrix(e00, e01, e02, e10, e11, e12, e20, e21, e22); } -extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, double i, double j, double k, double xyz) { sself->TransformContinuousIndexToPhysicalPoint(i, j, k, xyz); } -extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, const double ijk, double xyz) { sself->TransformContinuousIndexToPhysicalPoint(ijk, xyz); } -extern "C" void vtk_image_data_transform_index_to_physical_point(vtkNew sself, int i, int j, int k, double xyz) { sself->TransformIndexToPhysicalPoint(i, j, k, xyz); } -extern "C" void vtk_image_data_transform_index_to_physical_point(vtkNew sself, const int ijk, double xyz) { sself->TransformIndexToPhysicalPoint(ijk, xyz); } -extern "C" void vtk_image_data_transform_continuous_index_to_physical_point(vtkNew sself, double i, double j, double k, const double origin, const double spacing, const double direction, double xyz) { sself->TransformContinuousIndexToPhysicalPoint(i, j, k, origin, spacing, direction, xyz); } -extern "C" void vtk_image_data_transform_physical_point_to_continuous_index(vtkNew sself, double x, double y, double z, double ijk) { sself->TransformPhysicalPointToContinuousIndex(x, y, z, ijk); } -extern "C" void vtk_image_data_transform_physical_point_to_continuous_index(vtkNew sself, const double xyz, double ijk) { sself->TransformPhysicalPointToContinuousIndex(xyz, ijk); } -extern "C" void vtk_image_data_compute_index_to_physical_matrix(vtkNew sself, const double origin, const double spacing, const double direction, double result) { sself->ComputeIndexToPhysicalMatrix(origin, spacing, direction, result); } -extern "C" void vtk_image_data_transform_physical_normal_to_continuous_index(vtkNew sself, const double xyz, double ijk) { sself->TransformPhysicalNormalToContinuousIndex(xyz, ijk); } -extern "C" void vtk_image_data_transform_physical_plane_to_continuous_index(vtkNew sself, const double pplane, double iplane) { sself->TransformPhysicalPlaneToContinuousIndex(pplane, iplane); } -extern "C" int vtk_image_data_get_scalar_type(vtkNew sself) { return sself->GetScalarType(); } -extern "C" const char* vtk_image_data_get_scalar_type_as_string(vtkNew sself) { return sself->GetScalarTypeAsString(); } -extern "C" int vtk_image_data_get_number_of_scalar_components(vtkNew sself) { return sself->GetNumberOfScalarComponents(); } -extern "C" void vtk_image_data_prepare_for_new_data(vtkNew sself) { sself->PrepareForNewData(); } -extern "C" void vtk_image_data_compute_internal_extent(vtkNew sself, int intExt, int tgtExt, int bnds) { sself->ComputeInternalExtent(intExt, tgtExt, bnds); } -extern "C" int vtk_image_data_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } -extern "C" vtkNew < vtkImageTransform > vtkImageTransform_new () {return vtkNew < vtkImageTransform > () ;} -extern "C" void vtkImageTransform_destructor (vtkNew < vtkImageTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImageTransform_get_ptr (vtkNew < vtkImageTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImplicitBoolean > vtkImplicitBoolean_new () {return vtkNew < vtkImplicitBoolean > () ;} -extern "C" void vtkImplicitBoolean_destructor (vtkNew < vtkImplicitBoolean > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitBoolean_get_ptr (vtkNew < vtkImplicitBoolean > sself) {return sself . GetPointer () ;} -extern "C" double vtk_implicit_boolean_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_implicit_boolean_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } -extern "C" unsigned long vtk_implicit_boolean_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_implicit_boolean_set_operation_type(vtkNew sself, int _arg) { sself->SetOperationType(_arg); } -extern "C" int vtk_implicit_boolean_get_operation_type_min_value(vtkNew sself) { return sself->GetOperationTypeMinValue(); } -extern "C" int vtk_implicit_boolean_get_operation_type_max_value(vtkNew sself) { return sself->GetOperationTypeMaxValue(); } -extern "C" int vtk_implicit_boolean_get_operation_type(vtkNew sself) { return sself->GetOperationType(); } -extern "C" void vtk_implicit_boolean_set_operation_type_to_union(vtkNew sself) { sself->SetOperationTypeToUnion(); } -extern "C" void vtk_implicit_boolean_set_operation_type_to_intersection(vtkNew sself) { sself->SetOperationTypeToIntersection(); } -extern "C" void vtk_implicit_boolean_set_operation_type_to_difference(vtkNew sself) { sself->SetOperationTypeToDifference(); } -extern "C" void vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(vtkNew sself) { sself->SetOperationTypeToUnionOfMagnitudes(); } -extern "C" const char* vtk_implicit_boolean_get_operation_type_as_string(vtkNew sself) { return sself->GetOperationTypeAsString(); } -extern "C" vtkNew < vtkImplicitDataSet > vtkImplicitDataSet_new () {return vtkNew < vtkImplicitDataSet > () ;} -extern "C" void vtkImplicitDataSet_destructor (vtkNew < vtkImplicitDataSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitDataSet_get_ptr (vtkNew < vtkImplicitDataSet > sself) {return sself . GetPointer () ;} -extern "C" unsigned long vtk_implicit_data_set_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" double vtk_implicit_data_set_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_implicit_data_set_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } -extern "C" void vtk_implicit_data_set_set_out_value(vtkNew sself, double _arg) { sself->SetOutValue(_arg); } -extern "C" double vtk_implicit_data_set_get_out_value(vtkNew sself) { return sself->GetOutValue(); } -extern "C" void vtk_implicit_data_set_set_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetOutGradient(_arg1, _arg2, _arg3); } -extern "C" void vtk_implicit_data_set_set_out_gradient(vtkNew sself, const double _arg) { sself->SetOutGradient(_arg); } -extern "C" double* vtk_implicit_data_set_get_out_gradient(vtkNew sself) { return sself->GetOutGradient(); } -extern "C" void vtk_implicit_data_set_get_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetOutGradient(_arg1, _arg2, _arg3); } -extern "C" void vtk_implicit_data_set_get_out_gradient(vtkNew sself, double _arg) { sself->GetOutGradient(_arg); } -extern "C" vtkNew < vtkImplicitFunctionCollection > vtkImplicitFunctionCollection_new () {return vtkNew < vtkImplicitFunctionCollection > () ;} -extern "C" void vtkImplicitFunctionCollection_destructor (vtkNew < vtkImplicitFunctionCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitFunctionCollection_get_ptr (vtkNew < vtkImplicitFunctionCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImplicitHalo > vtkImplicitHalo_new () {return vtkNew < vtkImplicitHalo > () ;} -extern "C" void vtkImplicitHalo_destructor (vtkNew < vtkImplicitHalo > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitHalo_get_ptr (vtkNew < vtkImplicitHalo > sself) {return sself . GetPointer () ;} -extern "C" double vtk_implicit_halo_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_implicit_halo_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } -extern "C" void vtk_implicit_halo_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } -extern "C" double vtk_implicit_halo_get_radius(vtkNew sself) { return sself->GetRadius(); } -extern "C" void vtk_implicit_halo_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } -extern "C" void vtk_implicit_halo_set_center(vtkNew sself, const double _arg) { sself->SetCenter(_arg); } -extern "C" double* vtk_implicit_halo_get_center(vtkNew sself) { return sself->GetCenter(); } -extern "C" void vtk_implicit_halo_get_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetCenter(_arg1, _arg2, _arg3); } -extern "C" void vtk_implicit_halo_get_center(vtkNew sself, double _arg) { sself->GetCenter(_arg); } -extern "C" void vtk_implicit_halo_set_fade_out(vtkNew sself, double _arg) { sself->SetFadeOut(_arg); } -extern "C" double vtk_implicit_halo_get_fade_out(vtkNew sself) { return sself->GetFadeOut(); } -extern "C" vtkNew < vtkImplicitSelectionLoop > vtkImplicitSelectionLoop_new () {return vtkNew < vtkImplicitSelectionLoop > () ;} -extern "C" void vtkImplicitSelectionLoop_destructor (vtkNew < vtkImplicitSelectionLoop > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitSelectionLoop_get_ptr (vtkNew < vtkImplicitSelectionLoop > sself) {return sself . GetPointer () ;} -extern "C" double vtk_implicit_selection_loop_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_implicit_selection_loop_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } -extern "C" void vtk_implicit_selection_loop_set_automatic_normal_generation(vtkNew sself, int _arg) { sself->SetAutomaticNormalGeneration(_arg); } -extern "C" int vtk_implicit_selection_loop_get_automatic_normal_generation(vtkNew sself) { return sself->GetAutomaticNormalGeneration(); } -extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_on(vtkNew sself) { sself->AutomaticNormalGenerationOn(); } -extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_off(vtkNew sself) { sself->AutomaticNormalGenerationOff(); } -extern "C" void vtk_implicit_selection_loop_set_normal(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } -extern "C" void vtk_implicit_selection_loop_set_normal(vtkNew sself, const double _arg) { sself->SetNormal(_arg); } -extern "C" double* vtk_implicit_selection_loop_get_normal(vtkNew sself) { return sself->GetNormal(); } -extern "C" void vtk_implicit_selection_loop_get_normal(vtkNew sself, double data) { sself->GetNormal(data); } -extern "C" unsigned long vtk_implicit_selection_loop_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkImplicitSum > vtkImplicitSum_new () {return vtkNew < vtkImplicitSum > () ;} -extern "C" void vtkImplicitSum_destructor (vtkNew < vtkImplicitSum > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitSum_get_ptr (vtkNew < vtkImplicitSum > sself) {return sself . GetPointer () ;} -extern "C" double vtk_implicit_sum_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_implicit_sum_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } -extern "C" unsigned long vtk_implicit_sum_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_implicit_sum_remove_all_functions(vtkNew sself) { sself->RemoveAllFunctions(); } -extern "C" void vtk_implicit_sum_set_normalize_by_weight(vtkNew sself, int _arg) { sself->SetNormalizeByWeight(_arg); } -extern "C" int vtk_implicit_sum_get_normalize_by_weight(vtkNew sself) { return sself->GetNormalizeByWeight(); } -extern "C" void vtk_implicit_sum_normalize_by_weight_on(vtkNew sself) { sself->NormalizeByWeightOn(); } -extern "C" void vtk_implicit_sum_normalize_by_weight_off(vtkNew sself) { sself->NormalizeByWeightOff(); } -extern "C" vtkNew < vtkImplicitVolume > vtkImplicitVolume_new () {return vtkNew < vtkImplicitVolume > () ;} -extern "C" void vtkImplicitVolume_destructor (vtkNew < vtkImplicitVolume > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitVolume_get_ptr (vtkNew < vtkImplicitVolume > sself) {return sself . GetPointer () ;} -extern "C" unsigned long vtk_implicit_volume_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" double vtk_implicit_volume_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_implicit_volume_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } -extern "C" void vtk_implicit_volume_set_out_value(vtkNew sself, double _arg) { sself->SetOutValue(_arg); } -extern "C" double vtk_implicit_volume_get_out_value(vtkNew sself) { return sself->GetOutValue(); } -extern "C" void vtk_implicit_volume_set_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetOutGradient(_arg1, _arg2, _arg3); } -extern "C" void vtk_implicit_volume_set_out_gradient(vtkNew sself, const double _arg) { sself->SetOutGradient(_arg); } -extern "C" double* vtk_implicit_volume_get_out_gradient(vtkNew sself) { return sself->GetOutGradient(); } -extern "C" void vtk_implicit_volume_get_out_gradient(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetOutGradient(_arg1, _arg2, _arg3); } -extern "C" void vtk_implicit_volume_get_out_gradient(vtkNew sself, double _arg) { sself->GetOutGradient(_arg); } -extern "C" vtkNew < vtkImplicitWindowFunction > vtkImplicitWindowFunction_new () {return vtkNew < vtkImplicitWindowFunction > () ;} -extern "C" void vtkImplicitWindowFunction_destructor (vtkNew < vtkImplicitWindowFunction > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitWindowFunction_get_ptr (vtkNew < vtkImplicitWindowFunction > sself) {return sself . GetPointer () ;} -extern "C" double vtk_implicit_window_function_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_implicit_window_function_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } -extern "C" void vtk_implicit_window_function_set_window_range(vtkNew sself, double _arg1, double _arg2) { sself->SetWindowRange(_arg1, _arg2); } -extern "C" void vtk_implicit_window_function_set_window_range(vtkNew sself, const double _arg) { sself->SetWindowRange(_arg); } -extern "C" double* vtk_implicit_window_function_get_window_range(vtkNew sself) { return sself->GetWindowRange(); } -extern "C" void vtk_implicit_window_function_get_window_range(vtkNew sself, double data) { sself->GetWindowRange(data); } -extern "C" void vtk_implicit_window_function_set_window_values(vtkNew sself, double _arg1, double _arg2) { sself->SetWindowValues(_arg1, _arg2); } -extern "C" void vtk_implicit_window_function_set_window_values(vtkNew sself, const double _arg) { sself->SetWindowValues(_arg); } -extern "C" double* vtk_implicit_window_function_get_window_values(vtkNew sself) { return sself->GetWindowValues(); } -extern "C" void vtk_implicit_window_function_get_window_values(vtkNew sself, double data) { sself->GetWindowValues(data); } -extern "C" unsigned long vtk_implicit_window_function_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkInEdgeIterator > vtkInEdgeIterator_new () {return vtkNew < vtkInEdgeIterator > () ;} -extern "C" void vtkInEdgeIterator_destructor (vtkNew < vtkInEdgeIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkInEdgeIterator_get_ptr (vtkNew < vtkInEdgeIterator > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_in_edge_iterator_get_vertex(vtkNew sself) { return sself->GetVertex(); } -extern "C" bool vtk_in_edge_iterator_has_next(vtkNew sself) { return sself->HasNext(); } -extern "C" vtkNew < vtkIncrementalOctreeNode > vtkIncrementalOctreeNode_new () {return vtkNew < vtkIncrementalOctreeNode > () ;} -extern "C" void vtkIncrementalOctreeNode_destructor (vtkNew < vtkIncrementalOctreeNode > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIncrementalOctreeNode_get_ptr (vtkNew < vtkIncrementalOctreeNode > sself) {return sself . GetPointer () ;} -extern "C" int vtk_incremental_octree_node_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" void vtk_incremental_octree_node_delete_child_nodes(vtkNew sself) { sself->DeleteChildNodes(); } -extern "C" void vtk_incremental_octree_node_set_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetBounds(x1, x2, y1, y2, z1, z2); } -extern "C" void vtk_incremental_octree_node_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" double* vtk_incremental_octree_node_get_min_bounds(vtkNew sself) { return sself->GetMinBounds(); } -extern "C" void vtk_incremental_octree_node_get_min_bounds(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetMinBounds(_arg1, _arg2, _arg3); } -extern "C" void vtk_incremental_octree_node_get_min_bounds(vtkNew sself, double _arg) { sself->GetMinBounds(_arg); } -extern "C" double* vtk_incremental_octree_node_get_max_bounds(vtkNew sself) { return sself->GetMaxBounds(); } -extern "C" void vtk_incremental_octree_node_get_max_bounds(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetMaxBounds(_arg1, _arg2, _arg3); } -extern "C" void vtk_incremental_octree_node_get_max_bounds(vtkNew sself, double _arg) { sself->GetMaxBounds(_arg); } -extern "C" double* vtk_incremental_octree_node_get_min_data_bounds(vtkNew sself) { return sself->GetMinDataBounds(); } -extern "C" double* vtk_incremental_octree_node_get_max_data_bounds(vtkNew sself) { return sself->GetMaxDataBounds(); } -extern "C" int vtk_incremental_octree_node_is_leaf(vtkNew sself) { return sself->IsLeaf(); } -extern "C" int vtk_incremental_octree_node_get_child_index(vtkNew sself, const double point) { return sself->GetChildIndex(point); } -extern "C" int vtk_incremental_octree_node_contains_point(vtkNew sself, const double pnt) { return sself->ContainsPoint(pnt); } -extern "C" int vtk_incremental_octree_node_contains_point_by_data(vtkNew sself, const double pnt) { return sself->ContainsPointByData(pnt); } -extern "C" int vtk_incremental_octree_node_get_number_of_levels(vtkNew sself) { return sself->GetNumberOfLevels(); } -extern "C" int vtk_incremental_octree_node_get_id(vtkNew sself) { return sself->GetID(); } -extern "C" vtkNew < vtkIncrementalOctreePointLocator > vtkIncrementalOctreePointLocator_new () {return vtkNew < vtkIncrementalOctreePointLocator > () ;} -extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkNew < vtkIncrementalOctreePointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIncrementalOctreePointLocator_get_ptr (vtkNew < vtkIncrementalOctreePointLocator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_incremental_octree_point_locator_set_max_points_per_leaf(vtkNew sself, int _arg) { sself->SetMaxPointsPerLeaf(_arg); } -extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value(vtkNew sself) { return sself->GetMaxPointsPerLeafMinValue(); } -extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value(vtkNew sself) { return sself->GetMaxPointsPerLeafMaxValue(); } -extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf(vtkNew sself) { return sself->GetMaxPointsPerLeaf(); } -extern "C" void vtk_incremental_octree_point_locator_set_build_cubic_octree(vtkNew sself, int _arg) { sself->SetBuildCubicOctree(_arg); } -extern "C" int vtk_incremental_octree_point_locator_get_build_cubic_octree(vtkNew sself) { return sself->GetBuildCubicOctree(); } -extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_on(vtkNew sself) { sself->BuildCubicOctreeOn(); } -extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_off(vtkNew sself) { sself->BuildCubicOctreeOff(); } -extern "C" void vtk_incremental_octree_point_locator_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_incremental_octree_point_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } -extern "C" void vtk_incremental_octree_point_locator_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" double* vtk_incremental_octree_point_locator_get_bounds(vtkNew sself) { return sself->GetBounds(); } -extern "C" int vtk_incremental_octree_point_locator_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" int vtk_incremental_octree_point_locator_get_number_of_nodes(vtkNew sself) { return sself->GetNumberOfNodes(); } -extern "C" long long vtk_incremental_octree_point_locator_find_closest_inserted_point(vtkNew sself, const double x) { return sself->FindClosestInsertedPoint(x); } -extern "C" void vtk_incremental_octree_point_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z) { return sself->FindClosestPoint(x, y, z); } -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, const double x, double miniDist2) { return sself->FindClosestPoint(x, miniDist2); } -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z, double miniDist2) { return sself->FindClosestPoint(x, y, z, miniDist2); } -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } -extern "C" long long vtk_incremental_octree_point_locator_find_closest_point_within_squared_radius(vtkNew sself, double radius2, const double x, double dist2) { return sself->FindClosestPointWithinSquaredRadius(radius2, x, dist2); } -extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkNew sself, const double x) { return sself->IsInsertedPoint(x); } -extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkNew sself, double x, double y, double z) { return sself->IsInsertedPoint(x, y, z); } -extern "C" int vtk_incremental_octree_point_locator_insert_unique_point(vtkNew sself, const double point, long long pntId) { return sself->InsertUniquePoint(point, pntId); } -extern "C" void vtk_incremental_octree_point_locator_insert_point(vtkNew sself, long long ptId, const double x) { sself->InsertPoint(ptId, x); } -extern "C" long long vtk_incremental_octree_point_locator_insert_next_point(vtkNew sself, const double x) { return sself->InsertNextPoint(x); } -extern "C" void vtk_incremental_octree_point_locator_insert_point_without_checking(vtkNew sself, const double point, long long pntId, int insert) { sself->InsertPointWithoutChecking(point, pntId, insert); } -extern "C" int vtk_incremental_octree_point_locator_get_number_of_levels(vtkNew sself) { return sself->GetNumberOfLevels(); } -extern "C" vtkNew < vtkIterativeClosestPointTransform > vtkIterativeClosestPointTransform_new () {return vtkNew < vtkIterativeClosestPointTransform > () ;} -extern "C" void vtkIterativeClosestPointTransform_destructor (vtkNew < vtkIterativeClosestPointTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIterativeClosestPointTransform_get_ptr (vtkNew < vtkIterativeClosestPointTransform > sself) {return sself . GetPointer () ;} -extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_iterations(vtkNew sself, int _arg) { sself->SetMaximumNumberOfIterations(_arg); } -extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_iterations(vtkNew sself) { return sself->GetMaximumNumberOfIterations(); } -extern "C" int vtk_iterative_closest_point_transform_get_number_of_iterations(vtkNew sself) { return sself->GetNumberOfIterations(); } -extern "C" void vtk_iterative_closest_point_transform_set_check_mean_distance(vtkNew sself, int _arg) { sself->SetCheckMeanDistance(_arg); } -extern "C" int vtk_iterative_closest_point_transform_get_check_mean_distance(vtkNew sself) { return sself->GetCheckMeanDistance(); } -extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_on(vtkNew sself) { sself->CheckMeanDistanceOn(); } -extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_off(vtkNew sself) { sself->CheckMeanDistanceOff(); } -extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode(vtkNew sself, int _arg) { sself->SetMeanDistanceMode(_arg); } -extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value(vtkNew sself) { return sself->GetMeanDistanceModeMinValue(); } -extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value(vtkNew sself) { return sself->GetMeanDistanceModeMaxValue(); } -extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode(vtkNew sself) { return sself->GetMeanDistanceMode(); } -extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms(vtkNew sself) { sself->SetMeanDistanceModeToRMS(); } -extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value(vtkNew sself) { sself->SetMeanDistanceModeToAbsoluteValue(); } -extern "C" const char* vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string(vtkNew sself) { return sself->GetMeanDistanceModeAsString(); } -extern "C" void vtk_iterative_closest_point_transform_set_maximum_mean_distance(vtkNew sself, double _arg) { sself->SetMaximumMeanDistance(_arg); } -extern "C" double vtk_iterative_closest_point_transform_get_maximum_mean_distance(vtkNew sself) { return sself->GetMaximumMeanDistance(); } -extern "C" double vtk_iterative_closest_point_transform_get_mean_distance(vtkNew sself) { return sself->GetMeanDistance(); } -extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks(vtkNew sself, int _arg) { sself->SetMaximumNumberOfLandmarks(_arg); } -extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks(vtkNew sself) { return sself->GetMaximumNumberOfLandmarks(); } -extern "C" void vtk_iterative_closest_point_transform_set_start_by_matching_centroids(vtkNew sself, int _arg) { sself->SetStartByMatchingCentroids(_arg); } -extern "C" int vtk_iterative_closest_point_transform_get_start_by_matching_centroids(vtkNew sself) { return sself->GetStartByMatchingCentroids(); } -extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_on(vtkNew sself) { sself->StartByMatchingCentroidsOn(); } -extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_off(vtkNew sself) { sself->StartByMatchingCentroidsOff(); } -extern "C" void vtk_iterative_closest_point_transform_inverse(vtkNew sself) { sself->Inverse(); } -extern "C" vtkNew < vtkKdNode > vtkKdNode_new () {return vtkNew < vtkKdNode > () ;} -extern "C" void vtkKdNode_destructor (vtkNew < vtkKdNode > sself) {sself . Reset () ; return ;} -extern "C" void * vtkKdNode_get_ptr (vtkNew < vtkKdNode > sself) {return sself . GetPointer () ;} -extern "C" void vtk_kd_node_set_dim(vtkNew sself, int _arg) { sself->SetDim(_arg); } -extern "C" int vtk_kd_node_get_dim(vtkNew sself) { return sself->GetDim(); } -extern "C" double vtk_kd_node_get_division_position(vtkNew sself) { return sself->GetDivisionPosition(); } -extern "C" void vtk_kd_node_set_number_of_points(vtkNew sself, int _arg) { sself->SetNumberOfPoints(_arg); } -extern "C" int vtk_kd_node_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" void vtk_kd_node_set_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetBounds(x1, x2, y1, y2, z1, z2); } -extern "C" void vtk_kd_node_set_bounds(vtkNew sself, const double b) { sself->SetBounds(b); } -extern "C" void vtk_kd_node_get_bounds(vtkNew sself, double b) { sself->GetBounds(b); } -extern "C" void vtk_kd_node_set_data_bounds(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetDataBounds(x1, x2, y1, y2, z1, z2); } -extern "C" void vtk_kd_node_get_data_bounds(vtkNew sself, double b) { sself->GetDataBounds(b); } -extern "C" void vtk_kd_node_set_data_bounds(vtkNew sself, float v) { sself->SetDataBounds(v); } -extern "C" double* vtk_kd_node_get_min_bounds(vtkNew sself) { return sself->GetMinBounds(); } -extern "C" double* vtk_kd_node_get_max_bounds(vtkNew sself) { return sself->GetMaxBounds(); } -extern "C" void vtk_kd_node_set_min_bounds(vtkNew sself, const double mb) { sself->SetMinBounds(mb); } -extern "C" void vtk_kd_node_set_max_bounds(vtkNew sself, const double mb) { sself->SetMaxBounds(mb); } -extern "C" double* vtk_kd_node_get_min_data_bounds(vtkNew sself) { return sself->GetMinDataBounds(); } -extern "C" double* vtk_kd_node_get_max_data_bounds(vtkNew sself) { return sself->GetMaxDataBounds(); } -extern "C" void vtk_kd_node_set_min_data_bounds(vtkNew sself, const double mb) { sself->SetMinDataBounds(mb); } -extern "C" void vtk_kd_node_set_max_data_bounds(vtkNew sself, const double mb) { sself->SetMaxDataBounds(mb); } -extern "C" void vtk_kd_node_set_id(vtkNew sself, int _arg) { sself->SetID(_arg); } -extern "C" int vtk_kd_node_get_id(vtkNew sself) { return sself->GetID(); } -extern "C" int vtk_kd_node_get_min_id(vtkNew sself) { return sself->GetMinID(); } -extern "C" int vtk_kd_node_get_max_id(vtkNew sself) { return sself->GetMaxID(); } -extern "C" void vtk_kd_node_set_min_id(vtkNew sself, int _arg) { sself->SetMinID(_arg); } -extern "C" void vtk_kd_node_set_max_id(vtkNew sself, int _arg) { sself->SetMaxID(_arg); } -extern "C" void vtk_kd_node_delete_child_nodes(vtkNew sself) { sself->DeleteChildNodes(); } -extern "C" int vtk_kd_node_intersects_box(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds) { return sself->IntersectsBox(x1, x2, y1, y2, z1, z2, useDataBounds); } -extern "C" int vtk_kd_node_intersects_sphere_2(vtkNew sself, double x, double y, double z, double rSquared, int useDataBounds) { return sself->IntersectsSphere2(x, y, z, rSquared, useDataBounds); } -extern "C" int vtk_kd_node_contains_box(vtkNew sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds) { return sself->ContainsBox(x1, x2, y1, y2, z1, z2, useDataBounds); } -extern "C" int vtk_kd_node_contains_point(vtkNew sself, double x, double y, double z, int useDataBounds) { return sself->ContainsPoint(x, y, z, useDataBounds); } -extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkNew sself, double x, double y, double z, int useDataBounds) { return sself->GetDistance2ToBoundary(x, y, z, useDataBounds); } -extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkNew sself, double x, double y, double z, double boundaryPt, int useDataBounds) { return sself->GetDistance2ToBoundary(x, y, z, boundaryPt, useDataBounds); } -extern "C" double vtk_kd_node_get_distance_2_to_inner_boundary(vtkNew sself, double x, double y, double z) { return sself->GetDistance2ToInnerBoundary(x, y, z); } -extern "C" void vtk_kd_node_print_node(vtkNew sself, int depth) { sself->PrintNode(depth); } -extern "C" void vtk_kd_node_print_verbose_node(vtkNew sself, int depth) { sself->PrintVerboseNode(depth); } -extern "C" vtkNew < vtkKdTree > vtkKdTree_new () {return vtkNew < vtkKdTree > () ;} -extern "C" void vtkKdTree_destructor (vtkNew < vtkKdTree > sself) {sself . Reset () ; return ;} -extern "C" void * vtkKdTree_get_ptr (vtkNew < vtkKdTree > sself) {return sself . GetPointer () ;} -extern "C" void vtk_kd_tree_timing_on(vtkNew sself) { sself->TimingOn(); } -extern "C" void vtk_kd_tree_timing_off(vtkNew sself) { sself->TimingOff(); } -extern "C" void vtk_kd_tree_set_timing(vtkNew sself, int _arg) { sself->SetTiming(_arg); } -extern "C" int vtk_kd_tree_get_timing(vtkNew sself) { return sself->GetTiming(); } -extern "C" void vtk_kd_tree_set_min_cells(vtkNew sself, int _arg) { sself->SetMinCells(_arg); } -extern "C" int vtk_kd_tree_get_min_cells(vtkNew sself) { return sself->GetMinCells(); } -extern "C" int vtk_kd_tree_get_number_of_regions_or_less(vtkNew sself) { return sself->GetNumberOfRegionsOrLess(); } -extern "C" void vtk_kd_tree_set_number_of_regions_or_less(vtkNew sself, int _arg) { sself->SetNumberOfRegionsOrLess(_arg); } -extern "C" int vtk_kd_tree_get_number_of_regions_or_more(vtkNew sself) { return sself->GetNumberOfRegionsOrMore(); } -extern "C" void vtk_kd_tree_set_number_of_regions_or_more(vtkNew sself, int _arg) { sself->SetNumberOfRegionsOrMore(_arg); } -extern "C" double vtk_kd_tree_get_fudge_factor(vtkNew sself) { return sself->GetFudgeFactor(); } -extern "C" void vtk_kd_tree_set_fudge_factor(vtkNew sself, double _arg) { sself->SetFudgeFactor(_arg); } -extern "C" void vtk_kd_tree_omit_x_partitioning(vtkNew sself) { sself->OmitXPartitioning(); } -extern "C" void vtk_kd_tree_omit_y_partitioning(vtkNew sself) { sself->OmitYPartitioning(); } -extern "C" void vtk_kd_tree_omit_z_partitioning(vtkNew sself) { sself->OmitZPartitioning(); } -extern "C" void vtk_kd_tree_omit_xy_partitioning(vtkNew sself) { sself->OmitXYPartitioning(); } -extern "C" void vtk_kd_tree_omit_yz_partitioning(vtkNew sself) { sself->OmitYZPartitioning(); } -extern "C" void vtk_kd_tree_omit_zx_partitioning(vtkNew sself) { sself->OmitZXPartitioning(); } -extern "C" void vtk_kd_tree_omit_no_partitioning(vtkNew sself) { sself->OmitNoPartitioning(); } -extern "C" void vtk_kd_tree_remove_data_set(vtkNew sself, int index) { sself->RemoveDataSet(index); } -extern "C" void vtk_kd_tree_remove_all_data_sets(vtkNew sself) { sself->RemoveAllDataSets(); } -extern "C" int vtk_kd_tree_get_number_of_data_sets(vtkNew sself) { return sself->GetNumberOfDataSets(); } -extern "C" void vtk_kd_tree_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" void vtk_kd_tree_set_new_bounds(vtkNew sself, double bounds) { sself->SetNewBounds(bounds); } -extern "C" int vtk_kd_tree_get_number_of_regions(vtkNew sself) { return sself->GetNumberOfRegions(); } -extern "C" void vtk_kd_tree_get_region_bounds(vtkNew sself, int regionID, double bounds) { sself->GetRegionBounds(regionID, bounds); } -extern "C" void vtk_kd_tree_get_region_data_bounds(vtkNew sself, int regionID, double bounds) { sself->GetRegionDataBounds(regionID, bounds); } -extern "C" void vtk_kd_tree_print_tree(vtkNew sself) { sself->PrintTree(); } -extern "C" void vtk_kd_tree_print_verbose_tree(vtkNew sself) { sself->PrintVerboseTree(); } -extern "C" void vtk_kd_tree_print_region(vtkNew sself, int id) { sself->PrintRegion(id); } -extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself, int dataSetIndex, int regionReqList, int reqListSize) { sself->CreateCellLists(dataSetIndex, regionReqList, reqListSize); } -extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself, int regionReqList, int listSize) { sself->CreateCellLists(regionReqList, listSize); } -extern "C" void vtk_kd_tree_create_cell_lists(vtkNew sself) { sself->CreateCellLists(); } -extern "C" void vtk_kd_tree_set_include_region_boundary_cells(vtkNew sself, int _arg) { sself->SetIncludeRegionBoundaryCells(_arg); } -extern "C" int vtk_kd_tree_get_include_region_boundary_cells(vtkNew sself) { return sself->GetIncludeRegionBoundaryCells(); } -extern "C" void vtk_kd_tree_include_region_boundary_cells_on(vtkNew sself) { sself->IncludeRegionBoundaryCellsOn(); } -extern "C" void vtk_kd_tree_include_region_boundary_cells_off(vtkNew sself) { sself->IncludeRegionBoundaryCellsOff(); } -extern "C" void vtk_kd_tree_delete_cell_lists(vtkNew sself) { sself->DeleteCellLists(); } -extern "C" int vtk_kd_tree_get_region_containing_cell(vtkNew sself, int set, long long cellID) { return sself->GetRegionContainingCell(set, cellID); } -extern "C" int vtk_kd_tree_get_region_containing_cell(vtkNew sself, long long cellID) { return sself->GetRegionContainingCell(cellID); } -extern "C" int* vtk_kd_tree_all_get_region_containing_cell(vtkNew sself) { return sself->AllGetRegionContainingCell(); } -extern "C" int vtk_kd_tree_get_region_containing_point(vtkNew sself, double x, double y, double z) { return sself->GetRegionContainingPoint(x, y, z); } -extern "C" void vtk_kd_tree_build_locator(vtkNew sself) { sself->BuildLocator(); } -extern "C" long long vtk_kd_tree_find_point(vtkNew sself, double x) { return sself->FindPoint(x); } -extern "C" long long vtk_kd_tree_find_point(vtkNew sself, double x, double y, double z) { return sself->FindPoint(x, y, z); } -extern "C" long long vtk_kd_tree_find_closest_point(vtkNew sself, double x, double dist2) { return sself->FindClosestPoint(x, dist2); } -extern "C" long long vtk_kd_tree_find_closest_point(vtkNew sself, double x, double y, double z, double dist2) { return sself->FindClosestPoint(x, y, z, dist2); } -extern "C" long long vtk_kd_tree_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } -extern "C" long long vtk_kd_tree_find_closest_point_in_region(vtkNew sself, int regionId, double x, double dist2) { return sself->FindClosestPointInRegion(regionId, x, dist2); } -extern "C" long long vtk_kd_tree_find_closest_point_in_region(vtkNew sself, int regionId, double x, double y, double z, double dist2) { return sself->FindClosestPointInRegion(regionId, x, y, z, dist2); } -extern "C" void vtk_kd_tree_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } -extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_on(vtkNew sself) { sself->GenerateRepresentationUsingDataBoundsOn(); } -extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_off(vtkNew sself) { sself->GenerateRepresentationUsingDataBoundsOff(); } -extern "C" void vtk_kd_tree_set_generate_representation_using_data_bounds(vtkNew sself, int _arg) { sself->SetGenerateRepresentationUsingDataBounds(_arg); } -extern "C" int vtk_kd_tree_get_generate_representation_using_data_bounds(vtkNew sself) { return sself->GetGenerateRepresentationUsingDataBounds(); } -extern "C" int vtk_kd_tree_new_geometry(vtkNew sself) { return sself->NewGeometry(); } -extern "C" void vtk_kd_tree_invalidate_geometry(vtkNew sself) { sself->InvalidateGeometry(); } -extern "C" vtkNew < vtkKdTreePointLocator > vtkKdTreePointLocator_new () {return vtkNew < vtkKdTreePointLocator > () ;} -extern "C" void vtkKdTreePointLocator_destructor (vtkNew < vtkKdTreePointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkKdTreePointLocator_get_ptr (vtkNew < vtkKdTreePointLocator > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_kd_tree_point_locator_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } -extern "C" long long vtk_kd_tree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } -extern "C" void vtk_kd_tree_point_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } -extern "C" void vtk_kd_tree_point_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } -extern "C" vtkNew < vtkLagrangeCurve > vtkLagrangeCurve_new () {return vtkNew < vtkLagrangeCurve > () ;} -extern "C" void vtkLagrangeCurve_destructor (vtkNew < vtkLagrangeCurve > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeCurve_get_ptr (vtkNew < vtkLagrangeCurve > sself) {return sself . GetPointer () ;} -extern "C" int vtk_lagrange_curve_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_lagrange_curve_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkLagrangeHexahedron > vtkLagrangeHexahedron_new () {return vtkNew < vtkLagrangeHexahedron > () ;} -extern "C" void vtkLagrangeHexahedron_destructor (vtkNew < vtkLagrangeHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeHexahedron_get_ptr (vtkNew < vtkLagrangeHexahedron > sself) {return sself . GetPointer () ;} -extern "C" int vtk_lagrange_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_lagrange_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkLagrangeInterpolation > vtkLagrangeInterpolation_new () {return vtkNew < vtkLagrangeInterpolation > () ;} -extern "C" void vtkLagrangeInterpolation_destructor (vtkNew < vtkLagrangeInterpolation > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeInterpolation_get_ptr (vtkNew < vtkLagrangeInterpolation > sself) {return sself . GetPointer () ;} -extern "C" void vtk_lagrange_interpolation_evaluate_shape_functions(vtkNew sself, const int order, const double pcoord, double shape) { sself->EvaluateShapeFunctions(order, pcoord, shape); } -extern "C" void vtk_lagrange_interpolation_evaluate_shape_and_gradient(vtkNew sself, const int order, const double pcoord, double shape, double grad) { sself->EvaluateShapeAndGradient(order, pcoord, shape, grad); } -extern "C" int vtk_lagrange_interpolation_tensor_1_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor1ShapeFunctions(order, pcoords, shape); } -extern "C" int vtk_lagrange_interpolation_tensor_1_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor1ShapeDerivatives(order, pcoords, derivs); } -extern "C" int vtk_lagrange_interpolation_tensor_2_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor2ShapeFunctions(order, pcoords, shape); } -extern "C" int vtk_lagrange_interpolation_tensor_2_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor2ShapeDerivatives(order, pcoords, derivs); } -extern "C" int vtk_lagrange_interpolation_tensor_3_shape_functions(vtkNew sself, const int order, const double pcoords, double shape) { return sself->Tensor3ShapeFunctions(order, pcoords, shape); } -extern "C" int vtk_lagrange_interpolation_tensor_3_shape_derivatives(vtkNew sself, const int order, const double pcoords, double derivs) { return sself->Tensor3ShapeDerivatives(order, pcoords, derivs); } -extern "C" void vtk_lagrange_interpolation_wedge_shape_functions(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double shape) { sself->WedgeShapeFunctions(order, numberOfPoints, pcoords, shape); } -extern "C" void vtk_lagrange_interpolation_wedge_shape_derivatives(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double derivs) { sself->WedgeShapeDerivatives(order, numberOfPoints, pcoords, derivs); } -extern "C" void vtk_lagrange_interpolation_wedge_evaluate(vtkNew sself, const int order, const long long numberOfPoints, const double pcoords, double fieldVals, int fieldDim, double fieldAtPCoords) { sself->WedgeEvaluate(order, numberOfPoints, pcoords, fieldVals, fieldDim, fieldAtPCoords); } -extern "C" vtkNew < vtkLagrangeQuadrilateral > vtkLagrangeQuadrilateral_new () {return vtkNew < vtkLagrangeQuadrilateral > () ;} -extern "C" void vtkLagrangeQuadrilateral_destructor (vtkNew < vtkLagrangeQuadrilateral > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeQuadrilateral_get_ptr (vtkNew < vtkLagrangeQuadrilateral > sself) {return sself . GetPointer () ;} -extern "C" int vtk_lagrange_quadrilateral_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_lagrange_quadrilateral_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkLagrangeTetra > vtkLagrangeTetra_new () {return vtkNew < vtkLagrangeTetra > () ;} -extern "C" void vtkLagrangeTetra_destructor (vtkNew < vtkLagrangeTetra > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeTetra_get_ptr (vtkNew < vtkLagrangeTetra > sself) {return sself . GetPointer () ;} -extern "C" int vtk_lagrange_tetra_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_lagrange_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkLagrangeTriangle > vtkLagrangeTriangle_new () {return vtkNew < vtkLagrangeTriangle > () ;} -extern "C" void vtkLagrangeTriangle_destructor (vtkNew < vtkLagrangeTriangle > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeTriangle_get_ptr (vtkNew < vtkLagrangeTriangle > sself) {return sself . GetPointer () ;} -extern "C" int vtk_lagrange_triangle_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_lagrange_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkLagrangeWedge > vtkLagrangeWedge_new () {return vtkNew < vtkLagrangeWedge > () ;} -extern "C" void vtkLagrangeWedge_destructor (vtkNew < vtkLagrangeWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeWedge_get_ptr (vtkNew < vtkLagrangeWedge > sself) {return sself . GetPointer () ;} -extern "C" int vtk_lagrange_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" void vtk_lagrange_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" vtkNew < vtkLine > vtkLine_new () {return vtkNew < vtkLine > () ;} -extern "C" void vtkLine_destructor (vtkNew < vtkLine > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLine_get_ptr (vtkNew < vtkLine > sself) {return sself . GetPointer () ;} -extern "C" int vtk_line_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_line_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_line_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_line_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_line_inflate(vtkNew sself, double dist) { return sself->Inflate(dist); } -extern "C" int vtk_line_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" int vtk_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_line_intersection(vtkNew sself, const double p1, const double p2, const double x1, const double x2, double u, double v, const double tolerance, int toleranceType) { return sself->Intersection(p1, p2, x1, x2, u, v, tolerance, toleranceType); } -extern "C" int vtk_line_intersection_3_d(vtkNew sself, double p1, double p2, double x1, double x2, double u, double v, const double tolerance) { return sself->Intersection3D(p1, p2, x1, x2, u, v, tolerance); } -extern "C" double vtk_line_distance_to_line(vtkNew sself, const double x, const double p1, const double p2, double t, double closestPoint) { return sself->DistanceToLine(x, p1, p2, t, closestPoint); } -extern "C" double vtk_line_distance_to_line(vtkNew sself, const double x, const double p1, const double p2) { return sself->DistanceToLine(x, p1, p2); } -extern "C" double vtk_line_distance_between_lines(vtkNew sself, double l0, double l1, double m0, double m1, double closestPt1, double closestPt2, double t1, double t2) { return sself->DistanceBetweenLines(l0, l1, m0, m1, closestPt1, closestPt2, t1, t2); } -extern "C" double vtk_line_distance_between_line_segments(vtkNew sself, double l0, double l1, double m0, double m1, double closestPt1, double closestPt2, double t1, double t2) { return sself->DistanceBetweenLineSegments(l0, l1, m0, m1, closestPt1, closestPt2, t1, t2); } -extern "C" void vtk_line_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_line_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_line_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_line_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" vtkNew < vtkMeanValueCoordinatesInterpolator > vtkMeanValueCoordinatesInterpolator_new () {return vtkNew < vtkMeanValueCoordinatesInterpolator > () ;} -extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMeanValueCoordinatesInterpolator_get_ptr (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMergePoints > vtkMergePoints_new () {return vtkNew < vtkMergePoints > () ;} -extern "C" void vtkMergePoints_destructor (vtkNew < vtkMergePoints > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMergePoints_get_ptr (vtkNew < vtkMergePoints > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_merge_points_is_inserted_point(vtkNew sself, const double x) { return sself->IsInsertedPoint(x); } -extern "C" int vtk_merge_points_insert_unique_point(vtkNew sself, const double x, long long ptId) { return sself->InsertUniquePoint(x, ptId); } -extern "C" vtkNew < vtkMolecule > vtkMolecule_new () {return vtkNew < vtkMolecule > () ;} -extern "C" void vtkMolecule_destructor (vtkNew < vtkMolecule > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMolecule_get_ptr (vtkNew < vtkMolecule > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_molecule_get_number_of_atoms(vtkNew sself) { return sself->GetNumberOfAtoms(); } -extern "C" long long vtk_molecule_get_number_of_bonds(vtkNew sself) { return sself->GetNumberOfBonds(); } -extern "C" unsigned short vtk_molecule_get_atom_atomic_number(vtkNew sself, long long atomId) { return sself->GetAtomAtomicNumber(atomId); } -extern "C" void vtk_molecule_set_atom_atomic_number(vtkNew sself, long long atomId, unsigned short atomicNum) { sself->SetAtomAtomicNumber(atomId, atomicNum); } -extern "C" void vtk_molecule_set_atom_position(vtkNew sself, long long atomId, double x, double y, double z) { sself->SetAtomPosition(atomId, x, y, z); } -extern "C" void vtk_molecule_set_atom_position(vtkNew sself, long long atomId, double pos) { sself->SetAtomPosition(atomId, pos); } -extern "C" void vtk_molecule_get_atom_position(vtkNew sself, long long atomId, float pos) { sself->GetAtomPosition(atomId, pos); } -extern "C" void vtk_molecule_get_atom_position(vtkNew sself, long long atomId, double pos) { sself->GetAtomPosition(atomId, pos); } -extern "C" void vtk_molecule_set_bond_order(vtkNew sself, long long bondId, unsigned short order) { sself->SetBondOrder(bondId, order); } -extern "C" unsigned short vtk_molecule_get_bond_order(vtkNew sself, long long bondId) { return sself->GetBondOrder(bondId); } -extern "C" double vtk_molecule_get_bond_length(vtkNew sself, long long bondId) { return sself->GetBondLength(bondId); } -extern "C" bool vtk_molecule_has_lattice(vtkNew sself) { return sself->HasLattice(); } -extern "C" void vtk_molecule_clear_lattice(vtkNew sself) { sself->ClearLattice(); } -extern "C" void vtk_molecule_allocate_atom_ghost_array(vtkNew sself) { sself->AllocateAtomGhostArray(); } -extern "C" void vtk_molecule_allocate_bond_ghost_array(vtkNew sself) { sself->AllocateBondGhostArray(); } -extern "C" long long vtk_molecule_get_bond_id(vtkNew sself, long long a, long long b) { return sself->GetBondId(a, b); } -extern "C" void vtk_molecule_set_atomic_number_array_name(vtkNew sself, const char _arg) { sself->SetAtomicNumberArrayName(_arg); } -extern "C" char* vtk_molecule_get_atomic_number_array_name(vtkNew sself) { return sself->GetAtomicNumberArrayName(); } -extern "C" void vtk_molecule_set_bond_orders_array_name(vtkNew sself, const char _arg) { sself->SetBondOrdersArrayName(_arg); } -extern "C" char* vtk_molecule_get_bond_orders_array_name(vtkNew sself) { return sself->GetBondOrdersArrayName(); } -extern "C" vtkNew < vtkMultiBlockDataSet > vtkMultiBlockDataSet_new () {return vtkNew < vtkMultiBlockDataSet > () ;} -extern "C" void vtkMultiBlockDataSet_destructor (vtkNew < vtkMultiBlockDataSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMultiBlockDataSet_get_ptr (vtkNew < vtkMultiBlockDataSet > sself) {return sself . GetPointer () ;} -extern "C" void vtk_multi_block_data_set_set_number_of_blocks(vtkNew sself, unsigned int numBlocks) { sself->SetNumberOfBlocks(numBlocks); } -extern "C" unsigned int vtk_multi_block_data_set_get_number_of_blocks(vtkNew sself) { return sself->GetNumberOfBlocks(); } -extern "C" void vtk_multi_block_data_set_remove_block(vtkNew sself, unsigned int blockno) { sself->RemoveBlock(blockno); } -extern "C" int vtk_multi_block_data_set_has_meta_data(vtkNew sself, unsigned int blockno) { return sself->HasMetaData(blockno); } -extern "C" vtkNew < vtkMultiPieceDataSet > vtkMultiPieceDataSet_new () {return vtkNew < vtkMultiPieceDataSet > () ;} -extern "C" void vtkMultiPieceDataSet_destructor (vtkNew < vtkMultiPieceDataSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMultiPieceDataSet_get_ptr (vtkNew < vtkMultiPieceDataSet > sself) {return sself . GetPointer () ;} -extern "C" void vtk_multi_piece_data_set_set_number_of_pieces(vtkNew sself, unsigned int numpieces) { sself->SetNumberOfPieces(numpieces); } -extern "C" unsigned int vtk_multi_piece_data_set_get_number_of_pieces(vtkNew sself) { return sself->GetNumberOfPieces(); } -extern "C" vtkNew < vtkMutableDirectedGraph > vtkMutableDirectedGraph_new () {return vtkNew < vtkMutableDirectedGraph > () ;} -extern "C" void vtkMutableDirectedGraph_destructor (vtkNew < vtkMutableDirectedGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMutableDirectedGraph_get_ptr (vtkNew < vtkMutableDirectedGraph > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_mutable_directed_graph_set_number_of_vertices(vtkNew sself, long long numVerts) { return sself->SetNumberOfVertices(numVerts); } -extern "C" long long vtk_mutable_directed_graph_add_vertex(vtkNew sself) { return sself->AddVertex(); } -extern "C" void vtk_mutable_directed_graph_lazy_add_vertex(vtkNew sself) { sself->LazyAddVertex(); } -extern "C" long long vtk_mutable_directed_graph_add_child(vtkNew sself, long long parent) { return sself->AddChild(parent); } -extern "C" void vtk_mutable_directed_graph_remove_vertex(vtkNew sself, long long v) { sself->RemoveVertex(v); } -extern "C" void vtk_mutable_directed_graph_remove_edge(vtkNew sself, long long e) { sself->RemoveEdge(e); } -extern "C" vtkNew < vtkMutableUndirectedGraph > vtkMutableUndirectedGraph_new () {return vtkNew < vtkMutableUndirectedGraph > () ;} -extern "C" void vtkMutableUndirectedGraph_destructor (vtkNew < vtkMutableUndirectedGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMutableUndirectedGraph_get_ptr (vtkNew < vtkMutableUndirectedGraph > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_mutable_undirected_graph_set_number_of_vertices(vtkNew sself, long long numVerts) { return sself->SetNumberOfVertices(numVerts); } -extern "C" long long vtk_mutable_undirected_graph_add_vertex(vtkNew sself) { return sself->AddVertex(); } -extern "C" void vtk_mutable_undirected_graph_lazy_add_vertex(vtkNew sself) { sself->LazyAddVertex(); } -extern "C" void vtk_mutable_undirected_graph_lazy_add_edge(vtkNew sself, long long u, long long v) { sself->LazyAddEdge(u, v); } -extern "C" void vtk_mutable_undirected_graph_remove_vertex(vtkNew sself, long long v) { sself->RemoveVertex(v); } -extern "C" void vtk_mutable_undirected_graph_remove_edge(vtkNew sself, long long e) { sself->RemoveEdge(e); } -extern "C" vtkNew < vtkNonMergingPointLocator > vtkNonMergingPointLocator_new () {return vtkNew < vtkNonMergingPointLocator > () ;} -extern "C" void vtkNonMergingPointLocator_destructor (vtkNew < vtkNonMergingPointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkNonMergingPointLocator_get_ptr (vtkNew < vtkNonMergingPointLocator > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNew sself, const double p0) { return sself->IsInsertedPoint(p0); } -extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNew sself, double p0, double p1, double p2) { return sself->IsInsertedPoint(p0, p1, p2); } -extern "C" int vtk_non_merging_point_locator_insert_unique_point(vtkNew sself, const double x, long long ptId) { return sself->InsertUniquePoint(x, ptId); } -extern "C" vtkNew < vtkNonOverlappingAMR > vtkNonOverlappingAMR_new () {return vtkNew < vtkNonOverlappingAMR > () ;} -extern "C" void vtkNonOverlappingAMR_destructor (vtkNew < vtkNonOverlappingAMR > sself) {sself . Reset () ; return ;} -extern "C" void * vtkNonOverlappingAMR_get_ptr (vtkNew < vtkNonOverlappingAMR > sself) {return sself . GetPointer () ;} -extern "C" int vtk_non_overlapping_amr_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" vtkNew < vtkOctreePointLocator > vtkOctreePointLocator_new () {return vtkNew < vtkOctreePointLocator > () ;} -extern "C" void vtkOctreePointLocator_destructor (vtkNew < vtkOctreePointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOctreePointLocator_get_ptr (vtkNew < vtkOctreePointLocator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_octree_point_locator_set_maximum_points_per_region(vtkNew sself, int _arg) { sself->SetMaximumPointsPerRegion(_arg); } -extern "C" int vtk_octree_point_locator_get_maximum_points_per_region(vtkNew sself) { return sself->GetMaximumPointsPerRegion(); } -extern "C" void vtk_octree_point_locator_set_create_cubic_octants(vtkNew sself, int _arg) { sself->SetCreateCubicOctants(_arg); } -extern "C" int vtk_octree_point_locator_get_create_cubic_octants(vtkNew sself) { return sself->GetCreateCubicOctants(); } -extern "C" double vtk_octree_point_locator_get_fudge_factor(vtkNew sself) { return sself->GetFudgeFactor(); } -extern "C" void vtk_octree_point_locator_set_fudge_factor(vtkNew sself, double _arg) { sself->SetFudgeFactor(_arg); } -extern "C" double* vtk_octree_point_locator_get_bounds(vtkNew sself) { return sself->GetBounds(); } -extern "C" void vtk_octree_point_locator_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" int vtk_octree_point_locator_get_number_of_leaf_nodes(vtkNew sself) { return sself->GetNumberOfLeafNodes(); } -extern "C" void vtk_octree_point_locator_get_region_bounds(vtkNew sself, int regionID, double bounds) { sself->GetRegionBounds(regionID, bounds); } -extern "C" void vtk_octree_point_locator_get_region_data_bounds(vtkNew sself, int leafNodeID, double bounds) { sself->GetRegionDataBounds(leafNodeID, bounds); } -extern "C" int vtk_octree_point_locator_get_region_containing_point(vtkNew sself, double x, double y, double z) { return sself->GetRegionContainingPoint(x, y, z); } -extern "C" void vtk_octree_point_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } -extern "C" long long vtk_octree_point_locator_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } -extern "C" long long vtk_octree_point_locator_find_closest_point(vtkNew sself, double x, double y, double z, double dist2) { return sself->FindClosestPoint(x, y, z, dist2); } -extern "C" long long vtk_octree_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } -extern "C" long long vtk_octree_point_locator_find_closest_point_in_region(vtkNew sself, int regionId, double x, double dist2) { return sself->FindClosestPointInRegion(regionId, x, dist2); } -extern "C" long long vtk_octree_point_locator_find_closest_point_in_region(vtkNew sself, int regionId, double x, double y, double z, double dist2) { return sself->FindClosestPointInRegion(regionId, x, y, z, dist2); } -extern "C" void vtk_octree_point_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } -extern "C" vtkNew < vtkOctreePointLocatorNode > vtkOctreePointLocatorNode_new () {return vtkNew < vtkOctreePointLocatorNode > () ;} -extern "C" void vtkOctreePointLocatorNode_destructor (vtkNew < vtkOctreePointLocatorNode > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOctreePointLocatorNode_get_ptr (vtkNew < vtkOctreePointLocatorNode > sself) {return sself . GetPointer () ;} -extern "C" void vtk_octree_point_locator_node_set_number_of_points(vtkNew sself, int numberOfPoints) { sself->SetNumberOfPoints(numberOfPoints); } -extern "C" int vtk_octree_point_locator_node_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" void vtk_octree_point_locator_node_set_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } -extern "C" void vtk_octree_point_locator_node_set_bounds(vtkNew sself, const double b) { sself->SetBounds(b); } -extern "C" void vtk_octree_point_locator_node_get_bounds(vtkNew sself, double b) { sself->GetBounds(b); } -extern "C" void vtk_octree_point_locator_node_set_data_bounds(vtkNew sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetDataBounds(xMin, xMax, yMin, yMax, zMin, zMax); } -extern "C" void vtk_octree_point_locator_node_get_data_bounds(vtkNew sself, double b) { sself->GetDataBounds(b); } -extern "C" double* vtk_octree_point_locator_node_get_min_bounds(vtkNew sself) { return sself->GetMinBounds(); } -extern "C" double* vtk_octree_point_locator_node_get_max_bounds(vtkNew sself) { return sself->GetMaxBounds(); } -extern "C" void vtk_octree_point_locator_node_set_min_bounds(vtkNew sself, double minBounds) { sself->SetMinBounds(minBounds); } -extern "C" void vtk_octree_point_locator_node_set_max_bounds(vtkNew sself, double maxBounds) { sself->SetMaxBounds(maxBounds); } -extern "C" double* vtk_octree_point_locator_node_get_min_data_bounds(vtkNew sself) { return sself->GetMinDataBounds(); } -extern "C" double* vtk_octree_point_locator_node_get_max_data_bounds(vtkNew sself) { return sself->GetMaxDataBounds(); } -extern "C" void vtk_octree_point_locator_node_set_min_data_bounds(vtkNew sself, double minDataBounds) { sself->SetMinDataBounds(minDataBounds); } -extern "C" void vtk_octree_point_locator_node_set_max_data_bounds(vtkNew sself, double maxDataBounds) { sself->SetMaxDataBounds(maxDataBounds); } -extern "C" int vtk_octree_point_locator_node_get_id(vtkNew sself) { return sself->GetID(); } -extern "C" int vtk_octree_point_locator_node_get_min_id(vtkNew sself) { return sself->GetMinID(); } -extern "C" void vtk_octree_point_locator_node_create_child_nodes(vtkNew sself) { sself->CreateChildNodes(); } -extern "C" void vtk_octree_point_locator_node_delete_child_nodes(vtkNew sself) { sself->DeleteChildNodes(); } -extern "C" int vtk_octree_point_locator_node_contains_point(vtkNew sself, double x, double y, double z, int useDataBounds) { return sself->ContainsPoint(x, y, z, useDataBounds); } -extern "C" int vtk_octree_point_locator_node_get_sub_octant_index(vtkNew sself, double point, int CheckContainment) { return sself->GetSubOctantIndex(point, CheckContainment); } -extern "C" vtkNew < vtkOrderedTriangulator > vtkOrderedTriangulator_new () {return vtkNew < vtkOrderedTriangulator > () ;} -extern "C" void vtkOrderedTriangulator_destructor (vtkNew < vtkOrderedTriangulator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOrderedTriangulator_get_ptr (vtkNew < vtkOrderedTriangulator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_ordered_triangulator_init_triangulation(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts) { sself->InitTriangulation(xmin, xmax, ymin, ymax, zmin, zmax, numPts); } -extern "C" void vtk_ordered_triangulator_init_triangulation(vtkNew sself, double bounds, int numPts) { sself->InitTriangulation(bounds, numPts); } -extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, double x, double p, int type) { return sself->InsertPoint(id, x, p, type); } -extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, long long sortid, double x, double p, int type) { return sself->InsertPoint(id, sortid, x, p, type); } -extern "C" long long vtk_ordered_triangulator_insert_point(vtkNew sself, long long id, long long sortid, long long sortid2, double x, double p, int type) { return sself->InsertPoint(id, sortid, sortid2, x, p, type); } -extern "C" void vtk_ordered_triangulator_triangulate(vtkNew sself) { sself->Triangulate(); } -extern "C" void vtk_ordered_triangulator_template_triangulate(vtkNew sself, int cellType, int numPts, int numEdges) { sself->TemplateTriangulate(cellType, numPts, numEdges); } -extern "C" void vtk_ordered_triangulator_update_point_type(vtkNew sself, long long internalId, int type) { sself->UpdatePointType(internalId, type); } -extern "C" double* vtk_ordered_triangulator_get_point_position(vtkNew sself, long long internalId) { return sself->GetPointPosition(internalId); } -extern "C" double* vtk_ordered_triangulator_get_point_location(vtkNew sself, long long internalId) { return sself->GetPointLocation(internalId); } -extern "C" long long vtk_ordered_triangulator_get_point_id(vtkNew sself, long long internalId) { return sself->GetPointId(internalId); } -extern "C" int vtk_ordered_triangulator_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" void vtk_ordered_triangulator_set_use_templates(vtkNew sself, int _arg) { sself->SetUseTemplates(_arg); } -extern "C" int vtk_ordered_triangulator_get_use_templates(vtkNew sself) { return sself->GetUseTemplates(); } -extern "C" void vtk_ordered_triangulator_use_templates_on(vtkNew sself) { sself->UseTemplatesOn(); } -extern "C" void vtk_ordered_triangulator_use_templates_off(vtkNew sself) { sself->UseTemplatesOff(); } -extern "C" void vtk_ordered_triangulator_set_pre_sorted(vtkNew sself, int _arg) { sself->SetPreSorted(_arg); } -extern "C" int vtk_ordered_triangulator_get_pre_sorted(vtkNew sself) { return sself->GetPreSorted(); } -extern "C" void vtk_ordered_triangulator_pre_sorted_on(vtkNew sself) { sself->PreSortedOn(); } -extern "C" void vtk_ordered_triangulator_pre_sorted_off(vtkNew sself) { sself->PreSortedOff(); } -extern "C" void vtk_ordered_triangulator_set_use_two_sort_ids(vtkNew sself, int _arg) { sself->SetUseTwoSortIds(_arg); } -extern "C" int vtk_ordered_triangulator_get_use_two_sort_ids(vtkNew sself) { return sself->GetUseTwoSortIds(); } -extern "C" void vtk_ordered_triangulator_use_two_sort_ids_on(vtkNew sself) { sself->UseTwoSortIdsOn(); } -extern "C" void vtk_ordered_triangulator_use_two_sort_ids_off(vtkNew sself) { sself->UseTwoSortIdsOff(); } -extern "C" void vtk_ordered_triangulator_init_tetra_traversal(vtkNew sself) { sself->InitTetraTraversal(); } -extern "C" vtkNew < vtkOutEdgeIterator > vtkOutEdgeIterator_new () {return vtkNew < vtkOutEdgeIterator > () ;} -extern "C" void vtkOutEdgeIterator_destructor (vtkNew < vtkOutEdgeIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOutEdgeIterator_get_ptr (vtkNew < vtkOutEdgeIterator > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_out_edge_iterator_get_vertex(vtkNew sself) { return sself->GetVertex(); } -extern "C" bool vtk_out_edge_iterator_has_next(vtkNew sself) { return sself->HasNext(); } -extern "C" vtkNew < vtkOverlappingAMR > vtkOverlappingAMR_new () {return vtkNew < vtkOverlappingAMR > () ;} -extern "C" void vtkOverlappingAMR_destructor (vtkNew < vtkOverlappingAMR > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOverlappingAMR_get_ptr (vtkNew < vtkOverlappingAMR > sself) {return sself . GetPointer () ;} -extern "C" void vtk_overlapping_amr_set_origin(vtkNew sself, const double origin) { sself->SetOrigin(origin); } -extern "C" double* vtk_overlapping_amr_get_origin(vtkNew sself) { return sself->GetOrigin(); } -extern "C" void vtk_overlapping_amr_set_spacing(vtkNew sself, unsigned int level, const double spacing) { sself->SetSpacing(level, spacing); } -extern "C" void vtk_overlapping_amr_get_spacing(vtkNew sself, unsigned int level, double spacing) { sself->GetSpacing(level, spacing); } -extern "C" void vtk_overlapping_amr_get_bounds(vtkNew sself, unsigned int level, unsigned int id, double bb) { sself->GetBounds(level, id, bb); } -extern "C" void vtk_overlapping_amr_get_origin(vtkNew sself, unsigned int level, unsigned int id, double origin) { sself->GetOrigin(level, id, origin); } -extern "C" void vtk_overlapping_amr_set_refinement_ratio(vtkNew sself, unsigned int level, int refRatio) { sself->SetRefinementRatio(level, refRatio); } -extern "C" int vtk_overlapping_amr_get_refinement_ratio(vtkNew sself, unsigned int level) { return sself->GetRefinementRatio(level); } -extern "C" void vtk_overlapping_amr_set_amr_block_source_index(vtkNew sself, unsigned int level, unsigned int id, int sourceId) { sself->SetAMRBlockSourceIndex(level, id, sourceId); } -extern "C" int vtk_overlapping_amr_get_amr_block_source_index(vtkNew sself, unsigned int level, unsigned int id) { return sself->GetAMRBlockSourceIndex(level, id); } -extern "C" bool vtk_overlapping_amr_has_children_information(vtkNew sself) { return sself->HasChildrenInformation(); } -extern "C" void vtk_overlapping_amr_generate_parent_child_information(vtkNew sself) { sself->GenerateParentChildInformation(); } -extern "C" unsigned int* vtk_overlapping_amr_get_parents(vtkNew sself, unsigned int level, unsigned int index, unsigned int numParents) { return sself->GetParents(level, index, numParents); } -extern "C" unsigned int* vtk_overlapping_amr_get_children(vtkNew sself, unsigned int level, unsigned int index, unsigned int numChildren) { return sself->GetChildren(level, index, numChildren); } -extern "C" void vtk_overlapping_amr_print_parent_child_info(vtkNew sself, unsigned int level, unsigned int index) { sself->PrintParentChildInfo(level, index); } -extern "C" void vtk_overlapping_amr_get_bounds(vtkNew sself, double b) { sself->GetBounds(b); } -extern "C" bool vtk_overlapping_amr_find_grid(vtkNew sself, double q, unsigned int level, unsigned int gridId) { return sself->FindGrid(q, level, gridId); } -extern "C" void vtk_overlapping_amr_audit(vtkNew sself) { sself->Audit(); } -extern "C" vtkNew < vtkPartitionedDataSet > vtkPartitionedDataSet_new () {return vtkNew < vtkPartitionedDataSet > () ;} -extern "C" void vtkPartitionedDataSet_destructor (vtkNew < vtkPartitionedDataSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPartitionedDataSet_get_ptr (vtkNew < vtkPartitionedDataSet > sself) {return sself . GetPointer () ;} -extern "C" void vtk_partitioned_data_set_set_number_of_partitions(vtkNew sself, unsigned int numPartitions) { sself->SetNumberOfPartitions(numPartitions); } -extern "C" unsigned int vtk_partitioned_data_set_get_number_of_partitions(vtkNew sself) { return sself->GetNumberOfPartitions(); } -extern "C" int vtk_partitioned_data_set_has_meta_data(vtkNew sself, unsigned int idx) { return sself->HasMetaData(idx); } -extern "C" void vtk_partitioned_data_set_remove_null_partitions(vtkNew sself) { sself->RemoveNullPartitions(); } -extern "C" vtkNew < vtkPartitionedDataSetCollection > vtkPartitionedDataSetCollection_new () {return vtkNew < vtkPartitionedDataSetCollection > () ;} -extern "C" void vtkPartitionedDataSetCollection_destructor (vtkNew < vtkPartitionedDataSetCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPartitionedDataSetCollection_get_ptr (vtkNew < vtkPartitionedDataSetCollection > sself) {return sself . GetPointer () ;} -extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets(vtkNew sself, unsigned int numDataSets) { sself->SetNumberOfPartitionedDataSets(numDataSets); } -extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets(vtkNew sself) { return sself->GetNumberOfPartitionedDataSets(); } -extern "C" void vtk_partitioned_data_set_collection_remove_partitioned_data_set(vtkNew sself, unsigned int idx) { sself->RemovePartitionedDataSet(idx); } -extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitions(vtkNew sself, unsigned int idx) { return sself->GetNumberOfPartitions(idx); } -extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitions(vtkNew sself, unsigned int idx, unsigned int numPartitions) { sself->SetNumberOfPartitions(idx, numPartitions); } -extern "C" int vtk_partitioned_data_set_collection_has_meta_data(vtkNew sself, unsigned int idx) { return sself->HasMetaData(idx); } -extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkNew sself, unsigned int idx) { return sself->GetCompositeIndex(idx); } -extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkNew sself, unsigned int idx, unsigned int partition) { return sself->GetCompositeIndex(idx, partition); } -extern "C" unsigned long vtk_partitioned_data_set_collection_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkPath > vtkPath_new () {return vtkNew < vtkPath > () ;} -extern "C" void vtkPath_destructor (vtkNew < vtkPath > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPath_get_ptr (vtkNew < vtkPath > sself) {return sself . GetPointer () ;} -extern "C" int vtk_path_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" void vtk_path_insert_next_point(vtkNew sself, float pts, int code) { sself->InsertNextPoint(pts, code); } -extern "C" void vtk_path_insert_next_point(vtkNew sself, double pts, int code) { sself->InsertNextPoint(pts, code); } -extern "C" void vtk_path_insert_next_point(vtkNew sself, double x, double y, double z, int code) { sself->InsertNextPoint(x, y, z, code); } -extern "C" long long vtk_path_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } -extern "C" int vtk_path_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } -extern "C" void vtk_path_allocate(vtkNew sself, long long size, int extSize) { sself->Allocate(size, extSize); } -extern "C" void vtk_path_reset(vtkNew sself) { sself->Reset(); } -extern "C" vtkNew < vtkPentagonalPrism > vtkPentagonalPrism_new () {return vtkNew < vtkPentagonalPrism > () ;} -extern "C" void vtkPentagonalPrism_destructor (vtkNew < vtkPentagonalPrism > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPentagonalPrism_get_ptr (vtkNew < vtkPentagonalPrism > sself) {return sself . GetPointer () ;} -extern "C" void vtk_pentagonal_prism_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" void vtk_pentagonal_prism_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" long long vtk_pentagonal_prism_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_pentagonal_prism_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_pentagonal_prism_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } -extern "C" long long vtk_pentagonal_prism_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } -extern "C" long long vtk_pentagonal_prism_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } -extern "C" long long vtk_pentagonal_prism_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } -extern "C" long long vtk_pentagonal_prism_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } -extern "C" bool vtk_pentagonal_prism_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } -extern "C" int vtk_pentagonal_prism_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_pentagonal_prism_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_pentagonal_prism_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_pentagonal_prism_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_pentagonal_prism_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_pentagonal_prism_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_pentagonal_prism_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_pentagonal_prism_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_pentagonal_prism_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_pentagonal_prism_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_pentagonal_prism_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_pentagonal_prism_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_pentagonal_prism_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_pentagonal_prism_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" const long long* vtk_pentagonal_prism_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } -extern "C" const long long* vtk_pentagonal_prism_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } -extern "C" const long long* vtk_pentagonal_prism_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } -extern "C" const long long* vtk_pentagonal_prism_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } -extern "C" const long long* vtk_pentagonal_prism_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } -extern "C" void vtk_pentagonal_prism_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkPerlinNoise > vtkPerlinNoise_new () {return vtkNew < vtkPerlinNoise > () ;} -extern "C" void vtkPerlinNoise_destructor (vtkNew < vtkPerlinNoise > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPerlinNoise_get_ptr (vtkNew < vtkPerlinNoise > sself) {return sself . GetPointer () ;} -extern "C" double vtk_perlin_noise_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_perlin_noise_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } -extern "C" void vtk_perlin_noise_set_frequency(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetFrequency(_arg1, _arg2, _arg3); } -extern "C" void vtk_perlin_noise_set_frequency(vtkNew sself, const double _arg) { sself->SetFrequency(_arg); } -extern "C" double* vtk_perlin_noise_get_frequency(vtkNew sself) { return sself->GetFrequency(); } -extern "C" void vtk_perlin_noise_get_frequency(vtkNew sself, double data) { sself->GetFrequency(data); } -extern "C" void vtk_perlin_noise_set_phase(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetPhase(_arg1, _arg2, _arg3); } -extern "C" void vtk_perlin_noise_set_phase(vtkNew sself, const double _arg) { sself->SetPhase(_arg); } -extern "C" double* vtk_perlin_noise_get_phase(vtkNew sself) { return sself->GetPhase(); } -extern "C" void vtk_perlin_noise_get_phase(vtkNew sself, double data) { sself->GetPhase(data); } -extern "C" void vtk_perlin_noise_set_amplitude(vtkNew sself, double _arg) { sself->SetAmplitude(_arg); } -extern "C" double vtk_perlin_noise_get_amplitude(vtkNew sself) { return sself->GetAmplitude(); } -extern "C" vtkNew < vtkPiecewiseFunction > vtkPiecewiseFunction_new () {return vtkNew < vtkPiecewiseFunction > () ;} -extern "C" void vtkPiecewiseFunction_destructor (vtkNew < vtkPiecewiseFunction > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPiecewiseFunction_get_ptr (vtkNew < vtkPiecewiseFunction > sself) {return sself . GetPointer () ;} -extern "C" int vtk_piecewise_function_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" int vtk_piecewise_function_get_size(vtkNew sself) { return sself->GetSize(); } -extern "C" int vtk_piecewise_function_add_point(vtkNew sself, double x, double y) { return sself->AddPoint(x, y); } -extern "C" int vtk_piecewise_function_add_point(vtkNew sself, double x, double y, double midpoint, double sharpness) { return sself->AddPoint(x, y, midpoint, sharpness); } -extern "C" bool vtk_piecewise_function_remove_point_by_index(vtkNew sself, size_t id) { return sself->RemovePointByIndex(id); } -extern "C" int vtk_piecewise_function_remove_point(vtkNew sself, double x) { return sself->RemovePoint(x); } -extern "C" int vtk_piecewise_function_remove_point(vtkNew sself, double x, double y) { return sself->RemovePoint(x, y); } -extern "C" void vtk_piecewise_function_remove_all_points(vtkNew sself) { sself->RemoveAllPoints(); } -extern "C" void vtk_piecewise_function_add_segment(vtkNew sself, double x1, double y1, double x2, double y2) { sself->AddSegment(x1, y1, x2, y2); } -extern "C" double vtk_piecewise_function_get_value(vtkNew sself, double x) { return sself->GetValue(x); } -extern "C" int vtk_piecewise_function_get_node_value(vtkNew sself, int index, double val) { return sself->GetNodeValue(index, val); } -extern "C" int vtk_piecewise_function_set_node_value(vtkNew sself, int index, double val) { return sself->SetNodeValue(index, val); } -extern "C" double* vtk_piecewise_function_get_data_pointer(vtkNew sself) { return sself->GetDataPointer(); } -extern "C" void vtk_piecewise_function_fill_from_data_pointer(vtkNew sself, int p0, double p1) { sself->FillFromDataPointer(p0, p1); } -extern "C" double* vtk_piecewise_function_get_range(vtkNew sself) { return sself->GetRange(); } -extern "C" void vtk_piecewise_function_get_range(vtkNew sself, double _arg1, double _arg2) { sself->GetRange(_arg1, _arg2); } -extern "C" void vtk_piecewise_function_get_range(vtkNew sself, double _arg) { sself->GetRange(_arg); } -extern "C" int vtk_piecewise_function_adjust_range(vtkNew sself, double range) { return sself->AdjustRange(range); } -extern "C" void vtk_piecewise_function_get_table(vtkNew sself, double x1, double x2, int size, float table, int stride, int logIncrements) { sself->GetTable(x1, x2, size, table, stride, logIncrements); } -extern "C" void vtk_piecewise_function_get_table(vtkNew sself, double x1, double x2, int size, double table, int stride, int logIncrements) { sself->GetTable(x1, x2, size, table, stride, logIncrements); } -extern "C" void vtk_piecewise_function_build_function_from_table(vtkNew sself, double x1, double x2, int size, double table, int stride) { sself->BuildFunctionFromTable(x1, x2, size, table, stride); } -extern "C" void vtk_piecewise_function_set_clamping(vtkNew sself, int _arg) { sself->SetClamping(_arg); } -extern "C" int vtk_piecewise_function_get_clamping(vtkNew sself) { return sself->GetClamping(); } -extern "C" void vtk_piecewise_function_clamping_on(vtkNew sself) { sself->ClampingOn(); } -extern "C" void vtk_piecewise_function_clamping_off(vtkNew sself) { sself->ClampingOff(); } -extern "C" void vtk_piecewise_function_set_use_log_scale(vtkNew sself, bool _arg) { sself->SetUseLogScale(_arg); } -extern "C" bool vtk_piecewise_function_get_use_log_scale(vtkNew sself) { return sself->GetUseLogScale(); } -extern "C" void vtk_piecewise_function_use_log_scale_on(vtkNew sself) { sself->UseLogScaleOn(); } -extern "C" void vtk_piecewise_function_use_log_scale_off(vtkNew sself) { sself->UseLogScaleOff(); } -extern "C" const char* vtk_piecewise_function_get_type(vtkNew sself) { return sself->GetType(); } -extern "C" double vtk_piecewise_function_get_first_non_zero_value(vtkNew sself) { return sself->GetFirstNonZeroValue(); } -extern "C" void vtk_piecewise_function_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_piecewise_function_set_allow_duplicate_scalars(vtkNew sself, int _arg) { sself->SetAllowDuplicateScalars(_arg); } -extern "C" int vtk_piecewise_function_get_allow_duplicate_scalars(vtkNew sself) { return sself->GetAllowDuplicateScalars(); } -extern "C" void vtk_piecewise_function_allow_duplicate_scalars_on(vtkNew sself) { sself->AllowDuplicateScalarsOn(); } -extern "C" void vtk_piecewise_function_allow_duplicate_scalars_off(vtkNew sself) { sself->AllowDuplicateScalarsOff(); } -extern "C" int vtk_piecewise_function_estimate_min_number_of_samples(vtkNew sself, const double x1, const double x2) { return sself->EstimateMinNumberOfSamples(x1, x2); } -extern "C" vtkNew < vtkPixel > vtkPixel_new () {return vtkNew < vtkPixel > () ;} -extern "C" void vtkPixel_destructor (vtkNew < vtkPixel > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPixel_get_ptr (vtkNew < vtkPixel > sself) {return sself . GetPointer () ;} -extern "C" int vtk_pixel_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_pixel_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_pixel_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_pixel_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_pixel_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_pixel_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_pixel_inflate(vtkNew sself, double dist) { return sself->Inflate(dist); } -extern "C" double vtk_pixel_compute_bounding_sphere(vtkNew sself, double center) { return sself->ComputeBoundingSphere(center); } -extern "C" int vtk_pixel_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" int vtk_pixel_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_pixel_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" void vtk_pixel_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_pixel_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_pixel_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_pixel_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" int vtk_pixel_compute_normal(vtkNew sself, double n) { return sself->ComputeNormal(n); } -extern "C" vtkNew < vtkPlane > vtkPlane_new () {return vtkNew < vtkPlane > () ;} -extern "C" void vtkPlane_destructor (vtkNew < vtkPlane > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPlane_get_ptr (vtkNew < vtkPlane > sself) {return sself . GetPointer () ;} -extern "C" double vtk_plane_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_plane_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } -extern "C" void vtk_plane_set_normal(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } -extern "C" void vtk_plane_set_normal(vtkNew sself, const double _arg) { sself->SetNormal(_arg); } -extern "C" double* vtk_plane_get_normal(vtkNew sself) { return sself->GetNormal(); } -extern "C" void vtk_plane_get_normal(vtkNew sself, double data) { sself->GetNormal(data); } -extern "C" void vtk_plane_set_origin(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } -extern "C" void vtk_plane_set_origin(vtkNew sself, const double _arg) { sself->SetOrigin(_arg); } -extern "C" double* vtk_plane_get_origin(vtkNew sself) { return sself->GetOrigin(); } -extern "C" void vtk_plane_get_origin(vtkNew sself, double data) { sself->GetOrigin(data); } -extern "C" void vtk_plane_push(vtkNew sself, double distance) { sself->Push(distance); } -extern "C" void vtk_plane_project_point(vtkNew sself, const double x, const double origin, const double normal, double xproj) { sself->ProjectPoint(x, origin, normal, xproj); } -extern "C" void vtk_plane_project_point(vtkNew sself, const double x, double xproj) { sself->ProjectPoint(x, xproj); } -extern "C" void vtk_plane_project_vector(vtkNew sself, const double v, const double origin, const double normal, double vproj) { sself->ProjectVector(v, origin, normal, vproj); } -extern "C" void vtk_plane_project_vector(vtkNew sself, const double v, double vproj) { sself->ProjectVector(v, vproj); } -extern "C" void vtk_plane_generalized_project_point(vtkNew sself, const double x, const double origin, const double normal, double xproj) { sself->GeneralizedProjectPoint(x, origin, normal, xproj); } -extern "C" void vtk_plane_generalized_project_point(vtkNew sself, const double x, double xproj) { sself->GeneralizedProjectPoint(x, xproj); } -extern "C" double vtk_plane_evaluate(vtkNew sself, double normal, double origin, double x) { return sself->Evaluate(normal, origin, x); } -extern "C" double vtk_plane_distance_to_plane(vtkNew sself, double x, double n, double p0) { return sself->DistanceToPlane(x, n, p0); } -extern "C" double vtk_plane_distance_to_plane(vtkNew sself, double x) { return sself->DistanceToPlane(x); } -extern "C" int vtk_plane_intersect_with_line(vtkNew sself, const double p1, const double p2, double n, double p0, double t, double x) { return sself->IntersectWithLine(p1, p2, n, p0, t, x); } -extern "C" int vtk_plane_intersect_with_line(vtkNew sself, const double p1, const double p2, double t, double x) { return sself->IntersectWithLine(p1, p2, t, x); } -extern "C" int vtk_plane_intersect_with_finite_plane(vtkNew sself, double n, double o, double pOrigin, double px, double py, double x0, double x1) { return sself->IntersectWithFinitePlane(n, o, pOrigin, px, py, x0, x1); } -extern "C" int vtk_plane_intersect_with_finite_plane(vtkNew sself, double pOrigin, double px, double py, double x0, double x1) { return sself->IntersectWithFinitePlane(pOrigin, px, py, x0, x1); } -extern "C" vtkNew < vtkPlaneCollection > vtkPlaneCollection_new () {return vtkNew < vtkPlaneCollection > () ;} -extern "C" void vtkPlaneCollection_destructor (vtkNew < vtkPlaneCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPlaneCollection_get_ptr (vtkNew < vtkPlaneCollection > sself) {return sself . GetPointer () ;} -extern "C" int vtk_plane_collection_get_number_of_items(vtkNew sself) { return sself->GetNumberOfItems(); } -extern "C" vtkNew < vtkPlanes > vtkPlanes_new () {return vtkNew < vtkPlanes > () ;} -extern "C" void vtkPlanes_destructor (vtkNew < vtkPlanes > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPlanes_get_ptr (vtkNew < vtkPlanes > sself) {return sself . GetPointer () ;} -extern "C" double vtk_planes_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_planes_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } -extern "C" void vtk_planes_set_frustum_planes(vtkNew sself, double planes) { sself->SetFrustumPlanes(planes); } -extern "C" void vtk_planes_set_bounds(vtkNew sself, const double bounds) { sself->SetBounds(bounds); } -extern "C" void vtk_planes_set_bounds(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) { sself->SetBounds(xmin, xmax, ymin, ymax, zmin, zmax); } -extern "C" int vtk_planes_get_number_of_planes(vtkNew sself) { return sself->GetNumberOfPlanes(); } -extern "C" vtkNew < vtkPlanesIntersection > vtkPlanesIntersection_new () {return vtkNew < vtkPlanesIntersection > () ;} -extern "C" void vtkPlanesIntersection_destructor (vtkNew < vtkPlanesIntersection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPlanesIntersection_get_ptr (vtkNew < vtkPlanesIntersection > sself) {return sself . GetPointer () ;} -extern "C" void vtk_planes_intersection_set_region_vertices(vtkNew sself, double v, int nvertices) { sself->SetRegionVertices(v, nvertices); } -extern "C" int vtk_planes_intersection_get_number_of_region_vertices(vtkNew sself) { return sself->GetNumberOfRegionVertices(); } -extern "C" int vtk_planes_intersection_get_num_region_vertices(vtkNew sself) { return sself->GetNumRegionVertices(); } -extern "C" int vtk_planes_intersection_get_region_vertices(vtkNew sself, double v, int nvertices) { return sself->GetRegionVertices(v, nvertices); } -extern "C" vtkNew < vtkPointData > vtkPointData_new () {return vtkNew < vtkPointData > () ;} -extern "C" void vtkPointData_destructor (vtkNew < vtkPointData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointData_get_ptr (vtkNew < vtkPointData > sself) {return sself . GetPointer () ;} -extern "C" void vtk_point_data_null_point(vtkNew sself, long long ptId) { sself->NullPoint(ptId); } -extern "C" vtkNew < vtkPointLocator > vtkPointLocator_new () {return vtkNew < vtkPointLocator > () ;} -extern "C" void vtkPointLocator_destructor (vtkNew < vtkPointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointLocator_get_ptr (vtkNew < vtkPointLocator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_point_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } -extern "C" void vtk_point_locator_set_divisions(vtkNew sself, const int _arg) { sself->SetDivisions(_arg); } -extern "C" int* vtk_point_locator_get_divisions(vtkNew sself) { return sself->GetDivisions(); } -extern "C" void vtk_point_locator_get_divisions(vtkNew sself, int data) { sself->GetDivisions(data); } -extern "C" void vtk_point_locator_set_number_of_points_per_bucket(vtkNew sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } -extern "C" int vtk_point_locator_get_number_of_points_per_bucket_min_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } -extern "C" int vtk_point_locator_get_number_of_points_per_bucket_max_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } -extern "C" int vtk_point_locator_get_number_of_points_per_bucket(vtkNew sself) { return sself->GetNumberOfPointsPerBucket(); } -extern "C" long long vtk_point_locator_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } -extern "C" long long vtk_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } -extern "C" long long vtk_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, inputDataLength, dist2); } -extern "C" void vtk_point_locator_insert_point(vtkNew sself, long long ptId, const double x) { sself->InsertPoint(ptId, x); } -extern "C" long long vtk_point_locator_insert_next_point(vtkNew sself, const double x) { return sself->InsertNextPoint(x); } -extern "C" long long vtk_point_locator_is_inserted_point(vtkNew sself, double x, double y, double z) { return sself->IsInsertedPoint(x, y, z); } -extern "C" long long vtk_point_locator_is_inserted_point(vtkNew sself, const double x) { return sself->IsInsertedPoint(x); } -extern "C" int vtk_point_locator_insert_unique_point(vtkNew sself, const double x, long long ptId) { return sself->InsertUniquePoint(x, ptId); } -extern "C" long long vtk_point_locator_find_closest_inserted_point(vtkNew sself, const double x) { return sself->FindClosestInsertedPoint(x); } -extern "C" void vtk_point_locator_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_point_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } -extern "C" void vtk_point_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } -extern "C" vtkNew < vtkPointSet > vtkPointSet_new () {return vtkNew < vtkPointSet > () ;} -extern "C" void vtkPointSet_destructor (vtkNew < vtkPointSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointSet_get_ptr (vtkNew < vtkPointSet > sself) {return sself . GetPointer () ;} -extern "C" void vtk_point_set_set_editable(vtkNew sself, bool _arg) { sself->SetEditable(_arg); } -extern "C" bool vtk_point_set_get_editable(vtkNew sself) { return sself->GetEditable(); } -extern "C" void vtk_point_set_editable_on(vtkNew sself) { sself->EditableOn(); } -extern "C" void vtk_point_set_editable_off(vtkNew sself) { sself->EditableOff(); } -extern "C" void vtk_point_set_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" long long vtk_point_set_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" void vtk_point_set_get_point(vtkNew sself, long long ptId, double x) { sself->GetPoint(ptId, x); } -extern "C" long long vtk_point_set_find_point(vtkNew sself, double x) { return sself->FindPoint(x); } -extern "C" long long vtk_point_set_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } -extern "C" int vtk_point_set_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } -extern "C" int vtk_point_set_get_cell_type(vtkNew sself, long long p0) { return sself->GetCellType(p0); } -extern "C" double* vtk_point_set_get_point(vtkNew sself, long long ptId) { return sself->GetPoint(ptId); } -extern "C" void vtk_point_set_build_point_locator(vtkNew sself) { sself->BuildPointLocator(); } -extern "C" void vtk_point_set_build_locator(vtkNew sself) { sself->BuildLocator(); } -extern "C" void vtk_point_set_build_cell_locator(vtkNew sself) { sself->BuildCellLocator(); } -extern "C" unsigned long vtk_point_set_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_point_set_compute_bounds(vtkNew sself) { sself->ComputeBounds(); } -extern "C" void vtk_point_set_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" vtkNew < vtkPointSetCellIterator > vtkPointSetCellIterator_new () {return vtkNew < vtkPointSetCellIterator > () ;} -extern "C" void vtkPointSetCellIterator_destructor (vtkNew < vtkPointSetCellIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointSetCellIterator_get_ptr (vtkNew < vtkPointSetCellIterator > sself) {return sself . GetPointer () ;} -extern "C" bool vtk_point_set_cell_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } -extern "C" long long vtk_point_set_cell_iterator_get_cell_id(vtkNew sself) { return sself->GetCellId(); } -extern "C" vtkNew < vtkPointsProjectedHull > vtkPointsProjectedHull_new () {return vtkNew < vtkPointsProjectedHull > () ;} -extern "C" void vtkPointsProjectedHull_destructor (vtkNew < vtkPointsProjectedHull > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointsProjectedHull_get_ptr (vtkNew < vtkPointsProjectedHull > sself) {return sself . GetPointer () ;} -extern "C" int vtk_points_projected_hull_rectangle_intersection_x(vtkNew sself, float ymin, float ymax, float zmin, float zmax) { return sself->RectangleIntersectionX(ymin, ymax, zmin, zmax); } -extern "C" int vtk_points_projected_hull_rectangle_intersection_x(vtkNew sself, double ymin, double ymax, double zmin, double zmax) { return sself->RectangleIntersectionX(ymin, ymax, zmin, zmax); } -extern "C" int vtk_points_projected_hull_rectangle_intersection_y(vtkNew sself, float zmin, float zmax, float xmin, float xmax) { return sself->RectangleIntersectionY(zmin, zmax, xmin, xmax); } -extern "C" int vtk_points_projected_hull_rectangle_intersection_y(vtkNew sself, double zmin, double zmax, double xmin, double xmax) { return sself->RectangleIntersectionY(zmin, zmax, xmin, xmax); } -extern "C" int vtk_points_projected_hull_rectangle_intersection_z(vtkNew sself, float xmin, float xmax, float ymin, float ymax) { return sself->RectangleIntersectionZ(xmin, xmax, ymin, ymax); } -extern "C" int vtk_points_projected_hull_rectangle_intersection_z(vtkNew sself, double xmin, double xmax, double ymin, double ymax) { return sself->RectangleIntersectionZ(xmin, xmax, ymin, ymax); } -extern "C" int vtk_points_projected_hull_get_ccw_hull_x(vtkNew sself, float pts, int len) { return sself->GetCCWHullX(pts, len); } -extern "C" int vtk_points_projected_hull_get_ccw_hull_x(vtkNew sself, double pts, int len) { return sself->GetCCWHullX(pts, len); } -extern "C" int vtk_points_projected_hull_get_ccw_hull_y(vtkNew sself, float pts, int len) { return sself->GetCCWHullY(pts, len); } -extern "C" int vtk_points_projected_hull_get_ccw_hull_y(vtkNew sself, double pts, int len) { return sself->GetCCWHullY(pts, len); } -extern "C" int vtk_points_projected_hull_get_ccw_hull_z(vtkNew sself, float pts, int len) { return sself->GetCCWHullZ(pts, len); } -extern "C" int vtk_points_projected_hull_get_ccw_hull_z(vtkNew sself, double pts, int len) { return sself->GetCCWHullZ(pts, len); } -extern "C" int vtk_points_projected_hull_get_size_ccw_hull_x(vtkNew sself) { return sself->GetSizeCCWHullX(); } -extern "C" int vtk_points_projected_hull_get_size_ccw_hull_y(vtkNew sself) { return sself->GetSizeCCWHullY(); } -extern "C" int vtk_points_projected_hull_get_size_ccw_hull_z(vtkNew sself) { return sself->GetSizeCCWHullZ(); } -extern "C" void vtk_points_projected_hull_update(vtkNew sself) { sself->Update(); } -extern "C" vtkNew < vtkPolyData > vtkPolyData_new () {return vtkNew < vtkPolyData > () ;} -extern "C" void vtkPolyData_destructor (vtkNew < vtkPolyData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyData_get_ptr (vtkNew < vtkPolyData > sself) {return sself . GetPointer () ;} -extern "C" int vtk_poly_data_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" long long vtk_poly_data_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } -extern "C" int vtk_poly_data_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } -extern "C" void vtk_poly_data_compute_cells_bounds(vtkNew sself) { sself->ComputeCellsBounds(); } -extern "C" void vtk_poly_data_get_cells_bounds(vtkNew sself, double bounds) { sself->GetCellsBounds(bounds); } -extern "C" void vtk_poly_data_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" int vtk_poly_data_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } -extern "C" long long vtk_poly_data_get_cell_id_relative_to_cell_array(vtkNew sself, long long cellId) { return sself->GetCellIdRelativeToCellArray(cellId); } -extern "C" long long vtk_poly_data_get_number_of_verts(vtkNew sself) { return sself->GetNumberOfVerts(); } -extern "C" long long vtk_poly_data_get_number_of_lines(vtkNew sself) { return sself->GetNumberOfLines(); } -extern "C" long long vtk_poly_data_get_number_of_polys(vtkNew sself) { return sself->GetNumberOfPolys(); } -extern "C" long long vtk_poly_data_get_number_of_strips(vtkNew sself) { return sself->GetNumberOfStrips(); } -extern "C" bool vtk_poly_data_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } -extern "C" bool vtk_poly_data_allocate_estimate(vtkNew sself, long long numVerts, long long maxVertSize, long long numLines, long long maxLineSize, long long numPolys, long long maxPolySize, long long numStrips, long long maxStripSize) { return sself->AllocateEstimate(numVerts, maxVertSize, numLines, maxLineSize, numPolys, maxPolySize, numStrips, maxStripSize); } -extern "C" bool vtk_poly_data_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } -extern "C" bool vtk_poly_data_allocate_exact(vtkNew sself, long long numVerts, long long vertConnSize, long long numLines, long long lineConnSize, long long numPolys, long long polyConnSize, long long numStrips, long long stripConnSize) { return sself->AllocateExact(numVerts, vertConnSize, numLines, lineConnSize, numPolys, polyConnSize, numStrips, stripConnSize); } -extern "C" void vtk_poly_data_allocate(vtkNew sself, long long numCells, int extSize) { sself->Allocate(numCells, extSize); } -extern "C" long long vtk_poly_data_insert_next_cell(vtkNew sself, int type, int npts, const long long pts) { return sself->InsertNextCell(type, npts, pts); } -extern "C" void vtk_poly_data_reset(vtkNew sself) { sself->Reset(); } -extern "C" void vtk_poly_data_build_cells(vtkNew sself) { sself->BuildCells(); } -extern "C" bool vtk_poly_data_need_to_build_cells(vtkNew sself) { return sself->NeedToBuildCells(); } -extern "C" void vtk_poly_data_build_links(vtkNew sself, int initialSize) { sself->BuildLinks(initialSize); } -extern "C" void vtk_poly_data_delete_cells(vtkNew sself) { sself->DeleteCells(); } -extern "C" void vtk_poly_data_delete_links(vtkNew sself) { sself->DeleteLinks(); } -extern "C" void vtk_poly_data_get_point_cells(vtkNew sself, long long ptId, long long ncells, long long cells) { sself->GetPointCells(ptId, ncells, cells); } -extern "C" void vtk_poly_data_get_point_cells(vtkNew sself, long long ptId, unsigned short ncells, long long cells) { sself->GetPointCells(ptId, ncells, cells); } -extern "C" unsigned char vtk_poly_data_get_cell_points(vtkNew sself, long long cellId, long long npts, const long long pts) { return sself->GetCellPoints(cellId, npts, pts); } -extern "C" int vtk_poly_data_is_triangle(vtkNew sself, int v1, int v2, int v3) { return sself->IsTriangle(v1, v2, v3); } -extern "C" int vtk_poly_data_is_edge(vtkNew sself, long long p1, long long p2) { return sself->IsEdge(p1, p2); } -extern "C" int vtk_poly_data_is_point_used_by_cell(vtkNew sself, long long ptId, long long cellId) { return sself->IsPointUsedByCell(ptId, cellId); } -extern "C" void vtk_poly_data_replace_cell(vtkNew sself, long long cellId, int npts, const long long pts) { sself->ReplaceCell(cellId, npts, pts); } -extern "C" void vtk_poly_data_replace_cell_point(vtkNew sself, long long cellId, long long oldPtId, long long newPtId) { sself->ReplaceCellPoint(cellId, oldPtId, newPtId); } -extern "C" void vtk_poly_data_reverse_cell(vtkNew sself, long long cellId) { sself->ReverseCell(cellId); } -extern "C" void vtk_poly_data_delete_point(vtkNew sself, long long ptId) { sself->DeletePoint(ptId); } -extern "C" void vtk_poly_data_delete_cell(vtkNew sself, long long cellId) { sself->DeleteCell(cellId); } -extern "C" void vtk_poly_data_remove_deleted_cells(vtkNew sself) { sself->RemoveDeletedCells(); } -extern "C" long long vtk_poly_data_insert_next_linked_point(vtkNew sself, int numLinks) { return sself->InsertNextLinkedPoint(numLinks); } -extern "C" long long vtk_poly_data_insert_next_linked_point(vtkNew sself, double x, int numLinks) { return sself->InsertNextLinkedPoint(x, numLinks); } -extern "C" long long vtk_poly_data_insert_next_linked_cell(vtkNew sself, int type, int npts, const long long pts) { return sself->InsertNextLinkedCell(type, npts, pts); } -extern "C" void vtk_poly_data_replace_linked_cell(vtkNew sself, long long cellId, int npts, const long long pts) { sself->ReplaceLinkedCell(cellId, npts, pts); } -extern "C" void vtk_poly_data_remove_cell_reference(vtkNew sself, long long cellId) { sself->RemoveCellReference(cellId); } -extern "C" void vtk_poly_data_add_cell_reference(vtkNew sself, long long cellId) { sself->AddCellReference(cellId); } -extern "C" void vtk_poly_data_remove_reference_to_cell(vtkNew sself, long long ptId, long long cellId) { sself->RemoveReferenceToCell(ptId, cellId); } -extern "C" void vtk_poly_data_add_reference_to_cell(vtkNew sself, long long ptId, long long cellId) { sself->AddReferenceToCell(ptId, cellId); } -extern "C" void vtk_poly_data_resize_cell_list(vtkNew sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } -extern "C" void vtk_poly_data_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_poly_data_get_piece(vtkNew sself) { return sself->GetPiece(); } -extern "C" int vtk_poly_data_get_number_of_pieces(vtkNew sself) { return sself->GetNumberOfPieces(); } -extern "C" int vtk_poly_data_get_ghost_level(vtkNew sself) { return sself->GetGhostLevel(); } -extern "C" void vtk_poly_data_remove_ghost_cells(vtkNew sself) { sself->RemoveGhostCells(); } -extern "C" int vtk_poly_data_get_scalar_field_critical_index(vtkNew sself, long long pointId, int fieldId) { return sself->GetScalarFieldCriticalIndex(pointId, fieldId); } -extern "C" int vtk_poly_data_get_scalar_field_critical_index(vtkNew sself, long long pointId, const char fieldName) { return sself->GetScalarFieldCriticalIndex(pointId, fieldName); } -extern "C" unsigned long vtk_poly_data_get_mesh_m_time(vtkNew sself) { return sself->GetMeshMTime(); } -extern "C" unsigned long vtk_poly_data_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" unsigned char vtk_poly_data_get_cell(vtkNew sself, long long cellId, const long long pts) { return sself->GetCell(cellId, pts); } -extern "C" vtkNew < vtkPolyDataCollection > vtkPolyDataCollection_new () {return vtkNew < vtkPolyDataCollection > () ;} -extern "C" void vtkPolyDataCollection_destructor (vtkNew < vtkPolyDataCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyDataCollection_get_ptr (vtkNew < vtkPolyDataCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolyLine > vtkPolyLine_new () {return vtkNew < vtkPolyLine > () ;} -extern "C" void vtkPolyLine_destructor (vtkNew < vtkPolyLine > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyLine_get_ptr (vtkNew < vtkPolyLine > sself) {return sself . GetPointer () ;} -extern "C" int vtk_poly_line_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_poly_line_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_poly_line_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_poly_line_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_poly_line_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_poly_line_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_poly_line_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_poly_line_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_poly_line_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" vtkNew < vtkPolyPlane > vtkPolyPlane_new () {return vtkNew < vtkPolyPlane > () ;} -extern "C" void vtkPolyPlane_destructor (vtkNew < vtkPolyPlane > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyPlane_get_ptr (vtkNew < vtkPolyPlane > sself) {return sself . GetPointer () ;} -extern "C" double vtk_poly_plane_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_poly_plane_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } -extern "C" unsigned long vtk_poly_plane_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkPolyVertex > vtkPolyVertex_new () {return vtkNew < vtkPolyVertex > () ;} -extern "C" void vtkPolyVertex_destructor (vtkNew < vtkPolyVertex > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyVertex_get_ptr (vtkNew < vtkPolyVertex > sself) {return sself . GetPointer () ;} -extern "C" int vtk_poly_vertex_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_poly_vertex_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_poly_vertex_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_poly_vertex_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_poly_vertex_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_poly_vertex_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_poly_vertex_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_poly_vertex_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_poly_vertex_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" vtkNew < vtkPolygon > vtkPolygon_new () {return vtkNew < vtkPolygon > () ;} -extern "C" void vtkPolygon_destructor (vtkNew < vtkPolygon > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolygon_get_ptr (vtkNew < vtkPolygon > sself) {return sself . GetPointer () ;} -extern "C" int vtk_polygon_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_polygon_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_polygon_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_polygon_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_polygon_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_polygon_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_polygon_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_polygon_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" double vtk_polygon_compute_area(vtkNew sself) { return sself->ComputeArea(); } -extern "C" void vtk_polygon_interpolate_functions(vtkNew sself, const double x, double sf) { sself->InterpolateFunctions(x, sf); } -extern "C" void vtk_polygon_compute_normal(vtkNew sself, int numPts, double pts, double n) { sself->ComputeNormal(numPts, pts, n); } -extern "C" bool vtk_polygon_is_convex(vtkNew sself) { return sself->IsConvex(); } -extern "C" int vtk_polygon_parameterize_polygon(vtkNew sself, double p0, double p10, double l10, double p20, double l20, double n) { return sself->ParameterizePolygon(p0, p10, l10, p20, l20, n); } -extern "C" int vtk_polygon_point_in_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double n) { return sself->PointInPolygon(x, numPts, pts, bounds, n); } -extern "C" double vtk_polygon_distance_to_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double closest) { return sself->DistanceToPolygon(x, numPts, pts, bounds, closest); } -extern "C" int vtk_polygon_intersect_polygon_with_polygon(vtkNew sself, int npts, double pts, double bounds, int npts2, double pts2, double bounds2, double tol, double x) { return sself->IntersectPolygonWithPolygon(npts, pts, bounds, npts2, pts2, bounds2, tol, x); } -extern "C" bool vtk_polygon_get_use_mvc_interpolation(vtkNew sself) { return sself->GetUseMVCInterpolation(); } -extern "C" void vtk_polygon_set_use_mvc_interpolation(vtkNew sself, bool _arg) { sself->SetUseMVCInterpolation(_arg); } -extern "C" void vtk_polygon_set_tolerance(vtkNew sself, double _arg) { sself->SetTolerance(_arg); } -extern "C" double vtk_polygon_get_tolerance_min_value(vtkNew sself) { return sself->GetToleranceMinValue(); } -extern "C" double vtk_polygon_get_tolerance_max_value(vtkNew sself) { return sself->GetToleranceMaxValue(); } -extern "C" double vtk_polygon_get_tolerance(vtkNew sself) { return sself->GetTolerance(); } -extern "C" int vtk_polygon_ear_cut_triangulation(vtkNew sself, int measure) { return sself->EarCutTriangulation(measure); } -extern "C" int vtk_polygon_unbiased_ear_cut_triangulation(vtkNew sself, int seed, int measure) { return sself->UnbiasedEarCutTriangulation(seed, measure); } -extern "C" vtkNew < vtkPolyhedron > vtkPolyhedron_new () {return vtkNew < vtkPolyhedron > () ;} -extern "C" void vtkPolyhedron_destructor (vtkNew < vtkPolyhedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyhedron_get_ptr (vtkNew < vtkPolyhedron > sself) {return sself . GetPointer () ;} -extern "C" void vtk_polyhedron_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" void vtk_polyhedron_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" long long vtk_polyhedron_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_polyhedron_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_polyhedron_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } -extern "C" long long vtk_polyhedron_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } -extern "C" long long vtk_polyhedron_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } -extern "C" long long vtk_polyhedron_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } -extern "C" long long vtk_polyhedron_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } -extern "C" bool vtk_polyhedron_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } -extern "C" double* vtk_polyhedron_get_parametric_coords(vtkNew sself) { return sself->GetParametricCoords(); } -extern "C" int vtk_polyhedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_polyhedron_requires_initialization(vtkNew sself) { return sself->RequiresInitialization(); } -extern "C" int vtk_polyhedron_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_polyhedron_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_polyhedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_polyhedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_polyhedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_polyhedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_polyhedron_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" int vtk_polyhedron_is_primary_cell(vtkNew sself) { return sself->IsPrimaryCell(); } -extern "C" void vtk_polyhedron_interpolate_functions(vtkNew sself, const double x, double sf) { sself->InterpolateFunctions(x, sf); } -extern "C" void vtk_polyhedron_interpolate_derivs(vtkNew sself, const double x, double derivs) { sself->InterpolateDerivs(x, derivs); } -extern "C" int vtk_polyhedron_requires_explicit_face_representation(vtkNew sself) { return sself->RequiresExplicitFaceRepresentation(); } -extern "C" int vtk_polyhedron_is_inside(vtkNew sself, const double x, double tolerance) { return sself->IsInside(x, tolerance); } -extern "C" bool vtk_polyhedron_is_convex(vtkNew sself) { return sself->IsConvex(); } -extern "C" vtkNew < vtkPyramid > vtkPyramid_new () {return vtkNew < vtkPyramid > () ;} -extern "C" void vtkPyramid_destructor (vtkNew < vtkPyramid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPyramid_get_ptr (vtkNew < vtkPyramid > sself) {return sself . GetPointer () ;} -extern "C" void vtk_pyramid_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" void vtk_pyramid_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" long long vtk_pyramid_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_pyramid_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_pyramid_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } -extern "C" long long vtk_pyramid_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } -extern "C" long long vtk_pyramid_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } -extern "C" long long vtk_pyramid_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } -extern "C" long long vtk_pyramid_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } -extern "C" bool vtk_pyramid_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } -extern "C" int vtk_pyramid_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_pyramid_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_pyramid_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int* vtk_pyramid_get_triangle_cases(vtkNew sself, int caseId) { return sself->GetTriangleCases(caseId); } -extern "C" int vtk_pyramid_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" int vtk_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { return sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" const long long* vtk_pyramid_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_pyramid_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" const long long* vtk_pyramid_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } -extern "C" const long long* vtk_pyramid_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } -extern "C" const long long* vtk_pyramid_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } -extern "C" const long long* vtk_pyramid_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } -extern "C" const long long* vtk_pyramid_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } -extern "C" vtkNew < vtkQuad > vtkQuad_new () {return vtkNew < vtkQuad > () ;} -extern "C" void vtkQuad_destructor (vtkNew < vtkQuad > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuad_get_ptr (vtkNew < vtkQuad > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quad_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quad_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quad_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quad_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_quad_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_quad_interpolation_functions(vtkNew sself, const double pcoords, double sf) { sself->InterpolationFunctions(pcoords, sf); } -extern "C" void vtk_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_quad_interpolate_functions(vtkNew sself, const double pcoords, double sf) { sself->InterpolateFunctions(pcoords, sf); } -extern "C" void vtk_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_quad_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" vtkNew < vtkQuadraticEdge > vtkQuadraticEdge_new () {return vtkNew < vtkQuadraticEdge > () ;} -extern "C" void vtkQuadraticEdge_destructor (vtkNew < vtkQuadraticEdge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticEdge_get_ptr (vtkNew < vtkQuadraticEdge > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quadratic_edge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadratic_edge_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quadratic_edge_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quadratic_edge_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quadratic_edge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quadratic_edge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_quadratic_edge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_quadratic_edge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_quadratic_edge_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_quadratic_edge_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_edge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_quadratic_edge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_edge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" vtkNew < vtkQuadraticHexahedron > vtkQuadraticHexahedron_new () {return vtkNew < vtkQuadraticHexahedron > () ;} -extern "C" void vtkQuadraticHexahedron_destructor (vtkNew < vtkQuadraticHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticHexahedron_get_ptr (vtkNew < vtkQuadraticHexahedron > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quadratic_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadratic_hexahedron_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quadratic_hexahedron_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quadratic_hexahedron_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" void vtk_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkQuadraticLinearQuad > vtkQuadraticLinearQuad_new () {return vtkNew < vtkQuadraticLinearQuad > () ;} -extern "C" void vtkQuadraticLinearQuad_destructor (vtkNew < vtkQuadraticLinearQuad > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticLinearQuad_get_ptr (vtkNew < vtkQuadraticLinearQuad > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quadratic_linear_quad_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadratic_linear_quad_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quadratic_linear_quad_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quadratic_linear_quad_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quadratic_linear_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quadratic_linear_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_quadratic_linear_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_quadratic_linear_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_quadratic_linear_quad_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_quadratic_linear_quad_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_linear_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_quadratic_linear_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_linear_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" int* vtk_quadratic_linear_quad_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" vtkNew < vtkQuadraticLinearWedge > vtkQuadraticLinearWedge_new () {return vtkNew < vtkQuadraticLinearWedge > () ;} -extern "C" void vtkQuadraticLinearWedge_destructor (vtkNew < vtkQuadraticLinearWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticLinearWedge_get_ptr (vtkNew < vtkQuadraticLinearWedge > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quadratic_linear_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadratic_linear_wedge_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quadratic_linear_wedge_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quadratic_linear_wedge_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quadratic_linear_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quadratic_linear_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_quadratic_linear_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_quadratic_linear_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_quadratic_linear_wedge_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_quadratic_linear_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_linear_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_quadratic_linear_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_linear_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_quadratic_linear_wedge_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_quadratic_linear_wedge_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" void vtk_quadratic_linear_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkQuadraticPolygon > vtkQuadraticPolygon_new () {return vtkNew < vtkQuadraticPolygon > () ;} -extern "C" void vtkQuadraticPolygon_destructor (vtkNew < vtkQuadraticPolygon > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticPolygon_get_ptr (vtkNew < vtkQuadraticPolygon > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quadratic_polygon_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadratic_polygon_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quadratic_polygon_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quadratic_polygon_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quadratic_polygon_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quadratic_polygon_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_quadratic_polygon_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_quadratic_polygon_interpolate_functions(vtkNew sself, const double x, double weights) { sself->InterpolateFunctions(x, weights); } -extern "C" int vtk_quadratic_polygon_parameterize_polygon(vtkNew sself, double p0, double p10, double l10, double p20, double l20, double n) { return sself->ParameterizePolygon(p0, p10, l10, p20, l20, n); } -extern "C" int vtk_quadratic_polygon_point_in_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double n) { return sself->PointInPolygon(x, numPts, pts, bounds, n); } -extern "C" double vtk_quadratic_polygon_distance_to_polygon(vtkNew sself, double x, int numPts, double pts, double bounds, double closest) { return sself->DistanceToPolygon(x, numPts, pts, bounds, closest); } -extern "C" int vtk_quadratic_polygon_intersect_polygon_with_polygon(vtkNew sself, int npts, double pts, double bounds, int npts2, double pts2, double bounds2, double tol, double x) { return sself->IntersectPolygonWithPolygon(npts, pts, bounds, npts2, pts2, bounds2, tol, x); } -extern "C" void vtk_quadratic_polygon_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" bool vtk_quadratic_polygon_get_use_mvc_interpolation(vtkNew sself) { return sself->GetUseMVCInterpolation(); } -extern "C" void vtk_quadratic_polygon_set_use_mvc_interpolation(vtkNew sself, bool _arg) { sself->SetUseMVCInterpolation(_arg); } -extern "C" vtkNew < vtkQuadraticPyramid > vtkQuadraticPyramid_new () {return vtkNew < vtkQuadraticPyramid > () ;} -extern "C" void vtkQuadraticPyramid_destructor (vtkNew < vtkQuadraticPyramid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticPyramid_get_ptr (vtkNew < vtkQuadraticPyramid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quadratic_pyramid_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadratic_pyramid_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quadratic_pyramid_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quadratic_pyramid_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quadratic_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quadratic_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_quadratic_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_quadratic_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_quadratic_pyramid_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_quadratic_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_quadratic_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_quadratic_pyramid_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_quadratic_pyramid_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" void vtk_quadratic_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkQuadraticQuad > vtkQuadraticQuad_new () {return vtkNew < vtkQuadraticQuad > () ;} -extern "C" void vtkQuadraticQuad_destructor (vtkNew < vtkQuadraticQuad > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticQuad_get_ptr (vtkNew < vtkQuadraticQuad > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quadratic_quad_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadratic_quad_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quadratic_quad_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quadratic_quad_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quadratic_quad_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quadratic_quad_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_quadratic_quad_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_quadratic_quad_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_quadratic_quad_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_quadratic_quad_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_quad_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_quadratic_quad_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_quad_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" vtkNew < vtkQuadraticTetra > vtkQuadraticTetra_new () {return vtkNew < vtkQuadraticTetra > () ;} -extern "C" void vtkQuadraticTetra_destructor (vtkNew < vtkQuadraticTetra > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticTetra_get_ptr (vtkNew < vtkQuadraticTetra > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quadratic_tetra_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadratic_tetra_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quadratic_tetra_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quadratic_tetra_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quadratic_tetra_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quadratic_tetra_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_quadratic_tetra_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_quadratic_tetra_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_quadratic_tetra_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" double vtk_quadratic_tetra_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } -extern "C" void vtk_quadratic_tetra_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_tetra_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_quadratic_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_tetra_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_quadratic_tetra_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_quadratic_tetra_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" void vtk_quadratic_tetra_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkQuadraticTriangle > vtkQuadraticTriangle_new () {return vtkNew < vtkQuadraticTriangle > () ;} -extern "C" void vtkQuadraticTriangle_destructor (vtkNew < vtkQuadraticTriangle > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticTriangle_get_ptr (vtkNew < vtkQuadraticTriangle > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quadratic_triangle_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadratic_triangle_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quadratic_triangle_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quadratic_triangle_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quadratic_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quadratic_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_quadratic_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_quadratic_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_quadratic_triangle_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" double vtk_quadratic_triangle_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } -extern "C" void vtk_quadratic_triangle_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_quadratic_triangle_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" vtkNew < vtkQuadraticWedge > vtkQuadraticWedge_new () {return vtkNew < vtkQuadraticWedge > () ;} -extern "C" void vtkQuadraticWedge_destructor (vtkNew < vtkQuadraticWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticWedge_get_ptr (vtkNew < vtkQuadraticWedge > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quadratic_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadratic_wedge_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_quadratic_wedge_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_quadratic_wedge_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_quadratic_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_quadratic_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_quadratic_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_quadratic_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_quadratic_wedge_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_quadratic_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_quadratic_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_quadratic_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_quadratic_wedge_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_quadratic_wedge_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" void vtk_quadratic_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkQuadratureSchemeDefinition > vtkQuadratureSchemeDefinition_new () {return vtkNew < vtkQuadratureSchemeDefinition > () ;} -extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkNew < vtkQuadratureSchemeDefinition > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadratureSchemeDefinition_get_ptr (vtkNew < vtkQuadratureSchemeDefinition > sself) {return sself . GetPointer () ;} -extern "C" void vtk_quadrature_scheme_definition_clear(vtkNew sself) { sself->Clear(); } -extern "C" void vtk_quadrature_scheme_definition_initialize(vtkNew sself, int cellType, int numberOfNodes, int numberOfQuadraturePoints, double shapeFunctionWeights) { sself->Initialize(cellType, numberOfNodes, numberOfQuadraturePoints, shapeFunctionWeights); } -extern "C" void vtk_quadrature_scheme_definition_initialize(vtkNew sself, int cellType, int numberOfNodes, int numberOfQuadraturePoints, double shapeFunctionWeights, double quadratureWeights) { sself->Initialize(cellType, numberOfNodes, numberOfQuadraturePoints, shapeFunctionWeights, quadratureWeights); } -extern "C" int vtk_quadrature_scheme_definition_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_quadrature_scheme_definition_get_quadrature_key(vtkNew sself) { return sself->GetQuadratureKey(); } -extern "C" int vtk_quadrature_scheme_definition_get_number_of_nodes(vtkNew sself) { return sself->GetNumberOfNodes(); } -extern "C" int vtk_quadrature_scheme_definition_get_number_of_quadrature_points(vtkNew sself) { return sself->GetNumberOfQuadraturePoints(); } -extern "C" const double* vtk_quadrature_scheme_definition_get_shape_function_weights(vtkNew sself) { return sself->GetShapeFunctionWeights(); } -extern "C" const double* vtk_quadrature_scheme_definition_get_shape_function_weights(vtkNew sself, int quadraturePointId) { return sself->GetShapeFunctionWeights(quadraturePointId); } -extern "C" const double* vtk_quadrature_scheme_definition_get_quadrature_weights(vtkNew sself) { return sself->GetQuadratureWeights(); } -extern "C" vtkNew < vtkQuadric > vtkQuadric_new () {return vtkNew < vtkQuadric > () ;} -extern "C" void vtkQuadric_destructor (vtkNew < vtkQuadric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadric_get_ptr (vtkNew < vtkQuadric > sself) {return sself . GetPointer () ;} -extern "C" double vtk_quadric_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_quadric_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } -extern "C" void vtk_quadric_set_coefficients(vtkNew sself, double a) { sself->SetCoefficients(a); } -extern "C" void vtk_quadric_set_coefficients(vtkNew sself, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9) { sself->SetCoefficients(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } -extern "C" double* vtk_quadric_get_coefficients(vtkNew sself) { return sself->GetCoefficients(); } -extern "C" void vtk_quadric_get_coefficients(vtkNew sself, double data) { sself->GetCoefficients(data); } -extern "C" vtkNew < vtkRectilinearGrid > vtkRectilinearGrid_new () {return vtkNew < vtkRectilinearGrid > () ;} -extern "C" void vtkRectilinearGrid_destructor (vtkNew < vtkRectilinearGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRectilinearGrid_get_ptr (vtkNew < vtkRectilinearGrid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_rectilinear_grid_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" void vtk_rectilinear_grid_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" long long vtk_rectilinear_grid_get_number_of_cells(vtkNew sself) { return sself->GetNumberOfCells(); } -extern "C" long long vtk_rectilinear_grid_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" double* vtk_rectilinear_grid_get_point(vtkNew sself, long long ptId) { return sself->GetPoint(ptId); } -extern "C" long long vtk_rectilinear_grid_find_point(vtkNew sself, double x) { return sself->FindPoint(x); } -extern "C" int vtk_rectilinear_grid_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } -extern "C" int vtk_rectilinear_grid_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } -extern "C" unsigned char vtk_rectilinear_grid_is_point_visible(vtkNew sself, long long ptId) { return sself->IsPointVisible(ptId); } -extern "C" unsigned char vtk_rectilinear_grid_is_cell_visible(vtkNew sself, long long cellId) { return sself->IsCellVisible(cellId); } -extern "C" bool vtk_rectilinear_grid_has_any_blank_points(vtkNew sself) { return sself->HasAnyBlankPoints(); } -extern "C" bool vtk_rectilinear_grid_has_any_blank_cells(vtkNew sself) { return sself->HasAnyBlankCells(); } -extern "C" void vtk_rectilinear_grid_get_cell_dims(vtkNew sself, int cellDims) { sself->GetCellDims(cellDims); } -extern "C" void vtk_rectilinear_grid_set_dimensions(vtkNew sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } -extern "C" void vtk_rectilinear_grid_set_dimensions(vtkNew sself, const int dim) { sself->SetDimensions(dim); } -extern "C" int* vtk_rectilinear_grid_get_dimensions(vtkNew sself) { return sself->GetDimensions(); } -extern "C" void vtk_rectilinear_grid_get_dimensions(vtkNew sself, int data) { sself->GetDimensions(data); } -extern "C" int vtk_rectilinear_grid_get_data_dimension(vtkNew sself) { return sself->GetDataDimension(); } -extern "C" int vtk_rectilinear_grid_compute_structured_coordinates(vtkNew sself, double x, int ijk, double pcoords) { return sself->ComputeStructuredCoordinates(x, ijk, pcoords); } -extern "C" long long vtk_rectilinear_grid_compute_point_id(vtkNew sself, int ijk) { return sself->ComputePointId(ijk); } -extern "C" long long vtk_rectilinear_grid_compute_cell_id(vtkNew sself, int ijk) { return sself->ComputeCellId(ijk); } -extern "C" void vtk_rectilinear_grid_get_point(vtkNew sself, const int i, const int j, const int k, double p) { sself->GetPoint(i, j, k, p); } -extern "C" void vtk_rectilinear_grid_set_extent(vtkNew sself, int extent) { sself->SetExtent(extent); } -extern "C" void vtk_rectilinear_grid_set_extent(vtkNew sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax) { sself->SetExtent(xMin, xMax, yMin, yMax, zMin, zMax); } -extern "C" int* vtk_rectilinear_grid_get_extent(vtkNew sself) { return sself->GetExtent(); } -extern "C" void vtk_rectilinear_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_rectilinear_grid_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } -extern "C" int vtk_rectilinear_grid_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } -extern "C" void vtk_rectilinear_grid_crop(vtkNew sself, const int updateExtent) { sself->Crop(updateExtent); } -extern "C" int vtk_rectilinear_grid_get_scalar_type(vtkNew sself) { return sself->GetScalarType(); } -extern "C" const char* vtk_rectilinear_grid_get_scalar_type_as_string(vtkNew sself) { return sself->GetScalarTypeAsString(); } -extern "C" int vtk_rectilinear_grid_get_number_of_scalar_components(vtkNew sself) { return sself->GetNumberOfScalarComponents(); } -extern "C" vtkNew < vtkReebGraph > vtkReebGraph_new () {return vtkNew < vtkReebGraph > () ;} -extern "C" void vtkReebGraph_destructor (vtkNew < vtkReebGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkReebGraph_get_ptr (vtkNew < vtkReebGraph > sself) {return sself . GetPointer () ;} -extern "C" int vtk_reeb_graph_stream_triangle(vtkNew sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2) { return sself->StreamTriangle(vertex0Id, scalar0, vertex1Id, scalar1, vertex2Id, scalar2); } -extern "C" int vtk_reeb_graph_stream_tetrahedron(vtkNew sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2, long long vertex3Id, double scalar3) { return sself->StreamTetrahedron(vertex0Id, scalar0, vertex1Id, scalar1, vertex2Id, scalar2, vertex3Id, scalar3); } -extern "C" void vtk_reeb_graph_close_stream(vtkNew sself) { sself->CloseStream(); } -extern "C" vtkNew < vtkReebGraphSimplificationMetric > vtkReebGraphSimplificationMetric_new () {return vtkNew < vtkReebGraphSimplificationMetric > () ;} -extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkNew < vtkReebGraphSimplificationMetric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkReebGraphSimplificationMetric_get_ptr (vtkNew < vtkReebGraphSimplificationMetric > sself) {return sself . GetPointer () ;} -extern "C" void vtk_reeb_graph_simplification_metric_set_lower_bound(vtkNew sself, double _arg) { sself->SetLowerBound(_arg); } -extern "C" double vtk_reeb_graph_simplification_metric_get_lower_bound(vtkNew sself) { return sself->GetLowerBound(); } -extern "C" void vtk_reeb_graph_simplification_metric_set_upper_bound(vtkNew sself, double _arg) { sself->SetUpperBound(_arg); } -extern "C" double vtk_reeb_graph_simplification_metric_get_upper_bound(vtkNew sself) { return sself->GetUpperBound(); } -extern "C" vtkNew < vtkSelection > vtkSelection_new () {return vtkNew < vtkSelection > () ;} -extern "C" void vtkSelection_destructor (vtkNew < vtkSelection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSelection_get_ptr (vtkNew < vtkSelection > sself) {return sself . GetPointer () ;} -extern "C" int vtk_selection_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" unsigned int vtk_selection_get_number_of_nodes(vtkNew sself) { return sself->GetNumberOfNodes(); } -extern "C" const char* vtk_selection_get_node_name_at_index(vtkNew sself, unsigned int idx) { return sself->GetNodeNameAtIndex(idx); } -extern "C" void vtk_selection_remove_node(vtkNew sself, unsigned int idx) { sself->RemoveNode(idx); } -extern "C" void vtk_selection_remove_node(vtkNew sself, const char* name) { sself->RemoveNode(name); } -extern "C" void vtk_selection_remove_all_nodes(vtkNew sself) { sself->RemoveAllNodes(); } -extern "C" void vtk_selection_set_expression(vtkNew sself, const char* _arg) { sself->SetExpression(_arg); } -extern "C" const char* vtk_selection_get_expression(vtkNew sself) { return sself->GetExpression(); } -extern "C" unsigned long vtk_selection_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_selection_dump(vtkNew sself) { sself->Dump(); } -extern "C" vtkNew < vtkSelectionNode > vtkSelectionNode_new () {return vtkNew < vtkSelectionNode > () ;} -extern "C" void vtkSelectionNode_destructor (vtkNew < vtkSelectionNode > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSelectionNode_get_ptr (vtkNew < vtkSelectionNode > sself) {return sself . GetPointer () ;} -extern "C" void vtk_selection_node_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" unsigned long vtk_selection_node_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_selection_node_set_content_type(vtkNew sself, int type) { sself->SetContentType(type); } -extern "C" int vtk_selection_node_get_content_type(vtkNew sself) { return sself->GetContentType(); } -extern "C" const char* vtk_selection_node_get_content_type_as_string(vtkNew sself, int type) { return sself->GetContentTypeAsString(type); } -extern "C" void vtk_selection_node_set_field_type(vtkNew sself, int type) { sself->SetFieldType(type); } -extern "C" int vtk_selection_node_get_field_type(vtkNew sself) { return sself->GetFieldType(); } -extern "C" const char* vtk_selection_node_get_field_type_as_string(vtkNew sself, int type) { return sself->GetFieldTypeAsString(type); } -extern "C" int vtk_selection_node_get_field_type_from_string(vtkNew sself, const char type) { return sself->GetFieldTypeFromString(type); } -extern "C" int vtk_selection_node_convert_selection_field_to_attribute_type(vtkNew sself, int val) { return sself->ConvertSelectionFieldToAttributeType(val); } -extern "C" int vtk_selection_node_convert_attribute_type_to_selection_field(vtkNew sself, int val) { return sself->ConvertAttributeTypeToSelectionField(val); } -extern "C" void vtk_selection_node_set_query_string(vtkNew sself, const char _arg) { sself->SetQueryString(_arg); } -extern "C" char* vtk_selection_node_get_query_string(vtkNew sself) { return sself->GetQueryString(); } -extern "C" vtkNew < vtkSimpleCellTessellator > vtkSimpleCellTessellator_new () {return vtkNew < vtkSimpleCellTessellator > () ;} -extern "C" void vtkSimpleCellTessellator_destructor (vtkNew < vtkSimpleCellTessellator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSimpleCellTessellator_get_ptr (vtkNew < vtkSimpleCellTessellator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_simple_cell_tessellator_reset(vtkNew sself) { sself->Reset(); } -extern "C" int vtk_simple_cell_tessellator_get_fixed_subdivisions(vtkNew sself) { return sself->GetFixedSubdivisions(); } -extern "C" int vtk_simple_cell_tessellator_get_max_subdivision_level(vtkNew sself) { return sself->GetMaxSubdivisionLevel(); } -extern "C" int vtk_simple_cell_tessellator_get_max_adaptive_subdivisions(vtkNew sself) { return sself->GetMaxAdaptiveSubdivisions(); } -extern "C" void vtk_simple_cell_tessellator_set_fixed_subdivisions(vtkNew sself, int level) { sself->SetFixedSubdivisions(level); } -extern "C" void vtk_simple_cell_tessellator_set_max_subdivision_level(vtkNew sself, int level) { sself->SetMaxSubdivisionLevel(level); } -extern "C" void vtk_simple_cell_tessellator_set_subdivision_levels(vtkNew sself, int fixed, int maxLevel) { sself->SetSubdivisionLevels(fixed, maxLevel); } -extern "C" vtkNew < vtkSmoothErrorMetric > vtkSmoothErrorMetric_new () {return vtkNew < vtkSmoothErrorMetric > () ;} -extern "C" void vtkSmoothErrorMetric_destructor (vtkNew < vtkSmoothErrorMetric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSmoothErrorMetric_get_ptr (vtkNew < vtkSmoothErrorMetric > sself) {return sself . GetPointer () ;} -extern "C" double vtk_smooth_error_metric_get_angle_tolerance(vtkNew sself) { return sself->GetAngleTolerance(); } -extern "C" void vtk_smooth_error_metric_set_angle_tolerance(vtkNew sself, double value) { sself->SetAngleTolerance(value); } -extern "C" int vtk_smooth_error_metric_requires_edge_subdivision(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->RequiresEdgeSubdivision(leftPoint, midPoint, rightPoint, alpha); } -extern "C" double vtk_smooth_error_metric_get_error(vtkNew sself, double leftPoint, double midPoint, double rightPoint, double alpha) { return sself->GetError(leftPoint, midPoint, rightPoint, alpha); } -extern "C" vtkNew < vtkSortFieldData > vtkSortFieldData_new () {return vtkNew < vtkSortFieldData > () ;} -extern "C" void vtkSortFieldData_destructor (vtkNew < vtkSortFieldData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSortFieldData_get_ptr (vtkNew < vtkSortFieldData > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSphere > vtkSphere_new () {return vtkNew < vtkSphere > () ;} -extern "C" void vtkSphere_destructor (vtkNew < vtkSphere > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSphere_get_ptr (vtkNew < vtkSphere > sself) {return sself . GetPointer () ;} -extern "C" double vtk_sphere_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_sphere_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } -extern "C" void vtk_sphere_set_radius(vtkNew sself, double _arg) { sself->SetRadius(_arg); } -extern "C" double vtk_sphere_get_radius(vtkNew sself) { return sself->GetRadius(); } -extern "C" void vtk_sphere_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } -extern "C" void vtk_sphere_set_center(vtkNew sself, const double _arg) { sself->SetCenter(_arg); } -extern "C" double* vtk_sphere_get_center(vtkNew sself) { return sself->GetCenter(); } -extern "C" void vtk_sphere_get_center(vtkNew sself, double data) { sself->GetCenter(data); } -extern "C" double vtk_sphere_evaluate(vtkNew sself, double center, double R, double x) { return sself->Evaluate(center, R, x); } -extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, float pts, long long numPts, float sphere, long long hints) { sself->ComputeBoundingSphere(pts, numPts, sphere, hints); } -extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, double pts, long long numPts, double sphere, long long hints) { sself->ComputeBoundingSphere(pts, numPts, sphere, hints); } -extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, float spheres, long long numSpheres, float sphere, long long hints) { sself->ComputeBoundingSphere(spheres, numSpheres, sphere, hints); } -extern "C" void vtk_sphere_compute_bounding_sphere(vtkNew sself, double spheres, long long numSpheres, double sphere, long long hints) { sself->ComputeBoundingSphere(spheres, numSpheres, sphere, hints); } -extern "C" vtkNew < vtkSpheres > vtkSpheres_new () {return vtkNew < vtkSpheres > () ;} -extern "C" void vtkSpheres_destructor (vtkNew < vtkSpheres > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSpheres_get_ptr (vtkNew < vtkSpheres > sself) {return sself . GetPointer () ;} -extern "C" double vtk_spheres_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_spheres_evaluate_gradient(vtkNew sself, double x, double n) { sself->EvaluateGradient(x, n); } -extern "C" int vtk_spheres_get_number_of_spheres(vtkNew sself) { return sself->GetNumberOfSpheres(); } -extern "C" vtkNew < vtkStaticCellLinks > vtkStaticCellLinks_new () {return vtkNew < vtkStaticCellLinks > () ;} -extern "C" void vtkStaticCellLinks_destructor (vtkNew < vtkStaticCellLinks > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStaticCellLinks_get_ptr (vtkNew < vtkStaticCellLinks > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_static_cell_links_get_number_of_cells(vtkNew sself, long long ptId) { return sself->GetNumberOfCells(ptId); } -extern "C" long long vtk_static_cell_links_get_ncells(vtkNew sself, long long ptId) { return sself->GetNcells(ptId); } -extern "C" long long* vtk_static_cell_links_get_cells(vtkNew sself, long long ptId) { return sself->GetCells(ptId); } -extern "C" void vtk_static_cell_links_select_cells(vtkNew sself, long long minMaxDegree, unsigned char cellSelection) { sself->SelectCells(minMaxDegree, cellSelection); } -extern "C" void vtk_static_cell_links_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_static_cell_links_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" void vtk_static_cell_links_reset(vtkNew sself) { sself->Reset(); } -extern "C" unsigned long vtk_static_cell_links_get_actual_memory_size(vtkNew sself) { return sself->GetActualMemorySize(); } -extern "C" vtkNew < vtkStaticCellLocator > vtkStaticCellLocator_new () {return vtkNew < vtkStaticCellLocator > () ;} -extern "C" void vtkStaticCellLocator_destructor (vtkNew < vtkStaticCellLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStaticCellLocator_get_ptr (vtkNew < vtkStaticCellLocator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_static_cell_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } -extern "C" void vtk_static_cell_locator_set_divisions(vtkNew sself, const int _arg) { sself->SetDivisions(_arg); } -extern "C" int* vtk_static_cell_locator_get_divisions(vtkNew sself) { return sself->GetDivisions(); } -extern "C" void vtk_static_cell_locator_get_divisions(vtkNew sself, int data) { sself->GetDivisions(data); } -extern "C" long long vtk_static_cell_locator_find_cell(vtkNew sself, double x) { return sself->FindCell(x); } -extern "C" int vtk_static_cell_locator_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_static_cell_locator_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId, long long cellId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId, cellId); } -extern "C" void vtk_static_cell_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } -extern "C" void vtk_static_cell_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } -extern "C" void vtk_static_cell_locator_set_max_number_of_buckets(vtkNew sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } -extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_min_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMinValue(); } -extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_max_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } -extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets(vtkNew sself) { return sself->GetMaxNumberOfBuckets(); } -extern "C" bool vtk_static_cell_locator_get_large_ids(vtkNew sself) { return sself->GetLargeIds(); } -extern "C" void vtk_static_cell_locator_set_use_diagonal_length_tolerance(vtkNew sself, bool _arg) { sself->SetUseDiagonalLengthTolerance(_arg); } -extern "C" bool vtk_static_cell_locator_get_use_diagonal_length_tolerance(vtkNew sself) { return sself->GetUseDiagonalLengthTolerance(); } -extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_on(vtkNew sself) { sself->UseDiagonalLengthToleranceOn(); } -extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_off(vtkNew sself) { sself->UseDiagonalLengthToleranceOff(); } -extern "C" vtkNew < vtkStaticPointLocator > vtkStaticPointLocator_new () {return vtkNew < vtkStaticPointLocator > () ;} -extern "C" void vtkStaticPointLocator_destructor (vtkNew < vtkStaticPointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStaticPointLocator_get_ptr (vtkNew < vtkStaticPointLocator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_static_point_locator_set_number_of_points_per_bucket(vtkNew sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } -extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_min_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } -extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_max_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } -extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket(vtkNew sself) { return sself->GetNumberOfPointsPerBucket(); } -extern "C" void vtk_static_point_locator_set_divisions(vtkNew sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } -extern "C" void vtk_static_point_locator_set_divisions(vtkNew sself, const int _arg) { sself->SetDivisions(_arg); } -extern "C" int* vtk_static_point_locator_get_divisions(vtkNew sself) { return sself->GetDivisions(); } -extern "C" void vtk_static_point_locator_get_divisions(vtkNew sself, int data) { sself->GetDivisions(data); } -extern "C" long long vtk_static_point_locator_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } -extern "C" long long vtk_static_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } -extern "C" long long vtk_static_point_locator_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, inputDataLength, dist2); } -extern "C" int vtk_static_point_locator_intersect_with_line(vtkNew sself, double a0, double a1, double tol, double t, double lineX, double ptX, long long ptId) { return sself->IntersectWithLine(a0, a1, tol, t, lineX, ptX, ptId); } -extern "C" void vtk_static_point_locator_merge_points(vtkNew sself, double tol, long long mergeMap) { sself->MergePoints(tol, mergeMap); } -extern "C" void vtk_static_point_locator_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_static_point_locator_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } -extern "C" void vtk_static_point_locator_build_locator(vtkNew sself) { sself->BuildLocator(); } -extern "C" void vtk_static_point_locator_build_locator(vtkNew sself, const double inBounds) { sself->BuildLocator(inBounds); } -extern "C" long long vtk_static_point_locator_get_number_of_points_in_bucket(vtkNew sself, long long bNum) { return sself->GetNumberOfPointsInBucket(bNum); } -extern "C" void vtk_static_point_locator_set_max_number_of_buckets(vtkNew sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } -extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_min_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMinValue(); } -extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_max_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } -extern "C" long long vtk_static_point_locator_get_max_number_of_buckets(vtkNew sself) { return sself->GetMaxNumberOfBuckets(); } -extern "C" bool vtk_static_point_locator_get_large_ids(vtkNew sself) { return sself->GetLargeIds(); } -extern "C" double* vtk_static_point_locator_get_spacing(vtkNew sself) { return sself->GetSpacing(); } -extern "C" void vtk_static_point_locator_get_spacing(vtkNew sself, double spacing) { sself->GetSpacing(spacing); } -extern "C" vtkNew < vtkStaticPointLocator2D > vtkStaticPointLocator2D_new () {return vtkNew < vtkStaticPointLocator2D > () ;} -extern "C" void vtkStaticPointLocator2D_destructor (vtkNew < vtkStaticPointLocator2D > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStaticPointLocator2D_get_ptr (vtkNew < vtkStaticPointLocator2D > sself) {return sself . GetPointer () ;} -extern "C" void vtk_static_point_locator_2_d_set_number_of_points_per_bucket(vtkNew sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } -extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } -extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value(vtkNew sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } -extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket(vtkNew sself) { return sself->GetNumberOfPointsPerBucket(); } -extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkNew sself, int _arg1, int _arg2) { sself->SetDivisions(_arg1, _arg2); } -extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkNew sself, const int _arg) { sself->SetDivisions(_arg); } -extern "C" int* vtk_static_point_locator_2_d_get_divisions(vtkNew sself) { return sself->GetDivisions(); } -extern "C" void vtk_static_point_locator_2_d_get_divisions(vtkNew sself, int data) { sself->GetDivisions(data); } -extern "C" long long vtk_static_point_locator_2_d_find_closest_point(vtkNew sself, const double x) { return sself->FindClosestPoint(x); } -extern "C" long long vtk_static_point_locator_2_d_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, dist2); } -extern "C" long long vtk_static_point_locator_2_d_find_closest_point_within_radius(vtkNew sself, double radius, const double x, double inputDataLength, double dist2) { return sself->FindClosestPointWithinRadius(radius, x, inputDataLength, dist2); } -extern "C" int vtk_static_point_locator_2_d_intersect_with_line(vtkNew sself, double a0, double a1, double tol, double t, double lineX, double ptX, long long ptId) { return sself->IntersectWithLine(a0, a1, tol, t, lineX, ptX, ptId); } -extern "C" void vtk_static_point_locator_2_d_merge_points(vtkNew sself, double tol, long long mergeMap) { sself->MergePoints(tol, mergeMap); } -extern "C" void vtk_static_point_locator_2_d_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_static_point_locator_2_d_free_search_structure(vtkNew sself) { sself->FreeSearchStructure(); } -extern "C" void vtk_static_point_locator_2_d_build_locator(vtkNew sself) { sself->BuildLocator(); } -extern "C" long long vtk_static_point_locator_2_d_get_number_of_points_in_bucket(vtkNew sself, long long bNum) { return sself->GetNumberOfPointsInBucket(bNum); } -extern "C" void vtk_static_point_locator_2_d_set_max_number_of_buckets(vtkNew sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } -extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMinValue(); } -extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(vtkNew sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } -extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets(vtkNew sself) { return sself->GetMaxNumberOfBuckets(); } -extern "C" bool vtk_static_point_locator_2_d_get_large_ids(vtkNew sself) { return sself->GetLargeIds(); } -extern "C" void vtk_static_point_locator_2_d_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" double* vtk_static_point_locator_2_d_get_spacing(vtkNew sself) { return sself->GetSpacing(); } -extern "C" void vtk_static_point_locator_2_d_get_spacing(vtkNew sself, double spacing) { sself->GetSpacing(spacing); } -extern "C" void vtk_static_point_locator_2_d_get_bucket_indices(vtkNew sself, const double x, int ij) { sself->GetBucketIndices(x, ij); } -extern "C" long long vtk_static_point_locator_2_d_get_bucket_index(vtkNew sself, const double x) { return sself->GetBucketIndex(x); } -extern "C" vtkNew < vtkStructuredExtent > vtkStructuredExtent_new () {return vtkNew < vtkStructuredExtent > () ;} -extern "C" void vtkStructuredExtent_destructor (vtkNew < vtkStructuredExtent > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStructuredExtent_get_ptr (vtkNew < vtkStructuredExtent > sself) {return sself . GetPointer () ;} -extern "C" void vtk_structured_extent_clamp(vtkNew sself, int ext, const int wholeExt) { sself->Clamp(ext, wholeExt); } -extern "C" bool vtk_structured_extent_strictly_smaller(vtkNew sself, const int ext, const int wholeExt) { return sself->StrictlySmaller(ext, wholeExt); } -extern "C" bool vtk_structured_extent_smaller(vtkNew sself, const int ext, const int wholeExt) { return sself->Smaller(ext, wholeExt); } -extern "C" void vtk_structured_extent_grow(vtkNew sself, int ext, int count) { sself->Grow(ext, count); } -extern "C" void vtk_structured_extent_grow(vtkNew sself, int ext, int count, int wholeExt) { sself->Grow(ext, count, wholeExt); } -extern "C" void vtk_structured_extent_transform(vtkNew sself, int ext, int wholeExt) { sself->Transform(ext, wholeExt); } -extern "C" void vtk_structured_extent_get_dimensions(vtkNew sself, const int ext, int dims) { sself->GetDimensions(ext, dims); } -extern "C" vtkNew < vtkStructuredGrid > vtkStructuredGrid_new () {return vtkNew < vtkStructuredGrid > () ;} -extern "C" void vtkStructuredGrid_destructor (vtkNew < vtkStructuredGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStructuredGrid_get_ptr (vtkNew < vtkStructuredGrid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_structured_grid_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" long long vtk_structured_grid_get_number_of_points(vtkNew sself) { return sself->GetNumberOfPoints(); } -extern "C" void vtk_structured_grid_get_point(vtkNew sself, long long ptId, double p) { sself->GetPoint(ptId, p); } -extern "C" int vtk_structured_grid_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } -extern "C" void vtk_structured_grid_set_dimensions(vtkNew sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } -extern "C" void vtk_structured_grid_set_dimensions(vtkNew sself, const int dim) { sself->SetDimensions(dim); } -extern "C" int* vtk_structured_grid_get_dimensions(vtkNew sself) { return sself->GetDimensions(); } -extern "C" void vtk_structured_grid_get_dimensions(vtkNew sself, int dim) { sself->GetDimensions(dim); } -extern "C" int vtk_structured_grid_get_data_dimension(vtkNew sself) { return sself->GetDataDimension(); } -extern "C" void vtk_structured_grid_set_extent(vtkNew sself, int extent) { sself->SetExtent(extent); } -extern "C" void vtk_structured_grid_set_extent(vtkNew sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax) { sself->SetExtent(xMin, xMax, yMin, yMax, zMin, zMax); } -extern "C" int* vtk_structured_grid_get_extent(vtkNew sself) { return sself->GetExtent(); } -extern "C" void vtk_structured_grid_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_structured_grid_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } -extern "C" int vtk_structured_grid_get_extent_type(vtkNew sself) { return sself->GetExtentType(); } -extern "C" void vtk_structured_grid_blank_point(vtkNew sself, long long ptId) { sself->BlankPoint(ptId); } -extern "C" void vtk_structured_grid_un_blank_point(vtkNew sself, long long ptId) { sself->UnBlankPoint(ptId); } -extern "C" void vtk_structured_grid_blank_cell(vtkNew sself, long long ptId) { sself->BlankCell(ptId); } -extern "C" void vtk_structured_grid_un_blank_cell(vtkNew sself, long long ptId) { sself->UnBlankCell(ptId); } -extern "C" unsigned char vtk_structured_grid_is_point_visible(vtkNew sself, long long ptId) { return sself->IsPointVisible(ptId); } -extern "C" unsigned char vtk_structured_grid_is_cell_visible(vtkNew sself, long long cellId) { return sself->IsCellVisible(cellId); } -extern "C" bool vtk_structured_grid_has_any_blank_points(vtkNew sself) { return sself->HasAnyBlankPoints(); } -extern "C" bool vtk_structured_grid_has_any_blank_cells(vtkNew sself) { return sself->HasAnyBlankCells(); } -extern "C" void vtk_structured_grid_get_cell_dims(vtkNew sself, int cellDims) { sself->GetCellDims(cellDims); } -extern "C" void vtk_structured_grid_crop(vtkNew sself, const int updateExtent) { sself->Crop(updateExtent); } -extern "C" void vtk_structured_grid_get_point(vtkNew sself, int i, int j, int k, double p, bool adjustForExtent) { sself->GetPoint(i, j, k, p, adjustForExtent); } -extern "C" vtkNew < vtkStructuredPoints > vtkStructuredPoints_new () {return vtkNew < vtkStructuredPoints > () ;} -extern "C" void vtkStructuredPoints_destructor (vtkNew < vtkStructuredPoints > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStructuredPoints_get_ptr (vtkNew < vtkStructuredPoints > sself) {return sself . GetPointer () ;} -extern "C" int vtk_structured_points_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" vtkNew < vtkStructuredPointsCollection > vtkStructuredPointsCollection_new () {return vtkNew < vtkStructuredPointsCollection > () ;} -extern "C" void vtkStructuredPointsCollection_destructor (vtkNew < vtkStructuredPointsCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStructuredPointsCollection_get_ptr (vtkNew < vtkStructuredPointsCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSuperquadric > vtkSuperquadric_new () {return vtkNew < vtkSuperquadric > () ;} -extern "C" void vtkSuperquadric_destructor (vtkNew < vtkSuperquadric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSuperquadric_get_ptr (vtkNew < vtkSuperquadric > sself) {return sself . GetPointer () ;} -extern "C" double vtk_superquadric_evaluate_function(vtkNew sself, double x) { return sself->EvaluateFunction(x); } -extern "C" void vtk_superquadric_evaluate_gradient(vtkNew sself, double x, double g) { sself->EvaluateGradient(x, g); } -extern "C" void vtk_superquadric_set_center(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } -extern "C" void vtk_superquadric_set_center(vtkNew sself, const double _arg) { sself->SetCenter(_arg); } -extern "C" double* vtk_superquadric_get_center(vtkNew sself) { return sself->GetCenter(); } -extern "C" void vtk_superquadric_get_center(vtkNew sself, double data) { sself->GetCenter(data); } -extern "C" void vtk_superquadric_set_scale(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetScale(_arg1, _arg2, _arg3); } -extern "C" void vtk_superquadric_set_scale(vtkNew sself, const double _arg) { sself->SetScale(_arg); } -extern "C" double* vtk_superquadric_get_scale(vtkNew sself) { return sself->GetScale(); } -extern "C" void vtk_superquadric_get_scale(vtkNew sself, double data) { sself->GetScale(data); } -extern "C" double vtk_superquadric_get_thickness(vtkNew sself) { return sself->GetThickness(); } -extern "C" void vtk_superquadric_set_thickness(vtkNew sself, double _arg) { sself->SetThickness(_arg); } -extern "C" double vtk_superquadric_get_thickness_min_value(vtkNew sself) { return sself->GetThicknessMinValue(); } -extern "C" double vtk_superquadric_get_thickness_max_value(vtkNew sself) { return sself->GetThicknessMaxValue(); } -extern "C" double vtk_superquadric_get_phi_roundness(vtkNew sself) { return sself->GetPhiRoundness(); } -extern "C" void vtk_superquadric_set_phi_roundness(vtkNew sself, double e) { sself->SetPhiRoundness(e); } -extern "C" double vtk_superquadric_get_theta_roundness(vtkNew sself) { return sself->GetThetaRoundness(); } -extern "C" void vtk_superquadric_set_theta_roundness(vtkNew sself, double e) { sself->SetThetaRoundness(e); } -extern "C" void vtk_superquadric_set_size(vtkNew sself, double _arg) { sself->SetSize(_arg); } -extern "C" double vtk_superquadric_get_size(vtkNew sself) { return sself->GetSize(); } -extern "C" void vtk_superquadric_toroidal_on(vtkNew sself) { sself->ToroidalOn(); } -extern "C" void vtk_superquadric_toroidal_off(vtkNew sself) { sself->ToroidalOff(); } -extern "C" int vtk_superquadric_get_toroidal(vtkNew sself) { return sself->GetToroidal(); } -extern "C" void vtk_superquadric_set_toroidal(vtkNew sself, int _arg) { sself->SetToroidal(_arg); } -extern "C" vtkNew < vtkTable > vtkTable_new () {return vtkNew < vtkTable > () ;} -extern "C" void vtkTable_destructor (vtkNew < vtkTable > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTable_get_ptr (vtkNew < vtkTable > sself) {return sself . GetPointer () ;} -extern "C" void vtk_table_dump(vtkNew sself, unsigned int colWidth, int rowLimit) { sself->Dump(colWidth, rowLimit); } -extern "C" int vtk_table_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" long long vtk_table_get_number_of_rows(vtkNew sself) { return sself->GetNumberOfRows(); } -extern "C" void vtk_table_set_number_of_rows(vtkNew sself, const long long p0) { sself->SetNumberOfRows(p0); } -extern "C" long long vtk_table_insert_next_blank_row(vtkNew sself, double default_num_val) { return sself->InsertNextBlankRow(default_num_val); } -extern "C" void vtk_table_remove_row(vtkNew sself, long long row) { sself->RemoveRow(row); } -extern "C" long long vtk_table_get_number_of_columns(vtkNew sself) { return sself->GetNumberOfColumns(); } -extern "C" const char* vtk_table_get_column_name(vtkNew sself, long long col) { return sself->GetColumnName(col); } -extern "C" void vtk_table_remove_column_by_name(vtkNew sself, const char name) { sself->RemoveColumnByName(name); } -extern "C" void vtk_table_remove_column(vtkNew sself, long long col) { sself->RemoveColumn(col); } -extern "C" void vtk_table_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" long long vtk_table_get_number_of_elements(vtkNew sself, int type) { return sself->GetNumberOfElements(type); } -extern "C" vtkNew < vtkTetra > vtkTetra_new () {return vtkNew < vtkTetra > () ;} -extern "C" void vtkTetra_destructor (vtkNew < vtkTetra > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTetra_get_ptr (vtkNew < vtkTetra > sself) {return sself . GetPointer () ;} -extern "C" void vtk_tetra_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" void vtk_tetra_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" long long vtk_tetra_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_tetra_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_tetra_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } -extern "C" long long vtk_tetra_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } -extern "C" long long vtk_tetra_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } -extern "C" long long vtk_tetra_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } -extern "C" long long vtk_tetra_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } -extern "C" bool vtk_tetra_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } -extern "C" int vtk_tetra_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_tetra_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_tetra_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_tetra_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_tetra_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_tetra_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_tetra_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int* vtk_tetra_get_triangle_cases(vtkNew sself, int caseId) { return sself->GetTriangleCases(caseId); } -extern "C" int vtk_tetra_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" double vtk_tetra_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } -extern "C" void vtk_tetra_tetra_center(vtkNew sself, double p1, double p2, double p3, double p4, double center) { sself->TetraCenter(p1, p2, p3, p4, center); } -extern "C" double vtk_tetra_circumsphere(vtkNew sself, double x1, double x2, double x3, double x4, double center) { return sself->Circumsphere(x1, x2, x3, x4, center); } -extern "C" double vtk_tetra_insphere(vtkNew sself, double p1, double p2, double p3, double p4, double center) { return sself->Insphere(p1, p2, p3, p4, center); } -extern "C" int vtk_tetra_barycentric_coords(vtkNew sself, double x, double x1, double x2, double x3, double x4, double bcoords) { return sself->BarycentricCoords(x, x1, x2, x3, x4, bcoords); } -extern "C" double vtk_tetra_compute_volume(vtkNew sself, double p1, double p2, double p3, double p4) { return sself->ComputeVolume(p1, p2, p3, p4); } -extern "C" int vtk_tetra_jacobian_inverse(vtkNew sself, double inverse, double derivs) { return sself->JacobianInverse(inverse, derivs); } -extern "C" void vtk_tetra_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_tetra_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_tetra_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_tetra_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_tetra_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_tetra_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" const long long* vtk_tetra_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } -extern "C" const long long* vtk_tetra_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } -extern "C" const long long* vtk_tetra_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } -extern "C" const long long* vtk_tetra_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } -extern "C" const long long* vtk_tetra_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } -extern "C" vtkNew < vtkTree > vtkTree_new () {return vtkNew < vtkTree > () ;} -extern "C" void vtkTree_destructor (vtkNew < vtkTree > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTree_get_ptr (vtkNew < vtkTree > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_tree_get_root(vtkNew sself) { return sself->GetRoot(); } -extern "C" long long vtk_tree_get_number_of_children(vtkNew sself, long long v) { return sself->GetNumberOfChildren(v); } -extern "C" long long vtk_tree_get_child(vtkNew sself, long long v, long long i) { return sself->GetChild(v, i); } -extern "C" long long vtk_tree_get_parent(vtkNew sself, long long v) { return sself->GetParent(v); } -extern "C" long long vtk_tree_get_level(vtkNew sself, long long v) { return sself->GetLevel(v); } -extern "C" bool vtk_tree_is_leaf(vtkNew sself, long long vertex) { return sself->IsLeaf(vertex); } -extern "C" vtkNew < vtkTreeBFSIterator > vtkTreeBFSIterator_new () {return vtkNew < vtkTreeBFSIterator > () ;} -extern "C" void vtkTreeBFSIterator_destructor (vtkNew < vtkTreeBFSIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTreeBFSIterator_get_ptr (vtkNew < vtkTreeBFSIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTreeDFSIterator > vtkTreeDFSIterator_new () {return vtkNew < vtkTreeDFSIterator > () ;} -extern "C" void vtkTreeDFSIterator_destructor (vtkNew < vtkTreeDFSIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTreeDFSIterator_get_ptr (vtkNew < vtkTreeDFSIterator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_tree_dfs_iterator_set_mode(vtkNew sself, int mode) { sself->SetMode(mode); } -extern "C" int vtk_tree_dfs_iterator_get_mode(vtkNew sself) { return sself->GetMode(); } -extern "C" vtkNew < vtkTriQuadraticHexahedron > vtkTriQuadraticHexahedron_new () {return vtkNew < vtkTriQuadraticHexahedron > () ;} -extern "C" void vtkTriQuadraticHexahedron_destructor (vtkNew < vtkTriQuadraticHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTriQuadraticHexahedron_get_ptr (vtkNew < vtkTriQuadraticHexahedron > sself) {return sself . GetPointer () ;} -extern "C" int vtk_tri_quadratic_hexahedron_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_tri_quadratic_hexahedron_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_tri_quadratic_hexahedron_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_tri_quadratic_hexahedron_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_tri_quadratic_hexahedron_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_tri_quadratic_hexahedron_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_tri_quadratic_hexahedron_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_tri_quadratic_hexahedron_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_tri_quadratic_hexahedron_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_tri_quadratic_hexahedron_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_tri_quadratic_hexahedron_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_tri_quadratic_hexahedron_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" void vtk_tri_quadratic_hexahedron_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" vtkNew < vtkTriQuadraticPyramid > vtkTriQuadraticPyramid_new () {return vtkNew < vtkTriQuadraticPyramid > () ;} -extern "C" void vtkTriQuadraticPyramid_destructor (vtkNew < vtkTriQuadraticPyramid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTriQuadraticPyramid_get_ptr (vtkNew < vtkTriQuadraticPyramid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_tri_quadratic_pyramid_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_tri_quadratic_pyramid_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_tri_quadratic_pyramid_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_tri_quadratic_pyramid_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_tri_quadratic_pyramid_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_tri_quadratic_pyramid_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_tri_quadratic_pyramid_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_tri_quadratic_pyramid_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_tri_quadratic_pyramid_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" double vtk_tri_quadratic_pyramid_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } -extern "C" void vtk_tri_quadratic_pyramid_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_tri_quadratic_pyramid_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_tri_quadratic_pyramid_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_tri_quadratic_pyramid_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" void vtk_tri_quadratic_pyramid_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" const long long* vtk_tri_quadratic_pyramid_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_tri_quadratic_pyramid_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" vtkNew < vtkTriangle > vtkTriangle_new () {return vtkNew < vtkTriangle > () ;} -extern "C" void vtkTriangle_destructor (vtkNew < vtkTriangle > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTriangle_get_ptr (vtkNew < vtkTriangle > sself) {return sself . GetPointer () ;} -extern "C" int vtk_triangle_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_triangle_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_triangle_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_triangle_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_triangle_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_triangle_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" void vtk_triangle_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" double vtk_triangle_compute_area(vtkNew sself) { return sself->ComputeArea(); } -extern "C" void vtk_triangle_interpolation_functions(vtkNew sself, const double pcoords, double sf) { sself->InterpolationFunctions(pcoords, sf); } -extern "C" void vtk_triangle_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_triangle_interpolate_functions(vtkNew sself, const double pcoords, double sf) { sself->InterpolateFunctions(pcoords, sf); } -extern "C" void vtk_triangle_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" const long long* vtk_triangle_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" int vtk_triangle_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" int vtk_triangle_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" double vtk_triangle_get_parametric_distance(vtkNew sself, const double pcoords) { return sself->GetParametricDistance(pcoords); } -extern "C" void vtk_triangle_triangle_center(vtkNew sself, const double p1, const double p2, const double p3, double center) { sself->TriangleCenter(p1, p2, p3, center); } -extern "C" double vtk_triangle_triangle_area(vtkNew sself, const double p1, const double p2, const double p3) { return sself->TriangleArea(p1, p2, p3); } -extern "C" double vtk_triangle_circumcircle(vtkNew sself, const double p1, const double p2, const double p3, double center) { return sself->Circumcircle(p1, p2, p3, center); } -extern "C" int vtk_triangle_barycentric_coords(vtkNew sself, const double x, const double x1, const double x2, const double x3, double bcoords) { return sself->BarycentricCoords(x, x1, x2, x3, bcoords); } -extern "C" int vtk_triangle_project_to_2_d(vtkNew sself, const double x1, const double x2, const double x3, double v1, double v2, double v3) { return sself->ProjectTo2D(x1, x2, x3, v1, v2, v3); } -extern "C" void vtk_triangle_compute_normal(vtkNew sself, const double v1, const double v2, const double v3, double n) { sself->ComputeNormal(v1, v2, v3, n); } -extern "C" void vtk_triangle_compute_normal_direction(vtkNew sself, const double v1, const double v2, const double v3, double n) { sself->ComputeNormalDirection(v1, v2, v3, n); } -extern "C" int vtk_triangle_triangles_intersect(vtkNew sself, const double p1, const double q1, const double r1, const double p2, const double q2, const double r2) { return sself->TrianglesIntersect(p1, q1, r1, p2, q2, r2); } -extern "C" int vtk_triangle_point_in_triangle(vtkNew sself, const double x, const double x1, const double x2, const double x3, const double tol2) { return sself->PointInTriangle(x, x1, x2, x3, tol2); } -extern "C" void vtk_triangle_compute_quadric(vtkNew sself, const double x1, const double x2, const double x3, double quadric) { sself->ComputeQuadric(x1, x2, x3, quadric); } -extern "C" vtkNew < vtkTriangleStrip > vtkTriangleStrip_new () {return vtkNew < vtkTriangleStrip > () ;} -extern "C" void vtkTriangleStrip_destructor (vtkNew < vtkTriangleStrip > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTriangleStrip_get_ptr (vtkNew < vtkTriangleStrip > sself) {return sself . GetPointer () ;} -extern "C" int vtk_triangle_strip_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_triangle_strip_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_triangle_strip_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_triangle_strip_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_triangle_strip_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_triangle_strip_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_triangle_strip_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_triangle_strip_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_triangle_strip_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" vtkNew < vtkUndirectedGraph > vtkUndirectedGraph_new () {return vtkNew < vtkUndirectedGraph > () ;} -extern "C" void vtkUndirectedGraph_destructor (vtkNew < vtkUndirectedGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUndirectedGraph_get_ptr (vtkNew < vtkUndirectedGraph > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_undirected_graph_get_in_degree(vtkNew sself, long long v) { return sself->GetInDegree(v); } -extern "C" vtkNew < vtkUniformGrid > vtkUniformGrid_new () {return vtkNew < vtkUniformGrid > () ;} -extern "C" void vtkUniformGrid_destructor (vtkNew < vtkUniformGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformGrid_get_ptr (vtkNew < vtkUniformGrid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_uniform_grid_get_grid_description(vtkNew sself) { return sself->GetGridDescription(); } -extern "C" void vtk_uniform_grid_blank_point(vtkNew sself, long long ptId) { sself->BlankPoint(ptId); } -extern "C" void vtk_uniform_grid_un_blank_point(vtkNew sself, long long ptId) { sself->UnBlankPoint(ptId); } -extern "C" void vtk_uniform_grid_blank_point(vtkNew sself, const int i, const int j, const int k) { sself->BlankPoint(i, j, k); } -extern "C" void vtk_uniform_grid_un_blank_point(vtkNew sself, const int i, const int j, const int k) { sself->UnBlankPoint(i, j, k); } -extern "C" void vtk_uniform_grid_blank_cell(vtkNew sself, long long ptId) { sself->BlankCell(ptId); } -extern "C" void vtk_uniform_grid_un_blank_cell(vtkNew sself, long long ptId) { sself->UnBlankCell(ptId); } -extern "C" void vtk_uniform_grid_blank_cell(vtkNew sself, const int i, const int j, const int k) { sself->BlankCell(i, j, k); } -extern "C" void vtk_uniform_grid_un_blank_cell(vtkNew sself, const int i, const int j, const int k) { sself->UnBlankCell(i, j, k); } -extern "C" unsigned char vtk_uniform_grid_is_point_visible(vtkNew sself, long long pointId) { return sself->IsPointVisible(pointId); } -extern "C" unsigned char vtk_uniform_grid_is_cell_visible(vtkNew sself, long long cellId) { return sself->IsCellVisible(cellId); } -extern "C" vtkNew < vtkUniformGridAMR > vtkUniformGridAMR_new () {return vtkNew < vtkUniformGridAMR > () ;} -extern "C" void vtkUniformGridAMR_destructor (vtkNew < vtkUniformGridAMR > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformGridAMR_get_ptr (vtkNew < vtkUniformGridAMR > sself) {return sself . GetPointer () ;} -extern "C" int vtk_uniform_grid_amr_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" void vtk_uniform_grid_amr_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_uniform_grid_amr_initialize(vtkNew sself, int numLevels, const int blocksPerLevel) { sself->Initialize(numLevels, blocksPerLevel); } -extern "C" void vtk_uniform_grid_amr_set_grid_description(vtkNew sself, int gridDescription) { sself->SetGridDescription(gridDescription); } -extern "C" int vtk_uniform_grid_amr_get_grid_description(vtkNew sself) { return sself->GetGridDescription(); } -extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_levels(vtkNew sself) { return sself->GetNumberOfLevels(); } -extern "C" unsigned int vtk_uniform_grid_amr_get_total_number_of_blocks(vtkNew sself) { return sself->GetTotalNumberOfBlocks(); } -extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_data_sets(vtkNew sself, const unsigned int level) { return sself->GetNumberOfDataSets(level); } -extern "C" void vtk_uniform_grid_amr_get_bounds(vtkNew sself, double bounds) { sself->GetBounds(bounds); } -extern "C" const double* vtk_uniform_grid_amr_get_bounds(vtkNew sself) { return sself->GetBounds(); } -extern "C" void vtk_uniform_grid_amr_get_min(vtkNew sself, double min) { sself->GetMin(min); } -extern "C" void vtk_uniform_grid_amr_get_max(vtkNew sself, double max) { sself->GetMax(max); } -extern "C" int vtk_uniform_grid_amr_get_composite_index(vtkNew sself, const unsigned int level, const unsigned int index) { return sself->GetCompositeIndex(level, index); } -extern "C" void vtk_uniform_grid_amr_get_level_and_index(vtkNew sself, const unsigned int compositeIdx, unsigned int level, unsigned int idx) { sself->GetLevelAndIndex(compositeIdx, level, idx); } -extern "C" vtkNew < vtkUniformGridAMRDataIterator > vtkUniformGridAMRDataIterator_new () {return vtkNew < vtkUniformGridAMRDataIterator > () ;} -extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkNew < vtkUniformGridAMRDataIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformGridAMRDataIterator_get_ptr (vtkNew < vtkUniformGridAMRDataIterator > sself) {return sself . GetPointer () ;} -extern "C" int vtk_uniform_grid_amr_data_iterator_has_current_meta_data(vtkNew sself) { return sself->HasCurrentMetaData(); } -extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_flat_index(vtkNew sself) { return sself->GetCurrentFlatIndex(); } -extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_level(vtkNew sself) { return sself->GetCurrentLevel(); } -extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_index(vtkNew sself) { return sself->GetCurrentIndex(); } -extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_first_item(vtkNew sself) { sself->GoToFirstItem(); } -extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_next_item(vtkNew sself) { sself->GoToNextItem(); } -extern "C" int vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } -extern "C" vtkNew < vtkUniformHyperTreeGrid > vtkUniformHyperTreeGrid_new () {return vtkNew < vtkUniformHyperTreeGrid > () ;} -extern "C" void vtkUniformHyperTreeGrid_destructor (vtkNew < vtkUniformHyperTreeGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformHyperTreeGrid_get_ptr (vtkNew < vtkUniformHyperTreeGrid > sself) {return sself . GetPointer () ;} -extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } -extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkNew sself, const double _arg) { sself->SetOrigin(_arg); } -extern "C" double* vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself) { return sself->GetOrigin(); } -extern "C" void vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetOrigin(_arg1, _arg2, _arg3); } -extern "C" void vtk_uniform_hyper_tree_grid_get_origin(vtkNew sself, double _arg) { sself->GetOrigin(_arg); } -extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0, double p1, double p2) { sself->SetGridScale(p0, p1, p2); } -extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0) { sself->SetGridScale(p0); } -extern "C" double* vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself) { return sself->GetGridScale(); } -extern "C" void vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself, double _arg1, double _arg2, double _arg3) { sself->GetGridScale(_arg1, _arg2, _arg3); } -extern "C" void vtk_uniform_hyper_tree_grid_get_grid_scale(vtkNew sself, double _arg) { sself->GetGridScale(_arg); } -extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkNew sself, double p0) { sself->SetGridScale(p0); } -extern "C" void vtk_uniform_hyper_tree_grid_get_level_zero_origin_from_index(vtkNew sself, long long p0, double p1) { sself->GetLevelZeroOriginFromIndex(p0, p1); } -extern "C" unsigned long vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(vtkNew sself) { return sself->GetActualMemorySizeBytes(); } -extern "C" vtkNew < vtkUnstructuredGrid > vtkUnstructuredGrid_new () {return vtkNew < vtkUnstructuredGrid > () ;} -extern "C" void vtkUnstructuredGrid_destructor (vtkNew < vtkUnstructuredGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnstructuredGrid_get_ptr (vtkNew < vtkUnstructuredGrid > sself) {return sself . GetPointer () ;} -extern "C" int vtk_unstructured_grid_get_data_object_type(vtkNew sself) { return sself->GetDataObjectType(); } -extern "C" bool vtk_unstructured_grid_allocate_estimate(vtkNew sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } -extern "C" bool vtk_unstructured_grid_allocate_exact(vtkNew sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } -extern "C" void vtk_unstructured_grid_allocate(vtkNew sself, long long numCells, int extSize) { sself->Allocate(numCells, extSize); } -extern "C" void vtk_unstructured_grid_reset(vtkNew sself) { sself->Reset(); } -extern "C" int vtk_unstructured_grid_get_cell_type(vtkNew sself, long long cellId) { return sself->GetCellType(cellId); } -extern "C" void vtk_unstructured_grid_get_cell_points(vtkNew sself, long long cellId, long long npts, const long long pts) { sself->GetCellPoints(cellId, npts, pts); } -extern "C" void vtk_unstructured_grid_get_point_cells(vtkNew sself, long long ptId, long long ncells, long long cells) { sself->GetPointCells(ptId, ncells, cells); } -extern "C" void vtk_unstructured_grid_get_point_cells(vtkNew sself, long long ptId, unsigned short ncells, long long cells) { sself->GetPointCells(ptId, ncells, cells); } -extern "C" void vtk_unstructured_grid_squeeze(vtkNew sself) { sself->Squeeze(); } -extern "C" void vtk_unstructured_grid_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" int vtk_unstructured_grid_get_max_cell_size(vtkNew sself) { return sself->GetMaxCellSize(); } -extern "C" void vtk_unstructured_grid_build_links(vtkNew sself) { sself->BuildLinks(); } -extern "C" void vtk_unstructured_grid_get_face_stream(vtkNew sself, long long cellId, long long nfaces, const long long ptIds) { sself->GetFaceStream(cellId, nfaces, ptIds); } -extern "C" bool vtk_unstructured_grid_is_cell_boundary(vtkNew sself, long long cellId, long long npts, const long long ptIds) { return sself->IsCellBoundary(cellId, npts, ptIds); } -extern "C" long long vtk_unstructured_grid_insert_next_linked_cell(vtkNew sself, int type, int npts, const long long pts) { return sself->InsertNextLinkedCell(type, npts, pts); } -extern "C" void vtk_unstructured_grid_remove_reference_to_cell(vtkNew sself, long long ptId, long long cellId) { sself->RemoveReferenceToCell(ptId, cellId); } -extern "C" void vtk_unstructured_grid_add_reference_to_cell(vtkNew sself, long long ptId, long long cellId) { sself->AddReferenceToCell(ptId, cellId); } -extern "C" void vtk_unstructured_grid_resize_cell_list(vtkNew sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } -extern "C" int vtk_unstructured_grid_get_piece(vtkNew sself) { return sself->GetPiece(); } -extern "C" int vtk_unstructured_grid_get_number_of_pieces(vtkNew sself) { return sself->GetNumberOfPieces(); } -extern "C" int vtk_unstructured_grid_get_ghost_level(vtkNew sself) { return sself->GetGhostLevel(); } -extern "C" int vtk_unstructured_grid_is_homogeneous(vtkNew sself) { return sself->IsHomogeneous(); } -extern "C" void vtk_unstructured_grid_remove_ghost_cells(vtkNew sself) { sself->RemoveGhostCells(); } -extern "C" long long* vtk_unstructured_grid_get_faces(vtkNew sself, long long cellId) { return sself->GetFaces(cellId); } -extern "C" int vtk_unstructured_grid_initialize_faces_representation(vtkNew sself, long long numPrevCells) { return sself->InitializeFacesRepresentation(numPrevCells); } -extern "C" unsigned long vtk_unstructured_grid_get_mesh_m_time(vtkNew sself) { return sself->GetMeshMTime(); } -extern "C" void vtk_unstructured_grid_convert_face_stream_point_ids(vtkNew sself, long long nfaces, long long faceStream, long long idMap) { sself->ConvertFaceStreamPointIds(nfaces, faceStream, idMap); } -extern "C" vtkNew < vtkUnstructuredGridCellIterator > vtkUnstructuredGridCellIterator_new () {return vtkNew < vtkUnstructuredGridCellIterator > () ;} -extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkNew < vtkUnstructuredGridCellIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnstructuredGridCellIterator_get_ptr (vtkNew < vtkUnstructuredGridCellIterator > sself) {return sself . GetPointer () ;} -extern "C" bool vtk_unstructured_grid_cell_iterator_is_done_with_traversal(vtkNew sself) { return sself->IsDoneWithTraversal(); } -extern "C" long long vtk_unstructured_grid_cell_iterator_get_cell_id(vtkNew sself) { return sself->GetCellId(); } -extern "C" void vtk_unstructured_grid_cell_iterator_go_to_cell(vtkNew sself, long long cellId) { sself->GoToCell(cellId); } -extern "C" vtkNew < vtkVertex > vtkVertex_new () {return vtkNew < vtkVertex > () ;} -extern "C" void vtkVertex_destructor (vtkNew < vtkVertex > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVertex_get_ptr (vtkNew < vtkVertex > sself) {return sself . GetPointer () ;} -extern "C" int vtk_vertex_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_vertex_get_cell_dimension(vtkNew sself) { return sself->GetCellDimension(); } -extern "C" int vtk_vertex_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_vertex_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_vertex_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_vertex_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_vertex_inflate(vtkNew sself, double p0) { return sself->Inflate(p0); } -extern "C" int vtk_vertex_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" int vtk_vertex_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_vertex_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" void vtk_vertex_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_vertex_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_vertex_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_vertex_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" vtkNew < vtkVertexListIterator > vtkVertexListIterator_new () {return vtkNew < vtkVertexListIterator > () ;} -extern "C" void vtkVertexListIterator_destructor (vtkNew < vtkVertexListIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVertexListIterator_get_ptr (vtkNew < vtkVertexListIterator > sself) {return sself . GetPointer () ;} -extern "C" long long vtk_vertex_list_iterator_next(vtkNew sself) { return sself->Next(); } -extern "C" bool vtk_vertex_list_iterator_has_next(vtkNew sself) { return sself->HasNext(); } -extern "C" vtkNew < vtkVoxel > vtkVoxel_new () {return vtkNew < vtkVoxel > () ;} -extern "C" void vtkVoxel_destructor (vtkNew < vtkVoxel > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVoxel_get_ptr (vtkNew < vtkVoxel > sself) {return sself . GetPointer () ;} -extern "C" void vtk_voxel_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" void vtk_voxel_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" long long vtk_voxel_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_voxel_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_voxel_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } -extern "C" long long vtk_voxel_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faces) { return sself->GetFaceToAdjacentFaces(faceId, faces); } -extern "C" long long vtk_voxel_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edges) { return sself->GetPointToIncidentEdges(pointId, edges); } -extern "C" long long vtk_voxel_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faces) { return sself->GetPointToIncidentFaces(pointId, faces); } -extern "C" long long vtk_voxel_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } -extern "C" bool vtk_voxel_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } -extern "C" double vtk_voxel_compute_bounding_sphere(vtkNew sself, double center) { return sself->ComputeBoundingSphere(center); } -extern "C" int vtk_voxel_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_voxel_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_voxel_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_voxel_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_voxel_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_voxel_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_voxel_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int vtk_voxel_inflate(vtkNew sself, double dist) { return sself->Inflate(dist); } -extern "C" void vtk_voxel_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_voxel_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_voxel_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" void vtk_voxel_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" int* vtk_voxel_get_triangle_cases(vtkNew sself, int caseId) { return sself->GetTriangleCases(caseId); } -extern "C" const long long* vtk_voxel_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_voxel_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" const long long* vtk_voxel_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } -extern "C" const long long* vtk_voxel_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } -extern "C" const long long* vtk_voxel_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } -extern "C" const long long* vtk_voxel_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } -extern "C" const long long* vtk_voxel_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } -extern "C" vtkNew < vtkWedge > vtkWedge_new () {return vtkNew < vtkWedge > () ;} -extern "C" void vtkWedge_destructor (vtkNew < vtkWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkWedge_get_ptr (vtkNew < vtkWedge > sself) {return sself . GetPointer () ;} -extern "C" void vtk_wedge_get_edge_points(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" void vtk_wedge_get_edge_points(vtkNew sself, int edgeId, int pts) { sself->GetEdgePoints(edgeId, pts); } -extern "C" long long vtk_wedge_get_face_points(vtkNew sself, long long faceId, const long long pts) { return sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_wedge_get_face_points(vtkNew sself, int faceId, int pts) { sself->GetFacePoints(faceId, pts); } -extern "C" void vtk_wedge_get_edge_to_adjacent_faces(vtkNew sself, long long edgeId, const long long pts) { sself->GetEdgeToAdjacentFaces(edgeId, pts); } -extern "C" long long vtk_wedge_get_face_to_adjacent_faces(vtkNew sself, long long faceId, const long long faceIds) { return sself->GetFaceToAdjacentFaces(faceId, faceIds); } -extern "C" long long vtk_wedge_get_point_to_incident_edges(vtkNew sself, long long pointId, const long long edgeIds) { return sself->GetPointToIncidentEdges(pointId, edgeIds); } -extern "C" long long vtk_wedge_get_point_to_incident_faces(vtkNew sself, long long pointId, const long long faceIds) { return sself->GetPointToIncidentFaces(pointId, faceIds); } -extern "C" long long vtk_wedge_get_point_to_one_ring_points(vtkNew sself, long long pointId, const long long pts) { return sself->GetPointToOneRingPoints(pointId, pts); } -extern "C" bool vtk_wedge_get_centroid(vtkNew sself, double centroid) { return sself->GetCentroid(centroid); } -extern "C" int vtk_wedge_get_cell_type(vtkNew sself) { return sself->GetCellType(); } -extern "C" int vtk_wedge_get_number_of_edges(vtkNew sself) { return sself->GetNumberOfEdges(); } -extern "C" int vtk_wedge_get_number_of_faces(vtkNew sself) { return sself->GetNumberOfFaces(); } -extern "C" int vtk_wedge_evaluate_position(vtkNew sself, const double x, double closestPoint, int subId, double pcoords, double dist2, double weights) { return sself->EvaluatePosition(x, closestPoint, subId, pcoords, dist2, weights); } -extern "C" void vtk_wedge_evaluate_location(vtkNew sself, int subId, const double pcoords, double x, double weights) { sself->EvaluateLocation(subId, pcoords, x, weights); } -extern "C" int vtk_wedge_intersect_with_line(vtkNew sself, const double p1, const double p2, double tol, double t, double x, double pcoords, int subId) { return sself->IntersectWithLine(p1, p2, tol, t, x, pcoords, subId); } -extern "C" void vtk_wedge_derivatives(vtkNew sself, int subId, const double pcoords, const double values, int dim, double derivs) { sself->Derivatives(subId, pcoords, values, dim, derivs); } -extern "C" int* vtk_wedge_get_triangle_cases(vtkNew sself, int caseId) { return sself->GetTriangleCases(caseId); } -extern "C" int vtk_wedge_get_parametric_center(vtkNew sself, double pcoords) { return sself->GetParametricCenter(pcoords); } -extern "C" void vtk_wedge_interpolation_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolationFunctions(pcoords, weights); } -extern "C" void vtk_wedge_interpolation_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolationDerivs(pcoords, derivs); } -extern "C" void vtk_wedge_interpolate_functions(vtkNew sself, const double pcoords, double weights) { sself->InterpolateFunctions(pcoords, weights); } -extern "C" void vtk_wedge_interpolate_derivs(vtkNew sself, const double pcoords, double derivs) { sself->InterpolateDerivs(pcoords, derivs); } -extern "C" int vtk_wedge_jacobian_inverse(vtkNew sself, const double pcoords, double inverse, double derivs) { return sself->JacobianInverse(pcoords, inverse, derivs); } -extern "C" const long long* vtk_wedge_get_edge_array(vtkNew sself, long long edgeId) { return sself->GetEdgeArray(edgeId); } -extern "C" const long long* vtk_wedge_get_face_array(vtkNew sself, long long faceId) { return sself->GetFaceArray(faceId); } -extern "C" const long long* vtk_wedge_get_edge_to_adjacent_faces_array(vtkNew sself, long long edgeId) { return sself->GetEdgeToAdjacentFacesArray(edgeId); } -extern "C" const long long* vtk_wedge_get_face_to_adjacent_faces_array(vtkNew sself, long long faceId) { return sself->GetFaceToAdjacentFacesArray(faceId); } -extern "C" const long long* vtk_wedge_get_point_to_incident_edges_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentEdgesArray(pointId); } -extern "C" const long long* vtk_wedge_get_point_to_incident_faces_array(vtkNew sself, long long pointId) { return sself->GetPointToIncidentFacesArray(pointId); } -extern "C" const long long* vtk_wedge_get_point_to_one_ring_points_array(vtkNew sself, long long pointId) { return sself->GetPointToOneRingPointsArray(pointId); } -extern "C" vtkNew < vtkXMLDataElement > vtkXMLDataElement_new () {return vtkNew < vtkXMLDataElement > () ;} -extern "C" void vtkXMLDataElement_destructor (vtkNew < vtkXMLDataElement > sself) {sself . Reset () ; return ;} -extern "C" void * vtkXMLDataElement_get_ptr (vtkNew < vtkXMLDataElement > sself) {return sself . GetPointer () ;} -extern "C" char* vtk_xml_data_element_get_name(vtkNew sself) { return sself->GetName(); } -extern "C" void vtk_xml_data_element_set_name(vtkNew sself, const char _arg) { sself->SetName(_arg); } -extern "C" char* vtk_xml_data_element_get_id(vtkNew sself) { return sself->GetId(); } -extern "C" void vtk_xml_data_element_set_id(vtkNew sself, const char _arg) { sself->SetId(_arg); } -extern "C" const char* vtk_xml_data_element_get_attribute(vtkNew sself, const char name) { return sself->GetAttribute(name); } -extern "C" void vtk_xml_data_element_set_attribute(vtkNew sself, const char name, const char value) { sself->SetAttribute(name, value); } -extern "C" void vtk_xml_data_element_set_character_data(vtkNew sself, const char data, int length) { sself->SetCharacterData(data, length); } -extern "C" void vtk_xml_data_element_add_character_data(vtkNew sself, const char c, size_t length) { sself->AddCharacterData(c, length); } -extern "C" char* vtk_xml_data_element_get_character_data(vtkNew sself) { return sself->GetCharacterData(); } -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, int value) { return sself->GetScalarAttribute(name, value); } -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, float value) { return sself->GetScalarAttribute(name, value); } -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, double value) { return sself->GetScalarAttribute(name, value); } -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, long value) { return sself->GetScalarAttribute(name, value); } -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, unsigned long value) { return sself->GetScalarAttribute(name, value); } -extern "C" void vtk_xml_data_element_set_int_attribute(vtkNew sself, const char name, int value) { sself->SetIntAttribute(name, value); } -extern "C" void vtk_xml_data_element_set_float_attribute(vtkNew sself, const char name, float value) { sself->SetFloatAttribute(name, value); } -extern "C" void vtk_xml_data_element_set_double_attribute(vtkNew sself, const char name, double value) { sself->SetDoubleAttribute(name, value); } -extern "C" void vtk_xml_data_element_set_unsigned_long_attribute(vtkNew sself, const char name, unsigned long value) { sself->SetUnsignedLongAttribute(name, value); } -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, int value) { return sself->GetVectorAttribute(name, length, value); } -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, float value) { return sself->GetVectorAttribute(name, length, value); } -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, double value) { return sself->GetVectorAttribute(name, length, value); } -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, long value) { return sself->GetVectorAttribute(name, length, value); } -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, unsigned long value) { return sself->GetVectorAttribute(name, length, value); } -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const int value) { sself->SetVectorAttribute(name, length, value); } -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const float value) { sself->SetVectorAttribute(name, length, value); } -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const double value) { sself->SetVectorAttribute(name, length, value); } -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const unsigned long value) { sself->SetVectorAttribute(name, length, value); } -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, long long value) { return sself->GetScalarAttribute(name, value); } -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, long long value) { return sself->GetVectorAttribute(name, length, value); } -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const long long value) { sself->SetVectorAttribute(name, length, value); } -extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkNew sself, const char name, unsigned long long value) { return sself->GetScalarAttribute(name, value); } -extern "C" int vtk_xml_data_element_get_vector_attribute(vtkNew sself, const char name, int length, unsigned long long value) { return sself->GetVectorAttribute(name, length, value); } -extern "C" void vtk_xml_data_element_set_vector_attribute(vtkNew sself, const char name, int length, const unsigned long long value) { sself->SetVectorAttribute(name, length, value); } -extern "C" int vtk_xml_data_element_get_word_type_attribute(vtkNew sself, const char name, int value) { return sself->GetWordTypeAttribute(name, value); } -extern "C" int vtk_xml_data_element_get_number_of_attributes(vtkNew sself) { return sself->GetNumberOfAttributes(); } -extern "C" const char* vtk_xml_data_element_get_attribute_name(vtkNew sself, int idx) { return sself->GetAttributeName(idx); } -extern "C" const char* vtk_xml_data_element_get_attribute_value(vtkNew sself, int idx) { return sself->GetAttributeValue(idx); } -extern "C" void vtk_xml_data_element_remove_attribute(vtkNew sself, const char name) { sself->RemoveAttribute(name); } -extern "C" void vtk_xml_data_element_remove_all_attributes(vtkNew sself) { sself->RemoveAllAttributes(); } -extern "C" int vtk_xml_data_element_get_number_of_nested_elements(vtkNew sself) { return sself->GetNumberOfNestedElements(); } -extern "C" void vtk_xml_data_element_remove_all_nested_elements(vtkNew sself) { sself->RemoveAllNestedElements(); } -extern "C" long long vtk_xml_data_element_get_xml_byte_index(vtkNew sself) { return sself->GetXMLByteIndex(); } -extern "C" void vtk_xml_data_element_set_xml_byte_index(vtkNew sself, long long _arg) { sself->SetXMLByteIndex(_arg); } -extern "C" void vtk_xml_data_element_set_attribute_encoding(vtkNew sself, int _arg) { sself->SetAttributeEncoding(_arg); } -extern "C" int vtk_xml_data_element_get_attribute_encoding_min_value(vtkNew sself) { return sself->GetAttributeEncodingMinValue(); } -extern "C" int vtk_xml_data_element_get_attribute_encoding_max_value(vtkNew sself) { return sself->GetAttributeEncodingMaxValue(); } -extern "C" int vtk_xml_data_element_get_attribute_encoding(vtkNew sself) { return sself->GetAttributeEncoding(); } -extern "C" void vtk_xml_data_element_print_xml(vtkNew sself, const char fname) { sself->PrintXML(fname); } -extern "C" int vtk_xml_data_element_get_character_data_width(vtkNew sself) { return sself->GetCharacterDataWidth(); } -extern "C" void vtk_xml_data_element_set_character_data_width(vtkNew sself, int _arg) { sself->SetCharacterDataWidth(_arg); } +extern "C" vtkAMRDataInternals * vtkAMRDataInternals_new () {return vtkAMRDataInternals :: New () ;} +extern "C" void vtkAMRDataInternals_destructor (vtkAMRDataInternals * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAMRDataInternals_get_ptr (vtkAMRDataInternals * sself) {return sself ;} +extern "C" void vtk_amr_data_internals_initialize(vtkAMRDataInternals* sself) { sself->Initialize(); } +extern "C" bool vtk_amr_data_internals_empty(vtkAMRDataInternals* sself) { return sself->Empty(); } +extern "C" unsigned int vtk_amr_data_internals_get_number_of_blocks(vtkAMRDataInternals* sself) { return sself->GetNumberOfBlocks(); } +extern "C" vtkAdjacentVertexIterator * vtkAdjacentVertexIterator_new () {return vtkAdjacentVertexIterator :: New () ;} +extern "C" void vtkAdjacentVertexIterator_destructor (vtkAdjacentVertexIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAdjacentVertexIterator_get_ptr (vtkAdjacentVertexIterator * sself) {return sself ;} +extern "C" long long vtk_adjacent_vertex_iterator_get_vertex(vtkAdjacentVertexIterator* sself) { return sself->GetVertex(); } +extern "C" long long vtk_adjacent_vertex_iterator_next(vtkAdjacentVertexIterator* sself) { return sself->Next(); } +extern "C" bool vtk_adjacent_vertex_iterator_has_next(vtkAdjacentVertexIterator* sself) { return sself->HasNext(); } +extern "C" vtkAnimationScene * vtkAnimationScene_new () {return vtkAnimationScene :: New () ;} +extern "C" void vtkAnimationScene_destructor (vtkAnimationScene * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAnimationScene_get_ptr (vtkAnimationScene * sself) {return sself ;} +extern "C" void vtk_animation_scene_set_play_mode(vtkAnimationScene* sself, int _arg) { sself->SetPlayMode(_arg); } +extern "C" void vtk_animation_scene_set_mode_to_sequence(vtkAnimationScene* sself) { sself->SetModeToSequence(); } +extern "C" void vtk_animation_scene_set_mode_to_real_time(vtkAnimationScene* sself) { sself->SetModeToRealTime(); } +extern "C" int vtk_animation_scene_get_play_mode(vtkAnimationScene* sself) { return sself->GetPlayMode(); } +extern "C" void vtk_animation_scene_set_frame_rate(vtkAnimationScene* sself, double _arg) { sself->SetFrameRate(_arg); } +extern "C" double vtk_animation_scene_get_frame_rate(vtkAnimationScene* sself) { return sself->GetFrameRate(); } +extern "C" void vtk_animation_scene_remove_all_cues(vtkAnimationScene* sself) { sself->RemoveAllCues(); } +extern "C" int vtk_animation_scene_get_number_of_cues(vtkAnimationScene* sself) { return sself->GetNumberOfCues(); } +extern "C" void vtk_animation_scene_play(vtkAnimationScene* sself) { sself->Play(); } +extern "C" void vtk_animation_scene_stop(vtkAnimationScene* sself) { sself->Stop(); } +extern "C" void vtk_animation_scene_set_loop(vtkAnimationScene* sself, int _arg) { sself->SetLoop(_arg); } +extern "C" int vtk_animation_scene_get_loop(vtkAnimationScene* sself) { return sself->GetLoop(); } +extern "C" void vtk_animation_scene_set_animation_time(vtkAnimationScene* sself, double time) { sself->SetAnimationTime(time); } +extern "C" void vtk_animation_scene_set_time_mode(vtkAnimationScene* sself, int mode) { sself->SetTimeMode(mode); } +extern "C" int vtk_animation_scene_is_in_play(vtkAnimationScene* sself) { return sself->IsInPlay(); } +extern "C" vtkAnnotation * vtkAnnotation_new () {return vtkAnnotation :: New () ;} +extern "C" void vtkAnnotation_destructor (vtkAnnotation * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAnnotation_get_ptr (vtkAnnotation * sself) {return sself ;} +extern "C" int vtk_annotation_get_data_object_type(vtkAnnotation* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_annotation_initialize(vtkAnnotation* sself) { sself->Initialize(); } +extern "C" unsigned long vtk_annotation_get_m_time(vtkAnnotation* sself) { return sself->GetMTime(); } +extern "C" vtkAnnotationLayers * vtkAnnotationLayers_new () {return vtkAnnotationLayers :: New () ;} +extern "C" void vtkAnnotationLayers_destructor (vtkAnnotationLayers * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAnnotationLayers_get_ptr (vtkAnnotationLayers * sself) {return sself ;} +extern "C" int vtk_annotation_layers_get_data_object_type(vtkAnnotationLayers* sself) { return sself->GetDataObjectType(); } +extern "C" unsigned int vtk_annotation_layers_get_number_of_annotations(vtkAnnotationLayers* sself) { return sself->GetNumberOfAnnotations(); } +extern "C" void vtk_annotation_layers_initialize(vtkAnnotationLayers* sself) { sself->Initialize(); } +extern "C" unsigned long vtk_annotation_layers_get_m_time(vtkAnnotationLayers* sself) { return sself->GetMTime(); } +extern "C" vtkArrayData * vtkArrayData_new () {return vtkArrayData :: New () ;} +extern "C" void vtkArrayData_destructor (vtkArrayData * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkArrayData_get_ptr (vtkArrayData * sself) {return sself ;} +extern "C" void vtk_array_data_clear_arrays(vtkArrayData* sself) { sself->ClearArrays(); } +extern "C" long long vtk_array_data_get_number_of_arrays(vtkArrayData* sself) { return sself->GetNumberOfArrays(); } +extern "C" int vtk_array_data_get_data_object_type(vtkArrayData* sself) { return sself->GetDataObjectType(); } +extern "C" vtkAttributesErrorMetric * vtkAttributesErrorMetric_new () {return vtkAttributesErrorMetric :: New () ;} +extern "C" void vtkAttributesErrorMetric_destructor (vtkAttributesErrorMetric * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAttributesErrorMetric_get_ptr (vtkAttributesErrorMetric * sself) {return sself ;} +extern "C" double vtk_attributes_error_metric_get_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself) { return sself->GetAbsoluteAttributeTolerance(); } +extern "C" void vtk_attributes_error_metric_set_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself, double value) { sself->SetAbsoluteAttributeTolerance(value); } +extern "C" double vtk_attributes_error_metric_get_attribute_tolerance(vtkAttributesErrorMetric* sself) { return sself->GetAttributeTolerance(); } +extern "C" void vtk_attributes_error_metric_set_attribute_tolerance(vtkAttributesErrorMetric* sself, double value) { sself->SetAttributeTolerance(value); } +extern "C" vtkBSPCuts * vtkBSPCuts_new () {return vtkBSPCuts :: New () ;} +extern "C" void vtkBSPCuts_destructor (vtkBSPCuts * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBSPCuts_get_ptr (vtkBSPCuts * sself) {return sself ;} +extern "C" int vtk_bsp_cuts_get_data_object_type(vtkBSPCuts* sself) { return sself->GetDataObjectType(); } +extern "C" int vtk_bsp_cuts_get_number_of_cuts(vtkBSPCuts* sself) { return sself->GetNumberOfCuts(); } +extern "C" void vtk_bsp_cuts_print_tree(vtkBSPCuts* sself) { sself->PrintTree(); } +extern "C" void vtk_bsp_cuts_print_arrays(vtkBSPCuts* sself) { sself->PrintArrays(); } +extern "C" vtkBSPIntersections * vtkBSPIntersections_new () {return vtkBSPIntersections :: New () ;} +extern "C" void vtkBSPIntersections_destructor (vtkBSPIntersections * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBSPIntersections_get_ptr (vtkBSPIntersections * sself) {return sself ;} +extern "C" int vtk_bsp_intersections_get_number_of_regions(vtkBSPIntersections* sself) { return sself->GetNumberOfRegions(); } +extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkBSPIntersections* sself, int regionId, double x, double y, double z, double rSquared) { return sself->IntersectsSphere2(regionId, x, y, z, rSquared); } +extern "C" int vtk_bsp_intersections_get_compute_intersections_using_data_bounds(vtkBSPIntersections* sself) { return sself->GetComputeIntersectionsUsingDataBounds(); } +extern "C" void vtk_bsp_intersections_set_compute_intersections_using_data_bounds(vtkBSPIntersections* sself, int c) { sself->SetComputeIntersectionsUsingDataBounds(c); } +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_on(vtkBSPIntersections* sself) { sself->ComputeIntersectionsUsingDataBoundsOn(); } +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_off(vtkBSPIntersections* sself) { sself->ComputeIntersectionsUsingDataBoundsOff(); } +extern "C" vtkBezierCurve * vtkBezierCurve_new () {return vtkBezierCurve :: New () ;} +extern "C" void vtkBezierCurve_destructor (vtkBezierCurve * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBezierCurve_get_ptr (vtkBezierCurve * sself) {return sself ;} +extern "C" int vtk_bezier_curve_get_cell_type(vtkBezierCurve* sself) { return sself->GetCellType(); } +extern "C" vtkBezierHexahedron * vtkBezierHexahedron_new () {return vtkBezierHexahedron :: New () ;} +extern "C" void vtkBezierHexahedron_destructor (vtkBezierHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBezierHexahedron_get_ptr (vtkBezierHexahedron * sself) {return sself ;} +extern "C" int vtk_bezier_hexahedron_get_cell_type(vtkBezierHexahedron* sself) { return sself->GetCellType(); } +extern "C" vtkBezierInterpolation * vtkBezierInterpolation_new () {return vtkBezierInterpolation :: New () ;} +extern "C" void vtkBezierInterpolation_destructor (vtkBezierInterpolation * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBezierInterpolation_get_ptr (vtkBezierInterpolation * sself) {return sself ;} +extern "C" vtkBezierQuadrilateral * vtkBezierQuadrilateral_new () {return vtkBezierQuadrilateral :: New () ;} +extern "C" void vtkBezierQuadrilateral_destructor (vtkBezierQuadrilateral * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBezierQuadrilateral_get_ptr (vtkBezierQuadrilateral * sself) {return sself ;} +extern "C" int vtk_bezier_quadrilateral_get_cell_type(vtkBezierQuadrilateral* sself) { return sself->GetCellType(); } +extern "C" vtkBezierTetra * vtkBezierTetra_new () {return vtkBezierTetra :: New () ;} +extern "C" void vtkBezierTetra_destructor (vtkBezierTetra * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBezierTetra_get_ptr (vtkBezierTetra * sself) {return sself ;} +extern "C" int vtk_bezier_tetra_get_cell_type(vtkBezierTetra* sself) { return sself->GetCellType(); } +extern "C" vtkBezierTriangle * vtkBezierTriangle_new () {return vtkBezierTriangle :: New () ;} +extern "C" void vtkBezierTriangle_destructor (vtkBezierTriangle * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBezierTriangle_get_ptr (vtkBezierTriangle * sself) {return sself ;} +extern "C" int vtk_bezier_triangle_get_cell_type(vtkBezierTriangle* sself) { return sself->GetCellType(); } +extern "C" vtkBezierWedge * vtkBezierWedge_new () {return vtkBezierWedge :: New () ;} +extern "C" void vtkBezierWedge_destructor (vtkBezierWedge * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBezierWedge_get_ptr (vtkBezierWedge * sself) {return sself ;} +extern "C" int vtk_bezier_wedge_get_cell_type(vtkBezierWedge* sself) { return sself->GetCellType(); } +extern "C" vtkBiQuadraticQuad * vtkBiQuadraticQuad_new () {return vtkBiQuadraticQuad :: New () ;} +extern "C" void vtkBiQuadraticQuad_destructor (vtkBiQuadraticQuad * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBiQuadraticQuad_get_ptr (vtkBiQuadraticQuad * sself) {return sself ;} +extern "C" int vtk_bi_quadratic_quad_get_cell_type(vtkBiQuadraticQuad* sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_quad_get_cell_dimension(vtkBiQuadraticQuad* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_quad_get_number_of_edges(vtkBiQuadraticQuad* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_quad_get_number_of_faces(vtkBiQuadraticQuad* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkBiQuadraticQuadraticHexahedron * vtkBiQuadraticQuadraticHexahedron_new () {return vtkBiQuadraticQuadraticHexahedron :: New () ;} +extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkBiQuadraticQuadraticHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBiQuadraticQuadraticHexahedron_get_ptr (vtkBiQuadraticQuadraticHexahedron * sself) {return sself ;} +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkBiQuadraticQuadraticWedge * vtkBiQuadraticQuadraticWedge_new () {return vtkBiQuadraticQuadraticWedge :: New () ;} +extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkBiQuadraticQuadraticWedge * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBiQuadraticQuadraticWedge_get_ptr (vtkBiQuadraticQuadraticWedge * sself) {return sself ;} +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_type(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkBiQuadraticTriangle * vtkBiQuadraticTriangle_new () {return vtkBiQuadraticTriangle :: New () ;} +extern "C" void vtkBiQuadraticTriangle_destructor (vtkBiQuadraticTriangle * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBiQuadraticTriangle_get_ptr (vtkBiQuadraticTriangle * sself) {return sself ;} +extern "C" int vtk_bi_quadratic_triangle_get_cell_type(vtkBiQuadraticTriangle* sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_triangle_get_cell_dimension(vtkBiQuadraticTriangle* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_triangle_get_number_of_edges(vtkBiQuadraticTriangle* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_triangle_get_number_of_faces(vtkBiQuadraticTriangle* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkBox * vtkBox_new () {return vtkBox :: New () ;} +extern "C" void vtkBox_destructor (vtkBox * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkBox_get_ptr (vtkBox * sself) {return sself ;} +extern "C" void vtk_box_set_x_min(vtkBox* sself, double x, double y, double z) { sself->SetXMin(x, y, z); } +extern "C" void vtk_box_get_x_min(vtkBox* sself, double& x, double& y, double& z) { sself->GetXMin(x, y, z); } +extern "C" void vtk_box_set_x_max(vtkBox* sself, double x, double y, double z) { sself->SetXMax(x, y, z); } +extern "C" void vtk_box_get_x_max(vtkBox* sself, double& x, double& y, double& z) { sself->GetXMax(x, y, z); } +extern "C" void vtk_box_set_bounds(vtkBox* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" void vtk_box_get_bounds(vtkBox* sself, double& xMin, double& xMax, double& yMin, double& yMax, double& zMin, double& zMax) { sself->GetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" vtkCellArray * vtkCellArray_new () {return vtkCellArray :: New () ;} +extern "C" void vtkCellArray_destructor (vtkCellArray * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCellArray_get_ptr (vtkCellArray * sself) {return sself ;} +extern "C" int vtk_cell_array_allocate(vtkCellArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" bool vtk_cell_array_allocate_estimate(vtkCellArray* sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } +extern "C" bool vtk_cell_array_allocate_exact(vtkCellArray* sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } +extern "C" bool vtk_cell_array_resize_exact(vtkCellArray* sself, long long numCells, long long connectivitySize) { return sself->ResizeExact(numCells, connectivitySize); } +extern "C" void vtk_cell_array_initialize(vtkCellArray* sself) { sself->Initialize(); } +extern "C" void vtk_cell_array_reset(vtkCellArray* sself) { sself->Reset(); } +extern "C" void vtk_cell_array_squeeze(vtkCellArray* sself) { sself->Squeeze(); } +extern "C" bool vtk_cell_array_is_valid(vtkCellArray* sself) { return sself->IsValid(); } +extern "C" long long vtk_cell_array_get_number_of_cells(vtkCellArray* sself) { return sself->GetNumberOfCells(); } +extern "C" long long vtk_cell_array_get_number_of_offsets(vtkCellArray* sself) { return sself->GetNumberOfOffsets(); } +extern "C" long long vtk_cell_array_get_number_of_connectivity_ids(vtkCellArray* sself) { return sself->GetNumberOfConnectivityIds(); } +extern "C" bool vtk_cell_array_is_storage_64_bit(vtkCellArray* sself) { return sself->IsStorage64Bit(); } +extern "C" bool vtk_cell_array_is_storage_shareable(vtkCellArray* sself) { return sself->IsStorageShareable(); } +extern "C" void vtk_cell_array_use_32_bit_storage(vtkCellArray* sself) { sself->Use32BitStorage(); } +extern "C" void vtk_cell_array_use_64_bit_storage(vtkCellArray* sself) { sself->Use64BitStorage(); } +extern "C" void vtk_cell_array_use_default_storage(vtkCellArray* sself) { sself->UseDefaultStorage(); } +extern "C" bool vtk_cell_array_can_convert_to_32_bit_storage(vtkCellArray* sself) { return sself->CanConvertTo32BitStorage(); } +extern "C" bool vtk_cell_array_can_convert_to_64_bit_storage(vtkCellArray* sself) { return sself->CanConvertTo64BitStorage(); } +extern "C" bool vtk_cell_array_can_convert_to_default_storage(vtkCellArray* sself) { return sself->CanConvertToDefaultStorage(); } +extern "C" bool vtk_cell_array_convert_to_32_bit_storage(vtkCellArray* sself) { return sself->ConvertTo32BitStorage(); } +extern "C" bool vtk_cell_array_convert_to_64_bit_storage(vtkCellArray* sself) { return sself->ConvertTo64BitStorage(); } +extern "C" bool vtk_cell_array_convert_to_default_storage(vtkCellArray* sself) { return sself->ConvertToDefaultStorage(); } +extern "C" bool vtk_cell_array_convert_to_smallest_storage(vtkCellArray* sself) { return sself->ConvertToSmallestStorage(); } +extern "C" long long vtk_cell_array_is_homogeneous(vtkCellArray* sself) { return sself->IsHomogeneous(); } +extern "C" void vtk_cell_array_init_traversal(vtkCellArray* sself) { sself->InitTraversal(); } +extern "C" long long vtk_cell_array_get_cell_size(vtkCellArray* sself, const long long cellId) { return sself->GetCellSize(cellId); } +extern "C" void vtk_cell_array_insert_cell_point(vtkCellArray* sself, long long id) { sself->InsertCellPoint(id); } +extern "C" void vtk_cell_array_update_cell_count(vtkCellArray* sself, int npts) { sself->UpdateCellCount(npts); } +extern "C" long long vtk_cell_array_get_traversal_cell_id(vtkCellArray* sself) { return sself->GetTraversalCellId(); } +extern "C" void vtk_cell_array_set_traversal_cell_id(vtkCellArray* sself, long long cellId) { sself->SetTraversalCellId(cellId); } +extern "C" void vtk_cell_array_reverse_cell_at_id(vtkCellArray* sself, long long cellId) { sself->ReverseCellAtId(cellId); } +extern "C" int vtk_cell_array_get_max_cell_size(vtkCellArray* sself) { return sself->GetMaxCellSize(); } +extern "C" unsigned long vtk_cell_array_get_actual_memory_size(vtkCellArray* sself) { return sself->GetActualMemorySize(); } +extern "C" void vtk_cell_array_set_number_of_cells(vtkCellArray* sself, long long p0) { sself->SetNumberOfCells(p0); } +extern "C" long long vtk_cell_array_estimate_size(vtkCellArray* sself, long long numCells, int maxPtsPerCell) { return sself->EstimateSize(numCells, maxPtsPerCell); } +extern "C" long long vtk_cell_array_get_size(vtkCellArray* sself) { return sself->GetSize(); } +extern "C" long long vtk_cell_array_get_number_of_connectivity_entries(vtkCellArray* sself) { return sself->GetNumberOfConnectivityEntries(); } +extern "C" long long vtk_cell_array_get_insert_location(vtkCellArray* sself, int npts) { return sself->GetInsertLocation(npts); } +extern "C" long long vtk_cell_array_get_traversal_location(vtkCellArray* sself) { return sself->GetTraversalLocation(); } +extern "C" void vtk_cell_array_set_traversal_location(vtkCellArray* sself, long long loc) { sself->SetTraversalLocation(loc); } +extern "C" void vtk_cell_array_reverse_cell(vtkCellArray* sself, long long loc) { sself->ReverseCell(loc); } +extern "C" vtkCellArrayIterator * vtkCellArrayIterator_new () {return vtkCellArrayIterator :: New () ;} +extern "C" void vtkCellArrayIterator_destructor (vtkCellArrayIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCellArrayIterator_get_ptr (vtkCellArrayIterator * sself) {return sself ;} +extern "C" void vtk_cell_array_iterator_go_to_cell(vtkCellArrayIterator* sself, long long cellId) { sself->GoToCell(cellId); } +extern "C" void vtk_cell_array_iterator_go_to_first_cell(vtkCellArrayIterator* sself) { sself->GoToFirstCell(); } +extern "C" void vtk_cell_array_iterator_go_to_next_cell(vtkCellArrayIterator* sself) { sself->GoToNextCell(); } +extern "C" bool vtk_cell_array_iterator_is_done_with_traversal(vtkCellArrayIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_cell_array_iterator_get_current_cell_id(vtkCellArrayIterator* sself) { return sself->GetCurrentCellId(); } +extern "C" void vtk_cell_array_iterator_reverse_current_cell(vtkCellArrayIterator* sself) { sself->ReverseCurrentCell(); } +extern "C" vtkCellData * vtkCellData_new () {return vtkCellData :: New () ;} +extern "C" void vtkCellData_destructor (vtkCellData * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCellData_get_ptr (vtkCellData * sself) {return sself ;} +extern "C" vtkCellLinks * vtkCellLinks_new () {return vtkCellLinks :: New () ;} +extern "C" void vtkCellLinks_destructor (vtkCellLinks * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCellLinks_get_ptr (vtkCellLinks * sself) {return sself ;} +extern "C" void vtk_cell_links_allocate(vtkCellLinks* sself, long long numLinks, long long ext) { sself->Allocate(numLinks, ext); } +extern "C" void vtk_cell_links_initialize(vtkCellLinks* sself) { sself->Initialize(); } +extern "C" long long vtk_cell_links_get_ncells(vtkCellLinks* sself, long long ptId) { return sself->GetNcells(ptId); } +extern "C" long long vtk_cell_links_insert_next_point(vtkCellLinks* sself, int numLinks) { return sself->InsertNextPoint(numLinks); } +extern "C" void vtk_cell_links_insert_next_cell_reference(vtkCellLinks* sself, long long ptId, long long cellId) { sself->InsertNextCellReference(ptId, cellId); } +extern "C" void vtk_cell_links_delete_point(vtkCellLinks* sself, long long ptId) { sself->DeletePoint(ptId); } +extern "C" void vtk_cell_links_remove_cell_reference(vtkCellLinks* sself, long long cellId, long long ptId) { sself->RemoveCellReference(cellId, ptId); } +extern "C" void vtk_cell_links_add_cell_reference(vtkCellLinks* sself, long long cellId, long long ptId) { sself->AddCellReference(cellId, ptId); } +extern "C" void vtk_cell_links_resize_cell_list(vtkCellLinks* sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } +extern "C" void vtk_cell_links_squeeze(vtkCellLinks* sself) { sself->Squeeze(); } +extern "C" void vtk_cell_links_reset(vtkCellLinks* sself) { sself->Reset(); } +extern "C" unsigned long vtk_cell_links_get_actual_memory_size(vtkCellLinks* sself) { return sself->GetActualMemorySize(); } +extern "C" vtkCellLocator * vtkCellLocator_new () {return vtkCellLocator :: New () ;} +extern "C" void vtkCellLocator_destructor (vtkCellLocator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCellLocator_get_ptr (vtkCellLocator * sself) {return sself ;} +extern "C" void vtk_cell_locator_set_number_of_cells_per_bucket(vtkCellLocator* sself, int N) { sself->SetNumberOfCellsPerBucket(N); } +extern "C" int vtk_cell_locator_get_number_of_cells_per_bucket(vtkCellLocator* sself) { return sself->GetNumberOfCellsPerBucket(); } +extern "C" int vtk_cell_locator_get_number_of_buckets(vtkCellLocator* sself) { return sself->GetNumberOfBuckets(); } +extern "C" void vtk_cell_locator_free_search_structure(vtkCellLocator* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_cell_locator_build_locator(vtkCellLocator* sself) { sself->BuildLocator(); } +extern "C" void vtk_cell_locator_build_locator_if_needed(vtkCellLocator* sself) { sself->BuildLocatorIfNeeded(); } +extern "C" void vtk_cell_locator_force_build_locator(vtkCellLocator* sself) { sself->ForceBuildLocator(); } +extern "C" void vtk_cell_locator_build_locator_internal(vtkCellLocator* sself) { sself->BuildLocatorInternal(); } +extern "C" vtkCellLocatorStrategy * vtkCellLocatorStrategy_new () {return vtkCellLocatorStrategy :: New () ;} +extern "C" void vtkCellLocatorStrategy_destructor (vtkCellLocatorStrategy * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCellLocatorStrategy_get_ptr (vtkCellLocatorStrategy * sself) {return sself ;} +extern "C" vtkCellTypes * vtkCellTypes_new () {return vtkCellTypes :: New () ;} +extern "C" void vtkCellTypes_destructor (vtkCellTypes * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCellTypes_get_ptr (vtkCellTypes * sself) {return sself ;} +extern "C" int vtk_cell_types_allocate(vtkCellTypes* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_cell_types_insert_cell(vtkCellTypes* sself, long long id, unsigned char type, long long loc) { sself->InsertCell(id, type, loc); } +extern "C" long long vtk_cell_types_insert_next_cell(vtkCellTypes* sself, unsigned char type, long long loc) { return sself->InsertNextCell(type, loc); } +extern "C" long long vtk_cell_types_get_cell_location(vtkCellTypes* sself, long long cellId) { return sself->GetCellLocation(cellId); } +extern "C" void vtk_cell_types_delete_cell(vtkCellTypes* sself, long long cellId) { sself->DeleteCell(cellId); } +extern "C" long long vtk_cell_types_get_number_of_types(vtkCellTypes* sself) { return sself->GetNumberOfTypes(); } +extern "C" int vtk_cell_types_is_type(vtkCellTypes* sself, unsigned char type) { return sself->IsType(type); } +extern "C" long long vtk_cell_types_insert_next_type(vtkCellTypes* sself, unsigned char type) { return sself->InsertNextType(type); } +extern "C" unsigned char vtk_cell_types_get_cell_type(vtkCellTypes* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_cell_types_squeeze(vtkCellTypes* sself) { sself->Squeeze(); } +extern "C" void vtk_cell_types_reset(vtkCellTypes* sself) { sself->Reset(); } +extern "C" unsigned long vtk_cell_types_get_actual_memory_size(vtkCellTypes* sself) { return sself->GetActualMemorySize(); } +extern "C" const char* vtk_cell_types_get_class_name_from_type_id(vtkCellTypes* sself, int typeId) { return sself->GetClassNameFromTypeId(typeId); } +extern "C" int vtk_cell_types_get_type_id_from_class_name(vtkCellTypes* sself, const char* classname) { return sself->GetTypeIdFromClassName(classname); } +extern "C" int vtk_cell_types_is_linear(vtkCellTypes* sself, unsigned char type) { return sself->IsLinear(type); } +extern "C" vtkClosestNPointsStrategy * vtkClosestNPointsStrategy_new () {return vtkClosestNPointsStrategy :: New () ;} +extern "C" void vtkClosestNPointsStrategy_destructor (vtkClosestNPointsStrategy * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkClosestNPointsStrategy_get_ptr (vtkClosestNPointsStrategy * sself) {return sself ;} +extern "C" void vtk_closest_n_points_strategy_set_closest_n_points(vtkClosestNPointsStrategy* sself, int _arg) { sself->SetClosestNPoints(_arg); } +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_min_value(vtkClosestNPointsStrategy* sself) { return sself->GetClosestNPointsMinValue(); } +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_max_value(vtkClosestNPointsStrategy* sself) { return sself->GetClosestNPointsMaxValue(); } +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points(vtkClosestNPointsStrategy* sself) { return sself->GetClosestNPoints(); } +extern "C" vtkClosestPointStrategy * vtkClosestPointStrategy_new () {return vtkClosestPointStrategy :: New () ;} +extern "C" void vtkClosestPointStrategy_destructor (vtkClosestPointStrategy * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkClosestPointStrategy_get_ptr (vtkClosestPointStrategy * sself) {return sself ;} +extern "C" vtkCone * vtkCone_new () {return vtkCone :: New () ;} +extern "C" void vtkCone_destructor (vtkCone * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCone_get_ptr (vtkCone * sself) {return sself ;} +extern "C" void vtk_cone_set_angle(vtkCone* sself, double _arg) { sself->SetAngle(_arg); } +extern "C" double vtk_cone_get_angle_min_value(vtkCone* sself) { return sself->GetAngleMinValue(); } +extern "C" double vtk_cone_get_angle_max_value(vtkCone* sself) { return sself->GetAngleMaxValue(); } +extern "C" double vtk_cone_get_angle(vtkCone* sself) { return sself->GetAngle(); } +extern "C" vtkConvexPointSet * vtkConvexPointSet_new () {return vtkConvexPointSet :: New () ;} +extern "C" void vtkConvexPointSet_destructor (vtkConvexPointSet * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkConvexPointSet_get_ptr (vtkConvexPointSet * sself) {return sself ;} +extern "C" int vtk_convex_point_set_has_fixed_topology(vtkConvexPointSet* sself) { return sself->HasFixedTopology(); } +extern "C" int vtk_convex_point_set_get_cell_type(vtkConvexPointSet* sself) { return sself->GetCellType(); } +extern "C" int vtk_convex_point_set_requires_initialization(vtkConvexPointSet* sself) { return sself->RequiresInitialization(); } +extern "C" int vtk_convex_point_set_get_number_of_edges(vtkConvexPointSet* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_convex_point_set_get_number_of_faces(vtkConvexPointSet* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_convex_point_set_is_primary_cell(vtkConvexPointSet* sself) { return sself->IsPrimaryCell(); } +extern "C" vtkCubicLine * vtkCubicLine_new () {return vtkCubicLine :: New () ;} +extern "C" void vtkCubicLine_destructor (vtkCubicLine * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCubicLine_get_ptr (vtkCubicLine * sself) {return sself ;} +extern "C" int vtk_cubic_line_get_cell_type(vtkCubicLine* sself) { return sself->GetCellType(); } +extern "C" int vtk_cubic_line_get_cell_dimension(vtkCubicLine* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_cubic_line_get_number_of_edges(vtkCubicLine* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_cubic_line_get_number_of_faces(vtkCubicLine* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkCylinder * vtkCylinder_new () {return vtkCylinder :: New () ;} +extern "C" void vtkCylinder_destructor (vtkCylinder * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCylinder_get_ptr (vtkCylinder * sself) {return sself ;} +extern "C" void vtk_cylinder_set_radius(vtkCylinder* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_cylinder_get_radius(vtkCylinder* sself) { return sself->GetRadius(); } +extern "C" void vtk_cylinder_set_center(vtkCylinder* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_cylinder_set_axis(vtkCylinder* sself, double ax, double ay, double az) { sself->SetAxis(ax, ay, az); } +extern "C" vtkDataAssembly * vtkDataAssembly_new () {return vtkDataAssembly :: New () ;} +extern "C" void vtkDataAssembly_destructor (vtkDataAssembly * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataAssembly_get_ptr (vtkDataAssembly * sself) {return sself ;} +extern "C" void vtk_data_assembly_initialize(vtkDataAssembly* sself) { sself->Initialize(); } +extern "C" bool vtk_data_assembly_initialize_from_xml(vtkDataAssembly* sself, const char* xmlcontents) { return sself->InitializeFromXML(xmlcontents); } +extern "C" int vtk_data_assembly_get_root_node(vtkDataAssembly* sself) { return sself->GetRootNode(); } +extern "C" void vtk_data_assembly_set_root_node_name(vtkDataAssembly* sself, const char* name) { sself->SetRootNodeName(name); } +extern "C" const char* vtk_data_assembly_get_root_node_name(vtkDataAssembly* sself) { return sself->GetRootNodeName(); } +extern "C" int vtk_data_assembly_add_node(vtkDataAssembly* sself, const char* name, int parent) { return sself->AddNode(name, parent); } +extern "C" bool vtk_data_assembly_remove_node(vtkDataAssembly* sself, int id) { return sself->RemoveNode(id); } +extern "C" void vtk_data_assembly_set_node_name(vtkDataAssembly* sself, int id, const char* name) { sself->SetNodeName(id, name); } +extern "C" const char* vtk_data_assembly_get_node_name(vtkDataAssembly* sself, int id) { return sself->GetNodeName(id); } +extern "C" int vtk_data_assembly_get_first_node_by_path(vtkDataAssembly* sself, const char* path) { return sself->GetFirstNodeByPath(path); } +extern "C" bool vtk_data_assembly_add_data_set_index(vtkDataAssembly* sself, int id, unsigned int dataset_index) { return sself->AddDataSetIndex(id, dataset_index); } +extern "C" bool vtk_data_assembly_add_data_set_index_range(vtkDataAssembly* sself, int id, unsigned int index_start, int count) { return sself->AddDataSetIndexRange(id, index_start, count); } +extern "C" bool vtk_data_assembly_remove_data_set_index(vtkDataAssembly* sself, int id, unsigned int dataset_index) { return sself->RemoveDataSetIndex(id, dataset_index); } +extern "C" bool vtk_data_assembly_remove_all_data_set_indices(vtkDataAssembly* sself, int id, bool traverse_subtree) { return sself->RemoveAllDataSetIndices(id, traverse_subtree); } +extern "C" int vtk_data_assembly_find_first_node_with_name(vtkDataAssembly* sself, const char* name, int traversal_order) { return sself->FindFirstNodeWithName(name, traversal_order); } +extern "C" int vtk_data_assembly_get_number_of_children(vtkDataAssembly* sself, int parent) { return sself->GetNumberOfChildren(parent); } +extern "C" int vtk_data_assembly_get_child(vtkDataAssembly* sself, int parent, int index) { return sself->GetChild(parent, index); } +extern "C" int vtk_data_assembly_get_child_index(vtkDataAssembly* sself, int parent, int child) { return sself->GetChildIndex(parent, child); } +extern "C" int vtk_data_assembly_get_parent(vtkDataAssembly* sself, int id) { return sself->GetParent(id); } +extern "C" bool vtk_data_assembly_has_attribute(vtkDataAssembly* sself, int id, const char* name) { return sself->HasAttribute(id, name); } +extern "C" void vtk_data_assembly_set_attribute(vtkDataAssembly* sself, int id, const char* name, const char* value) { sself->SetAttribute(id, name, value); } +extern "C" bool vtk_data_assembly_get_attribute(vtkDataAssembly* sself, int id, const char* name, const char* value) { return sself->GetAttribute(id, name, value); } +extern "C" const char* vtk_data_assembly_get_attribute_or_default(vtkDataAssembly* sself, int id, const char* name, const char* default_value) { return sself->GetAttributeOrDefault(id, name, default_value); } +extern "C" bool vtk_data_assembly_is_node_name_valid(vtkDataAssembly* sself, const char* name) { return sself->IsNodeNameValid(name); } +extern "C" bool vtk_data_assembly_is_node_name_reserved(vtkDataAssembly* sself, const char* name) { return sself->IsNodeNameReserved(name); } +extern "C" vtkDataAssemblyUtilities * vtkDataAssemblyUtilities_new () {return vtkDataAssemblyUtilities :: New () ;} +extern "C" void vtkDataAssemblyUtilities_destructor (vtkDataAssemblyUtilities * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataAssemblyUtilities_get_ptr (vtkDataAssemblyUtilities * sself) {return sself ;} +extern "C" const char* vtk_data_assembly_utilities_hierarchy_name(vtkDataAssemblyUtilities* sself) { return sself->HierarchyName(); } +extern "C" vtkDataObject * vtkDataObject_new () {return vtkDataObject :: New () ;} +extern "C" void vtkDataObject_destructor (vtkDataObject * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataObject_get_ptr (vtkDataObject * sself) {return sself ;} +extern "C" unsigned long vtk_data_object_get_m_time(vtkDataObject* sself) { return sself->GetMTime(); } +extern "C" void vtk_data_object_initialize(vtkDataObject* sself) { sself->Initialize(); } +extern "C" void vtk_data_object_release_data(vtkDataObject* sself) { sself->ReleaseData(); } +extern "C" int vtk_data_object_get_data_released(vtkDataObject* sself) { return sself->GetDataReleased(); } +extern "C" void vtk_data_object_set_global_release_data_flag(vtkDataObject* sself, int val) { sself->SetGlobalReleaseDataFlag(val); } +extern "C" void vtk_data_object_global_release_data_flag_on(vtkDataObject* sself) { sself->GlobalReleaseDataFlagOn(); } +extern "C" void vtk_data_object_global_release_data_flag_off(vtkDataObject* sself) { sself->GlobalReleaseDataFlagOff(); } +extern "C" int vtk_data_object_get_global_release_data_flag(vtkDataObject* sself) { return sself->GetGlobalReleaseDataFlag(); } +extern "C" int vtk_data_object_get_data_object_type(vtkDataObject* sself) { return sself->GetDataObjectType(); } +extern "C" unsigned long vtk_data_object_get_update_time(vtkDataObject* sself) { return sself->GetUpdateTime(); } +extern "C" unsigned long vtk_data_object_get_actual_memory_size(vtkDataObject* sself) { return sself->GetActualMemorySize(); } +extern "C" void vtk_data_object_data_has_been_generated(vtkDataObject* sself) { sself->DataHasBeenGenerated(); } +extern "C" void vtk_data_object_prepare_for_new_data(vtkDataObject* sself) { sself->PrepareForNewData(); } +extern "C" int vtk_data_object_get_extent_type(vtkDataObject* sself) { return sself->GetExtentType(); } +extern "C" long long vtk_data_object_get_number_of_elements(vtkDataObject* sself, int type) { return sself->GetNumberOfElements(type); } +extern "C" const char* vtk_data_object_get_association_type_as_string(vtkDataObject* sself, int associationType) { return sself->GetAssociationTypeAsString(associationType); } +extern "C" int vtk_data_object_get_association_type_from_string(vtkDataObject* sself, const char* associationName) { return sself->GetAssociationTypeFromString(associationName); } +extern "C" vtkDataObjectCollection * vtkDataObjectCollection_new () {return vtkDataObjectCollection :: New () ;} +extern "C" void vtkDataObjectCollection_destructor (vtkDataObjectCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataObjectCollection_get_ptr (vtkDataObjectCollection * sself) {return sself ;} +extern "C" int vtk_data_object_collection_get_number_of_items(vtkDataObjectCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" vtkDataObjectTreeIterator * vtkDataObjectTreeIterator_new () {return vtkDataObjectTreeIterator :: New () ;} +extern "C" void vtkDataObjectTreeIterator_destructor (vtkDataObjectTreeIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataObjectTreeIterator_get_ptr (vtkDataObjectTreeIterator * sself) {return sself ;} +extern "C" void vtk_data_object_tree_iterator_go_to_first_item(vtkDataObjectTreeIterator* sself) { sself->GoToFirstItem(); } +extern "C" void vtk_data_object_tree_iterator_go_to_next_item(vtkDataObjectTreeIterator* sself) { sself->GoToNextItem(); } +extern "C" int vtk_data_object_tree_iterator_is_done_with_traversal(vtkDataObjectTreeIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" int vtk_data_object_tree_iterator_has_current_meta_data(vtkDataObjectTreeIterator* sself) { return sself->HasCurrentMetaData(); } +extern "C" unsigned int vtk_data_object_tree_iterator_get_current_flat_index(vtkDataObjectTreeIterator* sself) { return sself->GetCurrentFlatIndex(); } +extern "C" void vtk_data_object_tree_iterator_set_visit_only_leaves(vtkDataObjectTreeIterator* sself, int _arg) { sself->SetVisitOnlyLeaves(_arg); } +extern "C" int vtk_data_object_tree_iterator_get_visit_only_leaves(vtkDataObjectTreeIterator* sself) { return sself->GetVisitOnlyLeaves(); } +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_on(vtkDataObjectTreeIterator* sself) { sself->VisitOnlyLeavesOn(); } +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_off(vtkDataObjectTreeIterator* sself) { sself->VisitOnlyLeavesOff(); } +extern "C" void vtk_data_object_tree_iterator_set_traverse_sub_tree(vtkDataObjectTreeIterator* sself, int _arg) { sself->SetTraverseSubTree(_arg); } +extern "C" int vtk_data_object_tree_iterator_get_traverse_sub_tree(vtkDataObjectTreeIterator* sself) { return sself->GetTraverseSubTree(); } +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_on(vtkDataObjectTreeIterator* sself) { sself->TraverseSubTreeOn(); } +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_off(vtkDataObjectTreeIterator* sself) { sself->TraverseSubTreeOff(); } +extern "C" vtkDataObjectTypes * vtkDataObjectTypes_new () {return vtkDataObjectTypes :: New () ;} +extern "C" void vtkDataObjectTypes_destructor (vtkDataObjectTypes * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataObjectTypes_get_ptr (vtkDataObjectTypes * sself) {return sself ;} +extern "C" const char* vtk_data_object_types_get_class_name_from_type_id(vtkDataObjectTypes* sself, int typeId) { return sself->GetClassNameFromTypeId(typeId); } +extern "C" int vtk_data_object_types_get_type_id_from_class_name(vtkDataObjectTypes* sself, const char* classname) { return sself->GetTypeIdFromClassName(classname); } +extern "C" bool vtk_data_object_types_type_id_is_a(vtkDataObjectTypes* sself, int typeId, int targetTypeId) { return sself->TypeIdIsA(typeId, targetTypeId); } +extern "C" int vtk_data_object_types_get_common_base_type_id(vtkDataObjectTypes* sself, int typeA, int typeB) { return sself->GetCommonBaseTypeId(typeA, typeB); } +extern "C" vtkDataSetAttributes * vtkDataSetAttributes_new () {return vtkDataSetAttributes :: New () ;} +extern "C" void vtkDataSetAttributes_destructor (vtkDataSetAttributes * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataSetAttributes_get_ptr (vtkDataSetAttributes * sself) {return sself ;} +extern "C" void vtk_data_set_attributes_initialize(vtkDataSetAttributes* sself) { sself->Initialize(); } +extern "C" void vtk_data_set_attributes_update(vtkDataSetAttributes* sself) { sself->Update(); } +extern "C" const char* vtk_data_set_attributes_ghost_array_name(vtkDataSetAttributes* sself) { return sself->GhostArrayName(); } +extern "C" int vtk_data_set_attributes_set_active_scalars(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveScalars(name); } +extern "C" int vtk_data_set_attributes_set_active_vectors(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveVectors(name); } +extern "C" int vtk_data_set_attributes_set_active_normals(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveNormals(name); } +extern "C" int vtk_data_set_attributes_set_active_tangents(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveTangents(name); } +extern "C" int vtk_data_set_attributes_set_active_t_coords(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveTCoords(name); } +extern "C" int vtk_data_set_attributes_set_active_tensors(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveTensors(name); } +extern "C" int vtk_data_set_attributes_set_active_global_ids(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveGlobalIds(name); } +extern "C" int vtk_data_set_attributes_set_active_pedigree_ids(vtkDataSetAttributes* sself, const char* name) { return sself->SetActivePedigreeIds(name); } +extern "C" int vtk_data_set_attributes_set_active_rational_weights(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveRationalWeights(name); } +extern "C" int vtk_data_set_attributes_set_active_higher_order_degrees(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveHigherOrderDegrees(name); } +extern "C" int vtk_data_set_attributes_set_active_attribute(vtkDataSetAttributes* sself, const char* name, int attributeType) { return sself->SetActiveAttribute(name, attributeType); } +extern "C" int vtk_data_set_attributes_is_array_an_attribute(vtkDataSetAttributes* sself, int idx) { return sself->IsArrayAnAttribute(idx); } +extern "C" const char* vtk_data_set_attributes_get_attribute_type_as_string(vtkDataSetAttributes* sself, int attributeType) { return sself->GetAttributeTypeAsString(attributeType); } +extern "C" const char* vtk_data_set_attributes_get_long_attribute_type_as_string(vtkDataSetAttributes* sself, int attributeType) { return sself->GetLongAttributeTypeAsString(attributeType); } +extern "C" void vtk_data_set_attributes_set_copy_attribute(vtkDataSetAttributes* sself, int index, int value, int ctype) { sself->SetCopyAttribute(index, value, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_attribute(vtkDataSetAttributes* sself, int index, int ctype) { return sself->GetCopyAttribute(index, ctype); } +extern "C" void vtk_data_set_attributes_set_copy_scalars(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyScalars(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_scalars(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyScalars(ctype); } +extern "C" void vtk_data_set_attributes_copy_scalars_on(vtkDataSetAttributes* sself) { sself->CopyScalarsOn(); } +extern "C" void vtk_data_set_attributes_copy_scalars_off(vtkDataSetAttributes* sself) { sself->CopyScalarsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_vectors(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyVectors(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_vectors(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyVectors(ctype); } +extern "C" void vtk_data_set_attributes_copy_vectors_on(vtkDataSetAttributes* sself) { sself->CopyVectorsOn(); } +extern "C" void vtk_data_set_attributes_copy_vectors_off(vtkDataSetAttributes* sself) { sself->CopyVectorsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_normals(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyNormals(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_normals(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyNormals(ctype); } +extern "C" void vtk_data_set_attributes_copy_normals_on(vtkDataSetAttributes* sself) { sself->CopyNormalsOn(); } +extern "C" void vtk_data_set_attributes_copy_normals_off(vtkDataSetAttributes* sself) { sself->CopyNormalsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_tangents(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyTangents(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_tangents(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyTangents(ctype); } +extern "C" void vtk_data_set_attributes_copy_tangents_on(vtkDataSetAttributes* sself) { sself->CopyTangentsOn(); } +extern "C" void vtk_data_set_attributes_copy_tangents_off(vtkDataSetAttributes* sself) { sself->CopyTangentsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_t_coords(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyTCoords(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_t_coords(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyTCoords(ctype); } +extern "C" void vtk_data_set_attributes_copy_t_coords_on(vtkDataSetAttributes* sself) { sself->CopyTCoordsOn(); } +extern "C" void vtk_data_set_attributes_copy_t_coords_off(vtkDataSetAttributes* sself) { sself->CopyTCoordsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_tensors(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyTensors(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_tensors(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyTensors(ctype); } +extern "C" void vtk_data_set_attributes_copy_tensors_on(vtkDataSetAttributes* sself) { sself->CopyTensorsOn(); } +extern "C" void vtk_data_set_attributes_copy_tensors_off(vtkDataSetAttributes* sself) { sself->CopyTensorsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_global_ids(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyGlobalIds(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_global_ids(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyGlobalIds(ctype); } +extern "C" void vtk_data_set_attributes_copy_global_ids_on(vtkDataSetAttributes* sself) { sself->CopyGlobalIdsOn(); } +extern "C" void vtk_data_set_attributes_copy_global_ids_off(vtkDataSetAttributes* sself) { sself->CopyGlobalIdsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_pedigree_ids(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyPedigreeIds(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_pedigree_ids(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyPedigreeIds(ctype); } +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_on(vtkDataSetAttributes* sself) { sself->CopyPedigreeIdsOn(); } +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_off(vtkDataSetAttributes* sself) { sself->CopyPedigreeIdsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_rational_weights(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyRationalWeights(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_rational_weights(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyRationalWeights(ctype); } +extern "C" void vtk_data_set_attributes_copy_rational_weights_on(vtkDataSetAttributes* sself) { sself->CopyRationalWeightsOn(); } +extern "C" void vtk_data_set_attributes_copy_rational_weights_off(vtkDataSetAttributes* sself) { sself->CopyRationalWeightsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_higher_order_degrees(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyHigherOrderDegrees(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_higher_order_degrees(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyHigherOrderDegrees(ctype); } +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_on(vtkDataSetAttributes* sself) { sself->CopyHigherOrderDegreesOn(); } +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_off(vtkDataSetAttributes* sself) { sself->CopyHigherOrderDegreesOff(); } +extern "C" void vtk_data_set_attributes_copy_all_on(vtkDataSetAttributes* sself, int ctype) { sself->CopyAllOn(ctype); } +extern "C" void vtk_data_set_attributes_copy_all_off(vtkDataSetAttributes* sself, int ctype) { sself->CopyAllOff(ctype); } +extern "C" vtkDataSetCellIterator * vtkDataSetCellIterator_new () {return vtkDataSetCellIterator :: New () ;} +extern "C" void vtkDataSetCellIterator_destructor (vtkDataSetCellIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataSetCellIterator_get_ptr (vtkDataSetCellIterator * sself) {return sself ;} +extern "C" bool vtk_data_set_cell_iterator_is_done_with_traversal(vtkDataSetCellIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_data_set_cell_iterator_get_cell_id(vtkDataSetCellIterator* sself) { return sself->GetCellId(); } +extern "C" vtkDataSetCollection * vtkDataSetCollection_new () {return vtkDataSetCollection :: New () ;} +extern "C" void vtkDataSetCollection_destructor (vtkDataSetCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataSetCollection_get_ptr (vtkDataSetCollection * sself) {return sself ;} +extern "C" int vtk_data_set_collection_get_number_of_items(vtkDataSetCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" vtkDirectedAcyclicGraph * vtkDirectedAcyclicGraph_new () {return vtkDirectedAcyclicGraph :: New () ;} +extern "C" void vtkDirectedAcyclicGraph_destructor (vtkDirectedAcyclicGraph * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDirectedAcyclicGraph_get_ptr (vtkDirectedAcyclicGraph * sself) {return sself ;} +extern "C" vtkDirectedGraph * vtkDirectedGraph_new () {return vtkDirectedGraph :: New () ;} +extern "C" void vtkDirectedGraph_destructor (vtkDirectedGraph * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDirectedGraph_get_ptr (vtkDirectedGraph * sself) {return sself ;} +extern "C" vtkEdgeListIterator * vtkEdgeListIterator_new () {return vtkEdgeListIterator :: New () ;} +extern "C" void vtkEdgeListIterator_destructor (vtkEdgeListIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkEdgeListIterator_get_ptr (vtkEdgeListIterator * sself) {return sself ;} +extern "C" bool vtk_edge_list_iterator_has_next(vtkEdgeListIterator* sself) { return sself->HasNext(); } +extern "C" vtkEdgeTable * vtkEdgeTable_new () {return vtkEdgeTable :: New () ;} +extern "C" void vtkEdgeTable_destructor (vtkEdgeTable * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkEdgeTable_get_ptr (vtkEdgeTable * sself) {return sself ;} +extern "C" void vtk_edge_table_initialize(vtkEdgeTable* sself) { sself->Initialize(); } +extern "C" int vtk_edge_table_init_edge_insertion(vtkEdgeTable* sself, long long numPoints, int storeAttributes) { return sself->InitEdgeInsertion(numPoints, storeAttributes); } +extern "C" long long vtk_edge_table_insert_edge(vtkEdgeTable* sself, long long p1, long long p2) { return sself->InsertEdge(p1, p2); } +extern "C" long long vtk_edge_table_is_edge(vtkEdgeTable* sself, long long p1, long long p2) { return sself->IsEdge(p1, p2); } +extern "C" long long vtk_edge_table_get_number_of_edges(vtkEdgeTable* sself) { return sself->GetNumberOfEdges(); } +extern "C" void vtk_edge_table_init_traversal(vtkEdgeTable* sself) { sself->InitTraversal(); } +extern "C" long long vtk_edge_table_get_next_edge(vtkEdgeTable* sself, long long& p1, long long& p2) { return sself->GetNextEdge(p1, p2); } +extern "C" void vtk_edge_table_reset(vtkEdgeTable* sself) { sself->Reset(); } +extern "C" vtkEmptyCell * vtkEmptyCell_new () {return vtkEmptyCell :: New () ;} +extern "C" void vtkEmptyCell_destructor (vtkEmptyCell * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkEmptyCell_get_ptr (vtkEmptyCell * sself) {return sself ;} +extern "C" int vtk_empty_cell_get_cell_type(vtkEmptyCell* sself) { return sself->GetCellType(); } +extern "C" int vtk_empty_cell_get_cell_dimension(vtkEmptyCell* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_empty_cell_get_number_of_edges(vtkEmptyCell* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_empty_cell_get_number_of_faces(vtkEmptyCell* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkExplicitStructuredGrid * vtkExplicitStructuredGrid_new () {return vtkExplicitStructuredGrid :: New () ;} +extern "C" void vtkExplicitStructuredGrid_destructor (vtkExplicitStructuredGrid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkExplicitStructuredGrid_get_ptr (vtkExplicitStructuredGrid * sself) {return sself ;} +extern "C" int vtk_explicit_structured_grid_get_data_object_type(vtkExplicitStructuredGrid* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_explicit_structured_grid_initialize(vtkExplicitStructuredGrid* sself) { sself->Initialize(); } +extern "C" int vtk_explicit_structured_grid_get_cell_type(vtkExplicitStructuredGrid* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" int vtk_explicit_structured_grid_get_data_dimension(vtkExplicitStructuredGrid* sself) { return sself->GetDataDimension(); } +extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkExplicitStructuredGrid* sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" int vtk_explicit_structured_grid_get_extent_type(vtkExplicitStructuredGrid* sself) { return sself->GetExtentType(); } +extern "C" void vtk_explicit_structured_grid_set_extent(vtkExplicitStructuredGrid* sself, int x0, int x1, int y0, int y1, int z0, int z1) { sself->SetExtent(x0, x1, y0, y1, z0, z1); } +extern "C" void vtk_explicit_structured_grid_build_links(vtkExplicitStructuredGrid* sself) { sself->BuildLinks(); } +extern "C" void vtk_explicit_structured_grid_compute_cell_structured_coords(vtkExplicitStructuredGrid* sself, long long cellId, int& i, int& j, int& k, bool adjustForExtent) { sself->ComputeCellStructuredCoords(cellId, i, j, k, adjustForExtent); } +extern "C" long long vtk_explicit_structured_grid_compute_cell_id(vtkExplicitStructuredGrid* sself, int i, int j, int k, bool adjustForExtent) { return sself->ComputeCellId(i, j, k, adjustForExtent); } +extern "C" void vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(vtkExplicitStructuredGrid* sself) { sself->ComputeFacesConnectivityFlagsArray(); } +extern "C" void vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name(vtkExplicitStructuredGrid* sself, const char* _arg) { sself->SetFacesConnectivityFlagsArrayName(_arg); } +extern "C" void vtk_explicit_structured_grid_blank_cell(vtkExplicitStructuredGrid* sself, long long cellId) { sself->BlankCell(cellId); } +extern "C" void vtk_explicit_structured_grid_un_blank_cell(vtkExplicitStructuredGrid* sself, long long cellId) { sself->UnBlankCell(cellId); } +extern "C" bool vtk_explicit_structured_grid_has_any_blank_cells(vtkExplicitStructuredGrid* sself) { return sself->HasAnyBlankCells(); } +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_visible(vtkExplicitStructuredGrid* sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_ghost(vtkExplicitStructuredGrid* sself, long long cellId) { return sself->IsCellGhost(cellId); } +extern "C" bool vtk_explicit_structured_grid_has_any_ghost_cells(vtkExplicitStructuredGrid* sself) { return sself->HasAnyGhostCells(); } +extern "C" unsigned long vtk_explicit_structured_grid_get_actual_memory_size(vtkExplicitStructuredGrid* sself) { return sself->GetActualMemorySize(); } +extern "C" void vtk_explicit_structured_grid_check_and_reorder_faces(vtkExplicitStructuredGrid* sself) { sself->CheckAndReorderFaces(); } +extern "C" vtkExtractStructuredGridHelper * vtkExtractStructuredGridHelper_new () {return vtkExtractStructuredGridHelper :: New () ;} +extern "C" void vtkExtractStructuredGridHelper_destructor (vtkExtractStructuredGridHelper * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkExtractStructuredGridHelper_get_ptr (vtkExtractStructuredGridHelper * sself) {return sself ;} +extern "C" bool vtk_extract_structured_grid_helper_is_valid(vtkExtractStructuredGridHelper* sself) { return sself->IsValid(); } +extern "C" int vtk_extract_structured_grid_helper_get_size(vtkExtractStructuredGridHelper* sself, const int dim) { return sself->GetSize(dim); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx) { return sself->GetMappedIndex(dim, outIdx); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value(vtkExtractStructuredGridHelper* sself, int dim, int outExtVal) { return sself->GetMappedIndexFromExtentValue(dim, outExtVal); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value(vtkExtractStructuredGridHelper* sself, int dim, int outExtVal) { return sself->GetMappedExtentValue(dim, outExtVal); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx) { return sself->GetMappedExtentValueFromIndex(dim, outIdx); } +extern "C" vtkFieldData * vtkFieldData_new () {return vtkFieldData :: New () ;} +extern "C" void vtkFieldData_destructor (vtkFieldData * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkFieldData_get_ptr (vtkFieldData * sself) {return sself ;} +extern "C" void vtk_field_data_initialize(vtkFieldData* sself) { sself->Initialize(); } +extern "C" int vtk_field_data_allocate(vtkFieldData* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_field_data_allocate_arrays(vtkFieldData* sself, int num) { sself->AllocateArrays(num); } +extern "C" int vtk_field_data_get_number_of_arrays(vtkFieldData* sself) { return sself->GetNumberOfArrays(); } +extern "C" void vtk_field_data_null_data(vtkFieldData* sself, long long id) { sself->NullData(id); } +extern "C" void vtk_field_data_remove_array(vtkFieldData* sself, const char* name) { sself->RemoveArray(name); } +extern "C" int vtk_field_data_has_array(vtkFieldData* sself, const char* name) { return sself->HasArray(name); } +extern "C" const char* vtk_field_data_get_array_name(vtkFieldData* sself, int i) { return sself->GetArrayName(i); } +extern "C" void vtk_field_data_copy_field_on(vtkFieldData* sself, const char* name) { sself->CopyFieldOn(name); } +extern "C" void vtk_field_data_copy_field_off(vtkFieldData* sself, const char* name) { sself->CopyFieldOff(name); } +extern "C" void vtk_field_data_copy_all_on(vtkFieldData* sself, int unused) { sself->CopyAllOn(unused); } +extern "C" void vtk_field_data_copy_all_off(vtkFieldData* sself, int unused) { sself->CopyAllOff(unused); } +extern "C" void vtk_field_data_squeeze(vtkFieldData* sself) { sself->Squeeze(); } +extern "C" void vtk_field_data_reset(vtkFieldData* sself) { sself->Reset(); } +extern "C" unsigned long vtk_field_data_get_actual_memory_size(vtkFieldData* sself) { return sself->GetActualMemorySize(); } +extern "C" unsigned long vtk_field_data_get_m_time(vtkFieldData* sself) { return sself->GetMTime(); } +extern "C" int vtk_field_data_get_array_containing_component(vtkFieldData* sself, int i, int& arrayComp) { return sself->GetArrayContainingComponent(i, arrayComp); } +extern "C" int vtk_field_data_get_number_of_components(vtkFieldData* sself) { return sself->GetNumberOfComponents(); } +extern "C" long long vtk_field_data_get_number_of_tuples(vtkFieldData* sself) { return sself->GetNumberOfTuples(); } +extern "C" void vtk_field_data_set_number_of_tuples(vtkFieldData* sself, const long long number) { sself->SetNumberOfTuples(number); } +extern "C" vtkGenericAttributeCollection * vtkGenericAttributeCollection_new () {return vtkGenericAttributeCollection :: New () ;} +extern "C" void vtkGenericAttributeCollection_destructor (vtkGenericAttributeCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGenericAttributeCollection_get_ptr (vtkGenericAttributeCollection * sself) {return sself ;} +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfAttributes(); } +extern "C" int vtk_generic_attribute_collection_get_number_of_components(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfComponents(); } +extern "C" int vtk_generic_attribute_collection_get_number_of_point_centered_components(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfPointCenteredComponents(); } +extern "C" int vtk_generic_attribute_collection_get_max_number_of_components(vtkGenericAttributeCollection* sself) { return sself->GetMaxNumberOfComponents(); } +extern "C" unsigned long vtk_generic_attribute_collection_get_actual_memory_size(vtkGenericAttributeCollection* sself) { return sself->GetActualMemorySize(); } +extern "C" int vtk_generic_attribute_collection_is_empty(vtkGenericAttributeCollection* sself) { return sself->IsEmpty(); } +extern "C" int vtk_generic_attribute_collection_find_attribute(vtkGenericAttributeCollection* sself, const char* name) { return sself->FindAttribute(name); } +extern "C" int vtk_generic_attribute_collection_get_attribute_index(vtkGenericAttributeCollection* sself, int i) { return sself->GetAttributeIndex(i); } +extern "C" void vtk_generic_attribute_collection_remove_attribute(vtkGenericAttributeCollection* sself, int i) { sself->RemoveAttribute(i); } +extern "C" void vtk_generic_attribute_collection_reset(vtkGenericAttributeCollection* sself) { sself->Reset(); } +extern "C" unsigned long vtk_generic_attribute_collection_get_m_time(vtkGenericAttributeCollection* sself) { return sself->GetMTime(); } +extern "C" int vtk_generic_attribute_collection_get_active_attribute(vtkGenericAttributeCollection* sself) { return sself->GetActiveAttribute(); } +extern "C" int vtk_generic_attribute_collection_get_active_component(vtkGenericAttributeCollection* sself) { return sself->GetActiveComponent(); } +extern "C" void vtk_generic_attribute_collection_set_active_attribute(vtkGenericAttributeCollection* sself, int attribute, int component) { sself->SetActiveAttribute(attribute, component); } +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfAttributesToInterpolate(); } +extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(vtkGenericAttributeCollection* sself) { sself->SetAttributesToInterpolateToAll(); } +extern "C" vtkGenericCell * vtkGenericCell_new () {return vtkGenericCell :: New () ;} +extern "C" void vtkGenericCell_destructor (vtkGenericCell * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGenericCell_get_ptr (vtkGenericCell * sself) {return sself ;} +extern "C" int vtk_generic_cell_get_cell_type(vtkGenericCell* sself) { return sself->GetCellType(); } +extern "C" int vtk_generic_cell_get_cell_dimension(vtkGenericCell* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_generic_cell_get_number_of_edges(vtkGenericCell* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_generic_cell_get_number_of_faces(vtkGenericCell* sself) { return sself->GetNumberOfFaces(); } +extern "C" void vtk_generic_cell_set_cell_type(vtkGenericCell* sself, int cellType) { sself->SetCellType(cellType); } +extern "C" void vtk_generic_cell_set_cell_type_to_empty_cell(vtkGenericCell* sself) { sself->SetCellTypeToEmptyCell(); } +extern "C" void vtk_generic_cell_set_cell_type_to_vertex(vtkGenericCell* sself) { sself->SetCellTypeToVertex(); } +extern "C" void vtk_generic_cell_set_cell_type_to_poly_vertex(vtkGenericCell* sself) { sself->SetCellTypeToPolyVertex(); } +extern "C" void vtk_generic_cell_set_cell_type_to_line(vtkGenericCell* sself) { sself->SetCellTypeToLine(); } +extern "C" void vtk_generic_cell_set_cell_type_to_poly_line(vtkGenericCell* sself) { sself->SetCellTypeToPolyLine(); } +extern "C" void vtk_generic_cell_set_cell_type_to_triangle(vtkGenericCell* sself) { sself->SetCellTypeToTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_triangle_strip(vtkGenericCell* sself) { sself->SetCellTypeToTriangleStrip(); } +extern "C" void vtk_generic_cell_set_cell_type_to_polygon(vtkGenericCell* sself) { sself->SetCellTypeToPolygon(); } +extern "C" void vtk_generic_cell_set_cell_type_to_pixel(vtkGenericCell* sself) { sself->SetCellTypeToPixel(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quad(vtkGenericCell* sself) { sself->SetCellTypeToQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_tetra(vtkGenericCell* sself) { sself->SetCellTypeToTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_voxel(vtkGenericCell* sself) { sself->SetCellTypeToVoxel(); } +extern "C" void vtk_generic_cell_set_cell_type_to_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_wedge(vtkGenericCell* sself) { sself->SetCellTypeToWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_pyramid(vtkGenericCell* sself) { sself->SetCellTypeToPyramid(); } +extern "C" void vtk_generic_cell_set_cell_type_to_pentagonal_prism(vtkGenericCell* sself) { sself->SetCellTypeToPentagonalPrism(); } +extern "C" void vtk_generic_cell_set_cell_type_to_hexagonal_prism(vtkGenericCell* sself) { sself->SetCellTypeToHexagonalPrism(); } +extern "C" void vtk_generic_cell_set_cell_type_to_polyhedron(vtkGenericCell* sself) { sself->SetCellTypeToPolyhedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_convex_point_set(vtkGenericCell* sself) { sself->SetCellTypeToConvexPointSet(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_edge(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticEdge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_cubic_line(vtkGenericCell* sself) { sself->SetCellTypeToCubicLine(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_triangle(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle(vtkGenericCell* sself) { sself->SetCellTypeToBiQuadraticTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_quad(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_polygon(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticPolygon(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_tetra(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_wedge(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_pyramid(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticPyramid(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_quad(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticLinearQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quad(vtkGenericCell* sself) { sself->SetCellTypeToBiQuadraticQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticLinearWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge(vtkGenericCell* sself) { sself->SetCellTypeToBiQuadraticQuadraticWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToTriQuadraticHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid(vtkGenericCell* sself) { sself->SetCellTypeToTriQuadraticPyramid(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToBiQuadraticQuadraticHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_triangle(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_tetra(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_curve(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeCurve(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeQuadrilateral(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_wedge(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_triangle(vtkGenericCell* sself) { sself->SetCellTypeToBezierTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_tetra(vtkGenericCell* sself) { sself->SetCellTypeToBezierTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_curve(vtkGenericCell* sself) { sself->SetCellTypeToBezierCurve(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_quadrilateral(vtkGenericCell* sself) { sself->SetCellTypeToBezierQuadrilateral(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToBezierHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_wedge(vtkGenericCell* sself) { sself->SetCellTypeToBezierWedge(); } +extern "C" vtkGenericEdgeTable * vtkGenericEdgeTable_new () {return vtkGenericEdgeTable :: New () ;} +extern "C" void vtkGenericEdgeTable_destructor (vtkGenericEdgeTable * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGenericEdgeTable_get_ptr (vtkGenericEdgeTable * sself) {return sself ;} +extern "C" void vtk_generic_edge_table_insert_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long cellId, int ref, long long& ptId) { sself->InsertEdge(e1, e2, cellId, ref, ptId); } +extern "C" int vtk_generic_edge_table_remove_edge(vtkGenericEdgeTable* sself, long long e1, long long e2) { return sself->RemoveEdge(e1, e2); } +extern "C" int vtk_generic_edge_table_check_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long& ptId) { return sself->CheckEdge(e1, e2, ptId); } +extern "C" int vtk_generic_edge_table_increment_edge_reference_count(vtkGenericEdgeTable* sself, long long e1, long long e2, long long cellId) { return sself->IncrementEdgeReferenceCount(e1, e2, cellId); } +extern "C" int vtk_generic_edge_table_check_edge_reference_count(vtkGenericEdgeTable* sself, long long e1, long long e2) { return sself->CheckEdgeReferenceCount(e1, e2); } +extern "C" void vtk_generic_edge_table_initialize(vtkGenericEdgeTable* sself, long long start) { sself->Initialize(start); } +extern "C" int vtk_generic_edge_table_get_number_of_components(vtkGenericEdgeTable* sself) { return sself->GetNumberOfComponents(); } +extern "C" void vtk_generic_edge_table_set_number_of_components(vtkGenericEdgeTable* sself, int count) { sself->SetNumberOfComponents(count); } +extern "C" int vtk_generic_edge_table_check_point(vtkGenericEdgeTable* sself, long long ptId) { return sself->CheckPoint(ptId); } +extern "C" void vtk_generic_edge_table_remove_point(vtkGenericEdgeTable* sself, long long ptId) { sself->RemovePoint(ptId); } +extern "C" void vtk_generic_edge_table_increment_point_reference_count(vtkGenericEdgeTable* sself, long long ptId) { sself->IncrementPointReferenceCount(ptId); } +extern "C" void vtk_generic_edge_table_dump_table(vtkGenericEdgeTable* sself) { sself->DumpTable(); } +extern "C" void vtk_generic_edge_table_load_factor(vtkGenericEdgeTable* sself) { sself->LoadFactor(); } +extern "C" vtkGenericInterpolatedVelocityField * vtkGenericInterpolatedVelocityField_new () {return vtkGenericInterpolatedVelocityField :: New () ;} +extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkGenericInterpolatedVelocityField * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGenericInterpolatedVelocityField_get_ptr (vtkGenericInterpolatedVelocityField * sself) {return sself ;} +extern "C" void vtk_generic_interpolated_velocity_field_clear_last_cell(vtkGenericInterpolatedVelocityField* sself) { sself->ClearLastCell(); } +extern "C" int vtk_generic_interpolated_velocity_field_get_caching(vtkGenericInterpolatedVelocityField* sself) { return sself->GetCaching(); } +extern "C" void vtk_generic_interpolated_velocity_field_set_caching(vtkGenericInterpolatedVelocityField* sself, int _arg) { sself->SetCaching(_arg); } +extern "C" void vtk_generic_interpolated_velocity_field_caching_on(vtkGenericInterpolatedVelocityField* sself) { sself->CachingOn(); } +extern "C" void vtk_generic_interpolated_velocity_field_caching_off(vtkGenericInterpolatedVelocityField* sself) { sself->CachingOff(); } +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_hit(vtkGenericInterpolatedVelocityField* sself) { return sself->GetCacheHit(); } +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_miss(vtkGenericInterpolatedVelocityField* sself) { return sself->GetCacheMiss(); } +extern "C" void vtk_generic_interpolated_velocity_field_select_vectors(vtkGenericInterpolatedVelocityField* sself, const char* fieldName) { sself->SelectVectors(fieldName); } +extern "C" vtkGeometricErrorMetric * vtkGeometricErrorMetric_new () {return vtkGeometricErrorMetric :: New () ;} +extern "C" void vtkGeometricErrorMetric_destructor (vtkGeometricErrorMetric * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGeometricErrorMetric_get_ptr (vtkGeometricErrorMetric * sself) {return sself ;} +extern "C" double vtk_geometric_error_metric_get_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself) { return sself->GetAbsoluteGeometricTolerance(); } +extern "C" void vtk_geometric_error_metric_set_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself, double value) { sself->SetAbsoluteGeometricTolerance(value); } +extern "C" int vtk_geometric_error_metric_get_relative(vtkGeometricErrorMetric* sself) { return sself->GetRelative(); } +extern "C" vtkGraphEdge * vtkGraphEdge_new () {return vtkGraphEdge :: New () ;} +extern "C" void vtkGraphEdge_destructor (vtkGraphEdge * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGraphEdge_get_ptr (vtkGraphEdge * sself) {return sself ;} +extern "C" void vtk_graph_edge_set_source(vtkGraphEdge* sself, long long _arg) { sself->SetSource(_arg); } +extern "C" long long vtk_graph_edge_get_source(vtkGraphEdge* sself) { return sself->GetSource(); } +extern "C" void vtk_graph_edge_set_target(vtkGraphEdge* sself, long long _arg) { sself->SetTarget(_arg); } +extern "C" long long vtk_graph_edge_get_target(vtkGraphEdge* sself) { return sself->GetTarget(); } +extern "C" void vtk_graph_edge_set_id(vtkGraphEdge* sself, long long _arg) { sself->SetId(_arg); } +extern "C" long long vtk_graph_edge_get_id(vtkGraphEdge* sself) { return sself->GetId(); } +extern "C" vtkGraphInternals * vtkGraphInternals_new () {return vtkGraphInternals :: New () ;} +extern "C" void vtkGraphInternals_destructor (vtkGraphInternals * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGraphInternals_get_ptr (vtkGraphInternals * sself) {return sself ;} +extern "C" vtkHexagonalPrism * vtkHexagonalPrism_new () {return vtkHexagonalPrism :: New () ;} +extern "C" void vtkHexagonalPrism_destructor (vtkHexagonalPrism * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHexagonalPrism_get_ptr (vtkHexagonalPrism * sself) {return sself ;} +extern "C" int vtk_hexagonal_prism_get_cell_type(vtkHexagonalPrism* sself) { return sself->GetCellType(); } +extern "C" int vtk_hexagonal_prism_get_number_of_edges(vtkHexagonalPrism* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_hexagonal_prism_get_number_of_faces(vtkHexagonalPrism* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkHexahedron * vtkHexahedron_new () {return vtkHexahedron :: New () ;} +extern "C" void vtkHexahedron_destructor (vtkHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHexahedron_get_ptr (vtkHexahedron * sself) {return sself ;} +extern "C" int vtk_hexahedron_get_cell_type(vtkHexahedron* sself) { return sself->GetCellType(); } +extern "C" int vtk_hexahedron_get_number_of_edges(vtkHexahedron* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_hexahedron_get_number_of_faces(vtkHexahedron* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkHierarchicalBoxDataIterator * vtkHierarchicalBoxDataIterator_new () {return vtkHierarchicalBoxDataIterator :: New () ;} +extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkHierarchicalBoxDataIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHierarchicalBoxDataIterator_get_ptr (vtkHierarchicalBoxDataIterator * sself) {return sself ;} +extern "C" vtkHierarchicalBoxDataSet * vtkHierarchicalBoxDataSet_new () {return vtkHierarchicalBoxDataSet :: New () ;} +extern "C" void vtkHierarchicalBoxDataSet_destructor (vtkHierarchicalBoxDataSet * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHierarchicalBoxDataSet_get_ptr (vtkHierarchicalBoxDataSet * sself) {return sself ;} +extern "C" vtkHyperTreeGrid * vtkHyperTreeGrid_new () {return vtkHyperTreeGrid :: New () ;} +extern "C" void vtkHyperTreeGrid_destructor (vtkHyperTreeGrid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHyperTreeGrid_get_ptr (vtkHyperTreeGrid * sself) {return sself ;} +extern "C" void vtk_hyper_tree_grid_set_mode_squeeze(vtkHyperTreeGrid* sself, const char* _arg) { sself->SetModeSqueeze(_arg); } +extern "C" void vtk_hyper_tree_grid_squeeze(vtkHyperTreeGrid* sself) { sself->Squeeze(); } +extern "C" int vtk_hyper_tree_grid_get_data_object_type(vtkHyperTreeGrid* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkHyperTreeGrid* sself, unsigned int i, unsigned int j, unsigned int k) { sself->SetDimensions(i, j, k); } +extern "C" void vtk_hyper_tree_grid_set_extent(vtkHyperTreeGrid* sself, int x1, int x2, int y1, int y2, int z1, int z2) { sself->SetExtent(x1, x2, y1, y2, z1, z2); } +extern "C" unsigned int vtk_hyper_tree_grid_get_dimension(vtkHyperTreeGrid* sself) { return sself->GetDimension(); } +extern "C" void vtk_hyper_tree_grid_get_1_d_axis(vtkHyperTreeGrid* sself, unsigned int& axis) { sself->Get1DAxis(axis); } +extern "C" void vtk_hyper_tree_grid_get_2_d_axes(vtkHyperTreeGrid* sself, unsigned int& axis1, unsigned int& axis2) { sself->Get2DAxes(axis1, axis2); } +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_children(vtkHyperTreeGrid* sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_set_transposed_root_indexing(vtkHyperTreeGrid* sself, bool _arg) { sself->SetTransposedRootIndexing(_arg); } +extern "C" bool vtk_hyper_tree_grid_get_transposed_root_indexing(vtkHyperTreeGrid* sself) { return sself->GetTransposedRootIndexing(); } +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_kji(vtkHyperTreeGrid* sself) { sself->SetIndexingModeToKJI(); } +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_ijk(vtkHyperTreeGrid* sself) { sself->SetIndexingModeToIJK(); } +extern "C" unsigned int vtk_hyper_tree_grid_get_orientation(vtkHyperTreeGrid* sself) { return sself->GetOrientation(); } +extern "C" bool vtk_hyper_tree_grid_get_freeze_state(vtkHyperTreeGrid* sself) { return sself->GetFreezeState(); } +extern "C" void vtk_hyper_tree_grid_set_branch_factor(vtkHyperTreeGrid* sself, unsigned int p0) { sself->SetBranchFactor(p0); } +extern "C" unsigned int vtk_hyper_tree_grid_get_branch_factor(vtkHyperTreeGrid* sself) { return sself->GetBranchFactor(); } +extern "C" long long vtk_hyper_tree_grid_get_max_number_of_trees(vtkHyperTreeGrid* sself) { return sself->GetMaxNumberOfTrees(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_vertices(vtkHyperTreeGrid* sself) { return sself->GetNumberOfVertices(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_non_empty_trees(vtkHyperTreeGrid* sself) { return sself->GetNumberOfNonEmptyTrees(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_leaves(vtkHyperTreeGrid* sself) { return sself->GetNumberOfLeaves(); } +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkHyperTreeGrid* sself, long long p0) { return sself->GetNumberOfLevels(p0); } +extern "C" void vtk_hyper_tree_grid_set_fixed_coordinates(vtkHyperTreeGrid* sself, unsigned int axis, double value) { sself->SetFixedCoordinates(axis, value); } +extern "C" bool vtk_hyper_tree_grid_has_mask(vtkHyperTreeGrid* sself) { return sself->HasMask(); } +extern "C" void vtk_hyper_tree_grid_set_has_interface(vtkHyperTreeGrid* sself, bool _arg) { sself->SetHasInterface(_arg); } +extern "C" bool vtk_hyper_tree_grid_get_has_interface(vtkHyperTreeGrid* sself) { return sself->GetHasInterface(); } +extern "C" void vtk_hyper_tree_grid_has_interface_on(vtkHyperTreeGrid* sself) { sself->HasInterfaceOn(); } +extern "C" void vtk_hyper_tree_grid_has_interface_off(vtkHyperTreeGrid* sself) { sself->HasInterfaceOff(); } +extern "C" void vtk_hyper_tree_grid_set_interface_normals_name(vtkHyperTreeGrid* sself, const char* _arg) { sself->SetInterfaceNormalsName(_arg); } +extern "C" void vtk_hyper_tree_grid_set_interface_intercepts_name(vtkHyperTreeGrid* sself, const char* _arg) { sself->SetInterfaceInterceptsName(_arg); } +extern "C" void vtk_hyper_tree_grid_set_depth_limiter(vtkHyperTreeGrid* sself, unsigned int _arg) { sself->SetDepthLimiter(_arg); } +extern "C" unsigned int vtk_hyper_tree_grid_get_depth_limiter(vtkHyperTreeGrid* sself) { return sself->GetDepthLimiter(); } +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_x(vtkHyperTreeGrid* sself, double value) { return sself->FindDichotomicX(value); } +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_y(vtkHyperTreeGrid* sself, double value) { return sself->FindDichotomicY(value); } +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_z(vtkHyperTreeGrid* sself, double value) { return sself->FindDichotomicZ(value); } +extern "C" void vtk_hyper_tree_grid_initialize(vtkHyperTreeGrid* sself) { sself->Initialize(); } +extern "C" int vtk_hyper_tree_grid_get_extent_type(vtkHyperTreeGrid* sself) { return sself->GetExtentType(); } +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size_bytes(vtkHyperTreeGrid* sself) { return sself->GetActualMemorySizeBytes(); } +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size(vtkHyperTreeGrid* sself) { return sself->GetActualMemorySize(); } +extern "C" unsigned int vtk_hyper_tree_grid_get_child_mask(vtkHyperTreeGrid* sself, unsigned int p0) { return sself->GetChildMask(p0); } +extern "C" void vtk_hyper_tree_grid_get_index_from_level_zero_coordinates(vtkHyperTreeGrid* sself, long long& p0, unsigned int p1, unsigned int p2, unsigned int p3) { sself->GetIndexFromLevelZeroCoordinates(p0, p1, p2, p3); } +extern "C" long long vtk_hyper_tree_grid_get_shifted_level_zero_index(vtkHyperTreeGrid* sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3) { return sself->GetShiftedLevelZeroIndex(p0, p1, p2, p3); } +extern "C" void vtk_hyper_tree_grid_get_level_zero_coordinates_from_index(vtkHyperTreeGrid* sself, long long p0, unsigned int& p1, unsigned int& p2, unsigned int& p3) { sself->GetLevelZeroCoordinatesFromIndex(p0, p1, p2, p3); } +extern "C" long long vtk_hyper_tree_grid_get_global_node_index_max(vtkHyperTreeGrid* sself) { return sself->GetGlobalNodeIndexMax(); } +extern "C" void vtk_hyper_tree_grid_initialize_local_index_node(vtkHyperTreeGrid* sself) { sself->InitializeLocalIndexNode(); } +extern "C" bool vtk_hyper_tree_grid_has_any_ghost_cells(vtkHyperTreeGrid* sself) { return sself->HasAnyGhostCells(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_elements(vtkHyperTreeGrid* sself, int type) { return sself->GetNumberOfElements(type); } +extern "C" vtkHyperTreeGridNonOrientedCursor * vtkHyperTreeGridNonOrientedCursor_new () {return vtkHyperTreeGridNonOrientedCursor :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkHyperTreeGridNonOrientedCursor * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHyperTreeGridNonOrientedCursor_get_ptr (vtkHyperTreeGridNonOrientedCursor * sself) {return sself ;} +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_has_tree(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_dimension(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(vtkHyperTreeGridNonOrientedCursor* sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local(vtkHyperTreeGridNonOrientedCursor* sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_mask(vtkHyperTreeGridNonOrientedCursor* sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_masked(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_leaf(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf(vtkHyperTreeGridNonOrientedCursor* sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_root(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_cursor_get_level(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_child(vtkHyperTreeGridNonOrientedCursor* sself, unsigned char ichild) { sself->ToChild(ichild); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_root(vtkHyperTreeGridNonOrientedCursor* sself) { sself->ToRoot(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_parent(vtkHyperTreeGridNonOrientedCursor* sself) { sself->ToParent(); } +extern "C" vtkHyperTreeGridNonOrientedGeometryCursor * vtkHyperTreeGridNonOrientedGeometryCursor_new () {return vtkHyperTreeGridNonOrientedGeometryCursor :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkHyperTreeGridNonOrientedGeometryCursor * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr (vtkHyperTreeGridNonOrientedGeometryCursor * sself) {return sself ;} +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start(vtkHyperTreeGridNonOrientedGeometryCursor* sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local(vtkHyperTreeGridNonOrientedGeometryCursor* sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask(vtkHyperTreeGridNonOrientedGeometryCursor* sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child(vtkHyperTreeGridNonOrientedGeometryCursor* sself, unsigned char ichild) { sself->ToChild(ichild); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { sself->ToRoot(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { sself->ToParent(); } +extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursor * vtkHyperTreeGridNonOrientedMooreSuperCursor_new () {return vtkHyperTreeGridNonOrientedMooreSuperCursor :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursor * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr (vtkHyperTreeGridNonOrientedMooreSuperCursor * sself) {return sself ;} +extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursorLight * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new () {return vtkHyperTreeGridNonOrientedMooreSuperCursorLight :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursorLight * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr (vtkHyperTreeGridNonOrientedMooreSuperCursorLight * sself) {return sself ;} +extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new () {return vtkHyperTreeGridNonOrientedVonNeumannSuperCursor :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr (vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * sself) {return sself ;} +extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new () {return vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr (vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * sself) {return sself ;} +extern "C" vtkHyperTreeGridOrientedCursor * vtkHyperTreeGridOrientedCursor_new () {return vtkHyperTreeGridOrientedCursor :: New () ;} +extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkHyperTreeGridOrientedCursor * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHyperTreeGridOrientedCursor_get_ptr (vtkHyperTreeGridOrientedCursor * sself) {return sself ;} +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_has_tree(vtkHyperTreeGridOrientedCursor* sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_dimension(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(vtkHyperTreeGridOrientedCursor* sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local(vtkHyperTreeGridOrientedCursor* sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_mask(vtkHyperTreeGridOrientedCursor* sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_masked(vtkHyperTreeGridOrientedCursor* sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_leaf(vtkHyperTreeGridOrientedCursor* sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf(vtkHyperTreeGridOrientedCursor* sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_root(vtkHyperTreeGridOrientedCursor* sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_oriented_cursor_get_level(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_to_child(vtkHyperTreeGridOrientedCursor* sself, unsigned char ichild) { sself->ToChild(ichild); } +extern "C" vtkHyperTreeGridOrientedGeometryCursor * vtkHyperTreeGridOrientedGeometryCursor_new () {return vtkHyperTreeGridOrientedGeometryCursor :: New () ;} +extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkHyperTreeGridOrientedGeometryCursor * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHyperTreeGridOrientedGeometryCursor_get_ptr (vtkHyperTreeGridOrientedGeometryCursor * sself) {return sself ;} +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start(vtkHyperTreeGridOrientedGeometryCursor* sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local(vtkHyperTreeGridOrientedGeometryCursor* sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask(vtkHyperTreeGridOrientedGeometryCursor* sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf(vtkHyperTreeGridOrientedGeometryCursor* sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_root(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(vtkHyperTreeGridOrientedGeometryCursor* sself, unsigned char ichild) { sself->ToChild(ichild); } +extern "C" vtkImageData * vtkImageData_new () {return vtkImageData :: New () ;} +extern "C" void vtkImageData_destructor (vtkImageData * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImageData_get_ptr (vtkImageData * sself) {return sself ;} +extern "C" int vtk_image_data_get_data_object_type(vtkImageData* sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_image_data_get_number_of_cells(vtkImageData* sself) { return sself->GetNumberOfCells(); } +extern "C" long long vtk_image_data_get_number_of_points(vtkImageData* sself) { return sself->GetNumberOfPoints(); } +extern "C" long long vtk_image_data_find_point(vtkImageData* sself, double x, double y, double z) { return sself->FindPoint(x, y, z); } +extern "C" int vtk_image_data_get_cell_type(vtkImageData* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" int vtk_image_data_get_max_cell_size(vtkImageData* sself) { return sself->GetMaxCellSize(); } +extern "C" void vtk_image_data_initialize(vtkImageData* sself) { sself->Initialize(); } +extern "C" unsigned char vtk_image_data_is_point_visible(vtkImageData* sself, long long ptId) { return sself->IsPointVisible(ptId); } +extern "C" unsigned char vtk_image_data_is_cell_visible(vtkImageData* sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" bool vtk_image_data_has_any_blank_points(vtkImageData* sself) { return sself->HasAnyBlankPoints(); } +extern "C" bool vtk_image_data_has_any_blank_cells(vtkImageData* sself) { return sself->HasAnyBlankCells(); } +extern "C" void vtk_image_data_set_dimensions(vtkImageData* sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" int vtk_image_data_get_data_dimension(vtkImageData* sself) { return sself->GetDataDimension(); } +extern "C" void vtk_image_data_set_extent(vtkImageData* sself, int x1, int x2, int y1, int y2, int z1, int z2) { sself->SetExtent(x1, x2, y1, y2, z1, z2); } +extern "C" void* vtk_image_data_get_scalar_pointer(vtkImageData* sself, int x, int y, int z) { return sself->GetScalarPointer(x, y, z); } +extern "C" long long vtk_image_data_get_scalar_index(vtkImageData* sself, int x, int y, int z) { return sself->GetScalarIndex(x, y, z); } +extern "C" float vtk_image_data_get_scalar_component_as_float(vtkImageData* sself, int x, int y, int z, int component) { return sself->GetScalarComponentAsFloat(x, y, z, component); } +extern "C" void vtk_image_data_set_scalar_component_from_float(vtkImageData* sself, int x, int y, int z, int component, float v) { sself->SetScalarComponentFromFloat(x, y, z, component, v); } +extern "C" double vtk_image_data_get_scalar_component_as_double(vtkImageData* sself, int x, int y, int z, int component) { return sself->GetScalarComponentAsDouble(x, y, z, component); } +extern "C" void vtk_image_data_set_scalar_component_from_double(vtkImageData* sself, int x, int y, int z, int component, double v) { sself->SetScalarComponentFromDouble(x, y, z, component, v); } +extern "C" void vtk_image_data_allocate_scalars(vtkImageData* sself, int dataType, int numComponents) { sself->AllocateScalars(dataType, numComponents); } +extern "C" void vtk_image_data_set_spacing(vtkImageData* sself, double i, double j, double k) { sself->SetSpacing(i, j, k); } +extern "C" void vtk_image_data_set_origin(vtkImageData* sself, double i, double j, double k) { sself->SetOrigin(i, j, k); } +extern "C" const char* vtk_image_data_get_scalar_type_as_string(vtkImageData* sself) { return sself->GetScalarTypeAsString(); } +extern "C" void vtk_image_data_prepare_for_new_data(vtkImageData* sself) { sself->PrepareForNewData(); } +extern "C" int vtk_image_data_get_extent_type(vtkImageData* sself) { return sself->GetExtentType(); } +extern "C" vtkImageTransform * vtkImageTransform_new () {return vtkImageTransform :: New () ;} +extern "C" void vtkImageTransform_destructor (vtkImageTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImageTransform_get_ptr (vtkImageTransform * sself) {return sself ;} +extern "C" vtkImplicitBoolean * vtkImplicitBoolean_new () {return vtkImplicitBoolean :: New () ;} +extern "C" void vtkImplicitBoolean_destructor (vtkImplicitBoolean * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImplicitBoolean_get_ptr (vtkImplicitBoolean * sself) {return sself ;} +extern "C" unsigned long vtk_implicit_boolean_get_m_time(vtkImplicitBoolean* sself) { return sself->GetMTime(); } +extern "C" void vtk_implicit_boolean_set_operation_type(vtkImplicitBoolean* sself, int _arg) { sself->SetOperationType(_arg); } +extern "C" int vtk_implicit_boolean_get_operation_type_min_value(vtkImplicitBoolean* sself) { return sself->GetOperationTypeMinValue(); } +extern "C" int vtk_implicit_boolean_get_operation_type_max_value(vtkImplicitBoolean* sself) { return sself->GetOperationTypeMaxValue(); } +extern "C" int vtk_implicit_boolean_get_operation_type(vtkImplicitBoolean* sself) { return sself->GetOperationType(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_union(vtkImplicitBoolean* sself) { sself->SetOperationTypeToUnion(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_intersection(vtkImplicitBoolean* sself) { sself->SetOperationTypeToIntersection(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_difference(vtkImplicitBoolean* sself) { sself->SetOperationTypeToDifference(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(vtkImplicitBoolean* sself) { sself->SetOperationTypeToUnionOfMagnitudes(); } +extern "C" const char* vtk_implicit_boolean_get_operation_type_as_string(vtkImplicitBoolean* sself) { return sself->GetOperationTypeAsString(); } +extern "C" vtkImplicitDataSet * vtkImplicitDataSet_new () {return vtkImplicitDataSet :: New () ;} +extern "C" void vtkImplicitDataSet_destructor (vtkImplicitDataSet * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImplicitDataSet_get_ptr (vtkImplicitDataSet * sself) {return sself ;} +extern "C" unsigned long vtk_implicit_data_set_get_m_time(vtkImplicitDataSet* sself) { return sself->GetMTime(); } +extern "C" void vtk_implicit_data_set_set_out_value(vtkImplicitDataSet* sself, double _arg) { sself->SetOutValue(_arg); } +extern "C" double vtk_implicit_data_set_get_out_value(vtkImplicitDataSet* sself) { return sself->GetOutValue(); } +extern "C" void vtk_implicit_data_set_set_out_gradient(vtkImplicitDataSet* sself, double _arg1, double _arg2, double _arg3) { sself->SetOutGradient(_arg1, _arg2, _arg3); } +extern "C" vtkImplicitFunctionCollection * vtkImplicitFunctionCollection_new () {return vtkImplicitFunctionCollection :: New () ;} +extern "C" void vtkImplicitFunctionCollection_destructor (vtkImplicitFunctionCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImplicitFunctionCollection_get_ptr (vtkImplicitFunctionCollection * sself) {return sself ;} +extern "C" vtkImplicitHalo * vtkImplicitHalo_new () {return vtkImplicitHalo :: New () ;} +extern "C" void vtkImplicitHalo_destructor (vtkImplicitHalo * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImplicitHalo_get_ptr (vtkImplicitHalo * sself) {return sself ;} +extern "C" void vtk_implicit_halo_set_radius(vtkImplicitHalo* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_implicit_halo_get_radius(vtkImplicitHalo* sself) { return sself->GetRadius(); } +extern "C" void vtk_implicit_halo_set_center(vtkImplicitHalo* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_implicit_halo_set_fade_out(vtkImplicitHalo* sself, double _arg) { sself->SetFadeOut(_arg); } +extern "C" double vtk_implicit_halo_get_fade_out(vtkImplicitHalo* sself) { return sself->GetFadeOut(); } +extern "C" vtkImplicitSelectionLoop * vtkImplicitSelectionLoop_new () {return vtkImplicitSelectionLoop :: New () ;} +extern "C" void vtkImplicitSelectionLoop_destructor (vtkImplicitSelectionLoop * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImplicitSelectionLoop_get_ptr (vtkImplicitSelectionLoop * sself) {return sself ;} +extern "C" void vtk_implicit_selection_loop_set_automatic_normal_generation(vtkImplicitSelectionLoop* sself, int _arg) { sself->SetAutomaticNormalGeneration(_arg); } +extern "C" int vtk_implicit_selection_loop_get_automatic_normal_generation(vtkImplicitSelectionLoop* sself) { return sself->GetAutomaticNormalGeneration(); } +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_on(vtkImplicitSelectionLoop* sself) { sself->AutomaticNormalGenerationOn(); } +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_off(vtkImplicitSelectionLoop* sself) { sself->AutomaticNormalGenerationOff(); } +extern "C" void vtk_implicit_selection_loop_set_normal(vtkImplicitSelectionLoop* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" unsigned long vtk_implicit_selection_loop_get_m_time(vtkImplicitSelectionLoop* sself) { return sself->GetMTime(); } +extern "C" vtkImplicitSum * vtkImplicitSum_new () {return vtkImplicitSum :: New () ;} +extern "C" void vtkImplicitSum_destructor (vtkImplicitSum * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImplicitSum_get_ptr (vtkImplicitSum * sself) {return sself ;} +extern "C" unsigned long vtk_implicit_sum_get_m_time(vtkImplicitSum* sself) { return sself->GetMTime(); } +extern "C" void vtk_implicit_sum_remove_all_functions(vtkImplicitSum* sself) { sself->RemoveAllFunctions(); } +extern "C" void vtk_implicit_sum_set_normalize_by_weight(vtkImplicitSum* sself, int _arg) { sself->SetNormalizeByWeight(_arg); } +extern "C" int vtk_implicit_sum_get_normalize_by_weight(vtkImplicitSum* sself) { return sself->GetNormalizeByWeight(); } +extern "C" void vtk_implicit_sum_normalize_by_weight_on(vtkImplicitSum* sself) { sself->NormalizeByWeightOn(); } +extern "C" void vtk_implicit_sum_normalize_by_weight_off(vtkImplicitSum* sself) { sself->NormalizeByWeightOff(); } +extern "C" vtkImplicitVolume * vtkImplicitVolume_new () {return vtkImplicitVolume :: New () ;} +extern "C" void vtkImplicitVolume_destructor (vtkImplicitVolume * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImplicitVolume_get_ptr (vtkImplicitVolume * sself) {return sself ;} +extern "C" unsigned long vtk_implicit_volume_get_m_time(vtkImplicitVolume* sself) { return sself->GetMTime(); } +extern "C" void vtk_implicit_volume_set_out_value(vtkImplicitVolume* sself, double _arg) { sself->SetOutValue(_arg); } +extern "C" double vtk_implicit_volume_get_out_value(vtkImplicitVolume* sself) { return sself->GetOutValue(); } +extern "C" void vtk_implicit_volume_set_out_gradient(vtkImplicitVolume* sself, double _arg1, double _arg2, double _arg3) { sself->SetOutGradient(_arg1, _arg2, _arg3); } +extern "C" vtkImplicitWindowFunction * vtkImplicitWindowFunction_new () {return vtkImplicitWindowFunction :: New () ;} +extern "C" void vtkImplicitWindowFunction_destructor (vtkImplicitWindowFunction * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImplicitWindowFunction_get_ptr (vtkImplicitWindowFunction * sself) {return sself ;} +extern "C" void vtk_implicit_window_function_set_window_range(vtkImplicitWindowFunction* sself, double _arg1, double _arg2) { sself->SetWindowRange(_arg1, _arg2); } +extern "C" void vtk_implicit_window_function_set_window_values(vtkImplicitWindowFunction* sself, double _arg1, double _arg2) { sself->SetWindowValues(_arg1, _arg2); } +extern "C" unsigned long vtk_implicit_window_function_get_m_time(vtkImplicitWindowFunction* sself) { return sself->GetMTime(); } +extern "C" vtkInEdgeIterator * vtkInEdgeIterator_new () {return vtkInEdgeIterator :: New () ;} +extern "C" void vtkInEdgeIterator_destructor (vtkInEdgeIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkInEdgeIterator_get_ptr (vtkInEdgeIterator * sself) {return sself ;} +extern "C" long long vtk_in_edge_iterator_get_vertex(vtkInEdgeIterator* sself) { return sself->GetVertex(); } +extern "C" bool vtk_in_edge_iterator_has_next(vtkInEdgeIterator* sself) { return sself->HasNext(); } +extern "C" vtkIncrementalOctreeNode * vtkIncrementalOctreeNode_new () {return vtkIncrementalOctreeNode :: New () ;} +extern "C" void vtkIncrementalOctreeNode_destructor (vtkIncrementalOctreeNode * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkIncrementalOctreeNode_get_ptr (vtkIncrementalOctreeNode * sself) {return sself ;} +extern "C" int vtk_incremental_octree_node_get_number_of_points(vtkIncrementalOctreeNode* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_incremental_octree_node_delete_child_nodes(vtkIncrementalOctreeNode* sself) { sself->DeleteChildNodes(); } +extern "C" void vtk_incremental_octree_node_set_bounds(vtkIncrementalOctreeNode* sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetBounds(x1, x2, y1, y2, z1, z2); } +extern "C" int vtk_incremental_octree_node_is_leaf(vtkIncrementalOctreeNode* sself) { return sself->IsLeaf(); } +extern "C" int vtk_incremental_octree_node_get_number_of_levels(vtkIncrementalOctreeNode* sself) { return sself->GetNumberOfLevels(); } +extern "C" int vtk_incremental_octree_node_get_id(vtkIncrementalOctreeNode* sself) { return sself->GetID(); } +extern "C" vtkIncrementalOctreePointLocator * vtkIncrementalOctreePointLocator_new () {return vtkIncrementalOctreePointLocator :: New () ;} +extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkIncrementalOctreePointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkIncrementalOctreePointLocator_get_ptr (vtkIncrementalOctreePointLocator * sself) {return sself ;} +extern "C" void vtk_incremental_octree_point_locator_set_max_points_per_leaf(vtkIncrementalOctreePointLocator* sself, int _arg) { sself->SetMaxPointsPerLeaf(_arg); } +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value(vtkIncrementalOctreePointLocator* sself) { return sself->GetMaxPointsPerLeafMinValue(); } +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value(vtkIncrementalOctreePointLocator* sself) { return sself->GetMaxPointsPerLeafMaxValue(); } +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf(vtkIncrementalOctreePointLocator* sself) { return sself->GetMaxPointsPerLeaf(); } +extern "C" void vtk_incremental_octree_point_locator_set_build_cubic_octree(vtkIncrementalOctreePointLocator* sself, int _arg) { sself->SetBuildCubicOctree(_arg); } +extern "C" int vtk_incremental_octree_point_locator_get_build_cubic_octree(vtkIncrementalOctreePointLocator* sself) { return sself->GetBuildCubicOctree(); } +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_on(vtkIncrementalOctreePointLocator* sself) { sself->BuildCubicOctreeOn(); } +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_off(vtkIncrementalOctreePointLocator* sself) { sself->BuildCubicOctreeOff(); } +extern "C" void vtk_incremental_octree_point_locator_initialize(vtkIncrementalOctreePointLocator* sself) { sself->Initialize(); } +extern "C" void vtk_incremental_octree_point_locator_free_search_structure(vtkIncrementalOctreePointLocator* sself) { sself->FreeSearchStructure(); } +extern "C" int vtk_incremental_octree_point_locator_get_number_of_points(vtkIncrementalOctreePointLocator* sself) { return sself->GetNumberOfPoints(); } +extern "C" int vtk_incremental_octree_point_locator_get_number_of_nodes(vtkIncrementalOctreePointLocator* sself) { return sself->GetNumberOfNodes(); } +extern "C" void vtk_incremental_octree_point_locator_build_locator(vtkIncrementalOctreePointLocator* sself) { sself->BuildLocator(); } +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkIncrementalOctreePointLocator* sself, double x, double y, double z) { return sself->FindClosestPoint(x, y, z); } +extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkIncrementalOctreePointLocator* sself, double x, double y, double z) { return sself->IsInsertedPoint(x, y, z); } +extern "C" int vtk_incremental_octree_point_locator_get_number_of_levels(vtkIncrementalOctreePointLocator* sself) { return sself->GetNumberOfLevels(); } +extern "C" vtkIterativeClosestPointTransform * vtkIterativeClosestPointTransform_new () {return vtkIterativeClosestPointTransform :: New () ;} +extern "C" void vtkIterativeClosestPointTransform_destructor (vtkIterativeClosestPointTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkIterativeClosestPointTransform_get_ptr (vtkIterativeClosestPointTransform * sself) {return sself ;} +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetMaximumNumberOfIterations(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself) { return sself->GetMaximumNumberOfIterations(); } +extern "C" int vtk_iterative_closest_point_transform_get_number_of_iterations(vtkIterativeClosestPointTransform* sself) { return sself->GetNumberOfIterations(); } +extern "C" void vtk_iterative_closest_point_transform_set_check_mean_distance(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetCheckMeanDistance(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_check_mean_distance(vtkIterativeClosestPointTransform* sself) { return sself->GetCheckMeanDistance(); } +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_on(vtkIterativeClosestPointTransform* sself) { sself->CheckMeanDistanceOn(); } +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_off(vtkIterativeClosestPointTransform* sself) { sself->CheckMeanDistanceOff(); } +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetMeanDistanceMode(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value(vtkIterativeClosestPointTransform* sself) { return sself->GetMeanDistanceModeMinValue(); } +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value(vtkIterativeClosestPointTransform* sself) { return sself->GetMeanDistanceModeMaxValue(); } +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode(vtkIterativeClosestPointTransform* sself) { return sself->GetMeanDistanceMode(); } +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms(vtkIterativeClosestPointTransform* sself) { sself->SetMeanDistanceModeToRMS(); } +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value(vtkIterativeClosestPointTransform* sself) { sself->SetMeanDistanceModeToAbsoluteValue(); } +extern "C" const char* vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string(vtkIterativeClosestPointTransform* sself) { return sself->GetMeanDistanceModeAsString(); } +extern "C" void vtk_iterative_closest_point_transform_set_maximum_mean_distance(vtkIterativeClosestPointTransform* sself, double _arg) { sself->SetMaximumMeanDistance(_arg); } +extern "C" double vtk_iterative_closest_point_transform_get_maximum_mean_distance(vtkIterativeClosestPointTransform* sself) { return sself->GetMaximumMeanDistance(); } +extern "C" double vtk_iterative_closest_point_transform_get_mean_distance(vtkIterativeClosestPointTransform* sself) { return sself->GetMeanDistance(); } +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetMaximumNumberOfLandmarks(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks(vtkIterativeClosestPointTransform* sself) { return sself->GetMaximumNumberOfLandmarks(); } +extern "C" void vtk_iterative_closest_point_transform_set_start_by_matching_centroids(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetStartByMatchingCentroids(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_start_by_matching_centroids(vtkIterativeClosestPointTransform* sself) { return sself->GetStartByMatchingCentroids(); } +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_on(vtkIterativeClosestPointTransform* sself) { sself->StartByMatchingCentroidsOn(); } +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_off(vtkIterativeClosestPointTransform* sself) { sself->StartByMatchingCentroidsOff(); } +extern "C" void vtk_iterative_closest_point_transform_inverse(vtkIterativeClosestPointTransform* sself) { sself->Inverse(); } +extern "C" vtkKdNode * vtkKdNode_new () {return vtkKdNode :: New () ;} +extern "C" void vtkKdNode_destructor (vtkKdNode * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkKdNode_get_ptr (vtkKdNode * sself) {return sself ;} +extern "C" void vtk_kd_node_set_dim(vtkKdNode* sself, int _arg) { sself->SetDim(_arg); } +extern "C" int vtk_kd_node_get_dim(vtkKdNode* sself) { return sself->GetDim(); } +extern "C" double vtk_kd_node_get_division_position(vtkKdNode* sself) { return sself->GetDivisionPosition(); } +extern "C" void vtk_kd_node_set_number_of_points(vtkKdNode* sself, int _arg) { sself->SetNumberOfPoints(_arg); } +extern "C" int vtk_kd_node_get_number_of_points(vtkKdNode* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_kd_node_set_bounds(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetBounds(x1, x2, y1, y2, z1, z2); } +extern "C" void vtk_kd_node_set_data_bounds(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetDataBounds(x1, x2, y1, y2, z1, z2); } +extern "C" void vtk_kd_node_set_id(vtkKdNode* sself, int _arg) { sself->SetID(_arg); } +extern "C" int vtk_kd_node_get_id(vtkKdNode* sself) { return sself->GetID(); } +extern "C" int vtk_kd_node_get_min_id(vtkKdNode* sself) { return sself->GetMinID(); } +extern "C" int vtk_kd_node_get_max_id(vtkKdNode* sself) { return sself->GetMaxID(); } +extern "C" void vtk_kd_node_set_min_id(vtkKdNode* sself, int _arg) { sself->SetMinID(_arg); } +extern "C" void vtk_kd_node_set_max_id(vtkKdNode* sself, int _arg) { sself->SetMaxID(_arg); } +extern "C" void vtk_kd_node_delete_child_nodes(vtkKdNode* sself) { sself->DeleteChildNodes(); } +extern "C" int vtk_kd_node_intersects_box(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds) { return sself->IntersectsBox(x1, x2, y1, y2, z1, z2, useDataBounds); } +extern "C" int vtk_kd_node_intersects_sphere_2(vtkKdNode* sself, double x, double y, double z, double rSquared, int useDataBounds) { return sself->IntersectsSphere2(x, y, z, rSquared, useDataBounds); } +extern "C" int vtk_kd_node_contains_box(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds) { return sself->ContainsBox(x1, x2, y1, y2, z1, z2, useDataBounds); } +extern "C" int vtk_kd_node_contains_point(vtkKdNode* sself, double x, double y, double z, int useDataBounds) { return sself->ContainsPoint(x, y, z, useDataBounds); } +extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkKdNode* sself, double x, double y, double z, int useDataBounds) { return sself->GetDistance2ToBoundary(x, y, z, useDataBounds); } +extern "C" double vtk_kd_node_get_distance_2_to_inner_boundary(vtkKdNode* sself, double x, double y, double z) { return sself->GetDistance2ToInnerBoundary(x, y, z); } +extern "C" void vtk_kd_node_print_node(vtkKdNode* sself, int depth) { sself->PrintNode(depth); } +extern "C" void vtk_kd_node_print_verbose_node(vtkKdNode* sself, int depth) { sself->PrintVerboseNode(depth); } +extern "C" vtkKdTree * vtkKdTree_new () {return vtkKdTree :: New () ;} +extern "C" void vtkKdTree_destructor (vtkKdTree * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkKdTree_get_ptr (vtkKdTree * sself) {return sself ;} +extern "C" void vtk_kd_tree_timing_on(vtkKdTree* sself) { sself->TimingOn(); } +extern "C" void vtk_kd_tree_timing_off(vtkKdTree* sself) { sself->TimingOff(); } +extern "C" void vtk_kd_tree_set_timing(vtkKdTree* sself, int _arg) { sself->SetTiming(_arg); } +extern "C" int vtk_kd_tree_get_timing(vtkKdTree* sself) { return sself->GetTiming(); } +extern "C" void vtk_kd_tree_set_min_cells(vtkKdTree* sself, int _arg) { sself->SetMinCells(_arg); } +extern "C" int vtk_kd_tree_get_min_cells(vtkKdTree* sself) { return sself->GetMinCells(); } +extern "C" int vtk_kd_tree_get_number_of_regions_or_less(vtkKdTree* sself) { return sself->GetNumberOfRegionsOrLess(); } +extern "C" void vtk_kd_tree_set_number_of_regions_or_less(vtkKdTree* sself, int _arg) { sself->SetNumberOfRegionsOrLess(_arg); } +extern "C" int vtk_kd_tree_get_number_of_regions_or_more(vtkKdTree* sself) { return sself->GetNumberOfRegionsOrMore(); } +extern "C" void vtk_kd_tree_set_number_of_regions_or_more(vtkKdTree* sself, int _arg) { sself->SetNumberOfRegionsOrMore(_arg); } +extern "C" double vtk_kd_tree_get_fudge_factor(vtkKdTree* sself) { return sself->GetFudgeFactor(); } +extern "C" void vtk_kd_tree_set_fudge_factor(vtkKdTree* sself, double _arg) { sself->SetFudgeFactor(_arg); } +extern "C" void vtk_kd_tree_omit_x_partitioning(vtkKdTree* sself) { sself->OmitXPartitioning(); } +extern "C" void vtk_kd_tree_omit_y_partitioning(vtkKdTree* sself) { sself->OmitYPartitioning(); } +extern "C" void vtk_kd_tree_omit_z_partitioning(vtkKdTree* sself) { sself->OmitZPartitioning(); } +extern "C" void vtk_kd_tree_omit_xy_partitioning(vtkKdTree* sself) { sself->OmitXYPartitioning(); } +extern "C" void vtk_kd_tree_omit_yz_partitioning(vtkKdTree* sself) { sself->OmitYZPartitioning(); } +extern "C" void vtk_kd_tree_omit_zx_partitioning(vtkKdTree* sself) { sself->OmitZXPartitioning(); } +extern "C" void vtk_kd_tree_omit_no_partitioning(vtkKdTree* sself) { sself->OmitNoPartitioning(); } +extern "C" void vtk_kd_tree_remove_data_set(vtkKdTree* sself, int index) { sself->RemoveDataSet(index); } +extern "C" void vtk_kd_tree_remove_all_data_sets(vtkKdTree* sself) { sself->RemoveAllDataSets(); } +extern "C" int vtk_kd_tree_get_number_of_data_sets(vtkKdTree* sself) { return sself->GetNumberOfDataSets(); } +extern "C" int vtk_kd_tree_get_number_of_regions(vtkKdTree* sself) { return sself->GetNumberOfRegions(); } +extern "C" void vtk_kd_tree_print_tree(vtkKdTree* sself) { sself->PrintTree(); } +extern "C" void vtk_kd_tree_print_verbose_tree(vtkKdTree* sself) { sself->PrintVerboseTree(); } +extern "C" void vtk_kd_tree_print_region(vtkKdTree* sself, int id) { sself->PrintRegion(id); } +extern "C" void vtk_kd_tree_set_include_region_boundary_cells(vtkKdTree* sself, int _arg) { sself->SetIncludeRegionBoundaryCells(_arg); } +extern "C" int vtk_kd_tree_get_include_region_boundary_cells(vtkKdTree* sself) { return sself->GetIncludeRegionBoundaryCells(); } +extern "C" void vtk_kd_tree_include_region_boundary_cells_on(vtkKdTree* sself) { sself->IncludeRegionBoundaryCellsOn(); } +extern "C" void vtk_kd_tree_include_region_boundary_cells_off(vtkKdTree* sself) { sself->IncludeRegionBoundaryCellsOff(); } +extern "C" void vtk_kd_tree_delete_cell_lists(vtkKdTree* sself) { sself->DeleteCellLists(); } +extern "C" int vtk_kd_tree_get_region_containing_point(vtkKdTree* sself, double x, double y, double z) { return sself->GetRegionContainingPoint(x, y, z); } +extern "C" void vtk_kd_tree_build_locator(vtkKdTree* sself) { sself->BuildLocator(); } +extern "C" void vtk_kd_tree_free_search_structure(vtkKdTree* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_on(vtkKdTree* sself) { sself->GenerateRepresentationUsingDataBoundsOn(); } +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_off(vtkKdTree* sself) { sself->GenerateRepresentationUsingDataBoundsOff(); } +extern "C" void vtk_kd_tree_set_generate_representation_using_data_bounds(vtkKdTree* sself, int _arg) { sself->SetGenerateRepresentationUsingDataBounds(_arg); } +extern "C" int vtk_kd_tree_get_generate_representation_using_data_bounds(vtkKdTree* sself) { return sself->GetGenerateRepresentationUsingDataBounds(); } +extern "C" int vtk_kd_tree_new_geometry(vtkKdTree* sself) { return sself->NewGeometry(); } +extern "C" void vtk_kd_tree_invalidate_geometry(vtkKdTree* sself) { sself->InvalidateGeometry(); } +extern "C" vtkKdTreePointLocator * vtkKdTreePointLocator_new () {return vtkKdTreePointLocator :: New () ;} +extern "C" void vtkKdTreePointLocator_destructor (vtkKdTreePointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkKdTreePointLocator_get_ptr (vtkKdTreePointLocator * sself) {return sself ;} +extern "C" void vtk_kd_tree_point_locator_free_search_structure(vtkKdTreePointLocator* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_kd_tree_point_locator_build_locator(vtkKdTreePointLocator* sself) { sself->BuildLocator(); } +extern "C" vtkLagrangeCurve * vtkLagrangeCurve_new () {return vtkLagrangeCurve :: New () ;} +extern "C" void vtkLagrangeCurve_destructor (vtkLagrangeCurve * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLagrangeCurve_get_ptr (vtkLagrangeCurve * sself) {return sself ;} +extern "C" int vtk_lagrange_curve_get_cell_type(vtkLagrangeCurve* sself) { return sself->GetCellType(); } +extern "C" vtkLagrangeHexahedron * vtkLagrangeHexahedron_new () {return vtkLagrangeHexahedron :: New () ;} +extern "C" void vtkLagrangeHexahedron_destructor (vtkLagrangeHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLagrangeHexahedron_get_ptr (vtkLagrangeHexahedron * sself) {return sself ;} +extern "C" int vtk_lagrange_hexahedron_get_cell_type(vtkLagrangeHexahedron* sself) { return sself->GetCellType(); } +extern "C" vtkLagrangeInterpolation * vtkLagrangeInterpolation_new () {return vtkLagrangeInterpolation :: New () ;} +extern "C" void vtkLagrangeInterpolation_destructor (vtkLagrangeInterpolation * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLagrangeInterpolation_get_ptr (vtkLagrangeInterpolation * sself) {return sself ;} +extern "C" vtkLagrangeQuadrilateral * vtkLagrangeQuadrilateral_new () {return vtkLagrangeQuadrilateral :: New () ;} +extern "C" void vtkLagrangeQuadrilateral_destructor (vtkLagrangeQuadrilateral * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLagrangeQuadrilateral_get_ptr (vtkLagrangeQuadrilateral * sself) {return sself ;} +extern "C" int vtk_lagrange_quadrilateral_get_cell_type(vtkLagrangeQuadrilateral* sself) { return sself->GetCellType(); } +extern "C" vtkLagrangeTetra * vtkLagrangeTetra_new () {return vtkLagrangeTetra :: New () ;} +extern "C" void vtkLagrangeTetra_destructor (vtkLagrangeTetra * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLagrangeTetra_get_ptr (vtkLagrangeTetra * sself) {return sself ;} +extern "C" int vtk_lagrange_tetra_get_cell_type(vtkLagrangeTetra* sself) { return sself->GetCellType(); } +extern "C" vtkLagrangeTriangle * vtkLagrangeTriangle_new () {return vtkLagrangeTriangle :: New () ;} +extern "C" void vtkLagrangeTriangle_destructor (vtkLagrangeTriangle * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLagrangeTriangle_get_ptr (vtkLagrangeTriangle * sself) {return sself ;} +extern "C" int vtk_lagrange_triangle_get_cell_type(vtkLagrangeTriangle* sself) { return sself->GetCellType(); } +extern "C" vtkLagrangeWedge * vtkLagrangeWedge_new () {return vtkLagrangeWedge :: New () ;} +extern "C" void vtkLagrangeWedge_destructor (vtkLagrangeWedge * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLagrangeWedge_get_ptr (vtkLagrangeWedge * sself) {return sself ;} +extern "C" int vtk_lagrange_wedge_get_cell_type(vtkLagrangeWedge* sself) { return sself->GetCellType(); } +extern "C" vtkLine * vtkLine_new () {return vtkLine :: New () ;} +extern "C" void vtkLine_destructor (vtkLine * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLine_get_ptr (vtkLine * sself) {return sself ;} +extern "C" int vtk_line_get_cell_type(vtkLine* sself) { return sself->GetCellType(); } +extern "C" int vtk_line_get_cell_dimension(vtkLine* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_line_get_number_of_edges(vtkLine* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_line_get_number_of_faces(vtkLine* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_line_inflate(vtkLine* sself, double dist) { return sself->Inflate(dist); } +extern "C" vtkMeanValueCoordinatesInterpolator * vtkMeanValueCoordinatesInterpolator_new () {return vtkMeanValueCoordinatesInterpolator :: New () ;} +extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkMeanValueCoordinatesInterpolator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMeanValueCoordinatesInterpolator_get_ptr (vtkMeanValueCoordinatesInterpolator * sself) {return sself ;} +extern "C" vtkMergePoints * vtkMergePoints_new () {return vtkMergePoints :: New () ;} +extern "C" void vtkMergePoints_destructor (vtkMergePoints * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMergePoints_get_ptr (vtkMergePoints * sself) {return sself ;} +extern "C" vtkMolecule * vtkMolecule_new () {return vtkMolecule :: New () ;} +extern "C" void vtkMolecule_destructor (vtkMolecule * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMolecule_get_ptr (vtkMolecule * sself) {return sself ;} +extern "C" long long vtk_molecule_get_number_of_atoms(vtkMolecule* sself) { return sself->GetNumberOfAtoms(); } +extern "C" long long vtk_molecule_get_number_of_bonds(vtkMolecule* sself) { return sself->GetNumberOfBonds(); } +extern "C" unsigned short vtk_molecule_get_atom_atomic_number(vtkMolecule* sself, long long atomId) { return sself->GetAtomAtomicNumber(atomId); } +extern "C" void vtk_molecule_set_atom_atomic_number(vtkMolecule* sself, long long atomId, unsigned short atomicNum) { sself->SetAtomAtomicNumber(atomId, atomicNum); } +extern "C" void vtk_molecule_set_bond_order(vtkMolecule* sself, long long bondId, unsigned short order) { sself->SetBondOrder(bondId, order); } +extern "C" unsigned short vtk_molecule_get_bond_order(vtkMolecule* sself, long long bondId) { return sself->GetBondOrder(bondId); } +extern "C" double vtk_molecule_get_bond_length(vtkMolecule* sself, long long bondId) { return sself->GetBondLength(bondId); } +extern "C" bool vtk_molecule_has_lattice(vtkMolecule* sself) { return sself->HasLattice(); } +extern "C" void vtk_molecule_clear_lattice(vtkMolecule* sself) { sself->ClearLattice(); } +extern "C" void vtk_molecule_allocate_atom_ghost_array(vtkMolecule* sself) { sself->AllocateAtomGhostArray(); } +extern "C" void vtk_molecule_allocate_bond_ghost_array(vtkMolecule* sself) { sself->AllocateBondGhostArray(); } +extern "C" long long vtk_molecule_get_bond_id(vtkMolecule* sself, long long a, long long b) { return sself->GetBondId(a, b); } +extern "C" void vtk_molecule_set_atomic_number_array_name(vtkMolecule* sself, const char* _arg) { sself->SetAtomicNumberArrayName(_arg); } +extern "C" void vtk_molecule_set_bond_orders_array_name(vtkMolecule* sself, const char* _arg) { sself->SetBondOrdersArrayName(_arg); } +extern "C" vtkMultiBlockDataSet * vtkMultiBlockDataSet_new () {return vtkMultiBlockDataSet :: New () ;} +extern "C" void vtkMultiBlockDataSet_destructor (vtkMultiBlockDataSet * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMultiBlockDataSet_get_ptr (vtkMultiBlockDataSet * sself) {return sself ;} +extern "C" void vtk_multi_block_data_set_set_number_of_blocks(vtkMultiBlockDataSet* sself, unsigned int numBlocks) { sself->SetNumberOfBlocks(numBlocks); } +extern "C" unsigned int vtk_multi_block_data_set_get_number_of_blocks(vtkMultiBlockDataSet* sself) { return sself->GetNumberOfBlocks(); } +extern "C" void vtk_multi_block_data_set_remove_block(vtkMultiBlockDataSet* sself, unsigned int blockno) { sself->RemoveBlock(blockno); } +extern "C" int vtk_multi_block_data_set_has_meta_data(vtkMultiBlockDataSet* sself, unsigned int blockno) { return sself->HasMetaData(blockno); } +extern "C" vtkMultiPieceDataSet * vtkMultiPieceDataSet_new () {return vtkMultiPieceDataSet :: New () ;} +extern "C" void vtkMultiPieceDataSet_destructor (vtkMultiPieceDataSet * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMultiPieceDataSet_get_ptr (vtkMultiPieceDataSet * sself) {return sself ;} +extern "C" void vtk_multi_piece_data_set_set_number_of_pieces(vtkMultiPieceDataSet* sself, unsigned int numpieces) { sself->SetNumberOfPieces(numpieces); } +extern "C" unsigned int vtk_multi_piece_data_set_get_number_of_pieces(vtkMultiPieceDataSet* sself) { return sself->GetNumberOfPieces(); } +extern "C" vtkMutableDirectedGraph * vtkMutableDirectedGraph_new () {return vtkMutableDirectedGraph :: New () ;} +extern "C" void vtkMutableDirectedGraph_destructor (vtkMutableDirectedGraph * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMutableDirectedGraph_get_ptr (vtkMutableDirectedGraph * sself) {return sself ;} +extern "C" long long vtk_mutable_directed_graph_set_number_of_vertices(vtkMutableDirectedGraph* sself, long long numVerts) { return sself->SetNumberOfVertices(numVerts); } +extern "C" long long vtk_mutable_directed_graph_add_vertex(vtkMutableDirectedGraph* sself) { return sself->AddVertex(); } +extern "C" void vtk_mutable_directed_graph_lazy_add_vertex(vtkMutableDirectedGraph* sself) { sself->LazyAddVertex(); } +extern "C" void vtk_mutable_directed_graph_remove_vertex(vtkMutableDirectedGraph* sself, long long v) { sself->RemoveVertex(v); } +extern "C" void vtk_mutable_directed_graph_remove_edge(vtkMutableDirectedGraph* sself, long long e) { sself->RemoveEdge(e); } +extern "C" vtkMutableUndirectedGraph * vtkMutableUndirectedGraph_new () {return vtkMutableUndirectedGraph :: New () ;} +extern "C" void vtkMutableUndirectedGraph_destructor (vtkMutableUndirectedGraph * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMutableUndirectedGraph_get_ptr (vtkMutableUndirectedGraph * sself) {return sself ;} +extern "C" long long vtk_mutable_undirected_graph_set_number_of_vertices(vtkMutableUndirectedGraph* sself, long long numVerts) { return sself->SetNumberOfVertices(numVerts); } +extern "C" long long vtk_mutable_undirected_graph_add_vertex(vtkMutableUndirectedGraph* sself) { return sself->AddVertex(); } +extern "C" void vtk_mutable_undirected_graph_lazy_add_vertex(vtkMutableUndirectedGraph* sself) { sself->LazyAddVertex(); } +extern "C" void vtk_mutable_undirected_graph_lazy_add_edge(vtkMutableUndirectedGraph* sself, long long u, long long v) { sself->LazyAddEdge(u, v); } +extern "C" void vtk_mutable_undirected_graph_remove_vertex(vtkMutableUndirectedGraph* sself, long long v) { sself->RemoveVertex(v); } +extern "C" void vtk_mutable_undirected_graph_remove_edge(vtkMutableUndirectedGraph* sself, long long e) { sself->RemoveEdge(e); } +extern "C" vtkNonMergingPointLocator * vtkNonMergingPointLocator_new () {return vtkNonMergingPointLocator :: New () ;} +extern "C" void vtkNonMergingPointLocator_destructor (vtkNonMergingPointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkNonMergingPointLocator_get_ptr (vtkNonMergingPointLocator * sself) {return sself ;} +extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNonMergingPointLocator* sself, double p0, double p1, double p2) { return sself->IsInsertedPoint(p0, p1, p2); } +extern "C" vtkNonOverlappingAMR * vtkNonOverlappingAMR_new () {return vtkNonOverlappingAMR :: New () ;} +extern "C" void vtkNonOverlappingAMR_destructor (vtkNonOverlappingAMR * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkNonOverlappingAMR_get_ptr (vtkNonOverlappingAMR * sself) {return sself ;} +extern "C" int vtk_non_overlapping_amr_get_data_object_type(vtkNonOverlappingAMR* sself) { return sself->GetDataObjectType(); } +extern "C" vtkOctreePointLocator * vtkOctreePointLocator_new () {return vtkOctreePointLocator :: New () ;} +extern "C" void vtkOctreePointLocator_destructor (vtkOctreePointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOctreePointLocator_get_ptr (vtkOctreePointLocator * sself) {return sself ;} +extern "C" void vtk_octree_point_locator_set_maximum_points_per_region(vtkOctreePointLocator* sself, int _arg) { sself->SetMaximumPointsPerRegion(_arg); } +extern "C" int vtk_octree_point_locator_get_maximum_points_per_region(vtkOctreePointLocator* sself) { return sself->GetMaximumPointsPerRegion(); } +extern "C" void vtk_octree_point_locator_set_create_cubic_octants(vtkOctreePointLocator* sself, int _arg) { sself->SetCreateCubicOctants(_arg); } +extern "C" int vtk_octree_point_locator_get_create_cubic_octants(vtkOctreePointLocator* sself) { return sself->GetCreateCubicOctants(); } +extern "C" double vtk_octree_point_locator_get_fudge_factor(vtkOctreePointLocator* sself) { return sself->GetFudgeFactor(); } +extern "C" void vtk_octree_point_locator_set_fudge_factor(vtkOctreePointLocator* sself, double _arg) { sself->SetFudgeFactor(_arg); } +extern "C" int vtk_octree_point_locator_get_number_of_leaf_nodes(vtkOctreePointLocator* sself) { return sself->GetNumberOfLeafNodes(); } +extern "C" int vtk_octree_point_locator_get_region_containing_point(vtkOctreePointLocator* sself, double x, double y, double z) { return sself->GetRegionContainingPoint(x, y, z); } +extern "C" void vtk_octree_point_locator_build_locator(vtkOctreePointLocator* sself) { sself->BuildLocator(); } +extern "C" long long vtk_octree_point_locator_find_closest_point(vtkOctreePointLocator* sself, double x, double y, double z, double& dist2) { return sself->FindClosestPoint(x, y, z, dist2); } +extern "C" void vtk_octree_point_locator_free_search_structure(vtkOctreePointLocator* sself) { sself->FreeSearchStructure(); } +extern "C" vtkOctreePointLocatorNode * vtkOctreePointLocatorNode_new () {return vtkOctreePointLocatorNode :: New () ;} +extern "C" void vtkOctreePointLocatorNode_destructor (vtkOctreePointLocatorNode * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOctreePointLocatorNode_get_ptr (vtkOctreePointLocatorNode * sself) {return sself ;} +extern "C" void vtk_octree_point_locator_node_set_number_of_points(vtkOctreePointLocatorNode* sself, int numberOfPoints) { sself->SetNumberOfPoints(numberOfPoints); } +extern "C" int vtk_octree_point_locator_node_get_number_of_points(vtkOctreePointLocatorNode* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_octree_point_locator_node_set_bounds(vtkOctreePointLocatorNode* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" void vtk_octree_point_locator_node_set_data_bounds(vtkOctreePointLocatorNode* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetDataBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" int vtk_octree_point_locator_node_get_id(vtkOctreePointLocatorNode* sself) { return sself->GetID(); } +extern "C" int vtk_octree_point_locator_node_get_min_id(vtkOctreePointLocatorNode* sself) { return sself->GetMinID(); } +extern "C" void vtk_octree_point_locator_node_create_child_nodes(vtkOctreePointLocatorNode* sself) { sself->CreateChildNodes(); } +extern "C" void vtk_octree_point_locator_node_delete_child_nodes(vtkOctreePointLocatorNode* sself) { sself->DeleteChildNodes(); } +extern "C" int vtk_octree_point_locator_node_contains_point(vtkOctreePointLocatorNode* sself, double x, double y, double z, int useDataBounds) { return sself->ContainsPoint(x, y, z, useDataBounds); } +extern "C" vtkOrderedTriangulator * vtkOrderedTriangulator_new () {return vtkOrderedTriangulator :: New () ;} +extern "C" void vtkOrderedTriangulator_destructor (vtkOrderedTriangulator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOrderedTriangulator_get_ptr (vtkOrderedTriangulator * sself) {return sself ;} +extern "C" void vtk_ordered_triangulator_init_triangulation(vtkOrderedTriangulator* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts) { sself->InitTriangulation(xmin, xmax, ymin, ymax, zmin, zmax, numPts); } +extern "C" void vtk_ordered_triangulator_triangulate(vtkOrderedTriangulator* sself) { sself->Triangulate(); } +extern "C" void vtk_ordered_triangulator_template_triangulate(vtkOrderedTriangulator* sself, int cellType, int numPts, int numEdges) { sself->TemplateTriangulate(cellType, numPts, numEdges); } +extern "C" void vtk_ordered_triangulator_update_point_type(vtkOrderedTriangulator* sself, long long internalId, int type) { sself->UpdatePointType(internalId, type); } +extern "C" long long vtk_ordered_triangulator_get_point_id(vtkOrderedTriangulator* sself, long long internalId) { return sself->GetPointId(internalId); } +extern "C" int vtk_ordered_triangulator_get_number_of_points(vtkOrderedTriangulator* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_ordered_triangulator_set_use_templates(vtkOrderedTriangulator* sself, int _arg) { sself->SetUseTemplates(_arg); } +extern "C" int vtk_ordered_triangulator_get_use_templates(vtkOrderedTriangulator* sself) { return sself->GetUseTemplates(); } +extern "C" void vtk_ordered_triangulator_use_templates_on(vtkOrderedTriangulator* sself) { sself->UseTemplatesOn(); } +extern "C" void vtk_ordered_triangulator_use_templates_off(vtkOrderedTriangulator* sself) { sself->UseTemplatesOff(); } +extern "C" void vtk_ordered_triangulator_set_pre_sorted(vtkOrderedTriangulator* sself, int _arg) { sself->SetPreSorted(_arg); } +extern "C" int vtk_ordered_triangulator_get_pre_sorted(vtkOrderedTriangulator* sself) { return sself->GetPreSorted(); } +extern "C" void vtk_ordered_triangulator_pre_sorted_on(vtkOrderedTriangulator* sself) { sself->PreSortedOn(); } +extern "C" void vtk_ordered_triangulator_pre_sorted_off(vtkOrderedTriangulator* sself) { sself->PreSortedOff(); } +extern "C" void vtk_ordered_triangulator_set_use_two_sort_ids(vtkOrderedTriangulator* sself, int _arg) { sself->SetUseTwoSortIds(_arg); } +extern "C" int vtk_ordered_triangulator_get_use_two_sort_ids(vtkOrderedTriangulator* sself) { return sself->GetUseTwoSortIds(); } +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_on(vtkOrderedTriangulator* sself) { sself->UseTwoSortIdsOn(); } +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_off(vtkOrderedTriangulator* sself) { sself->UseTwoSortIdsOff(); } +extern "C" void vtk_ordered_triangulator_init_tetra_traversal(vtkOrderedTriangulator* sself) { sself->InitTetraTraversal(); } +extern "C" vtkOutEdgeIterator * vtkOutEdgeIterator_new () {return vtkOutEdgeIterator :: New () ;} +extern "C" void vtkOutEdgeIterator_destructor (vtkOutEdgeIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOutEdgeIterator_get_ptr (vtkOutEdgeIterator * sself) {return sself ;} +extern "C" long long vtk_out_edge_iterator_get_vertex(vtkOutEdgeIterator* sself) { return sself->GetVertex(); } +extern "C" bool vtk_out_edge_iterator_has_next(vtkOutEdgeIterator* sself) { return sself->HasNext(); } +extern "C" vtkOverlappingAMR * vtkOverlappingAMR_new () {return vtkOverlappingAMR :: New () ;} +extern "C" void vtkOverlappingAMR_destructor (vtkOverlappingAMR * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOverlappingAMR_get_ptr (vtkOverlappingAMR * sself) {return sself ;} +extern "C" void vtk_overlapping_amr_set_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level, int refRatio) { sself->SetRefinementRatio(level, refRatio); } +extern "C" int vtk_overlapping_amr_get_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level) { return sself->GetRefinementRatio(level); } +extern "C" void vtk_overlapping_amr_set_amr_block_source_index(vtkOverlappingAMR* sself, unsigned int level, unsigned int id, int sourceId) { sself->SetAMRBlockSourceIndex(level, id, sourceId); } +extern "C" int vtk_overlapping_amr_get_amr_block_source_index(vtkOverlappingAMR* sself, unsigned int level, unsigned int id) { return sself->GetAMRBlockSourceIndex(level, id); } +extern "C" bool vtk_overlapping_amr_has_children_information(vtkOverlappingAMR* sself) { return sself->HasChildrenInformation(); } +extern "C" void vtk_overlapping_amr_generate_parent_child_information(vtkOverlappingAMR* sself) { sself->GenerateParentChildInformation(); } +extern "C" void vtk_overlapping_amr_print_parent_child_info(vtkOverlappingAMR* sself, unsigned int level, unsigned int index) { sself->PrintParentChildInfo(level, index); } +extern "C" void vtk_overlapping_amr_audit(vtkOverlappingAMR* sself) { sself->Audit(); } +extern "C" vtkPartitionedDataSet * vtkPartitionedDataSet_new () {return vtkPartitionedDataSet :: New () ;} +extern "C" void vtkPartitionedDataSet_destructor (vtkPartitionedDataSet * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPartitionedDataSet_get_ptr (vtkPartitionedDataSet * sself) {return sself ;} +extern "C" void vtk_partitioned_data_set_set_number_of_partitions(vtkPartitionedDataSet* sself, unsigned int numPartitions) { sself->SetNumberOfPartitions(numPartitions); } +extern "C" unsigned int vtk_partitioned_data_set_get_number_of_partitions(vtkPartitionedDataSet* sself) { return sself->GetNumberOfPartitions(); } +extern "C" int vtk_partitioned_data_set_has_meta_data(vtkPartitionedDataSet* sself, unsigned int idx) { return sself->HasMetaData(idx); } +extern "C" void vtk_partitioned_data_set_remove_null_partitions(vtkPartitionedDataSet* sself) { sself->RemoveNullPartitions(); } +extern "C" vtkPartitionedDataSetCollection * vtkPartitionedDataSetCollection_new () {return vtkPartitionedDataSetCollection :: New () ;} +extern "C" void vtkPartitionedDataSetCollection_destructor (vtkPartitionedDataSetCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPartitionedDataSetCollection_get_ptr (vtkPartitionedDataSetCollection * sself) {return sself ;} +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself, unsigned int numDataSets) { sself->SetNumberOfPartitionedDataSets(numDataSets); } +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself) { return sself->GetNumberOfPartitionedDataSets(); } +extern "C" void vtk_partitioned_data_set_collection_remove_partitioned_data_set(vtkPartitionedDataSetCollection* sself, unsigned int idx) { sself->RemovePartitionedDataSet(idx); } +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitions(vtkPartitionedDataSetCollection* sself, unsigned int idx) { return sself->GetNumberOfPartitions(idx); } +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitions(vtkPartitionedDataSetCollection* sself, unsigned int idx, unsigned int numPartitions) { sself->SetNumberOfPartitions(idx, numPartitions); } +extern "C" int vtk_partitioned_data_set_collection_has_meta_data(vtkPartitionedDataSetCollection* sself, unsigned int idx) { return sself->HasMetaData(idx); } +extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkPartitionedDataSetCollection* sself, unsigned int idx) { return sself->GetCompositeIndex(idx); } +extern "C" unsigned long vtk_partitioned_data_set_collection_get_m_time(vtkPartitionedDataSetCollection* sself) { return sself->GetMTime(); } +extern "C" vtkPath * vtkPath_new () {return vtkPath :: New () ;} +extern "C" void vtkPath_destructor (vtkPath * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPath_get_ptr (vtkPath * sself) {return sself ;} +extern "C" int vtk_path_get_data_object_type(vtkPath* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_path_insert_next_point(vtkPath* sself, double x, double y, double z, int code) { sself->InsertNextPoint(x, y, z, code); } +extern "C" long long vtk_path_get_number_of_cells(vtkPath* sself) { return sself->GetNumberOfCells(); } +extern "C" int vtk_path_get_max_cell_size(vtkPath* sself) { return sself->GetMaxCellSize(); } +extern "C" void vtk_path_allocate(vtkPath* sself, long long size, int extSize) { sself->Allocate(size, extSize); } +extern "C" void vtk_path_reset(vtkPath* sself) { sself->Reset(); } +extern "C" vtkPentagonalPrism * vtkPentagonalPrism_new () {return vtkPentagonalPrism :: New () ;} +extern "C" void vtkPentagonalPrism_destructor (vtkPentagonalPrism * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPentagonalPrism_get_ptr (vtkPentagonalPrism * sself) {return sself ;} +extern "C" int vtk_pentagonal_prism_get_cell_type(vtkPentagonalPrism* sself) { return sself->GetCellType(); } +extern "C" int vtk_pentagonal_prism_get_number_of_edges(vtkPentagonalPrism* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_pentagonal_prism_get_number_of_faces(vtkPentagonalPrism* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkPerlinNoise * vtkPerlinNoise_new () {return vtkPerlinNoise :: New () ;} +extern "C" void vtkPerlinNoise_destructor (vtkPerlinNoise * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPerlinNoise_get_ptr (vtkPerlinNoise * sself) {return sself ;} +extern "C" void vtk_perlin_noise_set_frequency(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3) { sself->SetFrequency(_arg1, _arg2, _arg3); } +extern "C" void vtk_perlin_noise_set_phase(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3) { sself->SetPhase(_arg1, _arg2, _arg3); } +extern "C" void vtk_perlin_noise_set_amplitude(vtkPerlinNoise* sself, double _arg) { sself->SetAmplitude(_arg); } +extern "C" double vtk_perlin_noise_get_amplitude(vtkPerlinNoise* sself) { return sself->GetAmplitude(); } +extern "C" vtkPiecewiseFunction * vtkPiecewiseFunction_new () {return vtkPiecewiseFunction :: New () ;} +extern "C" void vtkPiecewiseFunction_destructor (vtkPiecewiseFunction * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPiecewiseFunction_get_ptr (vtkPiecewiseFunction * sself) {return sself ;} +extern "C" int vtk_piecewise_function_get_data_object_type(vtkPiecewiseFunction* sself) { return sself->GetDataObjectType(); } +extern "C" int vtk_piecewise_function_get_size(vtkPiecewiseFunction* sself) { return sself->GetSize(); } +extern "C" int vtk_piecewise_function_add_point(vtkPiecewiseFunction* sself, double x, double y) { return sself->AddPoint(x, y); } +extern "C" bool vtk_piecewise_function_remove_point_by_index(vtkPiecewiseFunction* sself, size_t id) { return sself->RemovePointByIndex(id); } +extern "C" int vtk_piecewise_function_remove_point(vtkPiecewiseFunction* sself, double x) { return sself->RemovePoint(x); } +extern "C" void vtk_piecewise_function_remove_all_points(vtkPiecewiseFunction* sself) { sself->RemoveAllPoints(); } +extern "C" void vtk_piecewise_function_add_segment(vtkPiecewiseFunction* sself, double x1, double y1, double x2, double y2) { sself->AddSegment(x1, y1, x2, y2); } +extern "C" double vtk_piecewise_function_get_value(vtkPiecewiseFunction* sself, double x) { return sself->GetValue(x); } +extern "C" void vtk_piecewise_function_set_clamping(vtkPiecewiseFunction* sself, int _arg) { sself->SetClamping(_arg); } +extern "C" int vtk_piecewise_function_get_clamping(vtkPiecewiseFunction* sself) { return sself->GetClamping(); } +extern "C" void vtk_piecewise_function_clamping_on(vtkPiecewiseFunction* sself) { sself->ClampingOn(); } +extern "C" void vtk_piecewise_function_clamping_off(vtkPiecewiseFunction* sself) { sself->ClampingOff(); } +extern "C" void vtk_piecewise_function_set_use_log_scale(vtkPiecewiseFunction* sself, bool _arg) { sself->SetUseLogScale(_arg); } +extern "C" bool vtk_piecewise_function_get_use_log_scale(vtkPiecewiseFunction* sself) { return sself->GetUseLogScale(); } +extern "C" void vtk_piecewise_function_use_log_scale_on(vtkPiecewiseFunction* sself) { sself->UseLogScaleOn(); } +extern "C" void vtk_piecewise_function_use_log_scale_off(vtkPiecewiseFunction* sself) { sself->UseLogScaleOff(); } +extern "C" const char* vtk_piecewise_function_get_type(vtkPiecewiseFunction* sself) { return sself->GetType(); } +extern "C" double vtk_piecewise_function_get_first_non_zero_value(vtkPiecewiseFunction* sself) { return sself->GetFirstNonZeroValue(); } +extern "C" void vtk_piecewise_function_initialize(vtkPiecewiseFunction* sself) { sself->Initialize(); } +extern "C" void vtk_piecewise_function_set_allow_duplicate_scalars(vtkPiecewiseFunction* sself, int _arg) { sself->SetAllowDuplicateScalars(_arg); } +extern "C" int vtk_piecewise_function_get_allow_duplicate_scalars(vtkPiecewiseFunction* sself) { return sself->GetAllowDuplicateScalars(); } +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_on(vtkPiecewiseFunction* sself) { sself->AllowDuplicateScalarsOn(); } +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_off(vtkPiecewiseFunction* sself) { sself->AllowDuplicateScalarsOff(); } +extern "C" int vtk_piecewise_function_estimate_min_number_of_samples(vtkPiecewiseFunction* sself, const double& x1, const double& x2) { return sself->EstimateMinNumberOfSamples(x1, x2); } +extern "C" vtkPixel * vtkPixel_new () {return vtkPixel :: New () ;} +extern "C" void vtkPixel_destructor (vtkPixel * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPixel_get_ptr (vtkPixel * sself) {return sself ;} +extern "C" int vtk_pixel_get_cell_type(vtkPixel* sself) { return sself->GetCellType(); } +extern "C" int vtk_pixel_get_cell_dimension(vtkPixel* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_pixel_get_number_of_edges(vtkPixel* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_pixel_get_number_of_faces(vtkPixel* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_pixel_inflate(vtkPixel* sself, double dist) { return sself->Inflate(dist); } +extern "C" vtkPlane * vtkPlane_new () {return vtkPlane :: New () ;} +extern "C" void vtkPlane_destructor (vtkPlane * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPlane_get_ptr (vtkPlane * sself) {return sself ;} +extern "C" void vtk_plane_set_normal(vtkPlane* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" void vtk_plane_set_origin(vtkPlane* sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_plane_push(vtkPlane* sself, double distance) { sself->Push(distance); } +extern "C" vtkPlaneCollection * vtkPlaneCollection_new () {return vtkPlaneCollection :: New () ;} +extern "C" void vtkPlaneCollection_destructor (vtkPlaneCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPlaneCollection_get_ptr (vtkPlaneCollection * sself) {return sself ;} +extern "C" int vtk_plane_collection_get_number_of_items(vtkPlaneCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" vtkPlanes * vtkPlanes_new () {return vtkPlanes :: New () ;} +extern "C" void vtkPlanes_destructor (vtkPlanes * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPlanes_get_ptr (vtkPlanes * sself) {return sself ;} +extern "C" void vtk_planes_set_bounds(vtkPlanes* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) { sself->SetBounds(xmin, xmax, ymin, ymax, zmin, zmax); } +extern "C" int vtk_planes_get_number_of_planes(vtkPlanes* sself) { return sself->GetNumberOfPlanes(); } +extern "C" vtkPlanesIntersection * vtkPlanesIntersection_new () {return vtkPlanesIntersection :: New () ;} +extern "C" void vtkPlanesIntersection_destructor (vtkPlanesIntersection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPlanesIntersection_get_ptr (vtkPlanesIntersection * sself) {return sself ;} +extern "C" int vtk_planes_intersection_get_number_of_region_vertices(vtkPlanesIntersection* sself) { return sself->GetNumberOfRegionVertices(); } +extern "C" int vtk_planes_intersection_get_num_region_vertices(vtkPlanesIntersection* sself) { return sself->GetNumRegionVertices(); } +extern "C" vtkPointData * vtkPointData_new () {return vtkPointData :: New () ;} +extern "C" void vtkPointData_destructor (vtkPointData * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPointData_get_ptr (vtkPointData * sself) {return sself ;} +extern "C" void vtk_point_data_null_point(vtkPointData* sself, long long ptId) { sself->NullPoint(ptId); } +extern "C" vtkPointLocator * vtkPointLocator_new () {return vtkPointLocator :: New () ;} +extern "C" void vtkPointLocator_destructor (vtkPointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPointLocator_get_ptr (vtkPointLocator * sself) {return sself ;} +extern "C" void vtk_point_locator_set_divisions(vtkPointLocator* sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } +extern "C" void vtk_point_locator_set_number_of_points_per_bucket(vtkPointLocator* sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_min_value(vtkPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_max_value(vtkPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } +extern "C" int vtk_point_locator_get_number_of_points_per_bucket(vtkPointLocator* sself) { return sself->GetNumberOfPointsPerBucket(); } +extern "C" long long vtk_point_locator_is_inserted_point(vtkPointLocator* sself, double x, double y, double z) { return sself->IsInsertedPoint(x, y, z); } +extern "C" void vtk_point_locator_initialize(vtkPointLocator* sself) { sself->Initialize(); } +extern "C" void vtk_point_locator_free_search_structure(vtkPointLocator* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_point_locator_build_locator(vtkPointLocator* sself) { sself->BuildLocator(); } +extern "C" vtkPointSet * vtkPointSet_new () {return vtkPointSet :: New () ;} +extern "C" void vtkPointSet_destructor (vtkPointSet * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPointSet_get_ptr (vtkPointSet * sself) {return sself ;} +extern "C" void vtk_point_set_set_editable(vtkPointSet* sself, bool _arg) { sself->SetEditable(_arg); } +extern "C" bool vtk_point_set_get_editable(vtkPointSet* sself) { return sself->GetEditable(); } +extern "C" void vtk_point_set_editable_on(vtkPointSet* sself) { sself->EditableOn(); } +extern "C" void vtk_point_set_editable_off(vtkPointSet* sself) { sself->EditableOff(); } +extern "C" void vtk_point_set_initialize(vtkPointSet* sself) { sself->Initialize(); } +extern "C" long long vtk_point_set_get_number_of_points(vtkPointSet* sself) { return sself->GetNumberOfPoints(); } +extern "C" long long vtk_point_set_get_number_of_cells(vtkPointSet* sself) { return sself->GetNumberOfCells(); } +extern "C" int vtk_point_set_get_max_cell_size(vtkPointSet* sself) { return sself->GetMaxCellSize(); } +extern "C" int vtk_point_set_get_cell_type(vtkPointSet* sself, long long p0) { return sself->GetCellType(p0); } +extern "C" void vtk_point_set_build_point_locator(vtkPointSet* sself) { sself->BuildPointLocator(); } +extern "C" void vtk_point_set_build_locator(vtkPointSet* sself) { sself->BuildLocator(); } +extern "C" void vtk_point_set_build_cell_locator(vtkPointSet* sself) { sself->BuildCellLocator(); } +extern "C" unsigned long vtk_point_set_get_m_time(vtkPointSet* sself) { return sself->GetMTime(); } +extern "C" void vtk_point_set_compute_bounds(vtkPointSet* sself) { sself->ComputeBounds(); } +extern "C" void vtk_point_set_squeeze(vtkPointSet* sself) { sself->Squeeze(); } +extern "C" vtkPointSetCellIterator * vtkPointSetCellIterator_new () {return vtkPointSetCellIterator :: New () ;} +extern "C" void vtkPointSetCellIterator_destructor (vtkPointSetCellIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPointSetCellIterator_get_ptr (vtkPointSetCellIterator * sself) {return sself ;} +extern "C" bool vtk_point_set_cell_iterator_is_done_with_traversal(vtkPointSetCellIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_point_set_cell_iterator_get_cell_id(vtkPointSetCellIterator* sself) { return sself->GetCellId(); } +extern "C" vtkPointsProjectedHull * vtkPointsProjectedHull_new () {return vtkPointsProjectedHull :: New () ;} +extern "C" void vtkPointsProjectedHull_destructor (vtkPointsProjectedHull * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPointsProjectedHull_get_ptr (vtkPointsProjectedHull * sself) {return sself ;} +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_x(vtkPointsProjectedHull* sself) { return sself->GetSizeCCWHullX(); } +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_y(vtkPointsProjectedHull* sself) { return sself->GetSizeCCWHullY(); } +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_z(vtkPointsProjectedHull* sself) { return sself->GetSizeCCWHullZ(); } +extern "C" void vtk_points_projected_hull_update(vtkPointsProjectedHull* sself) { sself->Update(); } +extern "C" vtkPolyData * vtkPolyData_new () {return vtkPolyData :: New () ;} +extern "C" void vtkPolyData_destructor (vtkPolyData * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolyData_get_ptr (vtkPolyData * sself) {return sself ;} +extern "C" int vtk_poly_data_get_data_object_type(vtkPolyData* sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_poly_data_get_number_of_cells(vtkPolyData* sself) { return sself->GetNumberOfCells(); } +extern "C" int vtk_poly_data_get_cell_type(vtkPolyData* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_poly_data_compute_cells_bounds(vtkPolyData* sself) { sself->ComputeCellsBounds(); } +extern "C" void vtk_poly_data_squeeze(vtkPolyData* sself) { sself->Squeeze(); } +extern "C" int vtk_poly_data_get_max_cell_size(vtkPolyData* sself) { return sself->GetMaxCellSize(); } +extern "C" long long vtk_poly_data_get_cell_id_relative_to_cell_array(vtkPolyData* sself, long long cellId) { return sself->GetCellIdRelativeToCellArray(cellId); } +extern "C" long long vtk_poly_data_get_number_of_verts(vtkPolyData* sself) { return sself->GetNumberOfVerts(); } +extern "C" long long vtk_poly_data_get_number_of_lines(vtkPolyData* sself) { return sself->GetNumberOfLines(); } +extern "C" long long vtk_poly_data_get_number_of_polys(vtkPolyData* sself) { return sself->GetNumberOfPolys(); } +extern "C" long long vtk_poly_data_get_number_of_strips(vtkPolyData* sself) { return sself->GetNumberOfStrips(); } +extern "C" bool vtk_poly_data_allocate_estimate(vtkPolyData* sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } +extern "C" bool vtk_poly_data_allocate_exact(vtkPolyData* sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } +extern "C" void vtk_poly_data_allocate(vtkPolyData* sself, long long numCells, int extSize) { sself->Allocate(numCells, extSize); } +extern "C" void vtk_poly_data_reset(vtkPolyData* sself) { sself->Reset(); } +extern "C" void vtk_poly_data_build_cells(vtkPolyData* sself) { sself->BuildCells(); } +extern "C" bool vtk_poly_data_need_to_build_cells(vtkPolyData* sself) { return sself->NeedToBuildCells(); } +extern "C" void vtk_poly_data_build_links(vtkPolyData* sself, int initialSize) { sself->BuildLinks(initialSize); } +extern "C" void vtk_poly_data_delete_cells(vtkPolyData* sself) { sself->DeleteCells(); } +extern "C" void vtk_poly_data_delete_links(vtkPolyData* sself) { sself->DeleteLinks(); } +extern "C" int vtk_poly_data_is_triangle(vtkPolyData* sself, int v1, int v2, int v3) { return sself->IsTriangle(v1, v2, v3); } +extern "C" int vtk_poly_data_is_edge(vtkPolyData* sself, long long p1, long long p2) { return sself->IsEdge(p1, p2); } +extern "C" int vtk_poly_data_is_point_used_by_cell(vtkPolyData* sself, long long ptId, long long cellId) { return sself->IsPointUsedByCell(ptId, cellId); } +extern "C" void vtk_poly_data_replace_cell_point(vtkPolyData* sself, long long cellId, long long oldPtId, long long newPtId) { sself->ReplaceCellPoint(cellId, oldPtId, newPtId); } +extern "C" void vtk_poly_data_reverse_cell(vtkPolyData* sself, long long cellId) { sself->ReverseCell(cellId); } +extern "C" void vtk_poly_data_delete_point(vtkPolyData* sself, long long ptId) { sself->DeletePoint(ptId); } +extern "C" void vtk_poly_data_delete_cell(vtkPolyData* sself, long long cellId) { sself->DeleteCell(cellId); } +extern "C" void vtk_poly_data_remove_deleted_cells(vtkPolyData* sself) { sself->RemoveDeletedCells(); } +extern "C" long long vtk_poly_data_insert_next_linked_point(vtkPolyData* sself, int numLinks) { return sself->InsertNextLinkedPoint(numLinks); } +extern "C" void vtk_poly_data_remove_cell_reference(vtkPolyData* sself, long long cellId) { sself->RemoveCellReference(cellId); } +extern "C" void vtk_poly_data_add_cell_reference(vtkPolyData* sself, long long cellId) { sself->AddCellReference(cellId); } +extern "C" void vtk_poly_data_remove_reference_to_cell(vtkPolyData* sself, long long ptId, long long cellId) { sself->RemoveReferenceToCell(ptId, cellId); } +extern "C" void vtk_poly_data_add_reference_to_cell(vtkPolyData* sself, long long ptId, long long cellId) { sself->AddReferenceToCell(ptId, cellId); } +extern "C" void vtk_poly_data_resize_cell_list(vtkPolyData* sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } +extern "C" void vtk_poly_data_initialize(vtkPolyData* sself) { sself->Initialize(); } +extern "C" int vtk_poly_data_get_piece(vtkPolyData* sself) { return sself->GetPiece(); } +extern "C" int vtk_poly_data_get_number_of_pieces(vtkPolyData* sself) { return sself->GetNumberOfPieces(); } +extern "C" int vtk_poly_data_get_ghost_level(vtkPolyData* sself) { return sself->GetGhostLevel(); } +extern "C" void vtk_poly_data_remove_ghost_cells(vtkPolyData* sself) { sself->RemoveGhostCells(); } +extern "C" unsigned long vtk_poly_data_get_mesh_m_time(vtkPolyData* sself) { return sself->GetMeshMTime(); } +extern "C" unsigned long vtk_poly_data_get_m_time(vtkPolyData* sself) { return sself->GetMTime(); } +extern "C" vtkPolyDataCollection * vtkPolyDataCollection_new () {return vtkPolyDataCollection :: New () ;} +extern "C" void vtkPolyDataCollection_destructor (vtkPolyDataCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolyDataCollection_get_ptr (vtkPolyDataCollection * sself) {return sself ;} +extern "C" vtkPolyLine * vtkPolyLine_new () {return vtkPolyLine :: New () ;} +extern "C" void vtkPolyLine_destructor (vtkPolyLine * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolyLine_get_ptr (vtkPolyLine * sself) {return sself ;} +extern "C" int vtk_poly_line_get_cell_type(vtkPolyLine* sself) { return sself->GetCellType(); } +extern "C" int vtk_poly_line_get_cell_dimension(vtkPolyLine* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_poly_line_get_number_of_edges(vtkPolyLine* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_poly_line_get_number_of_faces(vtkPolyLine* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkPolyPlane * vtkPolyPlane_new () {return vtkPolyPlane :: New () ;} +extern "C" void vtkPolyPlane_destructor (vtkPolyPlane * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolyPlane_get_ptr (vtkPolyPlane * sself) {return sself ;} +extern "C" unsigned long vtk_poly_plane_get_m_time(vtkPolyPlane* sself) { return sself->GetMTime(); } +extern "C" vtkPolyVertex * vtkPolyVertex_new () {return vtkPolyVertex :: New () ;} +extern "C" void vtkPolyVertex_destructor (vtkPolyVertex * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolyVertex_get_ptr (vtkPolyVertex * sself) {return sself ;} +extern "C" int vtk_poly_vertex_get_cell_type(vtkPolyVertex* sself) { return sself->GetCellType(); } +extern "C" int vtk_poly_vertex_get_cell_dimension(vtkPolyVertex* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_poly_vertex_get_number_of_edges(vtkPolyVertex* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_poly_vertex_get_number_of_faces(vtkPolyVertex* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkPolygon * vtkPolygon_new () {return vtkPolygon :: New () ;} +extern "C" void vtkPolygon_destructor (vtkPolygon * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolygon_get_ptr (vtkPolygon * sself) {return sself ;} +extern "C" int vtk_polygon_get_cell_type(vtkPolygon* sself) { return sself->GetCellType(); } +extern "C" int vtk_polygon_get_cell_dimension(vtkPolygon* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_polygon_get_number_of_edges(vtkPolygon* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_polygon_get_number_of_faces(vtkPolygon* sself) { return sself->GetNumberOfFaces(); } +extern "C" double vtk_polygon_compute_area(vtkPolygon* sself) { return sself->ComputeArea(); } +extern "C" bool vtk_polygon_is_convex(vtkPolygon* sself) { return sself->IsConvex(); } +extern "C" bool vtk_polygon_get_use_mvc_interpolation(vtkPolygon* sself) { return sself->GetUseMVCInterpolation(); } +extern "C" void vtk_polygon_set_use_mvc_interpolation(vtkPolygon* sself, bool _arg) { sself->SetUseMVCInterpolation(_arg); } +extern "C" void vtk_polygon_set_tolerance(vtkPolygon* sself, double _arg) { sself->SetTolerance(_arg); } +extern "C" double vtk_polygon_get_tolerance_min_value(vtkPolygon* sself) { return sself->GetToleranceMinValue(); } +extern "C" double vtk_polygon_get_tolerance_max_value(vtkPolygon* sself) { return sself->GetToleranceMaxValue(); } +extern "C" double vtk_polygon_get_tolerance(vtkPolygon* sself) { return sself->GetTolerance(); } +extern "C" int vtk_polygon_ear_cut_triangulation(vtkPolygon* sself, int measure) { return sself->EarCutTriangulation(measure); } +extern "C" int vtk_polygon_unbiased_ear_cut_triangulation(vtkPolygon* sself, int seed, int measure) { return sself->UnbiasedEarCutTriangulation(seed, measure); } +extern "C" vtkPolyhedron * vtkPolyhedron_new () {return vtkPolyhedron :: New () ;} +extern "C" void vtkPolyhedron_destructor (vtkPolyhedron * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolyhedron_get_ptr (vtkPolyhedron * sself) {return sself ;} +extern "C" int vtk_polyhedron_get_cell_type(vtkPolyhedron* sself) { return sself->GetCellType(); } +extern "C" int vtk_polyhedron_requires_initialization(vtkPolyhedron* sself) { return sself->RequiresInitialization(); } +extern "C" int vtk_polyhedron_get_number_of_edges(vtkPolyhedron* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_polyhedron_get_number_of_faces(vtkPolyhedron* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_polyhedron_is_primary_cell(vtkPolyhedron* sself) { return sself->IsPrimaryCell(); } +extern "C" int vtk_polyhedron_requires_explicit_face_representation(vtkPolyhedron* sself) { return sself->RequiresExplicitFaceRepresentation(); } +extern "C" bool vtk_polyhedron_is_convex(vtkPolyhedron* sself) { return sself->IsConvex(); } +extern "C" vtkPyramid * vtkPyramid_new () {return vtkPyramid :: New () ;} +extern "C" void vtkPyramid_destructor (vtkPyramid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPyramid_get_ptr (vtkPyramid * sself) {return sself ;} +extern "C" int vtk_pyramid_get_cell_type(vtkPyramid* sself) { return sself->GetCellType(); } +extern "C" int vtk_pyramid_get_number_of_edges(vtkPyramid* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_pyramid_get_number_of_faces(vtkPyramid* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuad * vtkQuad_new () {return vtkQuad :: New () ;} +extern "C" void vtkQuad_destructor (vtkQuad * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuad_get_ptr (vtkQuad * sself) {return sself ;} +extern "C" int vtk_quad_get_cell_type(vtkQuad* sself) { return sself->GetCellType(); } +extern "C" int vtk_quad_get_cell_dimension(vtkQuad* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quad_get_number_of_edges(vtkQuad* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quad_get_number_of_faces(vtkQuad* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticEdge * vtkQuadraticEdge_new () {return vtkQuadraticEdge :: New () ;} +extern "C" void vtkQuadraticEdge_destructor (vtkQuadraticEdge * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadraticEdge_get_ptr (vtkQuadraticEdge * sself) {return sself ;} +extern "C" int vtk_quadratic_edge_get_cell_type(vtkQuadraticEdge* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_edge_get_cell_dimension(vtkQuadraticEdge* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_edge_get_number_of_edges(vtkQuadraticEdge* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_edge_get_number_of_faces(vtkQuadraticEdge* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticHexahedron * vtkQuadraticHexahedron_new () {return vtkQuadraticHexahedron :: New () ;} +extern "C" void vtkQuadraticHexahedron_destructor (vtkQuadraticHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadraticHexahedron_get_ptr (vtkQuadraticHexahedron * sself) {return sself ;} +extern "C" int vtk_quadratic_hexahedron_get_cell_type(vtkQuadraticHexahedron* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_hexahedron_get_cell_dimension(vtkQuadraticHexahedron* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_hexahedron_get_number_of_edges(vtkQuadraticHexahedron* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_hexahedron_get_number_of_faces(vtkQuadraticHexahedron* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticLinearQuad * vtkQuadraticLinearQuad_new () {return vtkQuadraticLinearQuad :: New () ;} +extern "C" void vtkQuadraticLinearQuad_destructor (vtkQuadraticLinearQuad * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadraticLinearQuad_get_ptr (vtkQuadraticLinearQuad * sself) {return sself ;} +extern "C" int vtk_quadratic_linear_quad_get_cell_type(vtkQuadraticLinearQuad* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_linear_quad_get_cell_dimension(vtkQuadraticLinearQuad* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_linear_quad_get_number_of_edges(vtkQuadraticLinearQuad* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_linear_quad_get_number_of_faces(vtkQuadraticLinearQuad* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticLinearWedge * vtkQuadraticLinearWedge_new () {return vtkQuadraticLinearWedge :: New () ;} +extern "C" void vtkQuadraticLinearWedge_destructor (vtkQuadraticLinearWedge * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadraticLinearWedge_get_ptr (vtkQuadraticLinearWedge * sself) {return sself ;} +extern "C" int vtk_quadratic_linear_wedge_get_cell_type(vtkQuadraticLinearWedge* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_linear_wedge_get_cell_dimension(vtkQuadraticLinearWedge* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_linear_wedge_get_number_of_edges(vtkQuadraticLinearWedge* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_linear_wedge_get_number_of_faces(vtkQuadraticLinearWedge* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticPolygon * vtkQuadraticPolygon_new () {return vtkQuadraticPolygon :: New () ;} +extern "C" void vtkQuadraticPolygon_destructor (vtkQuadraticPolygon * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadraticPolygon_get_ptr (vtkQuadraticPolygon * sself) {return sself ;} +extern "C" int vtk_quadratic_polygon_get_cell_type(vtkQuadraticPolygon* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_polygon_get_cell_dimension(vtkQuadraticPolygon* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_polygon_get_number_of_edges(vtkQuadraticPolygon* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_polygon_get_number_of_faces(vtkQuadraticPolygon* sself) { return sself->GetNumberOfFaces(); } +extern "C" bool vtk_quadratic_polygon_get_use_mvc_interpolation(vtkQuadraticPolygon* sself) { return sself->GetUseMVCInterpolation(); } +extern "C" void vtk_quadratic_polygon_set_use_mvc_interpolation(vtkQuadraticPolygon* sself, bool _arg) { sself->SetUseMVCInterpolation(_arg); } +extern "C" vtkQuadraticPyramid * vtkQuadraticPyramid_new () {return vtkQuadraticPyramid :: New () ;} +extern "C" void vtkQuadraticPyramid_destructor (vtkQuadraticPyramid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadraticPyramid_get_ptr (vtkQuadraticPyramid * sself) {return sself ;} +extern "C" int vtk_quadratic_pyramid_get_cell_type(vtkQuadraticPyramid* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_pyramid_get_cell_dimension(vtkQuadraticPyramid* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_pyramid_get_number_of_edges(vtkQuadraticPyramid* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_pyramid_get_number_of_faces(vtkQuadraticPyramid* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticQuad * vtkQuadraticQuad_new () {return vtkQuadraticQuad :: New () ;} +extern "C" void vtkQuadraticQuad_destructor (vtkQuadraticQuad * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadraticQuad_get_ptr (vtkQuadraticQuad * sself) {return sself ;} +extern "C" int vtk_quadratic_quad_get_cell_type(vtkQuadraticQuad* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_quad_get_cell_dimension(vtkQuadraticQuad* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_quad_get_number_of_edges(vtkQuadraticQuad* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_quad_get_number_of_faces(vtkQuadraticQuad* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticTetra * vtkQuadraticTetra_new () {return vtkQuadraticTetra :: New () ;} +extern "C" void vtkQuadraticTetra_destructor (vtkQuadraticTetra * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadraticTetra_get_ptr (vtkQuadraticTetra * sself) {return sself ;} +extern "C" int vtk_quadratic_tetra_get_cell_type(vtkQuadraticTetra* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_tetra_get_cell_dimension(vtkQuadraticTetra* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_tetra_get_number_of_edges(vtkQuadraticTetra* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_tetra_get_number_of_faces(vtkQuadraticTetra* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticTriangle * vtkQuadraticTriangle_new () {return vtkQuadraticTriangle :: New () ;} +extern "C" void vtkQuadraticTriangle_destructor (vtkQuadraticTriangle * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadraticTriangle_get_ptr (vtkQuadraticTriangle * sself) {return sself ;} +extern "C" int vtk_quadratic_triangle_get_cell_type(vtkQuadraticTriangle* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_triangle_get_cell_dimension(vtkQuadraticTriangle* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_triangle_get_number_of_edges(vtkQuadraticTriangle* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_triangle_get_number_of_faces(vtkQuadraticTriangle* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticWedge * vtkQuadraticWedge_new () {return vtkQuadraticWedge :: New () ;} +extern "C" void vtkQuadraticWedge_destructor (vtkQuadraticWedge * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadraticWedge_get_ptr (vtkQuadraticWedge * sself) {return sself ;} +extern "C" int vtk_quadratic_wedge_get_cell_type(vtkQuadraticWedge* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_wedge_get_cell_dimension(vtkQuadraticWedge* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_wedge_get_number_of_edges(vtkQuadraticWedge* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_wedge_get_number_of_faces(vtkQuadraticWedge* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadratureSchemeDefinition * vtkQuadratureSchemeDefinition_new () {return vtkQuadratureSchemeDefinition :: New () ;} +extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkQuadratureSchemeDefinition * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadratureSchemeDefinition_get_ptr (vtkQuadratureSchemeDefinition * sself) {return sself ;} +extern "C" void vtk_quadrature_scheme_definition_clear(vtkQuadratureSchemeDefinition* sself) { sself->Clear(); } +extern "C" int vtk_quadrature_scheme_definition_get_cell_type(vtkQuadratureSchemeDefinition* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadrature_scheme_definition_get_quadrature_key(vtkQuadratureSchemeDefinition* sself) { return sself->GetQuadratureKey(); } +extern "C" int vtk_quadrature_scheme_definition_get_number_of_nodes(vtkQuadratureSchemeDefinition* sself) { return sself->GetNumberOfNodes(); } +extern "C" int vtk_quadrature_scheme_definition_get_number_of_quadrature_points(vtkQuadratureSchemeDefinition* sself) { return sself->GetNumberOfQuadraturePoints(); } +extern "C" vtkQuadric * vtkQuadric_new () {return vtkQuadric :: New () ;} +extern "C" void vtkQuadric_destructor (vtkQuadric * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuadric_get_ptr (vtkQuadric * sself) {return sself ;} +extern "C" void vtk_quadric_set_coefficients(vtkQuadric* sself, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9) { sself->SetCoefficients(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } +extern "C" vtkRectilinearGrid * vtkRectilinearGrid_new () {return vtkRectilinearGrid :: New () ;} +extern "C" void vtkRectilinearGrid_destructor (vtkRectilinearGrid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkRectilinearGrid_get_ptr (vtkRectilinearGrid * sself) {return sself ;} +extern "C" int vtk_rectilinear_grid_get_data_object_type(vtkRectilinearGrid* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_rectilinear_grid_initialize(vtkRectilinearGrid* sself) { sself->Initialize(); } +extern "C" long long vtk_rectilinear_grid_get_number_of_cells(vtkRectilinearGrid* sself) { return sself->GetNumberOfCells(); } +extern "C" long long vtk_rectilinear_grid_get_number_of_points(vtkRectilinearGrid* sself) { return sself->GetNumberOfPoints(); } +extern "C" int vtk_rectilinear_grid_get_cell_type(vtkRectilinearGrid* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" int vtk_rectilinear_grid_get_max_cell_size(vtkRectilinearGrid* sself) { return sself->GetMaxCellSize(); } +extern "C" unsigned char vtk_rectilinear_grid_is_point_visible(vtkRectilinearGrid* sself, long long ptId) { return sself->IsPointVisible(ptId); } +extern "C" unsigned char vtk_rectilinear_grid_is_cell_visible(vtkRectilinearGrid* sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" bool vtk_rectilinear_grid_has_any_blank_points(vtkRectilinearGrid* sself) { return sself->HasAnyBlankPoints(); } +extern "C" bool vtk_rectilinear_grid_has_any_blank_cells(vtkRectilinearGrid* sself) { return sself->HasAnyBlankCells(); } +extern "C" void vtk_rectilinear_grid_set_dimensions(vtkRectilinearGrid* sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" int vtk_rectilinear_grid_get_data_dimension(vtkRectilinearGrid* sself) { return sself->GetDataDimension(); } +extern "C" void vtk_rectilinear_grid_set_extent(vtkRectilinearGrid* sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax) { sself->SetExtent(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" int vtk_rectilinear_grid_get_extent_type(vtkRectilinearGrid* sself) { return sself->GetExtentType(); } +extern "C" const char* vtk_rectilinear_grid_get_scalar_type_as_string(vtkRectilinearGrid* sself) { return sself->GetScalarTypeAsString(); } +extern "C" vtkReebGraph * vtkReebGraph_new () {return vtkReebGraph :: New () ;} +extern "C" void vtkReebGraph_destructor (vtkReebGraph * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkReebGraph_get_ptr (vtkReebGraph * sself) {return sself ;} +extern "C" int vtk_reeb_graph_stream_triangle(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2) { return sself->StreamTriangle(vertex0Id, scalar0, vertex1Id, scalar1, vertex2Id, scalar2); } +extern "C" int vtk_reeb_graph_stream_tetrahedron(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2, long long vertex3Id, double scalar3) { return sself->StreamTetrahedron(vertex0Id, scalar0, vertex1Id, scalar1, vertex2Id, scalar2, vertex3Id, scalar3); } +extern "C" void vtk_reeb_graph_close_stream(vtkReebGraph* sself) { sself->CloseStream(); } +extern "C" vtkReebGraphSimplificationMetric * vtkReebGraphSimplificationMetric_new () {return vtkReebGraphSimplificationMetric :: New () ;} +extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkReebGraphSimplificationMetric * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkReebGraphSimplificationMetric_get_ptr (vtkReebGraphSimplificationMetric * sself) {return sself ;} +extern "C" void vtk_reeb_graph_simplification_metric_set_lower_bound(vtkReebGraphSimplificationMetric* sself, double _arg) { sself->SetLowerBound(_arg); } +extern "C" double vtk_reeb_graph_simplification_metric_get_lower_bound(vtkReebGraphSimplificationMetric* sself) { return sself->GetLowerBound(); } +extern "C" void vtk_reeb_graph_simplification_metric_set_upper_bound(vtkReebGraphSimplificationMetric* sself, double _arg) { sself->SetUpperBound(_arg); } +extern "C" double vtk_reeb_graph_simplification_metric_get_upper_bound(vtkReebGraphSimplificationMetric* sself) { return sself->GetUpperBound(); } +extern "C" vtkSelection * vtkSelection_new () {return vtkSelection :: New () ;} +extern "C" void vtkSelection_destructor (vtkSelection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSelection_get_ptr (vtkSelection * sself) {return sself ;} +extern "C" int vtk_selection_get_data_object_type(vtkSelection* sself) { return sself->GetDataObjectType(); } +extern "C" unsigned int vtk_selection_get_number_of_nodes(vtkSelection* sself) { return sself->GetNumberOfNodes(); } +extern "C" void vtk_selection_remove_node(vtkSelection* sself, unsigned int idx) { sself->RemoveNode(idx); } +extern "C" void vtk_selection_remove_all_nodes(vtkSelection* sself) { sself->RemoveAllNodes(); } +extern "C" void vtk_selection_set_expression(vtkSelection* sself, const char* _arg) { sself->SetExpression(_arg); } +extern "C" unsigned long vtk_selection_get_m_time(vtkSelection* sself) { return sself->GetMTime(); } +extern "C" void vtk_selection_dump(vtkSelection* sself) { sself->Dump(); } +extern "C" vtkSelectionNode * vtkSelectionNode_new () {return vtkSelectionNode :: New () ;} +extern "C" void vtkSelectionNode_destructor (vtkSelectionNode * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSelectionNode_get_ptr (vtkSelectionNode * sself) {return sself ;} +extern "C" void vtk_selection_node_initialize(vtkSelectionNode* sself) { sself->Initialize(); } +extern "C" unsigned long vtk_selection_node_get_m_time(vtkSelectionNode* sself) { return sself->GetMTime(); } +extern "C" void vtk_selection_node_set_content_type(vtkSelectionNode* sself, int type) { sself->SetContentType(type); } +extern "C" int vtk_selection_node_get_content_type(vtkSelectionNode* sself) { return sself->GetContentType(); } +extern "C" const char* vtk_selection_node_get_content_type_as_string(vtkSelectionNode* sself, int type) { return sself->GetContentTypeAsString(type); } +extern "C" void vtk_selection_node_set_field_type(vtkSelectionNode* sself, int type) { sself->SetFieldType(type); } +extern "C" int vtk_selection_node_get_field_type(vtkSelectionNode* sself) { return sself->GetFieldType(); } +extern "C" const char* vtk_selection_node_get_field_type_as_string(vtkSelectionNode* sself, int type) { return sself->GetFieldTypeAsString(type); } +extern "C" int vtk_selection_node_get_field_type_from_string(vtkSelectionNode* sself, const char* type) { return sself->GetFieldTypeFromString(type); } +extern "C" int vtk_selection_node_convert_selection_field_to_attribute_type(vtkSelectionNode* sself, int val) { return sself->ConvertSelectionFieldToAttributeType(val); } +extern "C" int vtk_selection_node_convert_attribute_type_to_selection_field(vtkSelectionNode* sself, int val) { return sself->ConvertAttributeTypeToSelectionField(val); } +extern "C" void vtk_selection_node_set_query_string(vtkSelectionNode* sself, const char* _arg) { sself->SetQueryString(_arg); } +extern "C" vtkSimpleCellTessellator * vtkSimpleCellTessellator_new () {return vtkSimpleCellTessellator :: New () ;} +extern "C" void vtkSimpleCellTessellator_destructor (vtkSimpleCellTessellator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSimpleCellTessellator_get_ptr (vtkSimpleCellTessellator * sself) {return sself ;} +extern "C" void vtk_simple_cell_tessellator_reset(vtkSimpleCellTessellator* sself) { sself->Reset(); } +extern "C" int vtk_simple_cell_tessellator_get_fixed_subdivisions(vtkSimpleCellTessellator* sself) { return sself->GetFixedSubdivisions(); } +extern "C" int vtk_simple_cell_tessellator_get_max_subdivision_level(vtkSimpleCellTessellator* sself) { return sself->GetMaxSubdivisionLevel(); } +extern "C" int vtk_simple_cell_tessellator_get_max_adaptive_subdivisions(vtkSimpleCellTessellator* sself) { return sself->GetMaxAdaptiveSubdivisions(); } +extern "C" void vtk_simple_cell_tessellator_set_fixed_subdivisions(vtkSimpleCellTessellator* sself, int level) { sself->SetFixedSubdivisions(level); } +extern "C" void vtk_simple_cell_tessellator_set_max_subdivision_level(vtkSimpleCellTessellator* sself, int level) { sself->SetMaxSubdivisionLevel(level); } +extern "C" void vtk_simple_cell_tessellator_set_subdivision_levels(vtkSimpleCellTessellator* sself, int fixed, int maxLevel) { sself->SetSubdivisionLevels(fixed, maxLevel); } +extern "C" vtkSmoothErrorMetric * vtkSmoothErrorMetric_new () {return vtkSmoothErrorMetric :: New () ;} +extern "C" void vtkSmoothErrorMetric_destructor (vtkSmoothErrorMetric * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSmoothErrorMetric_get_ptr (vtkSmoothErrorMetric * sself) {return sself ;} +extern "C" double vtk_smooth_error_metric_get_angle_tolerance(vtkSmoothErrorMetric* sself) { return sself->GetAngleTolerance(); } +extern "C" void vtk_smooth_error_metric_set_angle_tolerance(vtkSmoothErrorMetric* sself, double value) { sself->SetAngleTolerance(value); } +extern "C" vtkSortFieldData * vtkSortFieldData_new () {return vtkSortFieldData :: New () ;} +extern "C" void vtkSortFieldData_destructor (vtkSortFieldData * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSortFieldData_get_ptr (vtkSortFieldData * sself) {return sself ;} +extern "C" vtkSphere * vtkSphere_new () {return vtkSphere :: New () ;} +extern "C" void vtkSphere_destructor (vtkSphere * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSphere_get_ptr (vtkSphere * sself) {return sself ;} +extern "C" void vtk_sphere_set_radius(vtkSphere* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_sphere_get_radius(vtkSphere* sself) { return sself->GetRadius(); } +extern "C" void vtk_sphere_set_center(vtkSphere* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" vtkSpheres * vtkSpheres_new () {return vtkSpheres :: New () ;} +extern "C" void vtkSpheres_destructor (vtkSpheres * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSpheres_get_ptr (vtkSpheres * sself) {return sself ;} +extern "C" int vtk_spheres_get_number_of_spheres(vtkSpheres* sself) { return sself->GetNumberOfSpheres(); } +extern "C" vtkStaticCellLinks * vtkStaticCellLinks_new () {return vtkStaticCellLinks :: New () ;} +extern "C" void vtkStaticCellLinks_destructor (vtkStaticCellLinks * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStaticCellLinks_get_ptr (vtkStaticCellLinks * sself) {return sself ;} +extern "C" long long vtk_static_cell_links_get_number_of_cells(vtkStaticCellLinks* sself, long long ptId) { return sself->GetNumberOfCells(ptId); } +extern "C" long long vtk_static_cell_links_get_ncells(vtkStaticCellLinks* sself, long long ptId) { return sself->GetNcells(ptId); } +extern "C" void vtk_static_cell_links_initialize(vtkStaticCellLinks* sself) { sself->Initialize(); } +extern "C" void vtk_static_cell_links_squeeze(vtkStaticCellLinks* sself) { sself->Squeeze(); } +extern "C" void vtk_static_cell_links_reset(vtkStaticCellLinks* sself) { sself->Reset(); } +extern "C" unsigned long vtk_static_cell_links_get_actual_memory_size(vtkStaticCellLinks* sself) { return sself->GetActualMemorySize(); } +extern "C" vtkStaticCellLocator * vtkStaticCellLocator_new () {return vtkStaticCellLocator :: New () ;} +extern "C" void vtkStaticCellLocator_destructor (vtkStaticCellLocator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStaticCellLocator_get_ptr (vtkStaticCellLocator * sself) {return sself ;} +extern "C" void vtk_static_cell_locator_set_divisions(vtkStaticCellLocator* sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } +extern "C" void vtk_static_cell_locator_free_search_structure(vtkStaticCellLocator* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_static_cell_locator_build_locator(vtkStaticCellLocator* sself) { sself->BuildLocator(); } +extern "C" void vtk_static_cell_locator_set_max_number_of_buckets(vtkStaticCellLocator* sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_min_value(vtkStaticCellLocator* sself) { return sself->GetMaxNumberOfBucketsMinValue(); } +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_max_value(vtkStaticCellLocator* sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets(vtkStaticCellLocator* sself) { return sself->GetMaxNumberOfBuckets(); } +extern "C" bool vtk_static_cell_locator_get_large_ids(vtkStaticCellLocator* sself) { return sself->GetLargeIds(); } +extern "C" void vtk_static_cell_locator_set_use_diagonal_length_tolerance(vtkStaticCellLocator* sself, bool _arg) { sself->SetUseDiagonalLengthTolerance(_arg); } +extern "C" bool vtk_static_cell_locator_get_use_diagonal_length_tolerance(vtkStaticCellLocator* sself) { return sself->GetUseDiagonalLengthTolerance(); } +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_on(vtkStaticCellLocator* sself) { sself->UseDiagonalLengthToleranceOn(); } +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_off(vtkStaticCellLocator* sself) { sself->UseDiagonalLengthToleranceOff(); } +extern "C" vtkStaticPointLocator * vtkStaticPointLocator_new () {return vtkStaticPointLocator :: New () ;} +extern "C" void vtkStaticPointLocator_destructor (vtkStaticPointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStaticPointLocator_get_ptr (vtkStaticPointLocator * sself) {return sself ;} +extern "C" void vtk_static_point_locator_set_number_of_points_per_bucket(vtkStaticPointLocator* sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket(vtkStaticPointLocator* sself) { return sself->GetNumberOfPointsPerBucket(); } +extern "C" void vtk_static_point_locator_set_divisions(vtkStaticPointLocator* sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } +extern "C" void vtk_static_point_locator_initialize(vtkStaticPointLocator* sself) { sself->Initialize(); } +extern "C" void vtk_static_point_locator_free_search_structure(vtkStaticPointLocator* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_static_point_locator_build_locator(vtkStaticPointLocator* sself) { sself->BuildLocator(); } +extern "C" long long vtk_static_point_locator_get_number_of_points_in_bucket(vtkStaticPointLocator* sself, long long bNum) { return sself->GetNumberOfPointsInBucket(bNum); } +extern "C" void vtk_static_point_locator_set_max_number_of_buckets(vtkStaticPointLocator* sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_min_value(vtkStaticPointLocator* sself) { return sself->GetMaxNumberOfBucketsMinValue(); } +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_max_value(vtkStaticPointLocator* sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets(vtkStaticPointLocator* sself) { return sself->GetMaxNumberOfBuckets(); } +extern "C" bool vtk_static_point_locator_get_large_ids(vtkStaticPointLocator* sself) { return sself->GetLargeIds(); } +extern "C" vtkStaticPointLocator2D * vtkStaticPointLocator2D_new () {return vtkStaticPointLocator2D :: New () ;} +extern "C" void vtkStaticPointLocator2D_destructor (vtkStaticPointLocator2D * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStaticPointLocator2D_get_ptr (vtkStaticPointLocator2D * sself) {return sself ;} +extern "C" void vtk_static_point_locator_2_d_set_number_of_points_per_bucket(vtkStaticPointLocator2D* sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator2D* sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator2D* sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket(vtkStaticPointLocator2D* sself) { return sself->GetNumberOfPointsPerBucket(); } +extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkStaticPointLocator2D* sself, int _arg1, int _arg2) { sself->SetDivisions(_arg1, _arg2); } +extern "C" void vtk_static_point_locator_2_d_initialize(vtkStaticPointLocator2D* sself) { sself->Initialize(); } +extern "C" void vtk_static_point_locator_2_d_free_search_structure(vtkStaticPointLocator2D* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_static_point_locator_2_d_build_locator(vtkStaticPointLocator2D* sself) { sself->BuildLocator(); } +extern "C" long long vtk_static_point_locator_2_d_get_number_of_points_in_bucket(vtkStaticPointLocator2D* sself, long long bNum) { return sself->GetNumberOfPointsInBucket(bNum); } +extern "C" void vtk_static_point_locator_2_d_set_max_number_of_buckets(vtkStaticPointLocator2D* sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(vtkStaticPointLocator2D* sself) { return sself->GetMaxNumberOfBucketsMinValue(); } +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(vtkStaticPointLocator2D* sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets(vtkStaticPointLocator2D* sself) { return sself->GetMaxNumberOfBuckets(); } +extern "C" bool vtk_static_point_locator_2_d_get_large_ids(vtkStaticPointLocator2D* sself) { return sself->GetLargeIds(); } +extern "C" vtkStructuredExtent * vtkStructuredExtent_new () {return vtkStructuredExtent :: New () ;} +extern "C" void vtkStructuredExtent_destructor (vtkStructuredExtent * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStructuredExtent_get_ptr (vtkStructuredExtent * sself) {return sself ;} +extern "C" vtkStructuredGrid * vtkStructuredGrid_new () {return vtkStructuredGrid :: New () ;} +extern "C" void vtkStructuredGrid_destructor (vtkStructuredGrid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStructuredGrid_get_ptr (vtkStructuredGrid * sself) {return sself ;} +extern "C" int vtk_structured_grid_get_data_object_type(vtkStructuredGrid* sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_structured_grid_get_number_of_points(vtkStructuredGrid* sself) { return sself->GetNumberOfPoints(); } +extern "C" int vtk_structured_grid_get_cell_type(vtkStructuredGrid* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_structured_grid_set_dimensions(vtkStructuredGrid* sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" int vtk_structured_grid_get_data_dimension(vtkStructuredGrid* sself) { return sself->GetDataDimension(); } +extern "C" void vtk_structured_grid_set_extent(vtkStructuredGrid* sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax) { sself->SetExtent(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" int vtk_structured_grid_get_extent_type(vtkStructuredGrid* sself) { return sself->GetExtentType(); } +extern "C" void vtk_structured_grid_blank_point(vtkStructuredGrid* sself, long long ptId) { sself->BlankPoint(ptId); } +extern "C" void vtk_structured_grid_un_blank_point(vtkStructuredGrid* sself, long long ptId) { sself->UnBlankPoint(ptId); } +extern "C" void vtk_structured_grid_blank_cell(vtkStructuredGrid* sself, long long ptId) { sself->BlankCell(ptId); } +extern "C" void vtk_structured_grid_un_blank_cell(vtkStructuredGrid* sself, long long ptId) { sself->UnBlankCell(ptId); } +extern "C" unsigned char vtk_structured_grid_is_point_visible(vtkStructuredGrid* sself, long long ptId) { return sself->IsPointVisible(ptId); } +extern "C" unsigned char vtk_structured_grid_is_cell_visible(vtkStructuredGrid* sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" bool vtk_structured_grid_has_any_blank_points(vtkStructuredGrid* sself) { return sself->HasAnyBlankPoints(); } +extern "C" bool vtk_structured_grid_has_any_blank_cells(vtkStructuredGrid* sself) { return sself->HasAnyBlankCells(); } +extern "C" vtkStructuredPoints * vtkStructuredPoints_new () {return vtkStructuredPoints :: New () ;} +extern "C" void vtkStructuredPoints_destructor (vtkStructuredPoints * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStructuredPoints_get_ptr (vtkStructuredPoints * sself) {return sself ;} +extern "C" int vtk_structured_points_get_data_object_type(vtkStructuredPoints* sself) { return sself->GetDataObjectType(); } +extern "C" vtkStructuredPointsCollection * vtkStructuredPointsCollection_new () {return vtkStructuredPointsCollection :: New () ;} +extern "C" void vtkStructuredPointsCollection_destructor (vtkStructuredPointsCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStructuredPointsCollection_get_ptr (vtkStructuredPointsCollection * sself) {return sself ;} +extern "C" vtkSuperquadric * vtkSuperquadric_new () {return vtkSuperquadric :: New () ;} +extern "C" void vtkSuperquadric_destructor (vtkSuperquadric * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSuperquadric_get_ptr (vtkSuperquadric * sself) {return sself ;} +extern "C" void vtk_superquadric_set_center(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_superquadric_set_scale(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3) { sself->SetScale(_arg1, _arg2, _arg3); } +extern "C" double vtk_superquadric_get_thickness(vtkSuperquadric* sself) { return sself->GetThickness(); } +extern "C" void vtk_superquadric_set_thickness(vtkSuperquadric* sself, double _arg) { sself->SetThickness(_arg); } +extern "C" double vtk_superquadric_get_thickness_min_value(vtkSuperquadric* sself) { return sself->GetThicknessMinValue(); } +extern "C" double vtk_superquadric_get_thickness_max_value(vtkSuperquadric* sself) { return sself->GetThicknessMaxValue(); } +extern "C" double vtk_superquadric_get_phi_roundness(vtkSuperquadric* sself) { return sself->GetPhiRoundness(); } +extern "C" void vtk_superquadric_set_phi_roundness(vtkSuperquadric* sself, double e) { sself->SetPhiRoundness(e); } +extern "C" double vtk_superquadric_get_theta_roundness(vtkSuperquadric* sself) { return sself->GetThetaRoundness(); } +extern "C" void vtk_superquadric_set_theta_roundness(vtkSuperquadric* sself, double e) { sself->SetThetaRoundness(e); } +extern "C" void vtk_superquadric_set_size(vtkSuperquadric* sself, double _arg) { sself->SetSize(_arg); } +extern "C" double vtk_superquadric_get_size(vtkSuperquadric* sself) { return sself->GetSize(); } +extern "C" void vtk_superquadric_toroidal_on(vtkSuperquadric* sself) { sself->ToroidalOn(); } +extern "C" void vtk_superquadric_toroidal_off(vtkSuperquadric* sself) { sself->ToroidalOff(); } +extern "C" int vtk_superquadric_get_toroidal(vtkSuperquadric* sself) { return sself->GetToroidal(); } +extern "C" void vtk_superquadric_set_toroidal(vtkSuperquadric* sself, int _arg) { sself->SetToroidal(_arg); } +extern "C" vtkTable * vtkTable_new () {return vtkTable :: New () ;} +extern "C" void vtkTable_destructor (vtkTable * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTable_get_ptr (vtkTable * sself) {return sself ;} +extern "C" void vtk_table_dump(vtkTable* sself, unsigned int colWidth, int rowLimit) { sself->Dump(colWidth, rowLimit); } +extern "C" int vtk_table_get_data_object_type(vtkTable* sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_table_get_number_of_rows(vtkTable* sself) { return sself->GetNumberOfRows(); } +extern "C" void vtk_table_set_number_of_rows(vtkTable* sself, const long long p0) { sself->SetNumberOfRows(p0); } +extern "C" long long vtk_table_insert_next_blank_row(vtkTable* sself, double default_num_val) { return sself->InsertNextBlankRow(default_num_val); } +extern "C" void vtk_table_remove_row(vtkTable* sself, long long row) { sself->RemoveRow(row); } +extern "C" long long vtk_table_get_number_of_columns(vtkTable* sself) { return sself->GetNumberOfColumns(); } +extern "C" const char* vtk_table_get_column_name(vtkTable* sself, long long col) { return sself->GetColumnName(col); } +extern "C" void vtk_table_remove_column_by_name(vtkTable* sself, const char* name) { sself->RemoveColumnByName(name); } +extern "C" void vtk_table_remove_column(vtkTable* sself, long long col) { sself->RemoveColumn(col); } +extern "C" void vtk_table_initialize(vtkTable* sself) { sself->Initialize(); } +extern "C" long long vtk_table_get_number_of_elements(vtkTable* sself, int type) { return sself->GetNumberOfElements(type); } +extern "C" vtkTetra * vtkTetra_new () {return vtkTetra :: New () ;} +extern "C" void vtkTetra_destructor (vtkTetra * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTetra_get_ptr (vtkTetra * sself) {return sself ;} +extern "C" int vtk_tetra_get_cell_type(vtkTetra* sself) { return sself->GetCellType(); } +extern "C" int vtk_tetra_get_number_of_edges(vtkTetra* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_tetra_get_number_of_faces(vtkTetra* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkTree * vtkTree_new () {return vtkTree :: New () ;} +extern "C" void vtkTree_destructor (vtkTree * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTree_get_ptr (vtkTree * sself) {return sself ;} +extern "C" long long vtk_tree_get_root(vtkTree* sself) { return sself->GetRoot(); } +extern "C" long long vtk_tree_get_number_of_children(vtkTree* sself, long long v) { return sself->GetNumberOfChildren(v); } +extern "C" long long vtk_tree_get_child(vtkTree* sself, long long v, long long i) { return sself->GetChild(v, i); } +extern "C" long long vtk_tree_get_parent(vtkTree* sself, long long v) { return sself->GetParent(v); } +extern "C" long long vtk_tree_get_level(vtkTree* sself, long long v) { return sself->GetLevel(v); } +extern "C" bool vtk_tree_is_leaf(vtkTree* sself, long long vertex) { return sself->IsLeaf(vertex); } +extern "C" vtkTreeBFSIterator * vtkTreeBFSIterator_new () {return vtkTreeBFSIterator :: New () ;} +extern "C" void vtkTreeBFSIterator_destructor (vtkTreeBFSIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTreeBFSIterator_get_ptr (vtkTreeBFSIterator * sself) {return sself ;} +extern "C" vtkTreeDFSIterator * vtkTreeDFSIterator_new () {return vtkTreeDFSIterator :: New () ;} +extern "C" void vtkTreeDFSIterator_destructor (vtkTreeDFSIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTreeDFSIterator_get_ptr (vtkTreeDFSIterator * sself) {return sself ;} +extern "C" void vtk_tree_dfs_iterator_set_mode(vtkTreeDFSIterator* sself, int mode) { sself->SetMode(mode); } +extern "C" int vtk_tree_dfs_iterator_get_mode(vtkTreeDFSIterator* sself) { return sself->GetMode(); } +extern "C" vtkTriQuadraticHexahedron * vtkTriQuadraticHexahedron_new () {return vtkTriQuadraticHexahedron :: New () ;} +extern "C" void vtkTriQuadraticHexahedron_destructor (vtkTriQuadraticHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTriQuadraticHexahedron_get_ptr (vtkTriQuadraticHexahedron * sself) {return sself ;} +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_type(vtkTriQuadraticHexahedron* sself) { return sself->GetCellType(); } +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_dimension(vtkTriQuadraticHexahedron* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_edges(vtkTriQuadraticHexahedron* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_faces(vtkTriQuadraticHexahedron* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkTriQuadraticPyramid * vtkTriQuadraticPyramid_new () {return vtkTriQuadraticPyramid :: New () ;} +extern "C" void vtkTriQuadraticPyramid_destructor (vtkTriQuadraticPyramid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTriQuadraticPyramid_get_ptr (vtkTriQuadraticPyramid * sself) {return sself ;} +extern "C" int vtk_tri_quadratic_pyramid_get_cell_type(vtkTriQuadraticPyramid* sself) { return sself->GetCellType(); } +extern "C" int vtk_tri_quadratic_pyramid_get_cell_dimension(vtkTriQuadraticPyramid* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_edges(vtkTriQuadraticPyramid* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_faces(vtkTriQuadraticPyramid* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkTriangle * vtkTriangle_new () {return vtkTriangle :: New () ;} +extern "C" void vtkTriangle_destructor (vtkTriangle * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTriangle_get_ptr (vtkTriangle * sself) {return sself ;} +extern "C" int vtk_triangle_get_cell_type(vtkTriangle* sself) { return sself->GetCellType(); } +extern "C" int vtk_triangle_get_cell_dimension(vtkTriangle* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_triangle_get_number_of_edges(vtkTriangle* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_triangle_get_number_of_faces(vtkTriangle* sself) { return sself->GetNumberOfFaces(); } +extern "C" double vtk_triangle_compute_area(vtkTriangle* sself) { return sself->ComputeArea(); } +extern "C" vtkTriangleStrip * vtkTriangleStrip_new () {return vtkTriangleStrip :: New () ;} +extern "C" void vtkTriangleStrip_destructor (vtkTriangleStrip * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTriangleStrip_get_ptr (vtkTriangleStrip * sself) {return sself ;} +extern "C" int vtk_triangle_strip_get_cell_type(vtkTriangleStrip* sself) { return sself->GetCellType(); } +extern "C" int vtk_triangle_strip_get_cell_dimension(vtkTriangleStrip* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_triangle_strip_get_number_of_edges(vtkTriangleStrip* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_triangle_strip_get_number_of_faces(vtkTriangleStrip* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkUndirectedGraph * vtkUndirectedGraph_new () {return vtkUndirectedGraph :: New () ;} +extern "C" void vtkUndirectedGraph_destructor (vtkUndirectedGraph * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUndirectedGraph_get_ptr (vtkUndirectedGraph * sself) {return sself ;} +extern "C" long long vtk_undirected_graph_get_in_degree(vtkUndirectedGraph* sself, long long v) { return sself->GetInDegree(v); } +extern "C" vtkUniformGrid * vtkUniformGrid_new () {return vtkUniformGrid :: New () ;} +extern "C" void vtkUniformGrid_destructor (vtkUniformGrid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUniformGrid_get_ptr (vtkUniformGrid * sself) {return sself ;} +extern "C" int vtk_uniform_grid_get_grid_description(vtkUniformGrid* sself) { return sself->GetGridDescription(); } +extern "C" void vtk_uniform_grid_blank_point(vtkUniformGrid* sself, long long ptId) { sself->BlankPoint(ptId); } +extern "C" void vtk_uniform_grid_un_blank_point(vtkUniformGrid* sself, long long ptId) { sself->UnBlankPoint(ptId); } +extern "C" void vtk_uniform_grid_blank_cell(vtkUniformGrid* sself, long long ptId) { sself->BlankCell(ptId); } +extern "C" void vtk_uniform_grid_un_blank_cell(vtkUniformGrid* sself, long long ptId) { sself->UnBlankCell(ptId); } +extern "C" unsigned char vtk_uniform_grid_is_point_visible(vtkUniformGrid* sself, long long pointId) { return sself->IsPointVisible(pointId); } +extern "C" unsigned char vtk_uniform_grid_is_cell_visible(vtkUniformGrid* sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" vtkUniformGridAMR * vtkUniformGridAMR_new () {return vtkUniformGridAMR :: New () ;} +extern "C" void vtkUniformGridAMR_destructor (vtkUniformGridAMR * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUniformGridAMR_get_ptr (vtkUniformGridAMR * sself) {return sself ;} +extern "C" int vtk_uniform_grid_amr_get_data_object_type(vtkUniformGridAMR* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_uniform_grid_amr_initialize(vtkUniformGridAMR* sself) { sself->Initialize(); } +extern "C" void vtk_uniform_grid_amr_set_grid_description(vtkUniformGridAMR* sself, int gridDescription) { sself->SetGridDescription(gridDescription); } +extern "C" int vtk_uniform_grid_amr_get_grid_description(vtkUniformGridAMR* sself) { return sself->GetGridDescription(); } +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_levels(vtkUniformGridAMR* sself) { return sself->GetNumberOfLevels(); } +extern "C" unsigned int vtk_uniform_grid_amr_get_total_number_of_blocks(vtkUniformGridAMR* sself) { return sself->GetTotalNumberOfBlocks(); } +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_data_sets(vtkUniformGridAMR* sself, const unsigned int level) { return sself->GetNumberOfDataSets(level); } +extern "C" int vtk_uniform_grid_amr_get_composite_index(vtkUniformGridAMR* sself, const unsigned int level, const unsigned int index) { return sself->GetCompositeIndex(level, index); } +extern "C" void vtk_uniform_grid_amr_get_level_and_index(vtkUniformGridAMR* sself, const unsigned int compositeIdx, unsigned int& level, unsigned int& idx) { sself->GetLevelAndIndex(compositeIdx, level, idx); } +extern "C" vtkUniformGridAMRDataIterator * vtkUniformGridAMRDataIterator_new () {return vtkUniformGridAMRDataIterator :: New () ;} +extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkUniformGridAMRDataIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUniformGridAMRDataIterator_get_ptr (vtkUniformGridAMRDataIterator * sself) {return sself ;} +extern "C" int vtk_uniform_grid_amr_data_iterator_has_current_meta_data(vtkUniformGridAMRDataIterator* sself) { return sself->HasCurrentMetaData(); } +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_flat_index(vtkUniformGridAMRDataIterator* sself) { return sself->GetCurrentFlatIndex(); } +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_level(vtkUniformGridAMRDataIterator* sself) { return sself->GetCurrentLevel(); } +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_index(vtkUniformGridAMRDataIterator* sself) { return sself->GetCurrentIndex(); } +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_first_item(vtkUniformGridAMRDataIterator* sself) { sself->GoToFirstItem(); } +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_next_item(vtkUniformGridAMRDataIterator* sself) { sself->GoToNextItem(); } +extern "C" int vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(vtkUniformGridAMRDataIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" vtkUniformHyperTreeGrid * vtkUniformHyperTreeGrid_new () {return vtkUniformHyperTreeGrid :: New () ;} +extern "C" void vtkUniformHyperTreeGrid_destructor (vtkUniformHyperTreeGrid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUniformHyperTreeGrid_get_ptr (vtkUniformHyperTreeGrid * sself) {return sself ;} +extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkUniformHyperTreeGrid* sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkUniformHyperTreeGrid* sself, double p0, double p1, double p2) { sself->SetGridScale(p0, p1, p2); } +extern "C" unsigned long vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(vtkUniformHyperTreeGrid* sself) { return sself->GetActualMemorySizeBytes(); } +extern "C" vtkUnstructuredGrid * vtkUnstructuredGrid_new () {return vtkUnstructuredGrid :: New () ;} +extern "C" void vtkUnstructuredGrid_destructor (vtkUnstructuredGrid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUnstructuredGrid_get_ptr (vtkUnstructuredGrid * sself) {return sself ;} +extern "C" int vtk_unstructured_grid_get_data_object_type(vtkUnstructuredGrid* sself) { return sself->GetDataObjectType(); } +extern "C" bool vtk_unstructured_grid_allocate_estimate(vtkUnstructuredGrid* sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } +extern "C" bool vtk_unstructured_grid_allocate_exact(vtkUnstructuredGrid* sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } +extern "C" void vtk_unstructured_grid_allocate(vtkUnstructuredGrid* sself, long long numCells, int extSize) { sself->Allocate(numCells, extSize); } +extern "C" void vtk_unstructured_grid_reset(vtkUnstructuredGrid* sself) { sself->Reset(); } +extern "C" int vtk_unstructured_grid_get_cell_type(vtkUnstructuredGrid* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_unstructured_grid_squeeze(vtkUnstructuredGrid* sself) { sself->Squeeze(); } +extern "C" void vtk_unstructured_grid_initialize(vtkUnstructuredGrid* sself) { sself->Initialize(); } +extern "C" int vtk_unstructured_grid_get_max_cell_size(vtkUnstructuredGrid* sself) { return sself->GetMaxCellSize(); } +extern "C" void vtk_unstructured_grid_build_links(vtkUnstructuredGrid* sself) { sself->BuildLinks(); } +extern "C" void vtk_unstructured_grid_remove_reference_to_cell(vtkUnstructuredGrid* sself, long long ptId, long long cellId) { sself->RemoveReferenceToCell(ptId, cellId); } +extern "C" void vtk_unstructured_grid_add_reference_to_cell(vtkUnstructuredGrid* sself, long long ptId, long long cellId) { sself->AddReferenceToCell(ptId, cellId); } +extern "C" void vtk_unstructured_grid_resize_cell_list(vtkUnstructuredGrid* sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } +extern "C" int vtk_unstructured_grid_get_piece(vtkUnstructuredGrid* sself) { return sself->GetPiece(); } +extern "C" int vtk_unstructured_grid_get_number_of_pieces(vtkUnstructuredGrid* sself) { return sself->GetNumberOfPieces(); } +extern "C" int vtk_unstructured_grid_get_ghost_level(vtkUnstructuredGrid* sself) { return sself->GetGhostLevel(); } +extern "C" int vtk_unstructured_grid_is_homogeneous(vtkUnstructuredGrid* sself) { return sself->IsHomogeneous(); } +extern "C" void vtk_unstructured_grid_remove_ghost_cells(vtkUnstructuredGrid* sself) { sself->RemoveGhostCells(); } +extern "C" int vtk_unstructured_grid_initialize_faces_representation(vtkUnstructuredGrid* sself, long long numPrevCells) { return sself->InitializeFacesRepresentation(numPrevCells); } +extern "C" unsigned long vtk_unstructured_grid_get_mesh_m_time(vtkUnstructuredGrid* sself) { return sself->GetMeshMTime(); } +extern "C" vtkUnstructuredGridCellIterator * vtkUnstructuredGridCellIterator_new () {return vtkUnstructuredGridCellIterator :: New () ;} +extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkUnstructuredGridCellIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUnstructuredGridCellIterator_get_ptr (vtkUnstructuredGridCellIterator * sself) {return sself ;} +extern "C" bool vtk_unstructured_grid_cell_iterator_is_done_with_traversal(vtkUnstructuredGridCellIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_unstructured_grid_cell_iterator_get_cell_id(vtkUnstructuredGridCellIterator* sself) { return sself->GetCellId(); } +extern "C" void vtk_unstructured_grid_cell_iterator_go_to_cell(vtkUnstructuredGridCellIterator* sself, long long cellId) { sself->GoToCell(cellId); } +extern "C" vtkVertex * vtkVertex_new () {return vtkVertex :: New () ;} +extern "C" void vtkVertex_destructor (vtkVertex * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkVertex_get_ptr (vtkVertex * sself) {return sself ;} +extern "C" int vtk_vertex_get_cell_type(vtkVertex* sself) { return sself->GetCellType(); } +extern "C" int vtk_vertex_get_cell_dimension(vtkVertex* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_vertex_get_number_of_edges(vtkVertex* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_vertex_get_number_of_faces(vtkVertex* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_vertex_inflate(vtkVertex* sself, double p0) { return sself->Inflate(p0); } +extern "C" vtkVertexListIterator * vtkVertexListIterator_new () {return vtkVertexListIterator :: New () ;} +extern "C" void vtkVertexListIterator_destructor (vtkVertexListIterator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkVertexListIterator_get_ptr (vtkVertexListIterator * sself) {return sself ;} +extern "C" long long vtk_vertex_list_iterator_next(vtkVertexListIterator* sself) { return sself->Next(); } +extern "C" bool vtk_vertex_list_iterator_has_next(vtkVertexListIterator* sself) { return sself->HasNext(); } +extern "C" vtkVoxel * vtkVoxel_new () {return vtkVoxel :: New () ;} +extern "C" void vtkVoxel_destructor (vtkVoxel * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkVoxel_get_ptr (vtkVoxel * sself) {return sself ;} +extern "C" int vtk_voxel_get_cell_type(vtkVoxel* sself) { return sself->GetCellType(); } +extern "C" int vtk_voxel_get_number_of_edges(vtkVoxel* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_voxel_get_number_of_faces(vtkVoxel* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_voxel_inflate(vtkVoxel* sself, double dist) { return sself->Inflate(dist); } +extern "C" vtkWedge * vtkWedge_new () {return vtkWedge :: New () ;} +extern "C" void vtkWedge_destructor (vtkWedge * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkWedge_get_ptr (vtkWedge * sself) {return sself ;} +extern "C" int vtk_wedge_get_cell_type(vtkWedge* sself) { return sself->GetCellType(); } +extern "C" int vtk_wedge_get_number_of_edges(vtkWedge* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_wedge_get_number_of_faces(vtkWedge* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkXMLDataElement * vtkXMLDataElement_new () {return vtkXMLDataElement :: New () ;} +extern "C" void vtkXMLDataElement_destructor (vtkXMLDataElement * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkXMLDataElement_get_ptr (vtkXMLDataElement * sself) {return sself ;} +extern "C" void vtk_xml_data_element_set_name(vtkXMLDataElement* sself, const char* _arg) { sself->SetName(_arg); } +extern "C" void vtk_xml_data_element_set_id(vtkXMLDataElement* sself, const char* _arg) { sself->SetId(_arg); } +extern "C" const char* vtk_xml_data_element_get_attribute(vtkXMLDataElement* sself, const char* name) { return sself->GetAttribute(name); } +extern "C" void vtk_xml_data_element_set_attribute(vtkXMLDataElement* sself, const char* name, const char* value) { sself->SetAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_character_data(vtkXMLDataElement* sself, const char* data, int length) { sself->SetCharacterData(data, length); } +extern "C" void vtk_xml_data_element_add_character_data(vtkXMLDataElement* sself, const char* c, size_t length) { sself->AddCharacterData(c, length); } +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkXMLDataElement* sself, const char* name, int& value) { return sself->GetScalarAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_int_attribute(vtkXMLDataElement* sself, const char* name, int value) { sself->SetIntAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_float_attribute(vtkXMLDataElement* sself, const char* name, float value) { sself->SetFloatAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_double_attribute(vtkXMLDataElement* sself, const char* name, double value) { sself->SetDoubleAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_unsigned_long_attribute(vtkXMLDataElement* sself, const char* name, unsigned long value) { sself->SetUnsignedLongAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_word_type_attribute(vtkXMLDataElement* sself, const char* name, int& value) { return sself->GetWordTypeAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_number_of_attributes(vtkXMLDataElement* sself) { return sself->GetNumberOfAttributes(); } +extern "C" const char* vtk_xml_data_element_get_attribute_name(vtkXMLDataElement* sself, int idx) { return sself->GetAttributeName(idx); } +extern "C" const char* vtk_xml_data_element_get_attribute_value(vtkXMLDataElement* sself, int idx) { return sself->GetAttributeValue(idx); } +extern "C" void vtk_xml_data_element_remove_attribute(vtkXMLDataElement* sself, const char* name) { sself->RemoveAttribute(name); } +extern "C" void vtk_xml_data_element_remove_all_attributes(vtkXMLDataElement* sself) { sself->RemoveAllAttributes(); } +extern "C" int vtk_xml_data_element_get_number_of_nested_elements(vtkXMLDataElement* sself) { return sself->GetNumberOfNestedElements(); } +extern "C" void vtk_xml_data_element_remove_all_nested_elements(vtkXMLDataElement* sself) { sself->RemoveAllNestedElements(); } +extern "C" long long vtk_xml_data_element_get_xml_byte_index(vtkXMLDataElement* sself) { return sself->GetXMLByteIndex(); } +extern "C" void vtk_xml_data_element_set_xml_byte_index(vtkXMLDataElement* sself, long long _arg) { sself->SetXMLByteIndex(_arg); } +extern "C" void vtk_xml_data_element_set_attribute_encoding(vtkXMLDataElement* sself, int _arg) { sself->SetAttributeEncoding(_arg); } +extern "C" int vtk_xml_data_element_get_attribute_encoding_min_value(vtkXMLDataElement* sself) { return sself->GetAttributeEncodingMinValue(); } +extern "C" int vtk_xml_data_element_get_attribute_encoding_max_value(vtkXMLDataElement* sself) { return sself->GetAttributeEncodingMaxValue(); } +extern "C" int vtk_xml_data_element_get_attribute_encoding(vtkXMLDataElement* sself) { return sself->GetAttributeEncoding(); } +extern "C" void vtk_xml_data_element_print_xml(vtkXMLDataElement* sself, const char* fname) { sself->PrintXML(fname); } +extern "C" int vtk_xml_data_element_get_character_data_width(vtkXMLDataElement* sself) { return sself->GetCharacterDataWidth(); } +extern "C" void vtk_xml_data_element_set_character_data_width(vtkXMLDataElement* sself, int _arg) { sself->SetCharacterDataWidth(_arg); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp index 51babc2..1a38179 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp @@ -77,366 +77,319 @@ #include // Implement declared functions -extern "C" vtkNew < vtkAlgorithm > vtkAlgorithm_new () {return vtkNew < vtkAlgorithm > () ;} -extern "C" void vtkAlgorithm_destructor (vtkNew < vtkAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAlgorithm_get_ptr (vtkNew < vtkAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" int vtk_algorithm_has_executive(vtkNew sself) { return sself->HasExecutive(); } -extern "C" int vtk_algorithm_get_number_of_input_ports(vtkNew sself) { return sself->GetNumberOfInputPorts(); } -extern "C" int vtk_algorithm_get_number_of_output_ports(vtkNew sself) { return sself->GetNumberOfOutputPorts(); } -extern "C" void vtk_algorithm_set_abort_execute(vtkNew sself, int _arg) { sself->SetAbortExecute(_arg); } -extern "C" int vtk_algorithm_get_abort_execute(vtkNew sself) { return sself->GetAbortExecute(); } -extern "C" void vtk_algorithm_abort_execute_on(vtkNew sself) { sself->AbortExecuteOn(); } -extern "C" void vtk_algorithm_abort_execute_off(vtkNew sself) { sself->AbortExecuteOff(); } -extern "C" double vtk_algorithm_get_progress(vtkNew sself) { return sself->GetProgress(); } -extern "C" void vtk_algorithm_set_progress(vtkNew sself, double p0) { sself->SetProgress(p0); } -extern "C" void vtk_algorithm_update_progress(vtkNew sself, double amount) { sself->UpdateProgress(amount); } -extern "C" void vtk_algorithm_set_progress_shift_scale(vtkNew sself, double shift, double scale) { sself->SetProgressShiftScale(shift, scale); } -extern "C" double vtk_algorithm_get_progress_shift(vtkNew sself) { return sself->GetProgressShift(); } -extern "C" double vtk_algorithm_get_progress_scale(vtkNew sself) { return sself->GetProgressScale(); } -extern "C" void vtk_algorithm_set_progress_text(vtkNew sself, const char ptext) { sself->SetProgressText(ptext); } -extern "C" char* vtk_algorithm_get_progress_text(vtkNew sself) { return sself->GetProgressText(); } -extern "C" unsigned long vtk_algorithm_get_error_code(vtkNew sself) { return sself->GetErrorCode(); } -extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, int fieldAssociation, const char name) { sself->SetInputArrayToProcess(idx, port, connection, fieldAssociation, name); } -extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, int fieldAssociation, int fieldAttributeType) { sself->SetInputArrayToProcess(idx, port, connection, fieldAssociation, fieldAttributeType); } -extern "C" void vtk_algorithm_set_input_array_to_process(vtkNew sself, int idx, int port, int connection, const char fieldAssociation, const char attributeTypeorName) { sself->SetInputArrayToProcess(idx, port, connection, fieldAssociation, attributeTypeorName); } -extern "C" void vtk_algorithm_remove_all_inputs(vtkNew sself) { sself->RemoveAllInputs(); } -extern "C" void vtk_algorithm_remove_input_connection(vtkNew sself, int port, int idx) { sself->RemoveInputConnection(port, idx); } -extern "C" void vtk_algorithm_remove_all_input_connections(vtkNew sself, int port) { sself->RemoveAllInputConnections(port); } -extern "C" int vtk_algorithm_get_number_of_input_connections(vtkNew sself, int port) { return sself->GetNumberOfInputConnections(port); } -extern "C" int vtk_algorithm_get_total_number_of_input_connections(vtkNew sself) { return sself->GetTotalNumberOfInputConnections(); } -extern "C" void vtk_algorithm_update(vtkNew sself, int port) { sself->Update(port); } -extern "C" void vtk_algorithm_update(vtkNew sself) { sself->Update(); } -extern "C" int vtk_algorithm_update_piece(vtkNew sself, int piece, int numPieces, int ghostLevels, const int extents) { return sself->UpdatePiece(piece, numPieces, ghostLevels, extents); } -extern "C" int vtk_algorithm_update_extent(vtkNew sself, const int extents) { return sself->UpdateExtent(extents); } -extern "C" int vtk_algorithm_update_time_step(vtkNew sself, double time, int piece, int numPieces, int ghostLevels, const int extents) { return sself->UpdateTimeStep(time, piece, numPieces, ghostLevels, extents); } -extern "C" void vtk_algorithm_update_information(vtkNew sself) { sself->UpdateInformation(); } -extern "C" void vtk_algorithm_update_data_object(vtkNew sself) { sself->UpdateDataObject(); } -extern "C" void vtk_algorithm_propagate_update_extent(vtkNew sself) { sself->PropagateUpdateExtent(); } -extern "C" void vtk_algorithm_update_whole_extent(vtkNew sself) { sself->UpdateWholeExtent(); } -extern "C" void vtk_algorithm_convert_total_input_to_port_connection(vtkNew sself, int ind, int port, int conn) { sself->ConvertTotalInputToPortConnection(ind, port, conn); } -extern "C" void vtk_algorithm_set_release_data_flag(vtkNew sself, int p0) { sself->SetReleaseDataFlag(p0); } -extern "C" int vtk_algorithm_get_release_data_flag(vtkNew sself) { return sself->GetReleaseDataFlag(); } -extern "C" void vtk_algorithm_release_data_flag_on(vtkNew sself) { sself->ReleaseDataFlagOn(); } -extern "C" void vtk_algorithm_release_data_flag_off(vtkNew sself) { sself->ReleaseDataFlagOff(); } -extern "C" int* vtk_algorithm_get_update_extent(vtkNew sself) { return sself->GetUpdateExtent(); } -extern "C" int* vtk_algorithm_get_update_extent(vtkNew sself, int port) { return sself->GetUpdateExtent(port); } -extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1) { sself->GetUpdateExtent(x0, x1, y0, y1, z0, z1); } -extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int port, int x0, int x1, int y0, int y1, int z0, int z1) { sself->GetUpdateExtent(port, x0, x1, y0, y1, z0, z1); } -extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int extent) { sself->GetUpdateExtent(extent); } -extern "C" void vtk_algorithm_get_update_extent(vtkNew sself, int port, int extent) { sself->GetUpdateExtent(port, extent); } -extern "C" int vtk_algorithm_get_update_piece(vtkNew sself) { return sself->GetUpdatePiece(); } -extern "C" int vtk_algorithm_get_update_piece(vtkNew sself, int port) { return sself->GetUpdatePiece(port); } -extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkNew sself) { return sself->GetUpdateNumberOfPieces(); } -extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkNew sself, int port) { return sself->GetUpdateNumberOfPieces(port); } -extern "C" int vtk_algorithm_get_update_ghost_level(vtkNew sself) { return sself->GetUpdateGhostLevel(); } -extern "C" int vtk_algorithm_get_update_ghost_level(vtkNew sself, int port) { return sself->GetUpdateGhostLevel(port); } -extern "C" vtkNew < vtkAlgorithmOutput > vtkAlgorithmOutput_new () {return vtkNew < vtkAlgorithmOutput > () ;} -extern "C" void vtkAlgorithmOutput_destructor (vtkNew < vtkAlgorithmOutput > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAlgorithmOutput_get_ptr (vtkNew < vtkAlgorithmOutput > sself) {return sself . GetPointer () ;} -extern "C" void vtk_algorithm_output_set_index(vtkNew sself, int index) { sself->SetIndex(index); } -extern "C" int vtk_algorithm_output_get_index(vtkNew sself) { return sself->GetIndex(); } -extern "C" vtkNew < vtkAnnotationLayersAlgorithm > vtkAnnotationLayersAlgorithm_new () {return vtkNew < vtkAnnotationLayersAlgorithm > () ;} -extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkNew < vtkAnnotationLayersAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAnnotationLayersAlgorithm_get_ptr (vtkNew < vtkAnnotationLayersAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkArrayDataAlgorithm > vtkArrayDataAlgorithm_new () {return vtkNew < vtkArrayDataAlgorithm > () ;} -extern "C" void vtkArrayDataAlgorithm_destructor (vtkNew < vtkArrayDataAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkArrayDataAlgorithm_get_ptr (vtkNew < vtkArrayDataAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCachedStreamingDemandDrivenPipeline > vtkCachedStreamingDemandDrivenPipeline_new () {return vtkNew < vtkCachedStreamingDemandDrivenPipeline > () ;} -extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCachedStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) {return sself . GetPointer () ;} -extern "C" void vtk_cached_streaming_demand_driven_pipeline_set_cache_size(vtkNew sself, int size) { sself->SetCacheSize(size); } -extern "C" int vtk_cached_streaming_demand_driven_pipeline_get_cache_size(vtkNew sself) { return sself->GetCacheSize(); } -extern "C" vtkNew < vtkCastToConcrete > vtkCastToConcrete_new () {return vtkNew < vtkCastToConcrete > () ;} -extern "C" void vtkCastToConcrete_destructor (vtkNew < vtkCastToConcrete > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCastToConcrete_get_ptr (vtkNew < vtkCastToConcrete > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCompositeDataPipeline > vtkCompositeDataPipeline_new () {return vtkNew < vtkCompositeDataPipeline > () ;} -extern "C" void vtkCompositeDataPipeline_destructor (vtkNew < vtkCompositeDataPipeline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCompositeDataPipeline_get_ptr (vtkNew < vtkCompositeDataPipeline > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCompositeDataSetAlgorithm > vtkCompositeDataSetAlgorithm_new () {return vtkNew < vtkCompositeDataSetAlgorithm > () ;} -extern "C" void vtkCompositeDataSetAlgorithm_destructor (vtkNew < vtkCompositeDataSetAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCompositeDataSetAlgorithm_get_ptr (vtkNew < vtkCompositeDataSetAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataObjectAlgorithm > vtkDataObjectAlgorithm_new () {return vtkNew < vtkDataObjectAlgorithm > () ;} -extern "C" void vtkDataObjectAlgorithm_destructor (vtkNew < vtkDataObjectAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataObjectAlgorithm_get_ptr (vtkNew < vtkDataObjectAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataSetAlgorithm > vtkDataSetAlgorithm_new () {return vtkNew < vtkDataSetAlgorithm > () ;} -extern "C" void vtkDataSetAlgorithm_destructor (vtkNew < vtkDataSetAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataSetAlgorithm_get_ptr (vtkNew < vtkDataSetAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDemandDrivenPipeline > vtkDemandDrivenPipeline_new () {return vtkNew < vtkDemandDrivenPipeline > () ;} -extern "C" void vtkDemandDrivenPipeline_destructor (vtkNew < vtkDemandDrivenPipeline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDemandDrivenPipeline_get_ptr (vtkNew < vtkDemandDrivenPipeline > sself) {return sself . GetPointer () ;} -extern "C" unsigned long vtk_demand_driven_pipeline_get_pipeline_m_time(vtkNew sself) { return sself->GetPipelineMTime(); } -extern "C" int vtk_demand_driven_pipeline_set_release_data_flag(vtkNew sself, int port, int n) { return sself->SetReleaseDataFlag(port, n); } -extern "C" int vtk_demand_driven_pipeline_get_release_data_flag(vtkNew sself, int port) { return sself->GetReleaseDataFlag(port); } -extern "C" int vtk_demand_driven_pipeline_update_pipeline_m_time(vtkNew sself) { return sself->UpdatePipelineMTime(); } -extern "C" int vtk_demand_driven_pipeline_update_data_object(vtkNew sself) { return sself->UpdateDataObject(); } -extern "C" int vtk_demand_driven_pipeline_update_data(vtkNew sself, int outputPort) { return sself->UpdateData(outputPort); } -extern "C" vtkNew < vtkDirectedGraphAlgorithm > vtkDirectedGraphAlgorithm_new () {return vtkNew < vtkDirectedGraphAlgorithm > () ;} -extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkNew < vtkDirectedGraphAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDirectedGraphAlgorithm_get_ptr (vtkNew < vtkDirectedGraphAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkEnsembleSource > vtkEnsembleSource_new () {return vtkNew < vtkEnsembleSource > () ;} -extern "C" void vtkEnsembleSource_destructor (vtkNew < vtkEnsembleSource > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEnsembleSource_get_ptr (vtkNew < vtkEnsembleSource > sself) {return sself . GetPointer () ;} -extern "C" void vtk_ensemble_source_remove_all_members(vtkNew sself) { sself->RemoveAllMembers(); } -extern "C" unsigned int vtk_ensemble_source_get_number_of_members(vtkNew sself) { return sself->GetNumberOfMembers(); } -extern "C" void vtk_ensemble_source_set_current_member(vtkNew sself, unsigned int _arg) { sself->SetCurrentMember(_arg); } -extern "C" unsigned int vtk_ensemble_source_get_current_member(vtkNew sself) { return sself->GetCurrentMember(); } -extern "C" vtkNew < vtkExplicitStructuredGridAlgorithm > vtkExplicitStructuredGridAlgorithm_new () {return vtkNew < vtkExplicitStructuredGridAlgorithm > () ;} -extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExplicitStructuredGridAlgorithm_get_ptr (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkExtentRCBPartitioner > vtkExtentRCBPartitioner_new () {return vtkNew < vtkExtentRCBPartitioner > () ;} -extern "C" void vtkExtentRCBPartitioner_destructor (vtkNew < vtkExtentRCBPartitioner > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExtentRCBPartitioner_get_ptr (vtkNew < vtkExtentRCBPartitioner > sself) {return sself . GetPointer () ;} -extern "C" void vtk_extent_rcb_partitioner_set_number_of_partitions(vtkNew sself, const int N) { sself->SetNumberOfPartitions(N); } -extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkNew sself, int imin, int imax, int jmin, int jmax, int kmin, int kmax) { sself->SetGlobalExtent(imin, imax, jmin, jmax, kmin, kmax); } -extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkNew sself, int ext) { sself->SetGlobalExtent(ext); } -extern "C" void vtk_extent_rcb_partitioner_set_duplicate_nodes(vtkNew sself, int _arg) { sself->SetDuplicateNodes(_arg); } -extern "C" int vtk_extent_rcb_partitioner_get_duplicate_nodes(vtkNew sself) { return sself->GetDuplicateNodes(); } -extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_on(vtkNew sself) { sself->DuplicateNodesOn(); } -extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_off(vtkNew sself) { sself->DuplicateNodesOff(); } -extern "C" void vtk_extent_rcb_partitioner_set_number_of_ghost_layers(vtkNew sself, int _arg) { sself->SetNumberOfGhostLayers(_arg); } -extern "C" int vtk_extent_rcb_partitioner_get_number_of_ghost_layers(vtkNew sself) { return sself->GetNumberOfGhostLayers(); } -extern "C" int vtk_extent_rcb_partitioner_get_num_extents(vtkNew sself) { return sself->GetNumExtents(); } -extern "C" void vtk_extent_rcb_partitioner_partition(vtkNew sself) { sself->Partition(); } -extern "C" void vtk_extent_rcb_partitioner_get_partition_extent(vtkNew sself, const int idx, int ext) { sself->GetPartitionExtent(idx, ext); } -extern "C" vtkNew < vtkExtentSplitter > vtkExtentSplitter_new () {return vtkNew < vtkExtentSplitter > () ;} -extern "C" void vtkExtentSplitter_destructor (vtkNew < vtkExtentSplitter > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExtentSplitter_get_ptr (vtkNew < vtkExtentSplitter > sself) {return sself . GetPointer () ;} -extern "C" void vtk_extent_splitter_add_extent_source(vtkNew sself, int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1) { sself->AddExtentSource(id, priority, x0, x1, y0, y1, z0, z1); } -extern "C" void vtk_extent_splitter_add_extent_source(vtkNew sself, int id, int priority, int extent) { sself->AddExtentSource(id, priority, extent); } -extern "C" void vtk_extent_splitter_remove_extent_source(vtkNew sself, int id) { sself->RemoveExtentSource(id); } -extern "C" void vtk_extent_splitter_remove_all_extent_sources(vtkNew sself) { sself->RemoveAllExtentSources(); } -extern "C" void vtk_extent_splitter_add_extent(vtkNew sself, int x0, int x1, int y0, int y1, int z0, int z1) { sself->AddExtent(x0, x1, y0, y1, z0, z1); } -extern "C" void vtk_extent_splitter_add_extent(vtkNew sself, int extent) { sself->AddExtent(extent); } -extern "C" int vtk_extent_splitter_compute_sub_extents(vtkNew sself) { return sself->ComputeSubExtents(); } -extern "C" int vtk_extent_splitter_get_number_of_sub_extents(vtkNew sself) { return sself->GetNumberOfSubExtents(); } -extern "C" int* vtk_extent_splitter_get_sub_extent(vtkNew sself, int index) { return sself->GetSubExtent(index); } -extern "C" void vtk_extent_splitter_get_sub_extent(vtkNew sself, int index, int extent) { sself->GetSubExtent(index, extent); } -extern "C" int vtk_extent_splitter_get_sub_extent_source(vtkNew sself, int index) { return sself->GetSubExtentSource(index); } -extern "C" int vtk_extent_splitter_get_point_mode(vtkNew sself) { return sself->GetPointMode(); } -extern "C" void vtk_extent_splitter_set_point_mode(vtkNew sself, int _arg) { sself->SetPointMode(_arg); } -extern "C" void vtk_extent_splitter_point_mode_on(vtkNew sself) { sself->PointModeOn(); } -extern "C" void vtk_extent_splitter_point_mode_off(vtkNew sself) { sself->PointModeOff(); } -extern "C" vtkNew < vtkExtentTranslator > vtkExtentTranslator_new () {return vtkNew < vtkExtentTranslator > () ;} -extern "C" void vtkExtentTranslator_destructor (vtkNew < vtkExtentTranslator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExtentTranslator_get_ptr (vtkNew < vtkExtentTranslator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_extent_translator_set_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_extent_translator_set_whole_extent(vtkNew sself, const int _arg) { sself->SetWholeExtent(_arg); } -extern "C" int* vtk_extent_translator_get_whole_extent(vtkNew sself) { return sself->GetWholeExtent(); } -extern "C" void vtk_extent_translator_get_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_extent_translator_get_whole_extent(vtkNew sself, int _arg) { sself->GetWholeExtent(_arg); } -extern "C" void vtk_extent_translator_set_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_extent_translator_set_extent(vtkNew sself, const int _arg) { sself->SetExtent(_arg); } -extern "C" int* vtk_extent_translator_get_extent(vtkNew sself) { return sself->GetExtent(); } -extern "C" void vtk_extent_translator_get_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_extent_translator_get_extent(vtkNew sself, int _arg) { sself->GetExtent(_arg); } -extern "C" void vtk_extent_translator_set_piece(vtkNew sself, int _arg) { sself->SetPiece(_arg); } -extern "C" int vtk_extent_translator_get_piece(vtkNew sself) { return sself->GetPiece(); } -extern "C" void vtk_extent_translator_set_number_of_pieces(vtkNew sself, int _arg) { sself->SetNumberOfPieces(_arg); } -extern "C" int vtk_extent_translator_get_number_of_pieces(vtkNew sself) { return sself->GetNumberOfPieces(); } -extern "C" void vtk_extent_translator_set_ghost_level(vtkNew sself, int _arg) { sself->SetGhostLevel(_arg); } -extern "C" int vtk_extent_translator_get_ghost_level(vtkNew sself) { return sself->GetGhostLevel(); } -extern "C" int vtk_extent_translator_piece_to_extent(vtkNew sself) { return sself->PieceToExtent(); } -extern "C" int vtk_extent_translator_piece_to_extent_by_points(vtkNew sself) { return sself->PieceToExtentByPoints(); } -extern "C" int vtk_extent_translator_piece_to_extent_thread_safe(vtkNew sself, int piece, int numPieces, int ghostLevel, int wholeExtent, int resultExtent, int splitMode, int byPoints) { return sself->PieceToExtentThreadSafe(piece, numPieces, ghostLevel, wholeExtent, resultExtent, splitMode, byPoints); } -extern "C" void vtk_extent_translator_set_split_mode_to_block(vtkNew sself) { sself->SetSplitModeToBlock(); } -extern "C" void vtk_extent_translator_set_split_mode_to_x_slab(vtkNew sself) { sself->SetSplitModeToXSlab(); } -extern "C" void vtk_extent_translator_set_split_mode_to_y_slab(vtkNew sself) { sself->SetSplitModeToYSlab(); } -extern "C" void vtk_extent_translator_set_split_mode_to_z_slab(vtkNew sself) { sself->SetSplitModeToZSlab(); } -extern "C" int vtk_extent_translator_get_split_mode(vtkNew sself) { return sself->GetSplitMode(); } -extern "C" void vtk_extent_translator_set_split_path(vtkNew sself, int len, int splitpath) { sself->SetSplitPath(len, splitpath); } -extern "C" vtkNew < vtkGraphAlgorithm > vtkGraphAlgorithm_new () {return vtkNew < vtkGraphAlgorithm > () ;} -extern "C" void vtkGraphAlgorithm_destructor (vtkNew < vtkGraphAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGraphAlgorithm_get_ptr (vtkNew < vtkGraphAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHierarchicalBoxDataSetAlgorithm > vtkHierarchicalBoxDataSetAlgorithm_new () {return vtkNew < vtkHierarchicalBoxDataSetAlgorithm > () ;} -extern "C" void vtkHierarchicalBoxDataSetAlgorithm_destructor (vtkNew < vtkHierarchicalBoxDataSetAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHierarchicalBoxDataSetAlgorithm_get_ptr (vtkNew < vtkHierarchicalBoxDataSetAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImageToStructuredGrid > vtkImageToStructuredGrid_new () {return vtkNew < vtkImageToStructuredGrid > () ;} -extern "C" void vtkImageToStructuredGrid_destructor (vtkNew < vtkImageToStructuredGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImageToStructuredGrid_get_ptr (vtkNew < vtkImageToStructuredGrid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImageToStructuredPoints > vtkImageToStructuredPoints_new () {return vtkNew < vtkImageToStructuredPoints > () ;} -extern "C" void vtkImageToStructuredPoints_destructor (vtkNew < vtkImageToStructuredPoints > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImageToStructuredPoints_get_ptr (vtkNew < vtkImageToStructuredPoints > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMoleculeAlgorithm > vtkMoleculeAlgorithm_new () {return vtkNew < vtkMoleculeAlgorithm > () ;} -extern "C" void vtkMoleculeAlgorithm_destructor (vtkNew < vtkMoleculeAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMoleculeAlgorithm_get_ptr (vtkNew < vtkMoleculeAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMultiBlockDataSetAlgorithm > vtkMultiBlockDataSetAlgorithm_new () {return vtkNew < vtkMultiBlockDataSetAlgorithm > () ;} -extern "C" void vtkMultiBlockDataSetAlgorithm_destructor (vtkNew < vtkMultiBlockDataSetAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMultiBlockDataSetAlgorithm_get_ptr (vtkNew < vtkMultiBlockDataSetAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMultiTimeStepAlgorithm > vtkMultiTimeStepAlgorithm_new () {return vtkNew < vtkMultiTimeStepAlgorithm > () ;} -extern "C" void vtkMultiTimeStepAlgorithm_destructor (vtkNew < vtkMultiTimeStepAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMultiTimeStepAlgorithm_get_ptr (vtkNew < vtkMultiTimeStepAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkNonOverlappingAMRAlgorithm > vtkNonOverlappingAMRAlgorithm_new () {return vtkNew < vtkNonOverlappingAMRAlgorithm > () ;} -extern "C" void vtkNonOverlappingAMRAlgorithm_destructor (vtkNew < vtkNonOverlappingAMRAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkNonOverlappingAMRAlgorithm_get_ptr (vtkNew < vtkNonOverlappingAMRAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOverlappingAMRAlgorithm > vtkOverlappingAMRAlgorithm_new () {return vtkNew < vtkOverlappingAMRAlgorithm > () ;} -extern "C" void vtkOverlappingAMRAlgorithm_destructor (vtkNew < vtkOverlappingAMRAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOverlappingAMRAlgorithm_get_ptr (vtkNew < vtkOverlappingAMRAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPassInputTypeAlgorithm > vtkPassInputTypeAlgorithm_new () {return vtkNew < vtkPassInputTypeAlgorithm > () ;} -extern "C" void vtkPassInputTypeAlgorithm_destructor (vtkNew < vtkPassInputTypeAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPassInputTypeAlgorithm_get_ptr (vtkNew < vtkPassInputTypeAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPiecewiseFunctionAlgorithm > vtkPiecewiseFunctionAlgorithm_new () {return vtkNew < vtkPiecewiseFunctionAlgorithm > () ;} -extern "C" void vtkPiecewiseFunctionAlgorithm_destructor (vtkNew < vtkPiecewiseFunctionAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPiecewiseFunctionAlgorithm_get_ptr (vtkNew < vtkPiecewiseFunctionAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPiecewiseFunctionShiftScale > vtkPiecewiseFunctionShiftScale_new () {return vtkNew < vtkPiecewiseFunctionShiftScale > () ;} -extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkNew < vtkPiecewiseFunctionShiftScale > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPiecewiseFunctionShiftScale_get_ptr (vtkNew < vtkPiecewiseFunctionShiftScale > sself) {return sself . GetPointer () ;} -extern "C" void vtk_piecewise_function_shift_scale_set_position_shift(vtkNew sself, double _arg) { sself->SetPositionShift(_arg); } -extern "C" void vtk_piecewise_function_shift_scale_set_position_scale(vtkNew sself, double _arg) { sself->SetPositionScale(_arg); } -extern "C" void vtk_piecewise_function_shift_scale_set_value_shift(vtkNew sself, double _arg) { sself->SetValueShift(_arg); } -extern "C" void vtk_piecewise_function_shift_scale_set_value_scale(vtkNew sself, double _arg) { sself->SetValueScale(_arg); } -extern "C" double vtk_piecewise_function_shift_scale_get_position_shift(vtkNew sself) { return sself->GetPositionShift(); } -extern "C" double vtk_piecewise_function_shift_scale_get_position_scale(vtkNew sself) { return sself->GetPositionScale(); } -extern "C" double vtk_piecewise_function_shift_scale_get_value_shift(vtkNew sself) { return sself->GetValueShift(); } -extern "C" double vtk_piecewise_function_shift_scale_get_value_scale(vtkNew sself) { return sself->GetValueScale(); } -extern "C" vtkNew < vtkPointSetAlgorithm > vtkPointSetAlgorithm_new () {return vtkNew < vtkPointSetAlgorithm > () ;} -extern "C" void vtkPointSetAlgorithm_destructor (vtkNew < vtkPointSetAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointSetAlgorithm_get_ptr (vtkNew < vtkPointSetAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolyDataAlgorithm > vtkPolyDataAlgorithm_new () {return vtkNew < vtkPolyDataAlgorithm > () ;} -extern "C" void vtkPolyDataAlgorithm_destructor (vtkNew < vtkPolyDataAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyDataAlgorithm_get_ptr (vtkNew < vtkPolyDataAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkProgressObserver > vtkProgressObserver_new () {return vtkNew < vtkProgressObserver > () ;} -extern "C" void vtkProgressObserver_destructor (vtkNew < vtkProgressObserver > sself) {sself . Reset () ; return ;} -extern "C" void * vtkProgressObserver_get_ptr (vtkNew < vtkProgressObserver > sself) {return sself . GetPointer () ;} -extern "C" void vtk_progress_observer_update_progress(vtkNew sself, double amount) { sself->UpdateProgress(amount); } -extern "C" double vtk_progress_observer_get_progress(vtkNew sself) { return sself->GetProgress(); } -extern "C" vtkNew < vtkReaderExecutive > vtkReaderExecutive_new () {return vtkNew < vtkReaderExecutive > () ;} -extern "C" void vtkReaderExecutive_destructor (vtkNew < vtkReaderExecutive > sself) {sself . Reset () ; return ;} -extern "C" void * vtkReaderExecutive_get_ptr (vtkNew < vtkReaderExecutive > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkRectilinearGridAlgorithm > vtkRectilinearGridAlgorithm_new () {return vtkNew < vtkRectilinearGridAlgorithm > () ;} -extern "C" void vtkRectilinearGridAlgorithm_destructor (vtkNew < vtkRectilinearGridAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRectilinearGridAlgorithm_get_ptr (vtkNew < vtkRectilinearGridAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSMPProgressObserver > vtkSMPProgressObserver_new () {return vtkNew < vtkSMPProgressObserver > () ;} -extern "C" void vtkSMPProgressObserver_destructor (vtkNew < vtkSMPProgressObserver > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSMPProgressObserver_get_ptr (vtkNew < vtkSMPProgressObserver > sself) {return sself . GetPointer () ;} -extern "C" void vtk_smp_progress_observer_update_progress(vtkNew sself, double progress) { sself->UpdateProgress(progress); } -extern "C" vtkNew < vtkSelectionAlgorithm > vtkSelectionAlgorithm_new () {return vtkNew < vtkSelectionAlgorithm > () ;} -extern "C" void vtkSelectionAlgorithm_destructor (vtkNew < vtkSelectionAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSelectionAlgorithm_get_ptr (vtkNew < vtkSelectionAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSimpleScalarTree > vtkSimpleScalarTree_new () {return vtkNew < vtkSimpleScalarTree > () ;} -extern "C" void vtkSimpleScalarTree_destructor (vtkNew < vtkSimpleScalarTree > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSimpleScalarTree_get_ptr (vtkNew < vtkSimpleScalarTree > sself) {return sself . GetPointer () ;} -extern "C" void vtk_simple_scalar_tree_set_branching_factor(vtkNew sself, int _arg) { sself->SetBranchingFactor(_arg); } -extern "C" int vtk_simple_scalar_tree_get_branching_factor_min_value(vtkNew sself) { return sself->GetBranchingFactorMinValue(); } -extern "C" int vtk_simple_scalar_tree_get_branching_factor_max_value(vtkNew sself) { return sself->GetBranchingFactorMaxValue(); } -extern "C" int vtk_simple_scalar_tree_get_branching_factor(vtkNew sself) { return sself->GetBranchingFactor(); } -extern "C" int vtk_simple_scalar_tree_get_level(vtkNew sself) { return sself->GetLevel(); } -extern "C" void vtk_simple_scalar_tree_set_max_level(vtkNew sself, int _arg) { sself->SetMaxLevel(_arg); } -extern "C" int vtk_simple_scalar_tree_get_max_level_min_value(vtkNew sself) { return sself->GetMaxLevelMinValue(); } -extern "C" int vtk_simple_scalar_tree_get_max_level_max_value(vtkNew sself) { return sself->GetMaxLevelMaxValue(); } -extern "C" int vtk_simple_scalar_tree_get_max_level(vtkNew sself) { return sself->GetMaxLevel(); } -extern "C" void vtk_simple_scalar_tree_build_tree(vtkNew sself) { sself->BuildTree(); } -extern "C" void vtk_simple_scalar_tree_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_simple_scalar_tree_init_traversal(vtkNew sself, double scalarValue) { sself->InitTraversal(scalarValue); } -extern "C" long long vtk_simple_scalar_tree_get_number_of_cell_batches(vtkNew sself, double scalarValue) { return sself->GetNumberOfCellBatches(scalarValue); } -extern "C" const long long* vtk_simple_scalar_tree_get_cell_batch(vtkNew sself, long long batchNum, long long numCells) { return sself->GetCellBatch(batchNum, numCells); } -extern "C" vtkNew < vtkSpanSpace > vtkSpanSpace_new () {return vtkNew < vtkSpanSpace > () ;} -extern "C" void vtkSpanSpace_destructor (vtkNew < vtkSpanSpace > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSpanSpace_get_ptr (vtkNew < vtkSpanSpace > sself) {return sself . GetPointer () ;} -extern "C" void vtk_span_space_set_scalar_range(vtkNew sself, double _arg1, double _arg2) { sself->SetScalarRange(_arg1, _arg2); } -extern "C" void vtk_span_space_set_scalar_range(vtkNew sself, const double _arg) { sself->SetScalarRange(_arg); } -extern "C" double* vtk_span_space_get_scalar_range(vtkNew sself) { return sself->GetScalarRange(); } -extern "C" void vtk_span_space_get_scalar_range(vtkNew sself, double data) { sself->GetScalarRange(data); } -extern "C" void vtk_span_space_set_compute_scalar_range(vtkNew sself, int _arg) { sself->SetComputeScalarRange(_arg); } -extern "C" int vtk_span_space_get_compute_scalar_range(vtkNew sself) { return sself->GetComputeScalarRange(); } -extern "C" void vtk_span_space_compute_scalar_range_on(vtkNew sself) { sself->ComputeScalarRangeOn(); } -extern "C" void vtk_span_space_compute_scalar_range_off(vtkNew sself) { sself->ComputeScalarRangeOff(); } -extern "C" void vtk_span_space_set_resolution(vtkNew sself, long long _arg) { sself->SetResolution(_arg); } -extern "C" long long vtk_span_space_get_resolution_min_value(vtkNew sself) { return sself->GetResolutionMinValue(); } -extern "C" long long vtk_span_space_get_resolution_max_value(vtkNew sself) { return sself->GetResolutionMaxValue(); } -extern "C" long long vtk_span_space_get_resolution(vtkNew sself) { return sself->GetResolution(); } -extern "C" void vtk_span_space_set_compute_resolution(vtkNew sself, int _arg) { sself->SetComputeResolution(_arg); } -extern "C" int vtk_span_space_get_compute_resolution(vtkNew sself) { return sself->GetComputeResolution(); } -extern "C" void vtk_span_space_compute_resolution_on(vtkNew sself) { sself->ComputeResolutionOn(); } -extern "C" void vtk_span_space_compute_resolution_off(vtkNew sself) { sself->ComputeResolutionOff(); } -extern "C" void vtk_span_space_set_number_of_cells_per_bucket(vtkNew sself, int _arg) { sself->SetNumberOfCellsPerBucket(_arg); } -extern "C" int vtk_span_space_get_number_of_cells_per_bucket_min_value(vtkNew sself) { return sself->GetNumberOfCellsPerBucketMinValue(); } -extern "C" int vtk_span_space_get_number_of_cells_per_bucket_max_value(vtkNew sself) { return sself->GetNumberOfCellsPerBucketMaxValue(); } -extern "C" int vtk_span_space_get_number_of_cells_per_bucket(vtkNew sself) { return sself->GetNumberOfCellsPerBucket(); } -extern "C" void vtk_span_space_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_span_space_build_tree(vtkNew sself) { sself->BuildTree(); } -extern "C" void vtk_span_space_init_traversal(vtkNew sself, double scalarValue) { sself->InitTraversal(scalarValue); } -extern "C" long long vtk_span_space_get_number_of_cell_batches(vtkNew sself, double scalarValue) { return sself->GetNumberOfCellBatches(scalarValue); } -extern "C" const long long* vtk_span_space_get_cell_batch(vtkNew sself, long long batchNum, long long numCells) { return sself->GetCellBatch(batchNum, numCells); } -extern "C" void vtk_span_space_set_batch_size(vtkNew sself, long long _arg) { sself->SetBatchSize(_arg); } -extern "C" long long vtk_span_space_get_batch_size_min_value(vtkNew sself) { return sself->GetBatchSizeMinValue(); } -extern "C" long long vtk_span_space_get_batch_size_max_value(vtkNew sself) { return sself->GetBatchSizeMaxValue(); } -extern "C" long long vtk_span_space_get_batch_size(vtkNew sself) { return sself->GetBatchSize(); } -extern "C" vtkNew < vtkSphereTree > vtkSphereTree_new () {return vtkNew < vtkSphereTree > () ;} -extern "C" void vtkSphereTree_destructor (vtkNew < vtkSphereTree > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSphereTree_get_ptr (vtkNew < vtkSphereTree > sself) {return sself . GetPointer () ;} -extern "C" void vtk_sphere_tree_build(vtkNew sself) { sself->Build(); } -extern "C" void vtk_sphere_tree_set_build_hierarchy(vtkNew sself, bool _arg) { sself->SetBuildHierarchy(_arg); } -extern "C" bool vtk_sphere_tree_get_build_hierarchy(vtkNew sself) { return sself->GetBuildHierarchy(); } -extern "C" void vtk_sphere_tree_build_hierarchy_on(vtkNew sself) { sself->BuildHierarchyOn(); } -extern "C" void vtk_sphere_tree_build_hierarchy_off(vtkNew sself) { sself->BuildHierarchyOff(); } -extern "C" const unsigned char* vtk_sphere_tree_select_point(vtkNew sself, double point, long long numSelected) { return sself->SelectPoint(point, numSelected); } -extern "C" const unsigned char* vtk_sphere_tree_select_line(vtkNew sself, double origin, double ray, long long numSelected) { return sself->SelectLine(origin, ray, numSelected); } -extern "C" const unsigned char* vtk_sphere_tree_select_plane(vtkNew sself, double origin, double normal, long long numSelected) { return sself->SelectPlane(origin, normal, numSelected); } -extern "C" void vtk_sphere_tree_set_resolution(vtkNew sself, int _arg) { sself->SetResolution(_arg); } -extern "C" int vtk_sphere_tree_get_resolution_min_value(vtkNew sself) { return sself->GetResolutionMinValue(); } -extern "C" int vtk_sphere_tree_get_resolution_max_value(vtkNew sself) { return sself->GetResolutionMaxValue(); } -extern "C" int vtk_sphere_tree_get_resolution(vtkNew sself) { return sself->GetResolution(); } -extern "C" void vtk_sphere_tree_set_max_level(vtkNew sself, int _arg) { sself->SetMaxLevel(_arg); } -extern "C" int vtk_sphere_tree_get_max_level_min_value(vtkNew sself) { return sself->GetMaxLevelMinValue(); } -extern "C" int vtk_sphere_tree_get_max_level_max_value(vtkNew sself) { return sself->GetMaxLevelMaxValue(); } -extern "C" int vtk_sphere_tree_get_max_level(vtkNew sself) { return sself->GetMaxLevel(); } -extern "C" int vtk_sphere_tree_get_number_of_levels(vtkNew sself) { return sself->GetNumberOfLevels(); } -extern "C" const double* vtk_sphere_tree_get_cell_spheres(vtkNew sself) { return sself->GetCellSpheres(); } -extern "C" const double* vtk_sphere_tree_get_tree_spheres(vtkNew sself, int level, long long numSpheres) { return sself->GetTreeSpheres(level, numSpheres); } -extern "C" vtkNew < vtkStreamingDemandDrivenPipeline > vtkStreamingDemandDrivenPipeline_new () {return vtkNew < vtkStreamingDemandDrivenPipeline > () ;} -extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkNew < vtkStreamingDemandDrivenPipeline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkStreamingDemandDrivenPipeline > sself) {return sself . GetPointer () ;} -extern "C" int vtk_streaming_demand_driven_pipeline_update(vtkNew sself) { return sself->Update(); } -extern "C" int vtk_streaming_demand_driven_pipeline_update_whole_extent(vtkNew sself) { return sself->UpdateWholeExtent(); } -extern "C" int vtk_streaming_demand_driven_pipeline_propagate_update_extent(vtkNew sself, int outputPort) { return sself->PropagateUpdateExtent(outputPort); } -extern "C" int vtk_streaming_demand_driven_pipeline_propagate_time(vtkNew sself, int outputPort) { return sself->PropagateTime(outputPort); } -extern "C" int vtk_streaming_demand_driven_pipeline_update_time_dependent_information(vtkNew sself, int outputPort) { return sself->UpdateTimeDependentInformation(outputPort); } -extern "C" int vtk_streaming_demand_driven_pipeline_set_request_exact_extent(vtkNew sself, int port, int flag) { return sself->SetRequestExactExtent(port, flag); } -extern "C" int vtk_streaming_demand_driven_pipeline_get_request_exact_extent(vtkNew sself, int port) { return sself->GetRequestExactExtent(port); } -extern "C" vtkNew < vtkStructuredGridAlgorithm > vtkStructuredGridAlgorithm_new () {return vtkNew < vtkStructuredGridAlgorithm > () ;} -extern "C" void vtkStructuredGridAlgorithm_destructor (vtkNew < vtkStructuredGridAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStructuredGridAlgorithm_get_ptr (vtkNew < vtkStructuredGridAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTableAlgorithm > vtkTableAlgorithm_new () {return vtkNew < vtkTableAlgorithm > () ;} -extern "C" void vtkTableAlgorithm_destructor (vtkNew < vtkTableAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTableAlgorithm_get_ptr (vtkNew < vtkTableAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkThreadedCompositeDataPipeline > vtkThreadedCompositeDataPipeline_new () {return vtkNew < vtkThreadedCompositeDataPipeline > () ;} -extern "C" void vtkThreadedCompositeDataPipeline_destructor (vtkNew < vtkThreadedCompositeDataPipeline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkThreadedCompositeDataPipeline_get_ptr (vtkNew < vtkThreadedCompositeDataPipeline > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTreeAlgorithm > vtkTreeAlgorithm_new () {return vtkNew < vtkTreeAlgorithm > () ;} -extern "C" void vtkTreeAlgorithm_destructor (vtkNew < vtkTreeAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTreeAlgorithm_get_ptr (vtkNew < vtkTreeAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTrivialConsumer > vtkTrivialConsumer_new () {return vtkNew < vtkTrivialConsumer > () ;} -extern "C" void vtkTrivialConsumer_destructor (vtkNew < vtkTrivialConsumer > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTrivialConsumer_get_ptr (vtkNew < vtkTrivialConsumer > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTrivialProducer > vtkTrivialProducer_new () {return vtkNew < vtkTrivialProducer > () ;} -extern "C" void vtkTrivialProducer_destructor (vtkNew < vtkTrivialProducer > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTrivialProducer_get_ptr (vtkNew < vtkTrivialProducer > sself) {return sself . GetPointer () ;} -extern "C" unsigned long vtk_trivial_producer_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_trivial_producer_set_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_trivial_producer_set_whole_extent(vtkNew sself, const int _arg) { sself->SetWholeExtent(_arg); } -extern "C" int* vtk_trivial_producer_get_whole_extent(vtkNew sself) { return sself->GetWholeExtent(); } -extern "C" void vtk_trivial_producer_get_whole_extent(vtkNew sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->GetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } -extern "C" void vtk_trivial_producer_get_whole_extent(vtkNew sself, int _arg) { sself->GetWholeExtent(_arg); } -extern "C" vtkNew < vtkUndirectedGraphAlgorithm > vtkUndirectedGraphAlgorithm_new () {return vtkNew < vtkUndirectedGraphAlgorithm > () ;} -extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkNew < vtkUndirectedGraphAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUndirectedGraphAlgorithm_get_ptr (vtkNew < vtkUndirectedGraphAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUniformGridAMRAlgorithm > vtkUniformGridAMRAlgorithm_new () {return vtkNew < vtkUniformGridAMRAlgorithm > () ;} -extern "C" void vtkUniformGridAMRAlgorithm_destructor (vtkNew < vtkUniformGridAMRAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformGridAMRAlgorithm_get_ptr (vtkNew < vtkUniformGridAMRAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUniformGridPartitioner > vtkUniformGridPartitioner_new () {return vtkNew < vtkUniformGridPartitioner > () ;} -extern "C" void vtkUniformGridPartitioner_destructor (vtkNew < vtkUniformGridPartitioner > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformGridPartitioner_get_ptr (vtkNew < vtkUniformGridPartitioner > sself) {return sself . GetPointer () ;} -extern "C" int vtk_uniform_grid_partitioner_get_number_of_partitions(vtkNew sself) { return sself->GetNumberOfPartitions(); } -extern "C" void vtk_uniform_grid_partitioner_set_number_of_partitions(vtkNew sself, int _arg) { sself->SetNumberOfPartitions(_arg); } -extern "C" int vtk_uniform_grid_partitioner_get_number_of_ghost_layers(vtkNew sself) { return sself->GetNumberOfGhostLayers(); } -extern "C" void vtk_uniform_grid_partitioner_set_number_of_ghost_layers(vtkNew sself, int _arg) { sself->SetNumberOfGhostLayers(_arg); } -extern "C" int vtk_uniform_grid_partitioner_get_duplicate_nodes(vtkNew sself) { return sself->GetDuplicateNodes(); } -extern "C" void vtk_uniform_grid_partitioner_set_duplicate_nodes(vtkNew sself, int _arg) { sself->SetDuplicateNodes(_arg); } -extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_on(vtkNew sself) { sself->DuplicateNodesOn(); } -extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_off(vtkNew sself) { sself->DuplicateNodesOff(); } -extern "C" vtkNew < vtkUnstructuredGridAlgorithm > vtkUnstructuredGridAlgorithm_new () {return vtkNew < vtkUnstructuredGridAlgorithm > () ;} -extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkNew < vtkUnstructuredGridAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnstructuredGridAlgorithm_get_ptr (vtkNew < vtkUnstructuredGridAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnstructuredGridBaseAlgorithm > vtkUnstructuredGridBaseAlgorithm_new () {return vtkNew < vtkUnstructuredGridBaseAlgorithm > () ;} -extern "C" void vtkUnstructuredGridBaseAlgorithm_destructor (vtkNew < vtkUnstructuredGridBaseAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnstructuredGridBaseAlgorithm_get_ptr (vtkNew < vtkUnstructuredGridBaseAlgorithm > sself) {return sself . GetPointer () ;} +extern "C" vtkAlgorithm * vtkAlgorithm_new () {return vtkAlgorithm :: New () ;} +extern "C" void vtkAlgorithm_destructor (vtkAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAlgorithm_get_ptr (vtkAlgorithm * sself) {return sself ;} +extern "C" int vtk_algorithm_has_executive(vtkAlgorithm* sself) { return sself->HasExecutive(); } +extern "C" int vtk_algorithm_get_number_of_input_ports(vtkAlgorithm* sself) { return sself->GetNumberOfInputPorts(); } +extern "C" int vtk_algorithm_get_number_of_output_ports(vtkAlgorithm* sself) { return sself->GetNumberOfOutputPorts(); } +extern "C" void vtk_algorithm_set_abort_execute(vtkAlgorithm* sself, int _arg) { sself->SetAbortExecute(_arg); } +extern "C" int vtk_algorithm_get_abort_execute(vtkAlgorithm* sself) { return sself->GetAbortExecute(); } +extern "C" void vtk_algorithm_abort_execute_on(vtkAlgorithm* sself) { sself->AbortExecuteOn(); } +extern "C" void vtk_algorithm_abort_execute_off(vtkAlgorithm* sself) { sself->AbortExecuteOff(); } +extern "C" double vtk_algorithm_get_progress(vtkAlgorithm* sself) { return sself->GetProgress(); } +extern "C" void vtk_algorithm_set_progress(vtkAlgorithm* sself, double p0) { sself->SetProgress(p0); } +extern "C" void vtk_algorithm_update_progress(vtkAlgorithm* sself, double amount) { sself->UpdateProgress(amount); } +extern "C" void vtk_algorithm_set_progress_shift_scale(vtkAlgorithm* sself, double shift, double scale) { sself->SetProgressShiftScale(shift, scale); } +extern "C" double vtk_algorithm_get_progress_shift(vtkAlgorithm* sself) { return sself->GetProgressShift(); } +extern "C" double vtk_algorithm_get_progress_scale(vtkAlgorithm* sself) { return sself->GetProgressScale(); } +extern "C" void vtk_algorithm_set_progress_text(vtkAlgorithm* sself, const char* ptext) { sself->SetProgressText(ptext); } +extern "C" unsigned long vtk_algorithm_get_error_code(vtkAlgorithm* sself) { return sself->GetErrorCode(); } +extern "C" void vtk_algorithm_set_input_array_to_process(vtkAlgorithm* sself, int idx, int port, int connection, int fieldAssociation, const char* name) { sself->SetInputArrayToProcess(idx, port, connection, fieldAssociation, name); } +extern "C" void vtk_algorithm_remove_all_inputs(vtkAlgorithm* sself) { sself->RemoveAllInputs(); } +extern "C" void vtk_algorithm_remove_all_input_connections(vtkAlgorithm* sself, int port) { sself->RemoveAllInputConnections(port); } +extern "C" int vtk_algorithm_get_number_of_input_connections(vtkAlgorithm* sself, int port) { return sself->GetNumberOfInputConnections(port); } +extern "C" int vtk_algorithm_get_total_number_of_input_connections(vtkAlgorithm* sself) { return sself->GetTotalNumberOfInputConnections(); } +extern "C" void vtk_algorithm_update(vtkAlgorithm* sself, int port) { sself->Update(port); } +extern "C" void vtk_algorithm_update_information(vtkAlgorithm* sself) { sself->UpdateInformation(); } +extern "C" void vtk_algorithm_update_data_object(vtkAlgorithm* sself) { sself->UpdateDataObject(); } +extern "C" void vtk_algorithm_propagate_update_extent(vtkAlgorithm* sself) { sself->PropagateUpdateExtent(); } +extern "C" void vtk_algorithm_update_whole_extent(vtkAlgorithm* sself) { sself->UpdateWholeExtent(); } +extern "C" void vtk_algorithm_convert_total_input_to_port_connection(vtkAlgorithm* sself, int ind, int& port, int& conn) { sself->ConvertTotalInputToPortConnection(ind, port, conn); } +extern "C" void vtk_algorithm_set_release_data_flag(vtkAlgorithm* sself, int p0) { sself->SetReleaseDataFlag(p0); } +extern "C" int vtk_algorithm_get_release_data_flag(vtkAlgorithm* sself) { return sself->GetReleaseDataFlag(); } +extern "C" void vtk_algorithm_release_data_flag_on(vtkAlgorithm* sself) { sself->ReleaseDataFlagOn(); } +extern "C" void vtk_algorithm_release_data_flag_off(vtkAlgorithm* sself) { sself->ReleaseDataFlagOff(); } +extern "C" int vtk_algorithm_get_update_piece(vtkAlgorithm* sself) { return sself->GetUpdatePiece(); } +extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkAlgorithm* sself) { return sself->GetUpdateNumberOfPieces(); } +extern "C" int vtk_algorithm_get_update_ghost_level(vtkAlgorithm* sself) { return sself->GetUpdateGhostLevel(); } +extern "C" vtkAlgorithmOutput * vtkAlgorithmOutput_new () {return vtkAlgorithmOutput :: New () ;} +extern "C" void vtkAlgorithmOutput_destructor (vtkAlgorithmOutput * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAlgorithmOutput_get_ptr (vtkAlgorithmOutput * sself) {return sself ;} +extern "C" void vtk_algorithm_output_set_index(vtkAlgorithmOutput* sself, int index) { sself->SetIndex(index); } +extern "C" int vtk_algorithm_output_get_index(vtkAlgorithmOutput* sself) { return sself->GetIndex(); } +extern "C" vtkAnnotationLayersAlgorithm * vtkAnnotationLayersAlgorithm_new () {return vtkAnnotationLayersAlgorithm :: New () ;} +extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkAnnotationLayersAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAnnotationLayersAlgorithm_get_ptr (vtkAnnotationLayersAlgorithm * sself) {return sself ;} +extern "C" vtkArrayDataAlgorithm * vtkArrayDataAlgorithm_new () {return vtkArrayDataAlgorithm :: New () ;} +extern "C" void vtkArrayDataAlgorithm_destructor (vtkArrayDataAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkArrayDataAlgorithm_get_ptr (vtkArrayDataAlgorithm * sself) {return sself ;} +extern "C" vtkCachedStreamingDemandDrivenPipeline * vtkCachedStreamingDemandDrivenPipeline_new () {return vtkCachedStreamingDemandDrivenPipeline :: New () ;} +extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkCachedStreamingDemandDrivenPipeline * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCachedStreamingDemandDrivenPipeline_get_ptr (vtkCachedStreamingDemandDrivenPipeline * sself) {return sself ;} +extern "C" void vtk_cached_streaming_demand_driven_pipeline_set_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself, int size) { sself->SetCacheSize(size); } +extern "C" int vtk_cached_streaming_demand_driven_pipeline_get_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself) { return sself->GetCacheSize(); } +extern "C" vtkCastToConcrete * vtkCastToConcrete_new () {return vtkCastToConcrete :: New () ;} +extern "C" void vtkCastToConcrete_destructor (vtkCastToConcrete * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCastToConcrete_get_ptr (vtkCastToConcrete * sself) {return sself ;} +extern "C" vtkCompositeDataPipeline * vtkCompositeDataPipeline_new () {return vtkCompositeDataPipeline :: New () ;} +extern "C" void vtkCompositeDataPipeline_destructor (vtkCompositeDataPipeline * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCompositeDataPipeline_get_ptr (vtkCompositeDataPipeline * sself) {return sself ;} +extern "C" vtkCompositeDataSetAlgorithm * vtkCompositeDataSetAlgorithm_new () {return vtkCompositeDataSetAlgorithm :: New () ;} +extern "C" void vtkCompositeDataSetAlgorithm_destructor (vtkCompositeDataSetAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCompositeDataSetAlgorithm_get_ptr (vtkCompositeDataSetAlgorithm * sself) {return sself ;} +extern "C" vtkDataObjectAlgorithm * vtkDataObjectAlgorithm_new () {return vtkDataObjectAlgorithm :: New () ;} +extern "C" void vtkDataObjectAlgorithm_destructor (vtkDataObjectAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataObjectAlgorithm_get_ptr (vtkDataObjectAlgorithm * sself) {return sself ;} +extern "C" vtkDataSetAlgorithm * vtkDataSetAlgorithm_new () {return vtkDataSetAlgorithm :: New () ;} +extern "C" void vtkDataSetAlgorithm_destructor (vtkDataSetAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDataSetAlgorithm_get_ptr (vtkDataSetAlgorithm * sself) {return sself ;} +extern "C" vtkDemandDrivenPipeline * vtkDemandDrivenPipeline_new () {return vtkDemandDrivenPipeline :: New () ;} +extern "C" void vtkDemandDrivenPipeline_destructor (vtkDemandDrivenPipeline * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDemandDrivenPipeline_get_ptr (vtkDemandDrivenPipeline * sself) {return sself ;} +extern "C" unsigned long vtk_demand_driven_pipeline_get_pipeline_m_time(vtkDemandDrivenPipeline* sself) { return sself->GetPipelineMTime(); } +extern "C" int vtk_demand_driven_pipeline_set_release_data_flag(vtkDemandDrivenPipeline* sself, int port, int n) { return sself->SetReleaseDataFlag(port, n); } +extern "C" int vtk_demand_driven_pipeline_get_release_data_flag(vtkDemandDrivenPipeline* sself, int port) { return sself->GetReleaseDataFlag(port); } +extern "C" int vtk_demand_driven_pipeline_update_pipeline_m_time(vtkDemandDrivenPipeline* sself) { return sself->UpdatePipelineMTime(); } +extern "C" int vtk_demand_driven_pipeline_update_data_object(vtkDemandDrivenPipeline* sself) { return sself->UpdateDataObject(); } +extern "C" int vtk_demand_driven_pipeline_update_data(vtkDemandDrivenPipeline* sself, int outputPort) { return sself->UpdateData(outputPort); } +extern "C" vtkDirectedGraphAlgorithm * vtkDirectedGraphAlgorithm_new () {return vtkDirectedGraphAlgorithm :: New () ;} +extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkDirectedGraphAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDirectedGraphAlgorithm_get_ptr (vtkDirectedGraphAlgorithm * sself) {return sself ;} +extern "C" vtkEnsembleSource * vtkEnsembleSource_new () {return vtkEnsembleSource :: New () ;} +extern "C" void vtkEnsembleSource_destructor (vtkEnsembleSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkEnsembleSource_get_ptr (vtkEnsembleSource * sself) {return sself ;} +extern "C" void vtk_ensemble_source_remove_all_members(vtkEnsembleSource* sself) { sself->RemoveAllMembers(); } +extern "C" unsigned int vtk_ensemble_source_get_number_of_members(vtkEnsembleSource* sself) { return sself->GetNumberOfMembers(); } +extern "C" void vtk_ensemble_source_set_current_member(vtkEnsembleSource* sself, unsigned int _arg) { sself->SetCurrentMember(_arg); } +extern "C" unsigned int vtk_ensemble_source_get_current_member(vtkEnsembleSource* sself) { return sself->GetCurrentMember(); } +extern "C" vtkExplicitStructuredGridAlgorithm * vtkExplicitStructuredGridAlgorithm_new () {return vtkExplicitStructuredGridAlgorithm :: New () ;} +extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkExplicitStructuredGridAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkExplicitStructuredGridAlgorithm_get_ptr (vtkExplicitStructuredGridAlgorithm * sself) {return sself ;} +extern "C" vtkExtentRCBPartitioner * vtkExtentRCBPartitioner_new () {return vtkExtentRCBPartitioner :: New () ;} +extern "C" void vtkExtentRCBPartitioner_destructor (vtkExtentRCBPartitioner * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkExtentRCBPartitioner_get_ptr (vtkExtentRCBPartitioner * sself) {return sself ;} +extern "C" void vtk_extent_rcb_partitioner_set_number_of_partitions(vtkExtentRCBPartitioner* sself, const int N) { sself->SetNumberOfPartitions(N); } +extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkExtentRCBPartitioner* sself, int imin, int imax, int jmin, int jmax, int kmin, int kmax) { sself->SetGlobalExtent(imin, imax, jmin, jmax, kmin, kmax); } +extern "C" void vtk_extent_rcb_partitioner_set_duplicate_nodes(vtkExtentRCBPartitioner* sself, int _arg) { sself->SetDuplicateNodes(_arg); } +extern "C" int vtk_extent_rcb_partitioner_get_duplicate_nodes(vtkExtentRCBPartitioner* sself) { return sself->GetDuplicateNodes(); } +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_on(vtkExtentRCBPartitioner* sself) { sself->DuplicateNodesOn(); } +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_off(vtkExtentRCBPartitioner* sself) { sself->DuplicateNodesOff(); } +extern "C" void vtk_extent_rcb_partitioner_set_number_of_ghost_layers(vtkExtentRCBPartitioner* sself, int _arg) { sself->SetNumberOfGhostLayers(_arg); } +extern "C" int vtk_extent_rcb_partitioner_get_number_of_ghost_layers(vtkExtentRCBPartitioner* sself) { return sself->GetNumberOfGhostLayers(); } +extern "C" int vtk_extent_rcb_partitioner_get_num_extents(vtkExtentRCBPartitioner* sself) { return sself->GetNumExtents(); } +extern "C" void vtk_extent_rcb_partitioner_partition(vtkExtentRCBPartitioner* sself) { sself->Partition(); } +extern "C" vtkExtentSplitter * vtkExtentSplitter_new () {return vtkExtentSplitter :: New () ;} +extern "C" void vtkExtentSplitter_destructor (vtkExtentSplitter * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkExtentSplitter_get_ptr (vtkExtentSplitter * sself) {return sself ;} +extern "C" void vtk_extent_splitter_add_extent_source(vtkExtentSplitter* sself, int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1) { sself->AddExtentSource(id, priority, x0, x1, y0, y1, z0, z1); } +extern "C" void vtk_extent_splitter_remove_extent_source(vtkExtentSplitter* sself, int id) { sself->RemoveExtentSource(id); } +extern "C" void vtk_extent_splitter_remove_all_extent_sources(vtkExtentSplitter* sself) { sself->RemoveAllExtentSources(); } +extern "C" void vtk_extent_splitter_add_extent(vtkExtentSplitter* sself, int x0, int x1, int y0, int y1, int z0, int z1) { sself->AddExtent(x0, x1, y0, y1, z0, z1); } +extern "C" int vtk_extent_splitter_compute_sub_extents(vtkExtentSplitter* sself) { return sself->ComputeSubExtents(); } +extern "C" int vtk_extent_splitter_get_number_of_sub_extents(vtkExtentSplitter* sself) { return sself->GetNumberOfSubExtents(); } +extern "C" int vtk_extent_splitter_get_sub_extent_source(vtkExtentSplitter* sself, int index) { return sself->GetSubExtentSource(index); } +extern "C" int vtk_extent_splitter_get_point_mode(vtkExtentSplitter* sself) { return sself->GetPointMode(); } +extern "C" void vtk_extent_splitter_set_point_mode(vtkExtentSplitter* sself, int _arg) { sself->SetPointMode(_arg); } +extern "C" void vtk_extent_splitter_point_mode_on(vtkExtentSplitter* sself) { sself->PointModeOn(); } +extern "C" void vtk_extent_splitter_point_mode_off(vtkExtentSplitter* sself) { sself->PointModeOff(); } +extern "C" vtkExtentTranslator * vtkExtentTranslator_new () {return vtkExtentTranslator :: New () ;} +extern "C" void vtkExtentTranslator_destructor (vtkExtentTranslator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkExtentTranslator_get_ptr (vtkExtentTranslator * sself) {return sself ;} +extern "C" void vtk_extent_translator_set_whole_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_extent_translator_set_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_extent_translator_set_piece(vtkExtentTranslator* sself, int _arg) { sself->SetPiece(_arg); } +extern "C" int vtk_extent_translator_get_piece(vtkExtentTranslator* sself) { return sself->GetPiece(); } +extern "C" void vtk_extent_translator_set_number_of_pieces(vtkExtentTranslator* sself, int _arg) { sself->SetNumberOfPieces(_arg); } +extern "C" int vtk_extent_translator_get_number_of_pieces(vtkExtentTranslator* sself) { return sself->GetNumberOfPieces(); } +extern "C" void vtk_extent_translator_set_ghost_level(vtkExtentTranslator* sself, int _arg) { sself->SetGhostLevel(_arg); } +extern "C" int vtk_extent_translator_get_ghost_level(vtkExtentTranslator* sself) { return sself->GetGhostLevel(); } +extern "C" int vtk_extent_translator_piece_to_extent(vtkExtentTranslator* sself) { return sself->PieceToExtent(); } +extern "C" int vtk_extent_translator_piece_to_extent_by_points(vtkExtentTranslator* sself) { return sself->PieceToExtentByPoints(); } +extern "C" void vtk_extent_translator_set_split_mode_to_block(vtkExtentTranslator* sself) { sself->SetSplitModeToBlock(); } +extern "C" void vtk_extent_translator_set_split_mode_to_x_slab(vtkExtentTranslator* sself) { sself->SetSplitModeToXSlab(); } +extern "C" void vtk_extent_translator_set_split_mode_to_y_slab(vtkExtentTranslator* sself) { sself->SetSplitModeToYSlab(); } +extern "C" void vtk_extent_translator_set_split_mode_to_z_slab(vtkExtentTranslator* sself) { sself->SetSplitModeToZSlab(); } +extern "C" int vtk_extent_translator_get_split_mode(vtkExtentTranslator* sself) { return sself->GetSplitMode(); } +extern "C" vtkGraphAlgorithm * vtkGraphAlgorithm_new () {return vtkGraphAlgorithm :: New () ;} +extern "C" void vtkGraphAlgorithm_destructor (vtkGraphAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGraphAlgorithm_get_ptr (vtkGraphAlgorithm * sself) {return sself ;} +extern "C" vtkHierarchicalBoxDataSetAlgorithm * vtkHierarchicalBoxDataSetAlgorithm_new () {return vtkHierarchicalBoxDataSetAlgorithm :: New () ;} +extern "C" void vtkHierarchicalBoxDataSetAlgorithm_destructor (vtkHierarchicalBoxDataSetAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHierarchicalBoxDataSetAlgorithm_get_ptr (vtkHierarchicalBoxDataSetAlgorithm * sself) {return sself ;} +extern "C" vtkImageToStructuredGrid * vtkImageToStructuredGrid_new () {return vtkImageToStructuredGrid :: New () ;} +extern "C" void vtkImageToStructuredGrid_destructor (vtkImageToStructuredGrid * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImageToStructuredGrid_get_ptr (vtkImageToStructuredGrid * sself) {return sself ;} +extern "C" vtkImageToStructuredPoints * vtkImageToStructuredPoints_new () {return vtkImageToStructuredPoints :: New () ;} +extern "C" void vtkImageToStructuredPoints_destructor (vtkImageToStructuredPoints * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkImageToStructuredPoints_get_ptr (vtkImageToStructuredPoints * sself) {return sself ;} +extern "C" vtkMoleculeAlgorithm * vtkMoleculeAlgorithm_new () {return vtkMoleculeAlgorithm :: New () ;} +extern "C" void vtkMoleculeAlgorithm_destructor (vtkMoleculeAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMoleculeAlgorithm_get_ptr (vtkMoleculeAlgorithm * sself) {return sself ;} +extern "C" vtkMultiBlockDataSetAlgorithm * vtkMultiBlockDataSetAlgorithm_new () {return vtkMultiBlockDataSetAlgorithm :: New () ;} +extern "C" void vtkMultiBlockDataSetAlgorithm_destructor (vtkMultiBlockDataSetAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMultiBlockDataSetAlgorithm_get_ptr (vtkMultiBlockDataSetAlgorithm * sself) {return sself ;} +extern "C" vtkMultiTimeStepAlgorithm * vtkMultiTimeStepAlgorithm_new () {return vtkMultiTimeStepAlgorithm :: New () ;} +extern "C" void vtkMultiTimeStepAlgorithm_destructor (vtkMultiTimeStepAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMultiTimeStepAlgorithm_get_ptr (vtkMultiTimeStepAlgorithm * sself) {return sself ;} +extern "C" vtkNonOverlappingAMRAlgorithm * vtkNonOverlappingAMRAlgorithm_new () {return vtkNonOverlappingAMRAlgorithm :: New () ;} +extern "C" void vtkNonOverlappingAMRAlgorithm_destructor (vtkNonOverlappingAMRAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkNonOverlappingAMRAlgorithm_get_ptr (vtkNonOverlappingAMRAlgorithm * sself) {return sself ;} +extern "C" vtkOverlappingAMRAlgorithm * vtkOverlappingAMRAlgorithm_new () {return vtkOverlappingAMRAlgorithm :: New () ;} +extern "C" void vtkOverlappingAMRAlgorithm_destructor (vtkOverlappingAMRAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOverlappingAMRAlgorithm_get_ptr (vtkOverlappingAMRAlgorithm * sself) {return sself ;} +extern "C" vtkPassInputTypeAlgorithm * vtkPassInputTypeAlgorithm_new () {return vtkPassInputTypeAlgorithm :: New () ;} +extern "C" void vtkPassInputTypeAlgorithm_destructor (vtkPassInputTypeAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPassInputTypeAlgorithm_get_ptr (vtkPassInputTypeAlgorithm * sself) {return sself ;} +extern "C" vtkPiecewiseFunctionAlgorithm * vtkPiecewiseFunctionAlgorithm_new () {return vtkPiecewiseFunctionAlgorithm :: New () ;} +extern "C" void vtkPiecewiseFunctionAlgorithm_destructor (vtkPiecewiseFunctionAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPiecewiseFunctionAlgorithm_get_ptr (vtkPiecewiseFunctionAlgorithm * sself) {return sself ;} +extern "C" vtkPiecewiseFunctionShiftScale * vtkPiecewiseFunctionShiftScale_new () {return vtkPiecewiseFunctionShiftScale :: New () ;} +extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkPiecewiseFunctionShiftScale * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPiecewiseFunctionShiftScale_get_ptr (vtkPiecewiseFunctionShiftScale * sself) {return sself ;} +extern "C" void vtk_piecewise_function_shift_scale_set_position_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetPositionShift(_arg); } +extern "C" void vtk_piecewise_function_shift_scale_set_position_scale(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetPositionScale(_arg); } +extern "C" void vtk_piecewise_function_shift_scale_set_value_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetValueShift(_arg); } +extern "C" void vtk_piecewise_function_shift_scale_set_value_scale(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetValueScale(_arg); } +extern "C" double vtk_piecewise_function_shift_scale_get_position_shift(vtkPiecewiseFunctionShiftScale* sself) { return sself->GetPositionShift(); } +extern "C" double vtk_piecewise_function_shift_scale_get_position_scale(vtkPiecewiseFunctionShiftScale* sself) { return sself->GetPositionScale(); } +extern "C" double vtk_piecewise_function_shift_scale_get_value_shift(vtkPiecewiseFunctionShiftScale* sself) { return sself->GetValueShift(); } +extern "C" double vtk_piecewise_function_shift_scale_get_value_scale(vtkPiecewiseFunctionShiftScale* sself) { return sself->GetValueScale(); } +extern "C" vtkPointSetAlgorithm * vtkPointSetAlgorithm_new () {return vtkPointSetAlgorithm :: New () ;} +extern "C" void vtkPointSetAlgorithm_destructor (vtkPointSetAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPointSetAlgorithm_get_ptr (vtkPointSetAlgorithm * sself) {return sself ;} +extern "C" vtkPolyDataAlgorithm * vtkPolyDataAlgorithm_new () {return vtkPolyDataAlgorithm :: New () ;} +extern "C" void vtkPolyDataAlgorithm_destructor (vtkPolyDataAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolyDataAlgorithm_get_ptr (vtkPolyDataAlgorithm * sself) {return sself ;} +extern "C" vtkProgressObserver * vtkProgressObserver_new () {return vtkProgressObserver :: New () ;} +extern "C" void vtkProgressObserver_destructor (vtkProgressObserver * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkProgressObserver_get_ptr (vtkProgressObserver * sself) {return sself ;} +extern "C" void vtk_progress_observer_update_progress(vtkProgressObserver* sself, double amount) { sself->UpdateProgress(amount); } +extern "C" double vtk_progress_observer_get_progress(vtkProgressObserver* sself) { return sself->GetProgress(); } +extern "C" vtkReaderExecutive * vtkReaderExecutive_new () {return vtkReaderExecutive :: New () ;} +extern "C" void vtkReaderExecutive_destructor (vtkReaderExecutive * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkReaderExecutive_get_ptr (vtkReaderExecutive * sself) {return sself ;} +extern "C" vtkRectilinearGridAlgorithm * vtkRectilinearGridAlgorithm_new () {return vtkRectilinearGridAlgorithm :: New () ;} +extern "C" void vtkRectilinearGridAlgorithm_destructor (vtkRectilinearGridAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkRectilinearGridAlgorithm_get_ptr (vtkRectilinearGridAlgorithm * sself) {return sself ;} +extern "C" vtkSMPProgressObserver * vtkSMPProgressObserver_new () {return vtkSMPProgressObserver :: New () ;} +extern "C" void vtkSMPProgressObserver_destructor (vtkSMPProgressObserver * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSMPProgressObserver_get_ptr (vtkSMPProgressObserver * sself) {return sself ;} +extern "C" void vtk_smp_progress_observer_update_progress(vtkSMPProgressObserver* sself, double progress) { sself->UpdateProgress(progress); } +extern "C" vtkSelectionAlgorithm * vtkSelectionAlgorithm_new () {return vtkSelectionAlgorithm :: New () ;} +extern "C" void vtkSelectionAlgorithm_destructor (vtkSelectionAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSelectionAlgorithm_get_ptr (vtkSelectionAlgorithm * sself) {return sself ;} +extern "C" vtkSimpleScalarTree * vtkSimpleScalarTree_new () {return vtkSimpleScalarTree :: New () ;} +extern "C" void vtkSimpleScalarTree_destructor (vtkSimpleScalarTree * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSimpleScalarTree_get_ptr (vtkSimpleScalarTree * sself) {return sself ;} +extern "C" void vtk_simple_scalar_tree_set_branching_factor(vtkSimpleScalarTree* sself, int _arg) { sself->SetBranchingFactor(_arg); } +extern "C" int vtk_simple_scalar_tree_get_branching_factor_min_value(vtkSimpleScalarTree* sself) { return sself->GetBranchingFactorMinValue(); } +extern "C" int vtk_simple_scalar_tree_get_branching_factor_max_value(vtkSimpleScalarTree* sself) { return sself->GetBranchingFactorMaxValue(); } +extern "C" int vtk_simple_scalar_tree_get_branching_factor(vtkSimpleScalarTree* sself) { return sself->GetBranchingFactor(); } +extern "C" int vtk_simple_scalar_tree_get_level(vtkSimpleScalarTree* sself) { return sself->GetLevel(); } +extern "C" void vtk_simple_scalar_tree_set_max_level(vtkSimpleScalarTree* sself, int _arg) { sself->SetMaxLevel(_arg); } +extern "C" int vtk_simple_scalar_tree_get_max_level_min_value(vtkSimpleScalarTree* sself) { return sself->GetMaxLevelMinValue(); } +extern "C" int vtk_simple_scalar_tree_get_max_level_max_value(vtkSimpleScalarTree* sself) { return sself->GetMaxLevelMaxValue(); } +extern "C" int vtk_simple_scalar_tree_get_max_level(vtkSimpleScalarTree* sself) { return sself->GetMaxLevel(); } +extern "C" void vtk_simple_scalar_tree_build_tree(vtkSimpleScalarTree* sself) { sself->BuildTree(); } +extern "C" void vtk_simple_scalar_tree_initialize(vtkSimpleScalarTree* sself) { sself->Initialize(); } +extern "C" void vtk_simple_scalar_tree_init_traversal(vtkSimpleScalarTree* sself, double scalarValue) { sself->InitTraversal(scalarValue); } +extern "C" long long vtk_simple_scalar_tree_get_number_of_cell_batches(vtkSimpleScalarTree* sself, double scalarValue) { return sself->GetNumberOfCellBatches(scalarValue); } +extern "C" vtkSpanSpace * vtkSpanSpace_new () {return vtkSpanSpace :: New () ;} +extern "C" void vtkSpanSpace_destructor (vtkSpanSpace * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSpanSpace_get_ptr (vtkSpanSpace * sself) {return sself ;} +extern "C" void vtk_span_space_set_scalar_range(vtkSpanSpace* sself, double _arg1, double _arg2) { sself->SetScalarRange(_arg1, _arg2); } +extern "C" void vtk_span_space_set_compute_scalar_range(vtkSpanSpace* sself, int _arg) { sself->SetComputeScalarRange(_arg); } +extern "C" int vtk_span_space_get_compute_scalar_range(vtkSpanSpace* sself) { return sself->GetComputeScalarRange(); } +extern "C" void vtk_span_space_compute_scalar_range_on(vtkSpanSpace* sself) { sself->ComputeScalarRangeOn(); } +extern "C" void vtk_span_space_compute_scalar_range_off(vtkSpanSpace* sself) { sself->ComputeScalarRangeOff(); } +extern "C" void vtk_span_space_set_resolution(vtkSpanSpace* sself, long long _arg) { sself->SetResolution(_arg); } +extern "C" long long vtk_span_space_get_resolution_min_value(vtkSpanSpace* sself) { return sself->GetResolutionMinValue(); } +extern "C" long long vtk_span_space_get_resolution_max_value(vtkSpanSpace* sself) { return sself->GetResolutionMaxValue(); } +extern "C" long long vtk_span_space_get_resolution(vtkSpanSpace* sself) { return sself->GetResolution(); } +extern "C" void vtk_span_space_set_compute_resolution(vtkSpanSpace* sself, int _arg) { sself->SetComputeResolution(_arg); } +extern "C" int vtk_span_space_get_compute_resolution(vtkSpanSpace* sself) { return sself->GetComputeResolution(); } +extern "C" void vtk_span_space_compute_resolution_on(vtkSpanSpace* sself) { sself->ComputeResolutionOn(); } +extern "C" void vtk_span_space_compute_resolution_off(vtkSpanSpace* sself) { sself->ComputeResolutionOff(); } +extern "C" void vtk_span_space_set_number_of_cells_per_bucket(vtkSpanSpace* sself, int _arg) { sself->SetNumberOfCellsPerBucket(_arg); } +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_min_value(vtkSpanSpace* sself) { return sself->GetNumberOfCellsPerBucketMinValue(); } +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_max_value(vtkSpanSpace* sself) { return sself->GetNumberOfCellsPerBucketMaxValue(); } +extern "C" int vtk_span_space_get_number_of_cells_per_bucket(vtkSpanSpace* sself) { return sself->GetNumberOfCellsPerBucket(); } +extern "C" void vtk_span_space_initialize(vtkSpanSpace* sself) { sself->Initialize(); } +extern "C" void vtk_span_space_build_tree(vtkSpanSpace* sself) { sself->BuildTree(); } +extern "C" void vtk_span_space_init_traversal(vtkSpanSpace* sself, double scalarValue) { sself->InitTraversal(scalarValue); } +extern "C" long long vtk_span_space_get_number_of_cell_batches(vtkSpanSpace* sself, double scalarValue) { return sself->GetNumberOfCellBatches(scalarValue); } +extern "C" void vtk_span_space_set_batch_size(vtkSpanSpace* sself, long long _arg) { sself->SetBatchSize(_arg); } +extern "C" long long vtk_span_space_get_batch_size_min_value(vtkSpanSpace* sself) { return sself->GetBatchSizeMinValue(); } +extern "C" long long vtk_span_space_get_batch_size_max_value(vtkSpanSpace* sself) { return sself->GetBatchSizeMaxValue(); } +extern "C" long long vtk_span_space_get_batch_size(vtkSpanSpace* sself) { return sself->GetBatchSize(); } +extern "C" vtkSphereTree * vtkSphereTree_new () {return vtkSphereTree :: New () ;} +extern "C" void vtkSphereTree_destructor (vtkSphereTree * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSphereTree_get_ptr (vtkSphereTree * sself) {return sself ;} +extern "C" void vtk_sphere_tree_build(vtkSphereTree* sself) { sself->Build(); } +extern "C" void vtk_sphere_tree_set_build_hierarchy(vtkSphereTree* sself, bool _arg) { sself->SetBuildHierarchy(_arg); } +extern "C" bool vtk_sphere_tree_get_build_hierarchy(vtkSphereTree* sself) { return sself->GetBuildHierarchy(); } +extern "C" void vtk_sphere_tree_build_hierarchy_on(vtkSphereTree* sself) { sself->BuildHierarchyOn(); } +extern "C" void vtk_sphere_tree_build_hierarchy_off(vtkSphereTree* sself) { sself->BuildHierarchyOff(); } +extern "C" void vtk_sphere_tree_set_resolution(vtkSphereTree* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_sphere_tree_get_resolution_min_value(vtkSphereTree* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_sphere_tree_get_resolution_max_value(vtkSphereTree* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_sphere_tree_get_resolution(vtkSphereTree* sself) { return sself->GetResolution(); } +extern "C" void vtk_sphere_tree_set_max_level(vtkSphereTree* sself, int _arg) { sself->SetMaxLevel(_arg); } +extern "C" int vtk_sphere_tree_get_max_level_min_value(vtkSphereTree* sself) { return sself->GetMaxLevelMinValue(); } +extern "C" int vtk_sphere_tree_get_max_level_max_value(vtkSphereTree* sself) { return sself->GetMaxLevelMaxValue(); } +extern "C" int vtk_sphere_tree_get_max_level(vtkSphereTree* sself) { return sself->GetMaxLevel(); } +extern "C" int vtk_sphere_tree_get_number_of_levels(vtkSphereTree* sself) { return sself->GetNumberOfLevels(); } +extern "C" vtkStreamingDemandDrivenPipeline * vtkStreamingDemandDrivenPipeline_new () {return vtkStreamingDemandDrivenPipeline :: New () ;} +extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkStreamingDemandDrivenPipeline * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStreamingDemandDrivenPipeline_get_ptr (vtkStreamingDemandDrivenPipeline * sself) {return sself ;} +extern "C" int vtk_streaming_demand_driven_pipeline_update(vtkStreamingDemandDrivenPipeline* sself) { return sself->Update(); } +extern "C" int vtk_streaming_demand_driven_pipeline_update_whole_extent(vtkStreamingDemandDrivenPipeline* sself) { return sself->UpdateWholeExtent(); } +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_update_extent(vtkStreamingDemandDrivenPipeline* sself, int outputPort) { return sself->PropagateUpdateExtent(outputPort); } +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_time(vtkStreamingDemandDrivenPipeline* sself, int outputPort) { return sself->PropagateTime(outputPort); } +extern "C" int vtk_streaming_demand_driven_pipeline_update_time_dependent_information(vtkStreamingDemandDrivenPipeline* sself, int outputPort) { return sself->UpdateTimeDependentInformation(outputPort); } +extern "C" int vtk_streaming_demand_driven_pipeline_set_request_exact_extent(vtkStreamingDemandDrivenPipeline* sself, int port, int flag) { return sself->SetRequestExactExtent(port, flag); } +extern "C" int vtk_streaming_demand_driven_pipeline_get_request_exact_extent(vtkStreamingDemandDrivenPipeline* sself, int port) { return sself->GetRequestExactExtent(port); } +extern "C" vtkStructuredGridAlgorithm * vtkStructuredGridAlgorithm_new () {return vtkStructuredGridAlgorithm :: New () ;} +extern "C" void vtkStructuredGridAlgorithm_destructor (vtkStructuredGridAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkStructuredGridAlgorithm_get_ptr (vtkStructuredGridAlgorithm * sself) {return sself ;} +extern "C" vtkTableAlgorithm * vtkTableAlgorithm_new () {return vtkTableAlgorithm :: New () ;} +extern "C" void vtkTableAlgorithm_destructor (vtkTableAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTableAlgorithm_get_ptr (vtkTableAlgorithm * sself) {return sself ;} +extern "C" vtkThreadedCompositeDataPipeline * vtkThreadedCompositeDataPipeline_new () {return vtkThreadedCompositeDataPipeline :: New () ;} +extern "C" void vtkThreadedCompositeDataPipeline_destructor (vtkThreadedCompositeDataPipeline * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkThreadedCompositeDataPipeline_get_ptr (vtkThreadedCompositeDataPipeline * sself) {return sself ;} +extern "C" vtkTreeAlgorithm * vtkTreeAlgorithm_new () {return vtkTreeAlgorithm :: New () ;} +extern "C" void vtkTreeAlgorithm_destructor (vtkTreeAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTreeAlgorithm_get_ptr (vtkTreeAlgorithm * sself) {return sself ;} +extern "C" vtkTrivialConsumer * vtkTrivialConsumer_new () {return vtkTrivialConsumer :: New () ;} +extern "C" void vtkTrivialConsumer_destructor (vtkTrivialConsumer * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTrivialConsumer_get_ptr (vtkTrivialConsumer * sself) {return sself ;} +extern "C" vtkTrivialProducer * vtkTrivialProducer_new () {return vtkTrivialProducer :: New () ;} +extern "C" void vtkTrivialProducer_destructor (vtkTrivialProducer * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTrivialProducer_get_ptr (vtkTrivialProducer * sself) {return sself ;} +extern "C" unsigned long vtk_trivial_producer_get_m_time(vtkTrivialProducer* sself) { return sself->GetMTime(); } +extern "C" void vtk_trivial_producer_set_whole_extent(vtkTrivialProducer* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" vtkUndirectedGraphAlgorithm * vtkUndirectedGraphAlgorithm_new () {return vtkUndirectedGraphAlgorithm :: New () ;} +extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkUndirectedGraphAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUndirectedGraphAlgorithm_get_ptr (vtkUndirectedGraphAlgorithm * sself) {return sself ;} +extern "C" vtkUniformGridAMRAlgorithm * vtkUniformGridAMRAlgorithm_new () {return vtkUniformGridAMRAlgorithm :: New () ;} +extern "C" void vtkUniformGridAMRAlgorithm_destructor (vtkUniformGridAMRAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUniformGridAMRAlgorithm_get_ptr (vtkUniformGridAMRAlgorithm * sself) {return sself ;} +extern "C" vtkUniformGridPartitioner * vtkUniformGridPartitioner_new () {return vtkUniformGridPartitioner :: New () ;} +extern "C" void vtkUniformGridPartitioner_destructor (vtkUniformGridPartitioner * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUniformGridPartitioner_get_ptr (vtkUniformGridPartitioner * sself) {return sself ;} +extern "C" int vtk_uniform_grid_partitioner_get_number_of_partitions(vtkUniformGridPartitioner* sself) { return sself->GetNumberOfPartitions(); } +extern "C" void vtk_uniform_grid_partitioner_set_number_of_partitions(vtkUniformGridPartitioner* sself, int _arg) { sself->SetNumberOfPartitions(_arg); } +extern "C" int vtk_uniform_grid_partitioner_get_number_of_ghost_layers(vtkUniformGridPartitioner* sself) { return sself->GetNumberOfGhostLayers(); } +extern "C" void vtk_uniform_grid_partitioner_set_number_of_ghost_layers(vtkUniformGridPartitioner* sself, int _arg) { sself->SetNumberOfGhostLayers(_arg); } +extern "C" int vtk_uniform_grid_partitioner_get_duplicate_nodes(vtkUniformGridPartitioner* sself) { return sself->GetDuplicateNodes(); } +extern "C" void vtk_uniform_grid_partitioner_set_duplicate_nodes(vtkUniformGridPartitioner* sself, int _arg) { sself->SetDuplicateNodes(_arg); } +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_on(vtkUniformGridPartitioner* sself) { sself->DuplicateNodesOn(); } +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_off(vtkUniformGridPartitioner* sself) { sself->DuplicateNodesOff(); } +extern "C" vtkUnstructuredGridAlgorithm * vtkUnstructuredGridAlgorithm_new () {return vtkUnstructuredGridAlgorithm :: New () ;} +extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkUnstructuredGridAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUnstructuredGridAlgorithm_get_ptr (vtkUnstructuredGridAlgorithm * sself) {return sself ;} +extern "C" vtkUnstructuredGridBaseAlgorithm * vtkUnstructuredGridBaseAlgorithm_new () {return vtkUnstructuredGridBaseAlgorithm :: New () ;} +extern "C" void vtkUnstructuredGridBaseAlgorithm_destructor (vtkUnstructuredGridBaseAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUnstructuredGridBaseAlgorithm_get_ptr (vtkUnstructuredGridBaseAlgorithm * sself) {return sself ;} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp index 13f614a..adc8a08 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp @@ -23,157 +23,90 @@ #include // Implement declared functions -extern "C" vtkNew < vtkAmoebaMinimizer > vtkAmoebaMinimizer_new () {return vtkNew < vtkAmoebaMinimizer > () ;} -extern "C" void vtkAmoebaMinimizer_destructor (vtkNew < vtkAmoebaMinimizer > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAmoebaMinimizer_get_ptr (vtkNew < vtkAmoebaMinimizer > sself) {return sself . GetPointer () ;} -extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkNew sself, const char name, double value) { sself->SetParameterValue(name, value); } -extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkNew sself, int i, double value) { sself->SetParameterValue(i, value); } -extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkNew sself, const char name, double scale) { sself->SetParameterScale(name, scale); } -extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkNew sself, const char name) { return sself->GetParameterScale(name); } -extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkNew sself, int i, double scale) { sself->SetParameterScale(i, scale); } -extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkNew sself, int i) { return sself->GetParameterScale(i); } -extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkNew sself, const char name) { return sself->GetParameterValue(name); } -extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkNew sself, int i) { return sself->GetParameterValue(i); } -extern "C" const char* vtk_amoeba_minimizer_get_parameter_name(vtkNew sself, int i) { return sself->GetParameterName(i); } -extern "C" int vtk_amoeba_minimizer_get_number_of_parameters(vtkNew sself) { return sself->GetNumberOfParameters(); } -extern "C" void vtk_amoeba_minimizer_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_amoeba_minimizer_minimize(vtkNew sself) { sself->Minimize(); } -extern "C" int vtk_amoeba_minimizer_iterate(vtkNew sself) { return sself->Iterate(); } -extern "C" void vtk_amoeba_minimizer_set_function_value(vtkNew sself, double _arg) { sself->SetFunctionValue(_arg); } -extern "C" double vtk_amoeba_minimizer_get_function_value(vtkNew sself) { return sself->GetFunctionValue(); } -extern "C" void vtk_amoeba_minimizer_set_contraction_ratio(vtkNew sself, double _arg) { sself->SetContractionRatio(_arg); } -extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_min_value(vtkNew sself) { return sself->GetContractionRatioMinValue(); } -extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_max_value(vtkNew sself) { return sself->GetContractionRatioMaxValue(); } -extern "C" double vtk_amoeba_minimizer_get_contraction_ratio(vtkNew sself) { return sself->GetContractionRatio(); } -extern "C" void vtk_amoeba_minimizer_set_expansion_ratio(vtkNew sself, double _arg) { sself->SetExpansionRatio(_arg); } -extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_min_value(vtkNew sself) { return sself->GetExpansionRatioMinValue(); } -extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_max_value(vtkNew sself) { return sself->GetExpansionRatioMaxValue(); } -extern "C" double vtk_amoeba_minimizer_get_expansion_ratio(vtkNew sself) { return sself->GetExpansionRatio(); } -extern "C" void vtk_amoeba_minimizer_set_tolerance(vtkNew sself, double _arg) { sself->SetTolerance(_arg); } -extern "C" double vtk_amoeba_minimizer_get_tolerance(vtkNew sself) { return sself->GetTolerance(); } -extern "C" void vtk_amoeba_minimizer_set_parameter_tolerance(vtkNew sself, double _arg) { sself->SetParameterTolerance(_arg); } -extern "C" double vtk_amoeba_minimizer_get_parameter_tolerance(vtkNew sself) { return sself->GetParameterTolerance(); } -extern "C" void vtk_amoeba_minimizer_set_max_iterations(vtkNew sself, int _arg) { sself->SetMaxIterations(_arg); } -extern "C" int vtk_amoeba_minimizer_get_max_iterations(vtkNew sself) { return sself->GetMaxIterations(); } -extern "C" int vtk_amoeba_minimizer_get_iterations(vtkNew sself) { return sself->GetIterations(); } -extern "C" int vtk_amoeba_minimizer_get_function_evaluations(vtkNew sself) { return sself->GetFunctionEvaluations(); } -extern "C" void vtk_amoeba_minimizer_evaluate_function(vtkNew sself) { sself->EvaluateFunction(); } -extern "C" vtkNew < vtkFFT > vtkFFT_new () {return vtkNew < vtkFFT > () ;} -extern "C" void vtkFFT_destructor (vtkNew < vtkFFT > sself) {sself . Reset () ; return ;} -extern "C" void * vtkFFT_get_ptr (vtkNew < vtkFFT > sself) {return sself . GetPointer () ;} -extern "C" double vtk_fft_hanning_generator(vtkNew sself, const size_t x, const size_t size) { return sself->HanningGenerator(x, size); } -extern "C" double vtk_fft_bartlett_generator(vtkNew sself, const size_t x, const size_t size) { return sself->BartlettGenerator(x, size); } -extern "C" double vtk_fft_sine_generator(vtkNew sself, const size_t x, const size_t size) { return sself->SineGenerator(x, size); } -extern "C" double vtk_fft_blackman_generator(vtkNew sself, const size_t x, const size_t size) { return sself->BlackmanGenerator(x, size); } -extern "C" double vtk_fft_rectangular_generator(vtkNew sself, const size_t x, const size_t size) { return sself->RectangularGenerator(x, size); } -extern "C" vtkNew < vtkMatrix3x3 > vtkMatrix3x3_new () {return vtkNew < vtkMatrix3x3 > () ;} -extern "C" void vtkMatrix3x3_destructor (vtkNew < vtkMatrix3x3 > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMatrix3x3_get_ptr (vtkNew < vtkMatrix3x3 > sself) {return sself . GetPointer () ;} -extern "C" void vtk_matrix_3_x_3_deep_copy(vtkNew sself, double elements, const double newElements) { sself->DeepCopy(elements, newElements); } -extern "C" void vtk_matrix_3_x_3_deep_copy(vtkNew sself, const double elements) { sself->DeepCopy(elements); } -extern "C" void vtk_matrix_3_x_3_zero(vtkNew sself) { sself->Zero(); } -extern "C" void vtk_matrix_3_x_3_zero(vtkNew sself, double elements) { sself->Zero(elements); } -extern "C" void vtk_matrix_3_x_3_identity(vtkNew sself) { sself->Identity(); } -extern "C" void vtk_matrix_3_x_3_identity(vtkNew sself, double elements) { sself->Identity(elements); } -extern "C" void vtk_matrix_3_x_3_invert(vtkNew sself) { sself->Invert(); } -extern "C" void vtk_matrix_3_x_3_invert(vtkNew sself, const double inElements, double outElements) { sself->Invert(inElements, outElements); } -extern "C" void vtk_matrix_3_x_3_transpose(vtkNew sself) { sself->Transpose(); } -extern "C" void vtk_matrix_3_x_3_transpose(vtkNew sself, const double inElements, double outElements) { sself->Transpose(inElements, outElements); } -extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const float in, float out) { sself->MultiplyPoint(in, out); } -extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double in, double out) { sself->MultiplyPoint(in, out); } -extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double elements, const float in, float out) { sself->MultiplyPoint(elements, in, out); } -extern "C" void vtk_matrix_3_x_3_multiply_point(vtkNew sself, const double elements, const double in, double out) { sself->MultiplyPoint(elements, in, out); } -extern "C" void vtk_matrix_3_x_3_multiply_3_x_3(vtkNew sself, const double a, const double b, double c) { sself->Multiply3x3(a, b, c); } -extern "C" void vtk_matrix_3_x_3_adjoint(vtkNew sself, const double inElements, double outElements) { sself->Adjoint(inElements, outElements); } -extern "C" double vtk_matrix_3_x_3_determinant(vtkNew sself) { return sself->Determinant(); } -extern "C" double vtk_matrix_3_x_3_determinant(vtkNew sself, const double elements) { return sself->Determinant(elements); } -extern "C" void vtk_matrix_3_x_3_set_element(vtkNew sself, int i, int j, double value) { sself->SetElement(i, j, value); } -extern "C" double vtk_matrix_3_x_3_get_element(vtkNew sself, int i, int j) { return sself->GetElement(i, j); } -extern "C" bool vtk_matrix_3_x_3_is_identity(vtkNew sself) { return sself->IsIdentity(); } -extern "C" double* vtk_matrix_3_x_3_get_data(vtkNew sself) { return sself->GetData(); } -extern "C" const double* vtk_matrix_3_x_3_get_data(vtkNew sself) { return sself->GetData(); } -extern "C" vtkNew < vtkMatrix4x4 > vtkMatrix4x4_new () {return vtkNew < vtkMatrix4x4 > () ;} -extern "C" void vtkMatrix4x4_destructor (vtkNew < vtkMatrix4x4 > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMatrix4x4_get_ptr (vtkNew < vtkMatrix4x4 > sself) {return sself . GetPointer () ;} -extern "C" void vtk_matrix_4_x_4_deep_copy(vtkNew sself, double destination, const double source) { sself->DeepCopy(destination, source); } -extern "C" void vtk_matrix_4_x_4_deep_copy(vtkNew sself, const double elements) { sself->DeepCopy(elements); } -extern "C" void vtk_matrix_4_x_4_zero(vtkNew sself) { sself->Zero(); } -extern "C" void vtk_matrix_4_x_4_zero(vtkNew sself, double elements) { sself->Zero(elements); } -extern "C" void vtk_matrix_4_x_4_identity(vtkNew sself) { sself->Identity(); } -extern "C" void vtk_matrix_4_x_4_identity(vtkNew sself, double elements) { sself->Identity(elements); } -extern "C" bool vtk_matrix_4_x_4_is_identity(vtkNew sself) { return sself->IsIdentity(); } -extern "C" void vtk_matrix_4_x_4_invert(vtkNew sself) { sself->Invert(); } -extern "C" void vtk_matrix_4_x_4_invert(vtkNew sself, const double inElements, double outElements) { sself->Invert(inElements, outElements); } -extern "C" void vtk_matrix_4_x_4_transpose(vtkNew sself) { sself->Transpose(); } -extern "C" void vtk_matrix_4_x_4_transpose(vtkNew sself, const double inElements, double outElements) { sself->Transpose(inElements, outElements); } -extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const float in, float out) { sself->MultiplyPoint(in, out); } -extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double in, double out) { sself->MultiplyPoint(in, out); } -extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double elements, const float in, float out) { sself->MultiplyPoint(elements, in, out); } -extern "C" void vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double elements, const double in, double out) { sself->MultiplyPoint(elements, in, out); } -extern "C" float* vtk_matrix_4_x_4_multiply_point(vtkNew sself, const float in) { return sself->MultiplyPoint(in); } -extern "C" double* vtk_matrix_4_x_4_multiply_point(vtkNew sself, const double in) { return sself->MultiplyPoint(in); } -extern "C" float* vtk_matrix_4_x_4_multiply_float_point(vtkNew sself, const float in) { return sself->MultiplyFloatPoint(in); } -extern "C" double* vtk_matrix_4_x_4_multiply_double_point(vtkNew sself, const double in) { return sself->MultiplyDoublePoint(in); } -extern "C" void vtk_matrix_4_x_4_multiply_4_x_4(vtkNew sself, const double a, const double b, double c) { sself->Multiply4x4(a, b, c); } -extern "C" void vtk_matrix_4_x_4_multiply_4_x_4(vtkNew sself, const double a, const double b, float c) { sself->Multiply4x4(a, b, c); } -extern "C" void vtk_matrix_4_x_4_multiply_and_transpose_4_x_4(vtkNew sself, const double a, const double b, float c) { sself->MultiplyAndTranspose4x4(a, b, c); } -extern "C" void vtk_matrix_4_x_4_adjoint(vtkNew sself, const double inElements, double outElements) { sself->Adjoint(inElements, outElements); } -extern "C" double vtk_matrix_4_x_4_determinant(vtkNew sself) { return sself->Determinant(); } -extern "C" double vtk_matrix_4_x_4_determinant(vtkNew sself, const double elements) { return sself->Determinant(elements); } -extern "C" void vtk_matrix_4_x_4_set_element(vtkNew sself, int i, int j, double value) { sself->SetElement(i, j, value); } -extern "C" double vtk_matrix_4_x_4_get_element(vtkNew sself, int i, int j) { return sself->GetElement(i, j); } -extern "C" double* vtk_matrix_4_x_4_get_data(vtkNew sself) { return sself->GetData(); } -extern "C" const double* vtk_matrix_4_x_4_get_data(vtkNew sself) { return sself->GetData(); } -extern "C" vtkNew < vtkPolynomialSolversUnivariate > vtkPolynomialSolversUnivariate_new () {return vtkNew < vtkPolynomialSolversUnivariate > () ;} -extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkNew < vtkPolynomialSolversUnivariate > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolynomialSolversUnivariate_get_ptr (vtkNew < vtkPolynomialSolversUnivariate > sself) {return sself . GetPointer () ;} -extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol) { return sself->HabichtBisectionSolve(P, d, a, upperBnds, tol); } -extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType) { return sself->HabichtBisectionSolve(P, d, a, upperBnds, tol, intervalType); } -extern "C" int vtk_polynomial_solvers_univariate_habicht_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType, bool divideGCD) { return sself->HabichtBisectionSolve(P, d, a, upperBnds, tol, intervalType, divideGCD); } -extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol) { return sself->SturmBisectionSolve(P, d, a, upperBnds, tol); } -extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType) { return sself->SturmBisectionSolve(P, d, a, upperBnds, tol, intervalType); } -extern "C" int vtk_polynomial_solvers_univariate_sturm_bisection_solve(vtkNew sself, double P, int d, double a, double upperBnds, double tol, int intervalType, bool divideGCD) { return sself->SturmBisectionSolve(P, d, a, upperBnds, tol, intervalType, divideGCD); } -extern "C" int vtk_polynomial_solvers_univariate_filter_roots(vtkNew sself, double P, int d, double upperBnds, int rootcount, double diameter) { return sself->FilterRoots(P, d, upperBnds, rootcount, diameter); } -extern "C" int vtk_polynomial_solvers_univariate_lin_bairstow_solve(vtkNew sself, double c, int d, double r, double tolerance) { return sself->LinBairstowSolve(c, d, r, tolerance); } -extern "C" int vtk_polynomial_solvers_univariate_ferrari_solve(vtkNew sself, double c, double r, int m, double tol) { return sself->FerrariSolve(c, r, m, tol); } -extern "C" int vtk_polynomial_solvers_univariate_tartaglia_cardan_solve(vtkNew sself, double c, double r, int m, double tol) { return sself->TartagliaCardanSolve(c, r, m, tol); } -extern "C" double* vtk_polynomial_solvers_univariate_solve_cubic(vtkNew sself, double c0, double c1, double c2, double c3) { return sself->SolveCubic(c0, c1, c2, c3); } -extern "C" double* vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c0, double c1, double c2) { return sself->SolveQuadratic(c0, c1, c2); } -extern "C" double* vtk_polynomial_solvers_univariate_solve_linear(vtkNew sself, double c0, double c1) { return sself->SolveLinear(c0, c1); } -extern "C" int vtk_polynomial_solvers_univariate_solve_cubic(vtkNew sself, double c0, double c1, double c2, double c3, double r1, double r2, double r3, int num_roots) { return sself->SolveCubic(c0, c1, c2, c3, r1, r2, r3, num_roots); } -extern "C" int vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c0, double c1, double c2, double r1, double r2, int num_roots) { return sself->SolveQuadratic(c0, c1, c2, r1, r2, num_roots); } -extern "C" int vtk_polynomial_solvers_univariate_solve_quadratic(vtkNew sself, double c, double r, int m) { return sself->SolveQuadratic(c, r, m); } -extern "C" int vtk_polynomial_solvers_univariate_solve_linear(vtkNew sself, double c0, double c1, double r1, int num_roots) { return sself->SolveLinear(c0, c1, r1, num_roots); } -extern "C" void vtk_polynomial_solvers_univariate_set_division_tolerance(vtkNew sself, double tol) { sself->SetDivisionTolerance(tol); } -extern "C" double vtk_polynomial_solvers_univariate_get_division_tolerance(vtkNew sself) { return sself->GetDivisionTolerance(); } -extern "C" vtkNew < vtkQuaternionInterpolator > vtkQuaternionInterpolator_new () {return vtkNew < vtkQuaternionInterpolator > () ;} -extern "C" void vtkQuaternionInterpolator_destructor (vtkNew < vtkQuaternionInterpolator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuaternionInterpolator_get_ptr (vtkNew < vtkQuaternionInterpolator > sself) {return sself . GetPointer () ;} -extern "C" int vtk_quaternion_interpolator_get_number_of_quaternions(vtkNew sself) { return sself->GetNumberOfQuaternions(); } -extern "C" double vtk_quaternion_interpolator_get_minimum_t(vtkNew sself) { return sself->GetMinimumT(); } -extern "C" double vtk_quaternion_interpolator_get_maximum_t(vtkNew sself) { return sself->GetMaximumT(); } -extern "C" void vtk_quaternion_interpolator_initialize(vtkNew sself) { sself->Initialize(); } -extern "C" void vtk_quaternion_interpolator_add_quaternion(vtkNew sself, double t, double q) { sself->AddQuaternion(t, q); } -extern "C" void vtk_quaternion_interpolator_remove_quaternion(vtkNew sself, double t) { sself->RemoveQuaternion(t); } -extern "C" void vtk_quaternion_interpolator_interpolate_quaternion(vtkNew sself, double t, double q) { sself->InterpolateQuaternion(t, q); } -extern "C" int vtk_quaternion_interpolator_get_search_method(vtkNew sself) { return sself->GetSearchMethod(); } -extern "C" void vtk_quaternion_interpolator_set_search_method(vtkNew sself, int type) { sself->SetSearchMethod(type); } -extern "C" void vtk_quaternion_interpolator_set_interpolation_type(vtkNew sself, int _arg) { sself->SetInterpolationType(_arg); } -extern "C" int vtk_quaternion_interpolator_get_interpolation_type_min_value(vtkNew sself) { return sself->GetInterpolationTypeMinValue(); } -extern "C" int vtk_quaternion_interpolator_get_interpolation_type_max_value(vtkNew sself) { return sself->GetInterpolationTypeMaxValue(); } -extern "C" int vtk_quaternion_interpolator_get_interpolation_type(vtkNew sself) { return sself->GetInterpolationType(); } -extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_linear(vtkNew sself) { sself->SetInterpolationTypeToLinear(); } -extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_spline(vtkNew sself) { sself->SetInterpolationTypeToSpline(); } -extern "C" vtkNew < vtkRungeKutta2 > vtkRungeKutta2_new () {return vtkNew < vtkRungeKutta2 > () ;} -extern "C" void vtkRungeKutta2_destructor (vtkNew < vtkRungeKutta2 > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRungeKutta2_get_ptr (vtkNew < vtkRungeKutta2 > sself) {return sself . GetPointer () ;} -extern "C" int vtk_runge_kutta_2_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData) { return sself->ComputeNextStep(xprev, xnext, t, delT, maxError, error, userData); } -extern "C" vtkNew < vtkRungeKutta4 > vtkRungeKutta4_new () {return vtkNew < vtkRungeKutta4 > () ;} -extern "C" void vtkRungeKutta4_destructor (vtkNew < vtkRungeKutta4 > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRungeKutta4_get_ptr (vtkNew < vtkRungeKutta4 > sself) {return sself . GetPointer () ;} -extern "C" int vtk_runge_kutta_4_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData) { return sself->ComputeNextStep(xprev, xnext, t, delT, maxError, error, userData); } -extern "C" vtkNew < vtkRungeKutta45 > vtkRungeKutta45_new () {return vtkNew < vtkRungeKutta45 > () ;} -extern "C" void vtkRungeKutta45_destructor (vtkNew < vtkRungeKutta45 > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRungeKutta45_get_ptr (vtkNew < vtkRungeKutta45 > sself) {return sself . GetPointer () ;} -extern "C" int vtk_runge_kutta_45_compute_next_step(vtkNew sself, double xprev, double xnext, double t, double delT, double maxError, double error, void userData) { return sself->ComputeNextStep(xprev, xnext, t, delT, maxError, error, userData); } -extern "C" int vtk_runge_kutta_45_compute_next_step(vtkNew sself, double xprev, double dxprev, double xnext, double t, double delT, double delTActual, double minStep, double maxStep, double maxError, double estErr, void userData) { return sself->ComputeNextStep(xprev, dxprev, xnext, t, delT, delTActual, minStep, maxStep, maxError, estErr, userData); } +extern "C" vtkAmoebaMinimizer * vtkAmoebaMinimizer_new () {return vtkAmoebaMinimizer :: New () ;} +extern "C" void vtkAmoebaMinimizer_destructor (vtkAmoebaMinimizer * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkAmoebaMinimizer_get_ptr (vtkAmoebaMinimizer * sself) {return sself ;} +extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkAmoebaMinimizer* sself, const char* name, double value) { sself->SetParameterValue(name, value); } +extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkAmoebaMinimizer* sself, const char* name, double scale) { sself->SetParameterScale(name, scale); } +extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkAmoebaMinimizer* sself, const char* name) { return sself->GetParameterScale(name); } +extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkAmoebaMinimizer* sself, const char* name) { return sself->GetParameterValue(name); } +extern "C" const char* vtk_amoeba_minimizer_get_parameter_name(vtkAmoebaMinimizer* sself, int i) { return sself->GetParameterName(i); } +extern "C" int vtk_amoeba_minimizer_get_number_of_parameters(vtkAmoebaMinimizer* sself) { return sself->GetNumberOfParameters(); } +extern "C" void vtk_amoeba_minimizer_initialize(vtkAmoebaMinimizer* sself) { sself->Initialize(); } +extern "C" void vtk_amoeba_minimizer_minimize(vtkAmoebaMinimizer* sself) { sself->Minimize(); } +extern "C" int vtk_amoeba_minimizer_iterate(vtkAmoebaMinimizer* sself) { return sself->Iterate(); } +extern "C" void vtk_amoeba_minimizer_set_function_value(vtkAmoebaMinimizer* sself, double _arg) { sself->SetFunctionValue(_arg); } +extern "C" double vtk_amoeba_minimizer_get_function_value(vtkAmoebaMinimizer* sself) { return sself->GetFunctionValue(); } +extern "C" void vtk_amoeba_minimizer_set_contraction_ratio(vtkAmoebaMinimizer* sself, double _arg) { sself->SetContractionRatio(_arg); } +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_min_value(vtkAmoebaMinimizer* sself) { return sself->GetContractionRatioMinValue(); } +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_max_value(vtkAmoebaMinimizer* sself) { return sself->GetContractionRatioMaxValue(); } +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio(vtkAmoebaMinimizer* sself) { return sself->GetContractionRatio(); } +extern "C" void vtk_amoeba_minimizer_set_expansion_ratio(vtkAmoebaMinimizer* sself, double _arg) { sself->SetExpansionRatio(_arg); } +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_min_value(vtkAmoebaMinimizer* sself) { return sself->GetExpansionRatioMinValue(); } +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_max_value(vtkAmoebaMinimizer* sself) { return sself->GetExpansionRatioMaxValue(); } +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio(vtkAmoebaMinimizer* sself) { return sself->GetExpansionRatio(); } +extern "C" void vtk_amoeba_minimizer_set_tolerance(vtkAmoebaMinimizer* sself, double _arg) { sself->SetTolerance(_arg); } +extern "C" double vtk_amoeba_minimizer_get_tolerance(vtkAmoebaMinimizer* sself) { return sself->GetTolerance(); } +extern "C" void vtk_amoeba_minimizer_set_parameter_tolerance(vtkAmoebaMinimizer* sself, double _arg) { sself->SetParameterTolerance(_arg); } +extern "C" double vtk_amoeba_minimizer_get_parameter_tolerance(vtkAmoebaMinimizer* sself) { return sself->GetParameterTolerance(); } +extern "C" void vtk_amoeba_minimizer_set_max_iterations(vtkAmoebaMinimizer* sself, int _arg) { sself->SetMaxIterations(_arg); } +extern "C" int vtk_amoeba_minimizer_get_max_iterations(vtkAmoebaMinimizer* sself) { return sself->GetMaxIterations(); } +extern "C" int vtk_amoeba_minimizer_get_iterations(vtkAmoebaMinimizer* sself) { return sself->GetIterations(); } +extern "C" int vtk_amoeba_minimizer_get_function_evaluations(vtkAmoebaMinimizer* sself) { return sself->GetFunctionEvaluations(); } +extern "C" void vtk_amoeba_minimizer_evaluate_function(vtkAmoebaMinimizer* sself) { sself->EvaluateFunction(); } +extern "C" vtkFFT * vtkFFT_new () {return vtkFFT :: New () ;} +extern "C" void vtkFFT_destructor (vtkFFT * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkFFT_get_ptr (vtkFFT * sself) {return sself ;} +extern "C" double vtk_fft_hanning_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->HanningGenerator(x, size); } +extern "C" double vtk_fft_bartlett_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->BartlettGenerator(x, size); } +extern "C" double vtk_fft_sine_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->SineGenerator(x, size); } +extern "C" double vtk_fft_blackman_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->BlackmanGenerator(x, size); } +extern "C" double vtk_fft_rectangular_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->RectangularGenerator(x, size); } +extern "C" vtkMatrix3x3 * vtkMatrix3x3_new () {return vtkMatrix3x3 :: New () ;} +extern "C" void vtkMatrix3x3_destructor (vtkMatrix3x3 * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMatrix3x3_get_ptr (vtkMatrix3x3 * sself) {return sself ;} +extern "C" void vtk_matrix_3_x_3_zero(vtkMatrix3x3* sself) { sself->Zero(); } +extern "C" void vtk_matrix_3_x_3_identity(vtkMatrix3x3* sself) { sself->Identity(); } +extern "C" double vtk_matrix_3_x_3_determinant(vtkMatrix3x3* sself) { return sself->Determinant(); } +extern "C" void vtk_matrix_3_x_3_set_element(vtkMatrix3x3* sself, int i, int j, double value) { sself->SetElement(i, j, value); } +extern "C" double vtk_matrix_3_x_3_get_element(vtkMatrix3x3* sself, int i, int j) { return sself->GetElement(i, j); } +extern "C" bool vtk_matrix_3_x_3_is_identity(vtkMatrix3x3* sself) { return sself->IsIdentity(); } +extern "C" vtkMatrix4x4 * vtkMatrix4x4_new () {return vtkMatrix4x4 :: New () ;} +extern "C" void vtkMatrix4x4_destructor (vtkMatrix4x4 * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMatrix4x4_get_ptr (vtkMatrix4x4 * sself) {return sself ;} +extern "C" void vtk_matrix_4_x_4_zero(vtkMatrix4x4* sself) { sself->Zero(); } +extern "C" void vtk_matrix_4_x_4_identity(vtkMatrix4x4* sself) { sself->Identity(); } +extern "C" bool vtk_matrix_4_x_4_is_identity(vtkMatrix4x4* sself) { return sself->IsIdentity(); } +extern "C" double vtk_matrix_4_x_4_determinant(vtkMatrix4x4* sself) { return sself->Determinant(); } +extern "C" void vtk_matrix_4_x_4_set_element(vtkMatrix4x4* sself, int i, int j, double value) { sself->SetElement(i, j, value); } +extern "C" double vtk_matrix_4_x_4_get_element(vtkMatrix4x4* sself, int i, int j) { return sself->GetElement(i, j); } +extern "C" vtkPolynomialSolversUnivariate * vtkPolynomialSolversUnivariate_new () {return vtkPolynomialSolversUnivariate :: New () ;} +extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkPolynomialSolversUnivariate * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolynomialSolversUnivariate_get_ptr (vtkPolynomialSolversUnivariate * sself) {return sself ;} +extern "C" void vtk_polynomial_solvers_univariate_set_division_tolerance(vtkPolynomialSolversUnivariate* sself, double tol) { sself->SetDivisionTolerance(tol); } +extern "C" double vtk_polynomial_solvers_univariate_get_division_tolerance(vtkPolynomialSolversUnivariate* sself) { return sself->GetDivisionTolerance(); } +extern "C" vtkQuaternionInterpolator * vtkQuaternionInterpolator_new () {return vtkQuaternionInterpolator :: New () ;} +extern "C" void vtkQuaternionInterpolator_destructor (vtkQuaternionInterpolator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkQuaternionInterpolator_get_ptr (vtkQuaternionInterpolator * sself) {return sself ;} +extern "C" int vtk_quaternion_interpolator_get_number_of_quaternions(vtkQuaternionInterpolator* sself) { return sself->GetNumberOfQuaternions(); } +extern "C" double vtk_quaternion_interpolator_get_minimum_t(vtkQuaternionInterpolator* sself) { return sself->GetMinimumT(); } +extern "C" double vtk_quaternion_interpolator_get_maximum_t(vtkQuaternionInterpolator* sself) { return sself->GetMaximumT(); } +extern "C" void vtk_quaternion_interpolator_initialize(vtkQuaternionInterpolator* sself) { sself->Initialize(); } +extern "C" void vtk_quaternion_interpolator_remove_quaternion(vtkQuaternionInterpolator* sself, double t) { sself->RemoveQuaternion(t); } +extern "C" int vtk_quaternion_interpolator_get_search_method(vtkQuaternionInterpolator* sself) { return sself->GetSearchMethod(); } +extern "C" void vtk_quaternion_interpolator_set_search_method(vtkQuaternionInterpolator* sself, int type) { sself->SetSearchMethod(type); } +extern "C" void vtk_quaternion_interpolator_set_interpolation_type(vtkQuaternionInterpolator* sself, int _arg) { sself->SetInterpolationType(_arg); } +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_min_value(vtkQuaternionInterpolator* sself) { return sself->GetInterpolationTypeMinValue(); } +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_max_value(vtkQuaternionInterpolator* sself) { return sself->GetInterpolationTypeMaxValue(); } +extern "C" int vtk_quaternion_interpolator_get_interpolation_type(vtkQuaternionInterpolator* sself) { return sself->GetInterpolationType(); } +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_linear(vtkQuaternionInterpolator* sself) { sself->SetInterpolationTypeToLinear(); } +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_spline(vtkQuaternionInterpolator* sself) { sself->SetInterpolationTypeToSpline(); } +extern "C" vtkRungeKutta2 * vtkRungeKutta2_new () {return vtkRungeKutta2 :: New () ;} +extern "C" void vtkRungeKutta2_destructor (vtkRungeKutta2 * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkRungeKutta2_get_ptr (vtkRungeKutta2 * sself) {return sself ;} +extern "C" vtkRungeKutta4 * vtkRungeKutta4_new () {return vtkRungeKutta4 :: New () ;} +extern "C" void vtkRungeKutta4_destructor (vtkRungeKutta4 * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkRungeKutta4_get_ptr (vtkRungeKutta4 * sself) {return sself ;} +extern "C" vtkRungeKutta45 * vtkRungeKutta45_new () {return vtkRungeKutta45 :: New () ;} +extern "C" void vtkRungeKutta45_destructor (vtkRungeKutta45 * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkRungeKutta45_get_ptr (vtkRungeKutta45 * sself) {return sself ;} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp index eb16364..2ae920b 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp @@ -15,134 +15,86 @@ #include // Implement declared functions -extern "C" vtkNew < vtkContourValues > vtkContourValues_new () {return vtkNew < vtkContourValues > () ;} -extern "C" void vtkContourValues_destructor (vtkNew < vtkContourValues > sself) {sself . Reset () ; return ;} -extern "C" void * vtkContourValues_get_ptr (vtkNew < vtkContourValues > sself) {return sself . GetPointer () ;} -extern "C" void vtk_contour_values_set_value(vtkNew sself, int i, double value) { sself->SetValue(i, value); } -extern "C" double vtk_contour_values_get_value(vtkNew sself, int i) { return sself->GetValue(i); } -extern "C" double* vtk_contour_values_get_values(vtkNew sself) { return sself->GetValues(); } -extern "C" void vtk_contour_values_get_values(vtkNew sself, double contourValues) { sself->GetValues(contourValues); } -extern "C" void vtk_contour_values_set_number_of_contours(vtkNew sself, const int number) { sself->SetNumberOfContours(number); } -extern "C" int vtk_contour_values_get_number_of_contours(vtkNew sself) { return sself->GetNumberOfContours(); } -extern "C" void vtk_contour_values_generate_values(vtkNew sself, int numContours, double range) { sself->GenerateValues(numContours, range); } -extern "C" void vtk_contour_values_generate_values(vtkNew sself, int numContours, double rangeStart, double rangeEnd) { sself->GenerateValues(numContours, rangeStart, rangeEnd); } -extern "C" vtkNew < vtkExprTkFunctionParser > vtkExprTkFunctionParser_new () {return vtkNew < vtkExprTkFunctionParser > () ;} -extern "C" void vtkExprTkFunctionParser_destructor (vtkNew < vtkExprTkFunctionParser > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExprTkFunctionParser_get_ptr (vtkNew < vtkExprTkFunctionParser > sself) {return sself . GetPointer () ;} -extern "C" unsigned long vtk_expr_tk_function_parser_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_expr_tk_function_parser_set_function(vtkNew sself, const char function) { sself->SetFunction(function); } -extern "C" const char* vtk_expr_tk_function_parser_get_function(vtkNew sself) { return sself->GetFunction(); } -extern "C" int vtk_expr_tk_function_parser_is_scalar_result(vtkNew sself) { return sself->IsScalarResult(); } -extern "C" int vtk_expr_tk_function_parser_is_vector_result(vtkNew sself) { return sself->IsVectorResult(); } -extern "C" double vtk_expr_tk_function_parser_get_scalar_result(vtkNew sself) { return sself->GetScalarResult(); } -extern "C" double* vtk_expr_tk_function_parser_get_vector_result(vtkNew sself) { return sself->GetVectorResult(); } -extern "C" void vtk_expr_tk_function_parser_get_vector_result(vtkNew sself, double result) { sself->GetVectorResult(result); } -extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkNew sself, const char* variableName, double value) { sself->SetScalarVariableValue(variableName, value); } -extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkNew sself, int i, double value) { sself->SetScalarVariableValue(i, value); } -extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkNew sself, const char* variableName) { return sself->GetScalarVariableValue(variableName); } -extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkNew sself, int i) { return sself->GetScalarVariableValue(i); } -extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(variableName, xValue, yValue, zValue); } -extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double values) { sself->SetVectorVariableValue(variableName, values); } -extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, int i, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(i, xValue, yValue, zValue); } -extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkNew sself, int i, double values) { sself->SetVectorVariableValue(i, values); } -extern "C" double* vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName) { return sself->GetVectorVariableValue(variableName); } -extern "C" void vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName, double value) { sself->GetVectorVariableValue(variableName, value); } -extern "C" double* vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, int i) { return sself->GetVectorVariableValue(i); } -extern "C" void vtk_expr_tk_function_parser_get_vector_variable_value(vtkNew sself, int i, double value) { sself->GetVectorVariableValue(i, value); } -extern "C" int vtk_expr_tk_function_parser_get_number_of_scalar_variables(vtkNew sself) { return sself->GetNumberOfScalarVariables(); } -extern "C" int vtk_expr_tk_function_parser_get_scalar_variable_index(vtkNew sself, const char* name) { return sself->GetScalarVariableIndex(name); } -extern "C" int vtk_expr_tk_function_parser_get_number_of_vector_variables(vtkNew sself) { return sself->GetNumberOfVectorVariables(); } -extern "C" int vtk_expr_tk_function_parser_get_vector_variable_index(vtkNew sself, const char* name) { return sself->GetVectorVariableIndex(name); } -extern "C" const char* vtk_expr_tk_function_parser_get_scalar_variable_name(vtkNew sself, int i) { return sself->GetScalarVariableName(i); } -extern "C" const char* vtk_expr_tk_function_parser_get_vector_variable_name(vtkNew sself, int i) { return sself->GetVectorVariableName(i); } -extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkNew sself, int i) { return sself->GetScalarVariableNeeded(i); } -extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkNew sself, const char* variableName) { return sself->GetScalarVariableNeeded(variableName); } -extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkNew sself, int i) { return sself->GetVectorVariableNeeded(i); } -extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkNew sself, const char* variableName) { return sself->GetVectorVariableNeeded(variableName); } -extern "C" void vtk_expr_tk_function_parser_remove_all_variables(vtkNew sself) { sself->RemoveAllVariables(); } -extern "C" void vtk_expr_tk_function_parser_remove_scalar_variables(vtkNew sself) { sself->RemoveScalarVariables(); } -extern "C" void vtk_expr_tk_function_parser_remove_vector_variables(vtkNew sself) { sself->RemoveVectorVariables(); } -extern "C" void vtk_expr_tk_function_parser_set_replace_invalid_values(vtkNew sself, int _arg) { sself->SetReplaceInvalidValues(_arg); } -extern "C" int vtk_expr_tk_function_parser_get_replace_invalid_values(vtkNew sself) { return sself->GetReplaceInvalidValues(); } -extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_on(vtkNew sself) { sself->ReplaceInvalidValuesOn(); } -extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_off(vtkNew sself) { sself->ReplaceInvalidValuesOff(); } -extern "C" void vtk_expr_tk_function_parser_set_replacement_value(vtkNew sself, double _arg) { sself->SetReplacementValue(_arg); } -extern "C" double vtk_expr_tk_function_parser_get_replacement_value(vtkNew sself) { return sself->GetReplacementValue(); } -extern "C" void vtk_expr_tk_function_parser_invalidate_function(vtkNew sself) { sself->InvalidateFunction(); } -extern "C" const char* vtk_expr_tk_function_parser_sanitize_name(vtkNew sself, const char name) { return sself->SanitizeName(name); } -extern "C" vtkNew < vtkFunctionParser > vtkFunctionParser_new () {return vtkNew < vtkFunctionParser > () ;} -extern "C" void vtkFunctionParser_destructor (vtkNew < vtkFunctionParser > sself) {sself . Reset () ; return ;} -extern "C" void * vtkFunctionParser_get_ptr (vtkNew < vtkFunctionParser > sself) {return sself . GetPointer () ;} -extern "C" unsigned long vtk_function_parser_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_function_parser_set_function(vtkNew sself, const char function) { sself->SetFunction(function); } -extern "C" char* vtk_function_parser_get_function(vtkNew sself) { return sself->GetFunction(); } -extern "C" int vtk_function_parser_is_scalar_result(vtkNew sself) { return sself->IsScalarResult(); } -extern "C" int vtk_function_parser_is_vector_result(vtkNew sself) { return sself->IsVectorResult(); } -extern "C" double vtk_function_parser_get_scalar_result(vtkNew sself) { return sself->GetScalarResult(); } -extern "C" double* vtk_function_parser_get_vector_result(vtkNew sself) { return sself->GetVectorResult(); } -extern "C" void vtk_function_parser_get_vector_result(vtkNew sself, double result) { sself->GetVectorResult(result); } -extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, const char variableName, double value) { sself->SetScalarVariableValue(variableName, value); } -extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, const char* variableName, double value) { sself->SetScalarVariableValue(variableName, value); } -extern "C" void vtk_function_parser_set_scalar_variable_value(vtkNew sself, int i, double value) { sself->SetScalarVariableValue(i, value); } -extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, const char variableName) { return sself->GetScalarVariableValue(variableName); } -extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, const char* variableName) { return sself->GetScalarVariableValue(variableName); } -extern "C" double vtk_function_parser_get_scalar_variable_value(vtkNew sself, int i) { return sself->GetScalarVariableValue(i); } -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char variableName, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(variableName, xValue, yValue, zValue); } -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(variableName, xValue, yValue, zValue); } -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char variableName, const double values) { sself->SetVectorVariableValue(variableName, values); } -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, const char* variableName, const double values) { sself->SetVectorVariableValue(variableName, values); } -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, int i, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(i, xValue, yValue, zValue); } -extern "C" void vtk_function_parser_set_vector_variable_value(vtkNew sself, int i, const double values) { sself->SetVectorVariableValue(i, values); } -extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, const char variableName) { return sself->GetVectorVariableValue(variableName); } -extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName) { return sself->GetVectorVariableValue(variableName); } -extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, const char variableName, double value) { sself->GetVectorVariableValue(variableName, value); } -extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, const char* variableName, double value) { sself->GetVectorVariableValue(variableName, value); } -extern "C" double* vtk_function_parser_get_vector_variable_value(vtkNew sself, int i) { return sself->GetVectorVariableValue(i); } -extern "C" void vtk_function_parser_get_vector_variable_value(vtkNew sself, int i, double value) { sself->GetVectorVariableValue(i, value); } -extern "C" int vtk_function_parser_get_number_of_scalar_variables(vtkNew sself) { return sself->GetNumberOfScalarVariables(); } -extern "C" int vtk_function_parser_get_scalar_variable_index(vtkNew sself, const char name) { return sself->GetScalarVariableIndex(name); } -extern "C" int vtk_function_parser_get_scalar_variable_index(vtkNew sself, const char* name) { return sself->GetScalarVariableIndex(name); } -extern "C" int vtk_function_parser_get_number_of_vector_variables(vtkNew sself) { return sself->GetNumberOfVectorVariables(); } -extern "C" int vtk_function_parser_get_vector_variable_index(vtkNew sself, const char name) { return sself->GetVectorVariableIndex(name); } -extern "C" int vtk_function_parser_get_vector_variable_index(vtkNew sself, const char* name) { return sself->GetVectorVariableIndex(name); } -extern "C" const char* vtk_function_parser_get_scalar_variable_name(vtkNew sself, int i) { return sself->GetScalarVariableName(i); } -extern "C" const char* vtk_function_parser_get_vector_variable_name(vtkNew sself, int i) { return sself->GetVectorVariableName(i); } -extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, int i) { return sself->GetScalarVariableNeeded(i); } -extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, const char variableName) { return sself->GetScalarVariableNeeded(variableName); } -extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkNew sself, const char* variableName) { return sself->GetScalarVariableNeeded(variableName); } -extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, int i) { return sself->GetVectorVariableNeeded(i); } -extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, const char variableName) { return sself->GetVectorVariableNeeded(variableName); } -extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkNew sself, const char* variableName) { return sself->GetVectorVariableNeeded(variableName); } -extern "C" void vtk_function_parser_remove_all_variables(vtkNew sself) { sself->RemoveAllVariables(); } -extern "C" void vtk_function_parser_remove_scalar_variables(vtkNew sself) { sself->RemoveScalarVariables(); } -extern "C" void vtk_function_parser_remove_vector_variables(vtkNew sself) { sself->RemoveVectorVariables(); } -extern "C" void vtk_function_parser_set_replace_invalid_values(vtkNew sself, int _arg) { sself->SetReplaceInvalidValues(_arg); } -extern "C" int vtk_function_parser_get_replace_invalid_values(vtkNew sself) { return sself->GetReplaceInvalidValues(); } -extern "C" void vtk_function_parser_replace_invalid_values_on(vtkNew sself) { sself->ReplaceInvalidValuesOn(); } -extern "C" void vtk_function_parser_replace_invalid_values_off(vtkNew sself) { sself->ReplaceInvalidValuesOff(); } -extern "C" void vtk_function_parser_set_replacement_value(vtkNew sself, double _arg) { sself->SetReplacementValue(_arg); } -extern "C" double vtk_function_parser_get_replacement_value(vtkNew sself) { return sself->GetReplacementValue(); } -extern "C" void vtk_function_parser_check_expression(vtkNew sself, int pos, char error) { sself->CheckExpression(pos, error); } -extern "C" void vtk_function_parser_invalidate_function(vtkNew sself) { sself->InvalidateFunction(); } -extern "C" vtkNew < vtkHeap > vtkHeap_new () {return vtkNew < vtkHeap > () ;} -extern "C" void vtkHeap_destructor (vtkNew < vtkHeap > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHeap_get_ptr (vtkNew < vtkHeap > sself) {return sself . GetPointer () ;} -extern "C" void* vtk_heap_allocate_memory(vtkNew sself, size_t n) { return sself->AllocateMemory(n); } -extern "C" void vtk_heap_set_block_size(vtkNew sself, size_t p0) { sself->SetBlockSize(p0); } -extern "C" size_t vtk_heap_get_block_size(vtkNew sself) { return sself->GetBlockSize(); } -extern "C" int vtk_heap_get_number_of_blocks(vtkNew sself) { return sself->GetNumberOfBlocks(); } -extern "C" int vtk_heap_get_number_of_allocations(vtkNew sself) { return sself->GetNumberOfAllocations(); } -extern "C" void vtk_heap_reset(vtkNew sself) { sself->Reset(); } -extern "C" char* vtk_heap_string_dup(vtkNew sself, const char str) { return sself->StringDup(str); } -extern "C" vtkNew < vtkResourceFileLocator > vtkResourceFileLocator_new () {return vtkNew < vtkResourceFileLocator > () ;} -extern "C" void vtkResourceFileLocator_destructor (vtkNew < vtkResourceFileLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkResourceFileLocator_get_ptr (vtkNew < vtkResourceFileLocator > sself) {return sself . GetPointer () ;} -extern "C" void vtk_resource_file_locator_set_print_debug_information(vtkNew sself, bool p0) { sself->SetPrintDebugInformation(p0); } -extern "C" bool vtk_resource_file_locator_get_print_debug_information(vtkNew sself) { return sself->GetPrintDebugInformation(); } -extern "C" void vtk_resource_file_locator_print_debug_information_on(vtkNew sself) { sself->PrintDebugInformationOn(); } -extern "C" void vtk_resource_file_locator_print_debug_information_off(vtkNew sself) { sself->PrintDebugInformationOff(); } -extern "C" void vtk_resource_file_locator_set_log_verbosity(vtkNew sself, int _arg) { sself->SetLogVerbosity(_arg); } -extern "C" int vtk_resource_file_locator_get_log_verbosity(vtkNew sself) { return sself->GetLogVerbosity(); } -extern "C" const char* vtk_resource_file_locator_locate(vtkNew sself, const char* anchor, const char* landmark, const char* defaultDir) { return sself->Locate(anchor, landmark, defaultDir); } -extern "C" const char* vtk_resource_file_locator_get_library_path_for_symbol_unix(vtkNew sself, const char symbolname) { return sself->GetLibraryPathForSymbolUnix(symbolname); } -extern "C" const char* vtk_resource_file_locator_get_library_path_for_symbol_win_32(vtkNew sself, const void fptr) { return sself->GetLibraryPathForSymbolWin32(fptr); } +extern "C" vtkContourValues * vtkContourValues_new () {return vtkContourValues :: New () ;} +extern "C" void vtkContourValues_destructor (vtkContourValues * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkContourValues_get_ptr (vtkContourValues * sself) {return sself ;} +extern "C" void vtk_contour_values_set_value(vtkContourValues* sself, int i, double value) { sself->SetValue(i, value); } +extern "C" double vtk_contour_values_get_value(vtkContourValues* sself, int i) { return sself->GetValue(i); } +extern "C" void vtk_contour_values_set_number_of_contours(vtkContourValues* sself, const int number) { sself->SetNumberOfContours(number); } +extern "C" int vtk_contour_values_get_number_of_contours(vtkContourValues* sself) { return sself->GetNumberOfContours(); } +extern "C" void vtk_contour_values_generate_values(vtkContourValues* sself, int numContours, double rangeStart, double rangeEnd) { sself->GenerateValues(numContours, rangeStart, rangeEnd); } +extern "C" vtkExprTkFunctionParser * vtkExprTkFunctionParser_new () {return vtkExprTkFunctionParser :: New () ;} +extern "C" void vtkExprTkFunctionParser_destructor (vtkExprTkFunctionParser * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkExprTkFunctionParser_get_ptr (vtkExprTkFunctionParser * sself) {return sself ;} +extern "C" unsigned long vtk_expr_tk_function_parser_get_m_time(vtkExprTkFunctionParser* sself) { return sself->GetMTime(); } +extern "C" void vtk_expr_tk_function_parser_set_function(vtkExprTkFunctionParser* sself, const char* function) { sself->SetFunction(function); } +extern "C" const char* vtk_expr_tk_function_parser_get_function(vtkExprTkFunctionParser* sself) { return sself->GetFunction(); } +extern "C" int vtk_expr_tk_function_parser_is_scalar_result(vtkExprTkFunctionParser* sself) { return sself->IsScalarResult(); } +extern "C" int vtk_expr_tk_function_parser_is_vector_result(vtkExprTkFunctionParser* sself) { return sself->IsVectorResult(); } +extern "C" double vtk_expr_tk_function_parser_get_scalar_result(vtkExprTkFunctionParser* sself) { return sself->GetScalarResult(); } +extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName, double value) { sself->SetScalarVariableValue(variableName, value); } +extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName) { return sself->GetScalarVariableValue(variableName); } +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(variableName, xValue, yValue, zValue); } +extern "C" int vtk_expr_tk_function_parser_get_number_of_scalar_variables(vtkExprTkFunctionParser* sself) { return sself->GetNumberOfScalarVariables(); } +extern "C" int vtk_expr_tk_function_parser_get_scalar_variable_index(vtkExprTkFunctionParser* sself, const char*& name) { return sself->GetScalarVariableIndex(name); } +extern "C" int vtk_expr_tk_function_parser_get_number_of_vector_variables(vtkExprTkFunctionParser* sself) { return sself->GetNumberOfVectorVariables(); } +extern "C" int vtk_expr_tk_function_parser_get_vector_variable_index(vtkExprTkFunctionParser* sself, const char*& name) { return sself->GetVectorVariableIndex(name); } +extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkExprTkFunctionParser* sself, int i) { return sself->GetScalarVariableNeeded(i); } +extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkExprTkFunctionParser* sself, int i) { return sself->GetVectorVariableNeeded(i); } +extern "C" void vtk_expr_tk_function_parser_remove_all_variables(vtkExprTkFunctionParser* sself) { sself->RemoveAllVariables(); } +extern "C" void vtk_expr_tk_function_parser_remove_scalar_variables(vtkExprTkFunctionParser* sself) { sself->RemoveScalarVariables(); } +extern "C" void vtk_expr_tk_function_parser_remove_vector_variables(vtkExprTkFunctionParser* sself) { sself->RemoveVectorVariables(); } +extern "C" void vtk_expr_tk_function_parser_set_replace_invalid_values(vtkExprTkFunctionParser* sself, int _arg) { sself->SetReplaceInvalidValues(_arg); } +extern "C" int vtk_expr_tk_function_parser_get_replace_invalid_values(vtkExprTkFunctionParser* sself) { return sself->GetReplaceInvalidValues(); } +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_on(vtkExprTkFunctionParser* sself) { sself->ReplaceInvalidValuesOn(); } +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_off(vtkExprTkFunctionParser* sself) { sself->ReplaceInvalidValuesOff(); } +extern "C" void vtk_expr_tk_function_parser_set_replacement_value(vtkExprTkFunctionParser* sself, double _arg) { sself->SetReplacementValue(_arg); } +extern "C" double vtk_expr_tk_function_parser_get_replacement_value(vtkExprTkFunctionParser* sself) { return sself->GetReplacementValue(); } +extern "C" void vtk_expr_tk_function_parser_invalidate_function(vtkExprTkFunctionParser* sself) { sself->InvalidateFunction(); } +extern "C" vtkFunctionParser * vtkFunctionParser_new () {return vtkFunctionParser :: New () ;} +extern "C" void vtkFunctionParser_destructor (vtkFunctionParser * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkFunctionParser_get_ptr (vtkFunctionParser * sself) {return sself ;} +extern "C" unsigned long vtk_function_parser_get_m_time(vtkFunctionParser* sself) { return sself->GetMTime(); } +extern "C" void vtk_function_parser_set_function(vtkFunctionParser* sself, const char* function) { sself->SetFunction(function); } +extern "C" int vtk_function_parser_is_scalar_result(vtkFunctionParser* sself) { return sself->IsScalarResult(); } +extern "C" int vtk_function_parser_is_vector_result(vtkFunctionParser* sself) { return sself->IsVectorResult(); } +extern "C" double vtk_function_parser_get_scalar_result(vtkFunctionParser* sself) { return sself->GetScalarResult(); } +extern "C" void vtk_function_parser_set_scalar_variable_value(vtkFunctionParser* sself, const char* variableName, double value) { sself->SetScalarVariableValue(variableName, value); } +extern "C" double vtk_function_parser_get_scalar_variable_value(vtkFunctionParser* sself, const char* variableName) { return sself->GetScalarVariableValue(variableName); } +extern "C" void vtk_function_parser_set_vector_variable_value(vtkFunctionParser* sself, const char* variableName, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(variableName, xValue, yValue, zValue); } +extern "C" int vtk_function_parser_get_number_of_scalar_variables(vtkFunctionParser* sself) { return sself->GetNumberOfScalarVariables(); } +extern "C" int vtk_function_parser_get_scalar_variable_index(vtkFunctionParser* sself, const char* name) { return sself->GetScalarVariableIndex(name); } +extern "C" int vtk_function_parser_get_number_of_vector_variables(vtkFunctionParser* sself) { return sself->GetNumberOfVectorVariables(); } +extern "C" int vtk_function_parser_get_vector_variable_index(vtkFunctionParser* sself, const char* name) { return sself->GetVectorVariableIndex(name); } +extern "C" const char* vtk_function_parser_get_scalar_variable_name(vtkFunctionParser* sself, int i) { return sself->GetScalarVariableName(i); } +extern "C" const char* vtk_function_parser_get_vector_variable_name(vtkFunctionParser* sself, int i) { return sself->GetVectorVariableName(i); } +extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkFunctionParser* sself, int i) { return sself->GetScalarVariableNeeded(i); } +extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkFunctionParser* sself, int i) { return sself->GetVectorVariableNeeded(i); } +extern "C" void vtk_function_parser_remove_all_variables(vtkFunctionParser* sself) { sself->RemoveAllVariables(); } +extern "C" void vtk_function_parser_remove_scalar_variables(vtkFunctionParser* sself) { sself->RemoveScalarVariables(); } +extern "C" void vtk_function_parser_remove_vector_variables(vtkFunctionParser* sself) { sself->RemoveVectorVariables(); } +extern "C" void vtk_function_parser_set_replace_invalid_values(vtkFunctionParser* sself, int _arg) { sself->SetReplaceInvalidValues(_arg); } +extern "C" int vtk_function_parser_get_replace_invalid_values(vtkFunctionParser* sself) { return sself->GetReplaceInvalidValues(); } +extern "C" void vtk_function_parser_replace_invalid_values_on(vtkFunctionParser* sself) { sself->ReplaceInvalidValuesOn(); } +extern "C" void vtk_function_parser_replace_invalid_values_off(vtkFunctionParser* sself) { sself->ReplaceInvalidValuesOff(); } +extern "C" void vtk_function_parser_set_replacement_value(vtkFunctionParser* sself, double _arg) { sself->SetReplacementValue(_arg); } +extern "C" double vtk_function_parser_get_replacement_value(vtkFunctionParser* sself) { return sself->GetReplacementValue(); } +extern "C" void vtk_function_parser_invalidate_function(vtkFunctionParser* sself) { sself->InvalidateFunction(); } +extern "C" vtkHeap * vtkHeap_new () {return vtkHeap :: New () ;} +extern "C" void vtkHeap_destructor (vtkHeap * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHeap_get_ptr (vtkHeap * sself) {return sself ;} +extern "C" void* vtk_heap_allocate_memory(vtkHeap* sself, size_t n) { return sself->AllocateMemory(n); } +extern "C" void vtk_heap_set_block_size(vtkHeap* sself, size_t p0) { sself->SetBlockSize(p0); } +extern "C" size_t vtk_heap_get_block_size(vtkHeap* sself) { return sself->GetBlockSize(); } +extern "C" int vtk_heap_get_number_of_blocks(vtkHeap* sself) { return sself->GetNumberOfBlocks(); } +extern "C" int vtk_heap_get_number_of_allocations(vtkHeap* sself) { return sself->GetNumberOfAllocations(); } +extern "C" void vtk_heap_reset(vtkHeap* sself) { sself->Reset(); } +extern "C" vtkResourceFileLocator * vtkResourceFileLocator_new () {return vtkResourceFileLocator :: New () ;} +extern "C" void vtkResourceFileLocator_destructor (vtkResourceFileLocator * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkResourceFileLocator_get_ptr (vtkResourceFileLocator * sself) {return sself ;} +extern "C" void vtk_resource_file_locator_set_print_debug_information(vtkResourceFileLocator* sself, bool p0) { sself->SetPrintDebugInformation(p0); } +extern "C" bool vtk_resource_file_locator_get_print_debug_information(vtkResourceFileLocator* sself) { return sself->GetPrintDebugInformation(); } +extern "C" void vtk_resource_file_locator_print_debug_information_on(vtkResourceFileLocator* sself) { sself->PrintDebugInformationOn(); } +extern "C" void vtk_resource_file_locator_print_debug_information_off(vtkResourceFileLocator* sself) { sself->PrintDebugInformationOff(); } +extern "C" void vtk_resource_file_locator_set_log_verbosity(vtkResourceFileLocator* sself, int _arg) { sself->SetLogVerbosity(_arg); } +extern "C" int vtk_resource_file_locator_get_log_verbosity(vtkResourceFileLocator* sself) { return sself->GetLogVerbosity(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp index dcd8b09..698e9de 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp @@ -18,76 +18,75 @@ #include // Implement declared functions -extern "C" vtkNew < vtkClientSocket > vtkClientSocket_new () {return vtkNew < vtkClientSocket > () ;} -extern "C" void vtkClientSocket_destructor (vtkNew < vtkClientSocket > sself) {sself . Reset () ; return ;} -extern "C" void * vtkClientSocket_get_ptr (vtkNew < vtkClientSocket > sself) {return sself . GetPointer () ;} -extern "C" int vtk_client_socket_connect_to_server(vtkNew sself, const char hostname, int port) { return sself->ConnectToServer(hostname, port); } -extern "C" bool vtk_client_socket_get_connecting_side(vtkNew sself) { return sself->GetConnectingSide(); } -extern "C" vtkNew < vtkDirectory > vtkDirectory_new () {return vtkNew < vtkDirectory > () ;} -extern "C" void vtkDirectory_destructor (vtkNew < vtkDirectory > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDirectory_get_ptr (vtkNew < vtkDirectory > sself) {return sself . GetPointer () ;} -extern "C" int vtk_directory_open(vtkNew sself, const char dir) { return sself->Open(dir); } -extern "C" long long vtk_directory_get_number_of_files(vtkNew sself) { return sself->GetNumberOfFiles(); } -extern "C" const char* vtk_directory_get_file(vtkNew sself, long long index) { return sself->GetFile(index); } -extern "C" int vtk_directory_file_is_directory(vtkNew sself, const char name) { return sself->FileIsDirectory(name); } -extern "C" const char* vtk_directory_get_current_working_directory(vtkNew sself, char buf, unsigned int len) { return sself->GetCurrentWorkingDirectory(buf, len); } -extern "C" int vtk_directory_make_directory(vtkNew sself, const char dir) { return sself->MakeDirectory(dir); } -extern "C" int vtk_directory_delete_directory(vtkNew sself, const char dir) { return sself->DeleteDirectory(dir); } -extern "C" int vtk_directory_rename(vtkNew sself, const char oldname, const char newname) { return sself->Rename(oldname, newname); } -extern "C" vtkNew < vtkExecutableRunner > vtkExecutableRunner_new () {return vtkNew < vtkExecutableRunner > () ;} -extern "C" void vtkExecutableRunner_destructor (vtkNew < vtkExecutableRunner > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExecutableRunner_get_ptr (vtkNew < vtkExecutableRunner > sself) {return sself . GetPointer () ;} -extern "C" void vtk_executable_runner_execute(vtkNew sself) { sself->Execute(); } -extern "C" void vtk_executable_runner_set_timeout(vtkNew sself, double _arg) { sself->SetTimeout(_arg); } -extern "C" double vtk_executable_runner_get_timeout(vtkNew sself) { return sself->GetTimeout(); } -extern "C" void vtk_executable_runner_set_right_trim_result(vtkNew sself, bool _arg) { sself->SetRightTrimResult(_arg); } -extern "C" bool vtk_executable_runner_get_right_trim_result(vtkNew sself) { return sself->GetRightTrimResult(); } -extern "C" void vtk_executable_runner_right_trim_result_on(vtkNew sself) { sself->RightTrimResultOn(); } -extern "C" void vtk_executable_runner_right_trim_result_off(vtkNew sself) { sself->RightTrimResultOff(); } -extern "C" const char* vtk_executable_runner_get_command(vtkNew sself) { return sself->GetCommand(); } -extern "C" void vtk_executable_runner_set_command(vtkNew sself, const char arg) { sself->SetCommand(arg); } -extern "C" const char* vtk_executable_runner_get_std_out(vtkNew sself) { return sself->GetStdOut(); } -extern "C" const char* vtk_executable_runner_get_std_err(vtkNew sself) { return sself->GetStdErr(); } -extern "C" int vtk_executable_runner_get_return_value(vtkNew sself) { return sself->GetReturnValue(); } -extern "C" vtkNew < vtkServerSocket > vtkServerSocket_new () {return vtkNew < vtkServerSocket > () ;} -extern "C" void vtkServerSocket_destructor (vtkNew < vtkServerSocket > sself) {sself . Reset () ; return ;} -extern "C" void * vtkServerSocket_get_ptr (vtkNew < vtkServerSocket > sself) {return sself . GetPointer () ;} -extern "C" int vtk_server_socket_create_server(vtkNew sself, int port) { return sself->CreateServer(port); } -extern "C" int vtk_server_socket_get_server_port(vtkNew sself) { return sself->GetServerPort(); } -extern "C" vtkNew < vtkSocketCollection > vtkSocketCollection_new () {return vtkNew < vtkSocketCollection > () ;} -extern "C" void vtkSocketCollection_destructor (vtkNew < vtkSocketCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSocketCollection_get_ptr (vtkNew < vtkSocketCollection > sself) {return sself . GetPointer () ;} -extern "C" int vtk_socket_collection_select_sockets(vtkNew sself, unsigned long msec) { return sself->SelectSockets(msec); } -extern "C" vtkNew < vtkThreadMessager > vtkThreadMessager_new () {return vtkNew < vtkThreadMessager > () ;} -extern "C" void vtkThreadMessager_destructor (vtkNew < vtkThreadMessager > sself) {sself . Reset () ; return ;} -extern "C" void * vtkThreadMessager_get_ptr (vtkNew < vtkThreadMessager > sself) {return sself . GetPointer () ;} -extern "C" void vtk_thread_messager_wait_for_message(vtkNew sself) { sself->WaitForMessage(); } -extern "C" void vtk_thread_messager_send_wake_message(vtkNew sself) { sself->SendWakeMessage(); } -extern "C" void vtk_thread_messager_enable_wait_for_receiver(vtkNew sself) { sself->EnableWaitForReceiver(); } -extern "C" void vtk_thread_messager_disable_wait_for_receiver(vtkNew sself) { sself->DisableWaitForReceiver(); } -extern "C" void vtk_thread_messager_wait_for_receiver(vtkNew sself) { sself->WaitForReceiver(); } -extern "C" vtkNew < vtkTimerLog > vtkTimerLog_new () {return vtkNew < vtkTimerLog > () ;} -extern "C" void vtkTimerLog_destructor (vtkNew < vtkTimerLog > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTimerLog_get_ptr (vtkNew < vtkTimerLog > sself) {return sself . GetPointer () ;} -extern "C" void vtk_timer_log_set_logging(vtkNew sself, int v) { sself->SetLogging(v); } -extern "C" int vtk_timer_log_get_logging(vtkNew sself) { return sself->GetLogging(); } -extern "C" void vtk_timer_log_logging_on(vtkNew sself) { sself->LoggingOn(); } -extern "C" void vtk_timer_log_logging_off(vtkNew sself) { sself->LoggingOff(); } -extern "C" void vtk_timer_log_set_max_entries(vtkNew sself, int a) { sself->SetMaxEntries(a); } -extern "C" int vtk_timer_log_get_max_entries(vtkNew sself) { return sself->GetMaxEntries(); } -extern "C" void vtk_timer_log_dump_log(vtkNew sself, const char filename) { sself->DumpLog(filename); } -extern "C" void vtk_timer_log_mark_start_event(vtkNew sself, const char EventString) { sself->MarkStartEvent(EventString); } -extern "C" void vtk_timer_log_mark_end_event(vtkNew sself, const char EventString) { sself->MarkEndEvent(EventString); } -extern "C" void vtk_timer_log_insert_timed_event(vtkNew sself, const char EventString, double time, int cpuTicks) { sself->InsertTimedEvent(EventString, time, cpuTicks); } -extern "C" int vtk_timer_log_get_number_of_events(vtkNew sself) { return sself->GetNumberOfEvents(); } -extern "C" int vtk_timer_log_get_event_indent(vtkNew sself, int i) { return sself->GetEventIndent(i); } -extern "C" double vtk_timer_log_get_event_wall_time(vtkNew sself, int i) { return sself->GetEventWallTime(i); } -extern "C" const char* vtk_timer_log_get_event_string(vtkNew sself, int i) { return sself->GetEventString(i); } -extern "C" void vtk_timer_log_mark_event(vtkNew sself, const char EventString) { sself->MarkEvent(EventString); } -extern "C" void vtk_timer_log_reset_log(vtkNew sself) { sself->ResetLog(); } -extern "C" void vtk_timer_log_cleanup_log(vtkNew sself) { sself->CleanupLog(); } -extern "C" double vtk_timer_log_get_universal_time(vtkNew sself) { return sself->GetUniversalTime(); } -extern "C" double vtk_timer_log_get_cpu_time(vtkNew sself) { return sself->GetCPUTime(); } -extern "C" void vtk_timer_log_start_timer(vtkNew sself) { sself->StartTimer(); } -extern "C" void vtk_timer_log_stop_timer(vtkNew sself) { sself->StopTimer(); } -extern "C" double vtk_timer_log_get_elapsed_time(vtkNew sself) { return sself->GetElapsedTime(); } +extern "C" vtkClientSocket * vtkClientSocket_new () {return vtkClientSocket :: New () ;} +extern "C" void vtkClientSocket_destructor (vtkClientSocket * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkClientSocket_get_ptr (vtkClientSocket * sself) {return sself ;} +extern "C" int vtk_client_socket_connect_to_server(vtkClientSocket* sself, const char* hostname, int port) { return sself->ConnectToServer(hostname, port); } +extern "C" bool vtk_client_socket_get_connecting_side(vtkClientSocket* sself) { return sself->GetConnectingSide(); } +extern "C" vtkDirectory * vtkDirectory_new () {return vtkDirectory :: New () ;} +extern "C" void vtkDirectory_destructor (vtkDirectory * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDirectory_get_ptr (vtkDirectory * sself) {return sself ;} +extern "C" int vtk_directory_open(vtkDirectory* sself, const char* dir) { return sself->Open(dir); } +extern "C" long long vtk_directory_get_number_of_files(vtkDirectory* sself) { return sself->GetNumberOfFiles(); } +extern "C" const char* vtk_directory_get_file(vtkDirectory* sself, long long index) { return sself->GetFile(index); } +extern "C" int vtk_directory_file_is_directory(vtkDirectory* sself, const char* name) { return sself->FileIsDirectory(name); } +extern "C" int vtk_directory_make_directory(vtkDirectory* sself, const char* dir) { return sself->MakeDirectory(dir); } +extern "C" int vtk_directory_delete_directory(vtkDirectory* sself, const char* dir) { return sself->DeleteDirectory(dir); } +extern "C" int vtk_directory_rename(vtkDirectory* sself, const char* oldname, const char* newname) { return sself->Rename(oldname, newname); } +extern "C" vtkExecutableRunner * vtkExecutableRunner_new () {return vtkExecutableRunner :: New () ;} +extern "C" void vtkExecutableRunner_destructor (vtkExecutableRunner * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkExecutableRunner_get_ptr (vtkExecutableRunner * sself) {return sself ;} +extern "C" void vtk_executable_runner_execute(vtkExecutableRunner* sself) { sself->Execute(); } +extern "C" void vtk_executable_runner_set_timeout(vtkExecutableRunner* sself, double _arg) { sself->SetTimeout(_arg); } +extern "C" double vtk_executable_runner_get_timeout(vtkExecutableRunner* sself) { return sself->GetTimeout(); } +extern "C" void vtk_executable_runner_set_right_trim_result(vtkExecutableRunner* sself, bool _arg) { sself->SetRightTrimResult(_arg); } +extern "C" bool vtk_executable_runner_get_right_trim_result(vtkExecutableRunner* sself) { return sself->GetRightTrimResult(); } +extern "C" void vtk_executable_runner_right_trim_result_on(vtkExecutableRunner* sself) { sself->RightTrimResultOn(); } +extern "C" void vtk_executable_runner_right_trim_result_off(vtkExecutableRunner* sself) { sself->RightTrimResultOff(); } +extern "C" const char* vtk_executable_runner_get_command(vtkExecutableRunner* sself) { return sself->GetCommand(); } +extern "C" void vtk_executable_runner_set_command(vtkExecutableRunner* sself, const char* arg) { sself->SetCommand(arg); } +extern "C" const char* vtk_executable_runner_get_std_out(vtkExecutableRunner* sself) { return sself->GetStdOut(); } +extern "C" const char* vtk_executable_runner_get_std_err(vtkExecutableRunner* sself) { return sself->GetStdErr(); } +extern "C" int vtk_executable_runner_get_return_value(vtkExecutableRunner* sself) { return sself->GetReturnValue(); } +extern "C" vtkServerSocket * vtkServerSocket_new () {return vtkServerSocket :: New () ;} +extern "C" void vtkServerSocket_destructor (vtkServerSocket * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkServerSocket_get_ptr (vtkServerSocket * sself) {return sself ;} +extern "C" int vtk_server_socket_create_server(vtkServerSocket* sself, int port) { return sself->CreateServer(port); } +extern "C" int vtk_server_socket_get_server_port(vtkServerSocket* sself) { return sself->GetServerPort(); } +extern "C" vtkSocketCollection * vtkSocketCollection_new () {return vtkSocketCollection :: New () ;} +extern "C" void vtkSocketCollection_destructor (vtkSocketCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSocketCollection_get_ptr (vtkSocketCollection * sself) {return sself ;} +extern "C" int vtk_socket_collection_select_sockets(vtkSocketCollection* sself, unsigned long msec) { return sself->SelectSockets(msec); } +extern "C" vtkThreadMessager * vtkThreadMessager_new () {return vtkThreadMessager :: New () ;} +extern "C" void vtkThreadMessager_destructor (vtkThreadMessager * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkThreadMessager_get_ptr (vtkThreadMessager * sself) {return sself ;} +extern "C" void vtk_thread_messager_wait_for_message(vtkThreadMessager* sself) { sself->WaitForMessage(); } +extern "C" void vtk_thread_messager_send_wake_message(vtkThreadMessager* sself) { sself->SendWakeMessage(); } +extern "C" void vtk_thread_messager_enable_wait_for_receiver(vtkThreadMessager* sself) { sself->EnableWaitForReceiver(); } +extern "C" void vtk_thread_messager_disable_wait_for_receiver(vtkThreadMessager* sself) { sself->DisableWaitForReceiver(); } +extern "C" void vtk_thread_messager_wait_for_receiver(vtkThreadMessager* sself) { sself->WaitForReceiver(); } +extern "C" vtkTimerLog * vtkTimerLog_new () {return vtkTimerLog :: New () ;} +extern "C" void vtkTimerLog_destructor (vtkTimerLog * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTimerLog_get_ptr (vtkTimerLog * sself) {return sself ;} +extern "C" void vtk_timer_log_set_logging(vtkTimerLog* sself, int v) { sself->SetLogging(v); } +extern "C" int vtk_timer_log_get_logging(vtkTimerLog* sself) { return sself->GetLogging(); } +extern "C" void vtk_timer_log_logging_on(vtkTimerLog* sself) { sself->LoggingOn(); } +extern "C" void vtk_timer_log_logging_off(vtkTimerLog* sself) { sself->LoggingOff(); } +extern "C" void vtk_timer_log_set_max_entries(vtkTimerLog* sself, int a) { sself->SetMaxEntries(a); } +extern "C" int vtk_timer_log_get_max_entries(vtkTimerLog* sself) { return sself->GetMaxEntries(); } +extern "C" void vtk_timer_log_dump_log(vtkTimerLog* sself, const char* filename) { sself->DumpLog(filename); } +extern "C" void vtk_timer_log_mark_start_event(vtkTimerLog* sself, const char* EventString) { sself->MarkStartEvent(EventString); } +extern "C" void vtk_timer_log_mark_end_event(vtkTimerLog* sself, const char* EventString) { sself->MarkEndEvent(EventString); } +extern "C" void vtk_timer_log_insert_timed_event(vtkTimerLog* sself, const char* EventString, double time, int cpuTicks) { sself->InsertTimedEvent(EventString, time, cpuTicks); } +extern "C" int vtk_timer_log_get_number_of_events(vtkTimerLog* sself) { return sself->GetNumberOfEvents(); } +extern "C" int vtk_timer_log_get_event_indent(vtkTimerLog* sself, int i) { return sself->GetEventIndent(i); } +extern "C" double vtk_timer_log_get_event_wall_time(vtkTimerLog* sself, int i) { return sself->GetEventWallTime(i); } +extern "C" const char* vtk_timer_log_get_event_string(vtkTimerLog* sself, int i) { return sself->GetEventString(i); } +extern "C" void vtk_timer_log_mark_event(vtkTimerLog* sself, const char* EventString) { sself->MarkEvent(EventString); } +extern "C" void vtk_timer_log_reset_log(vtkTimerLog* sself) { sself->ResetLog(); } +extern "C" void vtk_timer_log_cleanup_log(vtkTimerLog* sself) { sself->CleanupLog(); } +extern "C" double vtk_timer_log_get_universal_time(vtkTimerLog* sself) { return sself->GetUniversalTime(); } +extern "C" double vtk_timer_log_get_cpu_time(vtkTimerLog* sself) { return sself->GetCPUTime(); } +extern "C" void vtk_timer_log_start_timer(vtkTimerLog* sself) { sself->StartTimer(); } +extern "C" void vtk_timer_log_stop_timer(vtkTimerLog* sself) { sself->StopTimer(); } +extern "C" double vtk_timer_log_get_elapsed_time(vtkTimerLog* sself) { return sself->GetElapsedTime(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp index dbc01da..e26b45c 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp @@ -27,180 +27,123 @@ #include // Implement declared functions -extern "C" vtkNew < vtkCylindricalTransform > vtkCylindricalTransform_new () {return vtkNew < vtkCylindricalTransform > () ;} -extern "C" void vtkCylindricalTransform_destructor (vtkNew < vtkCylindricalTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCylindricalTransform_get_ptr (vtkNew < vtkCylindricalTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGeneralTransform > vtkGeneralTransform_new () {return vtkNew < vtkGeneralTransform > () ;} -extern "C" void vtkGeneralTransform_destructor (vtkNew < vtkGeneralTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGeneralTransform_get_ptr (vtkNew < vtkGeneralTransform > sself) {return sself . GetPointer () ;} -extern "C" void vtk_general_transform_identity(vtkNew sself) { sself->Identity(); } -extern "C" void vtk_general_transform_inverse(vtkNew sself) { sself->Inverse(); } -extern "C" void vtk_general_transform_translate(vtkNew sself, double x, double y, double z) { sself->Translate(x, y, z); } -extern "C" void vtk_general_transform_translate(vtkNew sself, const double x) { sself->Translate(x); } -extern "C" void vtk_general_transform_translate(vtkNew sself, const float x) { sself->Translate(x); } -extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } -extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, const double axis) { sself->RotateWXYZ(angle, axis); } -extern "C" void vtk_general_transform_rotate_wxyz(vtkNew sself, double angle, const float axis) { sself->RotateWXYZ(angle, axis); } -extern "C" void vtk_general_transform_rotate_x(vtkNew sself, double angle) { sself->RotateX(angle); } -extern "C" void vtk_general_transform_rotate_y(vtkNew sself, double angle) { sself->RotateY(angle); } -extern "C" void vtk_general_transform_rotate_z(vtkNew sself, double angle) { sself->RotateZ(angle); } -extern "C" void vtk_general_transform_scale(vtkNew sself, double x, double y, double z) { sself->Scale(x, y, z); } -extern "C" void vtk_general_transform_scale(vtkNew sself, const double s) { sself->Scale(s); } -extern "C" void vtk_general_transform_scale(vtkNew sself, const float s) { sself->Scale(s); } -extern "C" void vtk_general_transform_concatenate(vtkNew sself, const double elements) { sself->Concatenate(elements); } -extern "C" void vtk_general_transform_pre_multiply(vtkNew sself) { sself->PreMultiply(); } -extern "C" void vtk_general_transform_post_multiply(vtkNew sself) { sself->PostMultiply(); } -extern "C" int vtk_general_transform_get_number_of_concatenated_transforms(vtkNew sself) { return sself->GetNumberOfConcatenatedTransforms(); } -extern "C" int vtk_general_transform_get_inverse_flag(vtkNew sself) { return sself->GetInverseFlag(); } -extern "C" void vtk_general_transform_push(vtkNew sself) { sself->Push(); } -extern "C" void vtk_general_transform_pop(vtkNew sself) { sself->Pop(); } -extern "C" void vtk_general_transform_internal_transform_point(vtkNew sself, const float in, float out) { sself->InternalTransformPoint(in, out); } -extern "C" void vtk_general_transform_internal_transform_point(vtkNew sself, const double in, double out) { sself->InternalTransformPoint(in, out); } -extern "C" void vtk_general_transform_internal_transform_derivative(vtkNew sself, const float in, float out, float derivative) { sself->InternalTransformDerivative(in, out, derivative); } -extern "C" void vtk_general_transform_internal_transform_derivative(vtkNew sself, const double in, double out, double derivative) { sself->InternalTransformDerivative(in, out, derivative); } -extern "C" unsigned long vtk_general_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkIdentityTransform > vtkIdentityTransform_new () {return vtkNew < vtkIdentityTransform > () ;} -extern "C" void vtkIdentityTransform_destructor (vtkNew < vtkIdentityTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIdentityTransform_get_ptr (vtkNew < vtkIdentityTransform > sself) {return sself . GetPointer () ;} -extern "C" void vtk_identity_transform_inverse(vtkNew sself) { sself->Inverse(); } -extern "C" vtkNew < vtkLandmarkTransform > vtkLandmarkTransform_new () {return vtkNew < vtkLandmarkTransform > () ;} -extern "C" void vtkLandmarkTransform_destructor (vtkNew < vtkLandmarkTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLandmarkTransform_get_ptr (vtkNew < vtkLandmarkTransform > sself) {return sself . GetPointer () ;} -extern "C" void vtk_landmark_transform_set_mode(vtkNew sself, int _arg) { sself->SetMode(_arg); } -extern "C" void vtk_landmark_transform_set_mode_to_rigid_body(vtkNew sself) { sself->SetModeToRigidBody(); } -extern "C" void vtk_landmark_transform_set_mode_to_similarity(vtkNew sself) { sself->SetModeToSimilarity(); } -extern "C" void vtk_landmark_transform_set_mode_to_affine(vtkNew sself) { sself->SetModeToAffine(); } -extern "C" int vtk_landmark_transform_get_mode(vtkNew sself) { return sself->GetMode(); } -extern "C" const char* vtk_landmark_transform_get_mode_as_string(vtkNew sself) { return sself->GetModeAsString(); } -extern "C" void vtk_landmark_transform_inverse(vtkNew sself) { sself->Inverse(); } -extern "C" unsigned long vtk_landmark_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkMatrixToHomogeneousTransform > vtkMatrixToHomogeneousTransform_new () {return vtkNew < vtkMatrixToHomogeneousTransform > () ;} -extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkNew < vtkMatrixToHomogeneousTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMatrixToHomogeneousTransform_get_ptr (vtkNew < vtkMatrixToHomogeneousTransform > sself) {return sself . GetPointer () ;} -extern "C" void vtk_matrix_to_homogeneous_transform_inverse(vtkNew sself) { sself->Inverse(); } -extern "C" unsigned long vtk_matrix_to_homogeneous_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkMatrixToLinearTransform > vtkMatrixToLinearTransform_new () {return vtkNew < vtkMatrixToLinearTransform > () ;} -extern "C" void vtkMatrixToLinearTransform_destructor (vtkNew < vtkMatrixToLinearTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMatrixToLinearTransform_get_ptr (vtkNew < vtkMatrixToLinearTransform > sself) {return sself . GetPointer () ;} -extern "C" void vtk_matrix_to_linear_transform_inverse(vtkNew sself) { sself->Inverse(); } -extern "C" unsigned long vtk_matrix_to_linear_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkPerspectiveTransform > vtkPerspectiveTransform_new () {return vtkNew < vtkPerspectiveTransform > () ;} -extern "C" void vtkPerspectiveTransform_destructor (vtkNew < vtkPerspectiveTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPerspectiveTransform_get_ptr (vtkNew < vtkPerspectiveTransform > sself) {return sself . GetPointer () ;} -extern "C" void vtk_perspective_transform_identity(vtkNew sself) { sself->Identity(); } -extern "C" void vtk_perspective_transform_inverse(vtkNew sself) { sself->Inverse(); } -extern "C" void vtk_perspective_transform_adjust_viewport(vtkNew sself, double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax) { sself->AdjustViewport(oldXMin, oldXMax, oldYMin, oldYMax, newXMin, newXMax, newYMin, newYMax); } -extern "C" void vtk_perspective_transform_adjust_z_buffer(vtkNew sself, double oldNearZ, double oldFarZ, double newNearZ, double newFarZ) { sself->AdjustZBuffer(oldNearZ, oldFarZ, newNearZ, newFarZ); } -extern "C" void vtk_perspective_transform_ortho(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar) { sself->Ortho(xmin, xmax, ymin, ymax, znear, zfar); } -extern "C" void vtk_perspective_transform_frustum(vtkNew sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar) { sself->Frustum(xmin, xmax, ymin, ymax, znear, zfar); } -extern "C" void vtk_perspective_transform_perspective(vtkNew sself, double angle, double aspect, double znear, double zfar) { sself->Perspective(angle, aspect, znear, zfar); } -extern "C" void vtk_perspective_transform_shear(vtkNew sself, double dxdz, double dydz, double zplane) { sself->Shear(dxdz, dydz, zplane); } -extern "C" void vtk_perspective_transform_stereo(vtkNew sself, double angle, double focaldistance) { sself->Stereo(angle, focaldistance); } -extern "C" void vtk_perspective_transform_setup_camera(vtkNew sself, const double position, const double focalpoint, const double viewup) { sself->SetupCamera(position, focalpoint, viewup); } -extern "C" void vtk_perspective_transform_setup_camera(vtkNew sself, double p0, double p1, double p2, double fp0, double fp1, double fp2, double vup0, double vup1, double vup2) { sself->SetupCamera(p0, p1, p2, fp0, fp1, fp2, vup0, vup1, vup2); } -extern "C" void vtk_perspective_transform_translate(vtkNew sself, double x, double y, double z) { sself->Translate(x, y, z); } -extern "C" void vtk_perspective_transform_translate(vtkNew sself, const double x) { sself->Translate(x); } -extern "C" void vtk_perspective_transform_translate(vtkNew sself, const float x) { sself->Translate(x); } -extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } -extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, const double axis) { sself->RotateWXYZ(angle, axis); } -extern "C" void vtk_perspective_transform_rotate_wxyz(vtkNew sself, double angle, const float axis) { sself->RotateWXYZ(angle, axis); } -extern "C" void vtk_perspective_transform_rotate_x(vtkNew sself, double angle) { sself->RotateX(angle); } -extern "C" void vtk_perspective_transform_rotate_y(vtkNew sself, double angle) { sself->RotateY(angle); } -extern "C" void vtk_perspective_transform_rotate_z(vtkNew sself, double angle) { sself->RotateZ(angle); } -extern "C" void vtk_perspective_transform_scale(vtkNew sself, double x, double y, double z) { sself->Scale(x, y, z); } -extern "C" void vtk_perspective_transform_scale(vtkNew sself, const double s) { sself->Scale(s); } -extern "C" void vtk_perspective_transform_scale(vtkNew sself, const float s) { sself->Scale(s); } -extern "C" void vtk_perspective_transform_set_matrix(vtkNew sself, const double elements) { sself->SetMatrix(elements); } -extern "C" void vtk_perspective_transform_concatenate(vtkNew sself, const double elements) { sself->Concatenate(elements); } -extern "C" void vtk_perspective_transform_pre_multiply(vtkNew sself) { sself->PreMultiply(); } -extern "C" void vtk_perspective_transform_post_multiply(vtkNew sself) { sself->PostMultiply(); } -extern "C" int vtk_perspective_transform_get_number_of_concatenated_transforms(vtkNew sself) { return sself->GetNumberOfConcatenatedTransforms(); } -extern "C" int vtk_perspective_transform_get_inverse_flag(vtkNew sself) { return sself->GetInverseFlag(); } -extern "C" void vtk_perspective_transform_push(vtkNew sself) { sself->Push(); } -extern "C" void vtk_perspective_transform_pop(vtkNew sself) { sself->Pop(); } -extern "C" unsigned long vtk_perspective_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" vtkNew < vtkSphericalTransform > vtkSphericalTransform_new () {return vtkNew < vtkSphericalTransform > () ;} -extern "C" void vtkSphericalTransform_destructor (vtkNew < vtkSphericalTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSphericalTransform_get_ptr (vtkNew < vtkSphericalTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkThinPlateSplineTransform > vtkThinPlateSplineTransform_new () {return vtkNew < vtkThinPlateSplineTransform > () ;} -extern "C" void vtkThinPlateSplineTransform_destructor (vtkNew < vtkThinPlateSplineTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkThinPlateSplineTransform_get_ptr (vtkNew < vtkThinPlateSplineTransform > sself) {return sself . GetPointer () ;} -extern "C" double vtk_thin_plate_spline_transform_get_sigma(vtkNew sself) { return sself->GetSigma(); } -extern "C" void vtk_thin_plate_spline_transform_set_sigma(vtkNew sself, double _arg) { sself->SetSigma(_arg); } -extern "C" void vtk_thin_plate_spline_transform_set_basis(vtkNew sself, int basis) { sself->SetBasis(basis); } -extern "C" int vtk_thin_plate_spline_transform_get_basis(vtkNew sself) { return sself->GetBasis(); } -extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r(vtkNew sself) { sself->SetBasisToR(); } -extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(vtkNew sself) { sself->SetBasisToR2LogR(); } -extern "C" const char* vtk_thin_plate_spline_transform_get_basis_as_string(vtkNew sself) { return sself->GetBasisAsString(); } -extern "C" unsigned long vtk_thin_plate_spline_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" bool vtk_thin_plate_spline_transform_get_regularize_bulk_transform(vtkNew sself) { return sself->GetRegularizeBulkTransform(); } -extern "C" void vtk_thin_plate_spline_transform_set_regularize_bulk_transform(vtkNew sself, bool _arg) { sself->SetRegularizeBulkTransform(_arg); } -extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_on(vtkNew sself) { sself->RegularizeBulkTransformOn(); } -extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_off(vtkNew sself) { sself->RegularizeBulkTransformOff(); } -extern "C" vtkNew < vtkTransform > vtkTransform_new () {return vtkNew < vtkTransform > () ;} -extern "C" void vtkTransform_destructor (vtkNew < vtkTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTransform_get_ptr (vtkNew < vtkTransform > sself) {return sself . GetPointer () ;} -extern "C" void vtk_transform_identity(vtkNew sself) { sself->Identity(); } -extern "C" void vtk_transform_inverse(vtkNew sself) { sself->Inverse(); } -extern "C" void vtk_transform_translate(vtkNew sself, double x, double y, double z) { sself->Translate(x, y, z); } -extern "C" void vtk_transform_translate(vtkNew sself, const double x) { sself->Translate(x); } -extern "C" void vtk_transform_translate(vtkNew sself, const float x) { sself->Translate(x); } -extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } -extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, const double axis) { sself->RotateWXYZ(angle, axis); } -extern "C" void vtk_transform_rotate_wxyz(vtkNew sself, double angle, const float axis) { sself->RotateWXYZ(angle, axis); } -extern "C" void vtk_transform_rotate_x(vtkNew sself, double angle) { sself->RotateX(angle); } -extern "C" void vtk_transform_rotate_y(vtkNew sself, double angle) { sself->RotateY(angle); } -extern "C" void vtk_transform_rotate_z(vtkNew sself, double angle) { sself->RotateZ(angle); } -extern "C" void vtk_transform_scale(vtkNew sself, double x, double y, double z) { sself->Scale(x, y, z); } -extern "C" void vtk_transform_scale(vtkNew sself, const double s) { sself->Scale(s); } -extern "C" void vtk_transform_scale(vtkNew sself, const float s) { sself->Scale(s); } -extern "C" void vtk_transform_set_matrix(vtkNew sself, const double elements) { sself->SetMatrix(elements); } -extern "C" void vtk_transform_concatenate(vtkNew sself, const double elements) { sself->Concatenate(elements); } -extern "C" void vtk_transform_pre_multiply(vtkNew sself) { sself->PreMultiply(); } -extern "C" void vtk_transform_post_multiply(vtkNew sself) { sself->PostMultiply(); } -extern "C" int vtk_transform_get_number_of_concatenated_transforms(vtkNew sself) { return sself->GetNumberOfConcatenatedTransforms(); } -extern "C" void vtk_transform_get_orientation(vtkNew sself, double orient) { sself->GetOrientation(orient); } -extern "C" void vtk_transform_get_orientation(vtkNew sself, float orient) { sself->GetOrientation(orient); } -extern "C" double* vtk_transform_get_orientation(vtkNew sself) { return sself->GetOrientation(); } -extern "C" void vtk_transform_get_orientation_wxyz(vtkNew sself, double wxyz) { sself->GetOrientationWXYZ(wxyz); } -extern "C" void vtk_transform_get_orientation_wxyz(vtkNew sself, float wxyz) { sself->GetOrientationWXYZ(wxyz); } -extern "C" double* vtk_transform_get_orientation_wxyz(vtkNew sself) { return sself->GetOrientationWXYZ(); } -extern "C" void vtk_transform_get_position(vtkNew sself, double pos) { sself->GetPosition(pos); } -extern "C" void vtk_transform_get_position(vtkNew sself, float pos) { sself->GetPosition(pos); } -extern "C" double* vtk_transform_get_position(vtkNew sself) { return sself->GetPosition(); } -extern "C" void vtk_transform_get_scale(vtkNew sself, double scale) { sself->GetScale(scale); } -extern "C" void vtk_transform_get_scale(vtkNew sself, float scale) { sself->GetScale(scale); } -extern "C" double* vtk_transform_get_scale(vtkNew sself) { return sself->GetScale(); } -extern "C" int vtk_transform_get_inverse_flag(vtkNew sself) { return sself->GetInverseFlag(); } -extern "C" void vtk_transform_push(vtkNew sself) { sself->Push(); } -extern "C" void vtk_transform_pop(vtkNew sself) { sself->Pop(); } -extern "C" unsigned long vtk_transform_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_transform_multiply_point(vtkNew sself, const float in, float out) { sself->MultiplyPoint(in, out); } -extern "C" void vtk_transform_multiply_point(vtkNew sself, const double in, double out) { sself->MultiplyPoint(in, out); } -extern "C" vtkNew < vtkTransform2D > vtkTransform2D_new () {return vtkNew < vtkTransform2D > () ;} -extern "C" void vtkTransform2D_destructor (vtkNew < vtkTransform2D > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTransform2D_get_ptr (vtkNew < vtkTransform2D > sself) {return sself . GetPointer () ;} -extern "C" void vtk_transform_2_d_identity(vtkNew sself) { sself->Identity(); } -extern "C" void vtk_transform_2_d_inverse(vtkNew sself) { sself->Inverse(); } -extern "C" void vtk_transform_2_d_translate(vtkNew sself, double x, double y) { sself->Translate(x, y); } -extern "C" void vtk_transform_2_d_translate(vtkNew sself, const double x) { sself->Translate(x); } -extern "C" void vtk_transform_2_d_translate(vtkNew sself, const float x) { sself->Translate(x); } -extern "C" void vtk_transform_2_d_rotate(vtkNew sself, double angle) { sself->Rotate(angle); } -extern "C" void vtk_transform_2_d_scale(vtkNew sself, double x, double y) { sself->Scale(x, y); } -extern "C" void vtk_transform_2_d_scale(vtkNew sself, const double s) { sself->Scale(s); } -extern "C" void vtk_transform_2_d_scale(vtkNew sself, const float s) { sself->Scale(s); } -extern "C" void vtk_transform_2_d_set_matrix(vtkNew sself, const double elements) { sself->SetMatrix(elements); } -extern "C" void vtk_transform_2_d_get_position(vtkNew sself, double pos) { sself->GetPosition(pos); } -extern "C" void vtk_transform_2_d_get_position(vtkNew sself, float pos) { sself->GetPosition(pos); } -extern "C" void vtk_transform_2_d_get_scale(vtkNew sself, double scale) { sself->GetScale(scale); } -extern "C" void vtk_transform_2_d_get_scale(vtkNew sself, float pos) { sself->GetScale(pos); } -extern "C" unsigned long vtk_transform_2_d_get_m_time(vtkNew sself) { return sself->GetMTime(); } -extern "C" void vtk_transform_2_d_transform_points(vtkNew sself, const float inPts, float outPts, int n) { sself->TransformPoints(inPts, outPts, n); } -extern "C" void vtk_transform_2_d_transform_points(vtkNew sself, const double inPts, double outPts, int n) { sself->TransformPoints(inPts, outPts, n); } -extern "C" void vtk_transform_2_d_inverse_transform_points(vtkNew sself, const float inPts, float outPts, int n) { sself->InverseTransformPoints(inPts, outPts, n); } -extern "C" void vtk_transform_2_d_inverse_transform_points(vtkNew sself, const double inPts, double outPts, int n) { sself->InverseTransformPoints(inPts, outPts, n); } -extern "C" void vtk_transform_2_d_multiply_point(vtkNew sself, const float in, float out) { sself->MultiplyPoint(in, out); } -extern "C" void vtk_transform_2_d_multiply_point(vtkNew sself, const double in, double out) { sself->MultiplyPoint(in, out); } -extern "C" vtkNew < vtkTransformCollection > vtkTransformCollection_new () {return vtkNew < vtkTransformCollection > () ;} -extern "C" void vtkTransformCollection_destructor (vtkNew < vtkTransformCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTransformCollection_get_ptr (vtkNew < vtkTransformCollection > sself) {return sself . GetPointer () ;} +extern "C" vtkCylindricalTransform * vtkCylindricalTransform_new () {return vtkCylindricalTransform :: New () ;} +extern "C" void vtkCylindricalTransform_destructor (vtkCylindricalTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCylindricalTransform_get_ptr (vtkCylindricalTransform * sself) {return sself ;} +extern "C" vtkGeneralTransform * vtkGeneralTransform_new () {return vtkGeneralTransform :: New () ;} +extern "C" void vtkGeneralTransform_destructor (vtkGeneralTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGeneralTransform_get_ptr (vtkGeneralTransform * sself) {return sself ;} +extern "C" void vtk_general_transform_identity(vtkGeneralTransform* sself) { sself->Identity(); } +extern "C" void vtk_general_transform_inverse(vtkGeneralTransform* sself) { sself->Inverse(); } +extern "C" void vtk_general_transform_translate(vtkGeneralTransform* sself, double x, double y, double z) { sself->Translate(x, y, z); } +extern "C" void vtk_general_transform_rotate_wxyz(vtkGeneralTransform* sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } +extern "C" void vtk_general_transform_rotate_x(vtkGeneralTransform* sself, double angle) { sself->RotateX(angle); } +extern "C" void vtk_general_transform_rotate_y(vtkGeneralTransform* sself, double angle) { sself->RotateY(angle); } +extern "C" void vtk_general_transform_rotate_z(vtkGeneralTransform* sself, double angle) { sself->RotateZ(angle); } +extern "C" void vtk_general_transform_scale(vtkGeneralTransform* sself, double x, double y, double z) { sself->Scale(x, y, z); } +extern "C" void vtk_general_transform_pre_multiply(vtkGeneralTransform* sself) { sself->PreMultiply(); } +extern "C" void vtk_general_transform_post_multiply(vtkGeneralTransform* sself) { sself->PostMultiply(); } +extern "C" int vtk_general_transform_get_number_of_concatenated_transforms(vtkGeneralTransform* sself) { return sself->GetNumberOfConcatenatedTransforms(); } +extern "C" int vtk_general_transform_get_inverse_flag(vtkGeneralTransform* sself) { return sself->GetInverseFlag(); } +extern "C" void vtk_general_transform_push(vtkGeneralTransform* sself) { sself->Push(); } +extern "C" void vtk_general_transform_pop(vtkGeneralTransform* sself) { sself->Pop(); } +extern "C" unsigned long vtk_general_transform_get_m_time(vtkGeneralTransform* sself) { return sself->GetMTime(); } +extern "C" vtkIdentityTransform * vtkIdentityTransform_new () {return vtkIdentityTransform :: New () ;} +extern "C" void vtkIdentityTransform_destructor (vtkIdentityTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkIdentityTransform_get_ptr (vtkIdentityTransform * sself) {return sself ;} +extern "C" void vtk_identity_transform_inverse(vtkIdentityTransform* sself) { sself->Inverse(); } +extern "C" vtkLandmarkTransform * vtkLandmarkTransform_new () {return vtkLandmarkTransform :: New () ;} +extern "C" void vtkLandmarkTransform_destructor (vtkLandmarkTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLandmarkTransform_get_ptr (vtkLandmarkTransform * sself) {return sself ;} +extern "C" void vtk_landmark_transform_set_mode(vtkLandmarkTransform* sself, int _arg) { sself->SetMode(_arg); } +extern "C" void vtk_landmark_transform_set_mode_to_rigid_body(vtkLandmarkTransform* sself) { sself->SetModeToRigidBody(); } +extern "C" void vtk_landmark_transform_set_mode_to_similarity(vtkLandmarkTransform* sself) { sself->SetModeToSimilarity(); } +extern "C" void vtk_landmark_transform_set_mode_to_affine(vtkLandmarkTransform* sself) { sself->SetModeToAffine(); } +extern "C" int vtk_landmark_transform_get_mode(vtkLandmarkTransform* sself) { return sself->GetMode(); } +extern "C" const char* vtk_landmark_transform_get_mode_as_string(vtkLandmarkTransform* sself) { return sself->GetModeAsString(); } +extern "C" void vtk_landmark_transform_inverse(vtkLandmarkTransform* sself) { sself->Inverse(); } +extern "C" unsigned long vtk_landmark_transform_get_m_time(vtkLandmarkTransform* sself) { return sself->GetMTime(); } +extern "C" vtkMatrixToHomogeneousTransform * vtkMatrixToHomogeneousTransform_new () {return vtkMatrixToHomogeneousTransform :: New () ;} +extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkMatrixToHomogeneousTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMatrixToHomogeneousTransform_get_ptr (vtkMatrixToHomogeneousTransform * sself) {return sself ;} +extern "C" void vtk_matrix_to_homogeneous_transform_inverse(vtkMatrixToHomogeneousTransform* sself) { sself->Inverse(); } +extern "C" unsigned long vtk_matrix_to_homogeneous_transform_get_m_time(vtkMatrixToHomogeneousTransform* sself) { return sself->GetMTime(); } +extern "C" vtkMatrixToLinearTransform * vtkMatrixToLinearTransform_new () {return vtkMatrixToLinearTransform :: New () ;} +extern "C" void vtkMatrixToLinearTransform_destructor (vtkMatrixToLinearTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkMatrixToLinearTransform_get_ptr (vtkMatrixToLinearTransform * sself) {return sself ;} +extern "C" void vtk_matrix_to_linear_transform_inverse(vtkMatrixToLinearTransform* sself) { sself->Inverse(); } +extern "C" unsigned long vtk_matrix_to_linear_transform_get_m_time(vtkMatrixToLinearTransform* sself) { return sself->GetMTime(); } +extern "C" vtkPerspectiveTransform * vtkPerspectiveTransform_new () {return vtkPerspectiveTransform :: New () ;} +extern "C" void vtkPerspectiveTransform_destructor (vtkPerspectiveTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPerspectiveTransform_get_ptr (vtkPerspectiveTransform * sself) {return sself ;} +extern "C" void vtk_perspective_transform_identity(vtkPerspectiveTransform* sself) { sself->Identity(); } +extern "C" void vtk_perspective_transform_inverse(vtkPerspectiveTransform* sself) { sself->Inverse(); } +extern "C" void vtk_perspective_transform_adjust_viewport(vtkPerspectiveTransform* sself, double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax) { sself->AdjustViewport(oldXMin, oldXMax, oldYMin, oldYMax, newXMin, newXMax, newYMin, newYMax); } +extern "C" void vtk_perspective_transform_adjust_z_buffer(vtkPerspectiveTransform* sself, double oldNearZ, double oldFarZ, double newNearZ, double newFarZ) { sself->AdjustZBuffer(oldNearZ, oldFarZ, newNearZ, newFarZ); } +extern "C" void vtk_perspective_transform_ortho(vtkPerspectiveTransform* sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar) { sself->Ortho(xmin, xmax, ymin, ymax, znear, zfar); } +extern "C" void vtk_perspective_transform_frustum(vtkPerspectiveTransform* sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar) { sself->Frustum(xmin, xmax, ymin, ymax, znear, zfar); } +extern "C" void vtk_perspective_transform_perspective(vtkPerspectiveTransform* sself, double angle, double aspect, double znear, double zfar) { sself->Perspective(angle, aspect, znear, zfar); } +extern "C" void vtk_perspective_transform_shear(vtkPerspectiveTransform* sself, double dxdz, double dydz, double zplane) { sself->Shear(dxdz, dydz, zplane); } +extern "C" void vtk_perspective_transform_stereo(vtkPerspectiveTransform* sself, double angle, double focaldistance) { sself->Stereo(angle, focaldistance); } +extern "C" void vtk_perspective_transform_setup_camera(vtkPerspectiveTransform* sself, double p0, double p1, double p2, double fp0, double fp1, double fp2, double vup0, double vup1, double vup2) { sself->SetupCamera(p0, p1, p2, fp0, fp1, fp2, vup0, vup1, vup2); } +extern "C" void vtk_perspective_transform_translate(vtkPerspectiveTransform* sself, double x, double y, double z) { sself->Translate(x, y, z); } +extern "C" void vtk_perspective_transform_rotate_wxyz(vtkPerspectiveTransform* sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } +extern "C" void vtk_perspective_transform_rotate_x(vtkPerspectiveTransform* sself, double angle) { sself->RotateX(angle); } +extern "C" void vtk_perspective_transform_rotate_y(vtkPerspectiveTransform* sself, double angle) { sself->RotateY(angle); } +extern "C" void vtk_perspective_transform_rotate_z(vtkPerspectiveTransform* sself, double angle) { sself->RotateZ(angle); } +extern "C" void vtk_perspective_transform_scale(vtkPerspectiveTransform* sself, double x, double y, double z) { sself->Scale(x, y, z); } +extern "C" void vtk_perspective_transform_pre_multiply(vtkPerspectiveTransform* sself) { sself->PreMultiply(); } +extern "C" void vtk_perspective_transform_post_multiply(vtkPerspectiveTransform* sself) { sself->PostMultiply(); } +extern "C" int vtk_perspective_transform_get_number_of_concatenated_transforms(vtkPerspectiveTransform* sself) { return sself->GetNumberOfConcatenatedTransforms(); } +extern "C" int vtk_perspective_transform_get_inverse_flag(vtkPerspectiveTransform* sself) { return sself->GetInverseFlag(); } +extern "C" void vtk_perspective_transform_push(vtkPerspectiveTransform* sself) { sself->Push(); } +extern "C" void vtk_perspective_transform_pop(vtkPerspectiveTransform* sself) { sself->Pop(); } +extern "C" unsigned long vtk_perspective_transform_get_m_time(vtkPerspectiveTransform* sself) { return sself->GetMTime(); } +extern "C" vtkSphericalTransform * vtkSphericalTransform_new () {return vtkSphericalTransform :: New () ;} +extern "C" void vtkSphericalTransform_destructor (vtkSphericalTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSphericalTransform_get_ptr (vtkSphericalTransform * sself) {return sself ;} +extern "C" vtkThinPlateSplineTransform * vtkThinPlateSplineTransform_new () {return vtkThinPlateSplineTransform :: New () ;} +extern "C" void vtkThinPlateSplineTransform_destructor (vtkThinPlateSplineTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkThinPlateSplineTransform_get_ptr (vtkThinPlateSplineTransform * sself) {return sself ;} +extern "C" double vtk_thin_plate_spline_transform_get_sigma(vtkThinPlateSplineTransform* sself) { return sself->GetSigma(); } +extern "C" void vtk_thin_plate_spline_transform_set_sigma(vtkThinPlateSplineTransform* sself, double _arg) { sself->SetSigma(_arg); } +extern "C" void vtk_thin_plate_spline_transform_set_basis(vtkThinPlateSplineTransform* sself, int basis) { sself->SetBasis(basis); } +extern "C" int vtk_thin_plate_spline_transform_get_basis(vtkThinPlateSplineTransform* sself) { return sself->GetBasis(); } +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r(vtkThinPlateSplineTransform* sself) { sself->SetBasisToR(); } +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(vtkThinPlateSplineTransform* sself) { sself->SetBasisToR2LogR(); } +extern "C" const char* vtk_thin_plate_spline_transform_get_basis_as_string(vtkThinPlateSplineTransform* sself) { return sself->GetBasisAsString(); } +extern "C" unsigned long vtk_thin_plate_spline_transform_get_m_time(vtkThinPlateSplineTransform* sself) { return sself->GetMTime(); } +extern "C" bool vtk_thin_plate_spline_transform_get_regularize_bulk_transform(vtkThinPlateSplineTransform* sself) { return sself->GetRegularizeBulkTransform(); } +extern "C" void vtk_thin_plate_spline_transform_set_regularize_bulk_transform(vtkThinPlateSplineTransform* sself, bool _arg) { sself->SetRegularizeBulkTransform(_arg); } +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_on(vtkThinPlateSplineTransform* sself) { sself->RegularizeBulkTransformOn(); } +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_off(vtkThinPlateSplineTransform* sself) { sself->RegularizeBulkTransformOff(); } +extern "C" vtkTransform * vtkTransform_new () {return vtkTransform :: New () ;} +extern "C" void vtkTransform_destructor (vtkTransform * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTransform_get_ptr (vtkTransform * sself) {return sself ;} +extern "C" void vtk_transform_identity(vtkTransform* sself) { sself->Identity(); } +extern "C" void vtk_transform_inverse(vtkTransform* sself) { sself->Inverse(); } +extern "C" void vtk_transform_translate(vtkTransform* sself, double x, double y, double z) { sself->Translate(x, y, z); } +extern "C" void vtk_transform_rotate_wxyz(vtkTransform* sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } +extern "C" void vtk_transform_rotate_x(vtkTransform* sself, double angle) { sself->RotateX(angle); } +extern "C" void vtk_transform_rotate_y(vtkTransform* sself, double angle) { sself->RotateY(angle); } +extern "C" void vtk_transform_rotate_z(vtkTransform* sself, double angle) { sself->RotateZ(angle); } +extern "C" void vtk_transform_scale(vtkTransform* sself, double x, double y, double z) { sself->Scale(x, y, z); } +extern "C" void vtk_transform_pre_multiply(vtkTransform* sself) { sself->PreMultiply(); } +extern "C" void vtk_transform_post_multiply(vtkTransform* sself) { sself->PostMultiply(); } +extern "C" int vtk_transform_get_number_of_concatenated_transforms(vtkTransform* sself) { return sself->GetNumberOfConcatenatedTransforms(); } +extern "C" int vtk_transform_get_inverse_flag(vtkTransform* sself) { return sself->GetInverseFlag(); } +extern "C" void vtk_transform_push(vtkTransform* sself) { sself->Push(); } +extern "C" void vtk_transform_pop(vtkTransform* sself) { sself->Pop(); } +extern "C" unsigned long vtk_transform_get_m_time(vtkTransform* sself) { return sself->GetMTime(); } +extern "C" vtkTransform2D * vtkTransform2D_new () {return vtkTransform2D :: New () ;} +extern "C" void vtkTransform2D_destructor (vtkTransform2D * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTransform2D_get_ptr (vtkTransform2D * sself) {return sself ;} +extern "C" void vtk_transform_2_d_identity(vtkTransform2D* sself) { sself->Identity(); } +extern "C" void vtk_transform_2_d_inverse(vtkTransform2D* sself) { sself->Inverse(); } +extern "C" void vtk_transform_2_d_translate(vtkTransform2D* sself, double x, double y) { sself->Translate(x, y); } +extern "C" void vtk_transform_2_d_rotate(vtkTransform2D* sself, double angle) { sself->Rotate(angle); } +extern "C" void vtk_transform_2_d_scale(vtkTransform2D* sself, double x, double y) { sself->Scale(x, y); } +extern "C" unsigned long vtk_transform_2_d_get_m_time(vtkTransform2D* sself) { return sself->GetMTime(); } +extern "C" vtkTransformCollection * vtkTransformCollection_new () {return vtkTransformCollection :: New () ;} +extern "C" void vtkTransformCollection_destructor (vtkTransformCollection * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTransformCollection_get_ptr (vtkTransformCollection * sself) {return sself ;} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp new file mode 100644 index 0000000..9692df8 --- /dev/null +++ b/vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp @@ -0,0 +1,842 @@ +// Include header file +#include + +// Default include in all modules +#include +#include + +// Include objects of this module +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Implement declared functions +extern "C" vtkArcSource * vtkArcSource_new () {return vtkArcSource :: New () ;} +extern "C" void vtkArcSource_destructor (vtkArcSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkArcSource_get_ptr (vtkArcSource * sself) {return sself ;} +extern "C" void vtk_arc_source_set_point_1(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint1(_arg1, _arg2, _arg3); } +extern "C" void vtk_arc_source_set_point_2(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint2(_arg1, _arg2, _arg3); } +extern "C" void vtk_arc_source_set_center(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_arc_source_set_normal(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" void vtk_arc_source_set_polar_vector(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPolarVector(_arg1, _arg2, _arg3); } +extern "C" void vtk_arc_source_set_angle(vtkArcSource* sself, double _arg) { sself->SetAngle(_arg); } +extern "C" double vtk_arc_source_get_angle_min_value(vtkArcSource* sself) { return sself->GetAngleMinValue(); } +extern "C" double vtk_arc_source_get_angle_max_value(vtkArcSource* sself) { return sself->GetAngleMaxValue(); } +extern "C" double vtk_arc_source_get_angle(vtkArcSource* sself) { return sself->GetAngle(); } +extern "C" void vtk_arc_source_set_resolution(vtkArcSource* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_arc_source_get_resolution_min_value(vtkArcSource* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_arc_source_get_resolution_max_value(vtkArcSource* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_arc_source_get_resolution(vtkArcSource* sself) { return sself->GetResolution(); } +extern "C" void vtk_arc_source_set_negative(vtkArcSource* sself, bool _arg) { sself->SetNegative(_arg); } +extern "C" bool vtk_arc_source_get_negative(vtkArcSource* sself) { return sself->GetNegative(); } +extern "C" void vtk_arc_source_negative_on(vtkArcSource* sself) { sself->NegativeOn(); } +extern "C" void vtk_arc_source_negative_off(vtkArcSource* sself) { sself->NegativeOff(); } +extern "C" void vtk_arc_source_set_use_normal_and_angle(vtkArcSource* sself, bool _arg) { sself->SetUseNormalAndAngle(_arg); } +extern "C" bool vtk_arc_source_get_use_normal_and_angle(vtkArcSource* sself) { return sself->GetUseNormalAndAngle(); } +extern "C" void vtk_arc_source_use_normal_and_angle_on(vtkArcSource* sself) { sself->UseNormalAndAngleOn(); } +extern "C" void vtk_arc_source_use_normal_and_angle_off(vtkArcSource* sself) { sself->UseNormalAndAngleOff(); } +extern "C" void vtk_arc_source_set_output_points_precision(vtkArcSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_arc_source_get_output_points_precision(vtkArcSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkArrowSource * vtkArrowSource_new () {return vtkArrowSource :: New () ;} +extern "C" void vtkArrowSource_destructor (vtkArrowSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkArrowSource_get_ptr (vtkArrowSource * sself) {return sself ;} +extern "C" void vtk_arrow_source_set_tip_length(vtkArrowSource* sself, double _arg) { sself->SetTipLength(_arg); } +extern "C" double vtk_arrow_source_get_tip_length_min_value(vtkArrowSource* sself) { return sself->GetTipLengthMinValue(); } +extern "C" double vtk_arrow_source_get_tip_length_max_value(vtkArrowSource* sself) { return sself->GetTipLengthMaxValue(); } +extern "C" double vtk_arrow_source_get_tip_length(vtkArrowSource* sself) { return sself->GetTipLength(); } +extern "C" void vtk_arrow_source_set_tip_radius(vtkArrowSource* sself, double _arg) { sself->SetTipRadius(_arg); } +extern "C" double vtk_arrow_source_get_tip_radius_min_value(vtkArrowSource* sself) { return sself->GetTipRadiusMinValue(); } +extern "C" double vtk_arrow_source_get_tip_radius_max_value(vtkArrowSource* sself) { return sself->GetTipRadiusMaxValue(); } +extern "C" double vtk_arrow_source_get_tip_radius(vtkArrowSource* sself) { return sself->GetTipRadius(); } +extern "C" void vtk_arrow_source_set_tip_resolution(vtkArrowSource* sself, int _arg) { sself->SetTipResolution(_arg); } +extern "C" int vtk_arrow_source_get_tip_resolution_min_value(vtkArrowSource* sself) { return sself->GetTipResolutionMinValue(); } +extern "C" int vtk_arrow_source_get_tip_resolution_max_value(vtkArrowSource* sself) { return sself->GetTipResolutionMaxValue(); } +extern "C" int vtk_arrow_source_get_tip_resolution(vtkArrowSource* sself) { return sself->GetTipResolution(); } +extern "C" void vtk_arrow_source_set_shaft_radius(vtkArrowSource* sself, double _arg) { sself->SetShaftRadius(_arg); } +extern "C" double vtk_arrow_source_get_shaft_radius_min_value(vtkArrowSource* sself) { return sself->GetShaftRadiusMinValue(); } +extern "C" double vtk_arrow_source_get_shaft_radius_max_value(vtkArrowSource* sself) { return sself->GetShaftRadiusMaxValue(); } +extern "C" double vtk_arrow_source_get_shaft_radius(vtkArrowSource* sself) { return sself->GetShaftRadius(); } +extern "C" void vtk_arrow_source_set_shaft_resolution(vtkArrowSource* sself, int _arg) { sself->SetShaftResolution(_arg); } +extern "C" int vtk_arrow_source_get_shaft_resolution_min_value(vtkArrowSource* sself) { return sself->GetShaftResolutionMinValue(); } +extern "C" int vtk_arrow_source_get_shaft_resolution_max_value(vtkArrowSource* sself) { return sself->GetShaftResolutionMaxValue(); } +extern "C" int vtk_arrow_source_get_shaft_resolution(vtkArrowSource* sself) { return sself->GetShaftResolution(); } +extern "C" void vtk_arrow_source_invert_on(vtkArrowSource* sself) { sself->InvertOn(); } +extern "C" void vtk_arrow_source_invert_off(vtkArrowSource* sself) { sself->InvertOff(); } +extern "C" void vtk_arrow_source_set_invert(vtkArrowSource* sself, bool _arg) { sself->SetInvert(_arg); } +extern "C" bool vtk_arrow_source_get_invert(vtkArrowSource* sself) { return sself->GetInvert(); } +extern "C" void vtk_arrow_source_set_arrow_origin_to_default(vtkArrowSource* sself) { sself->SetArrowOriginToDefault(); } +extern "C" void vtk_arrow_source_set_arrow_origin_to_center(vtkArrowSource* sself) { sself->SetArrowOriginToCenter(); } +extern "C" vtkCapsuleSource * vtkCapsuleSource_new () {return vtkCapsuleSource :: New () ;} +extern "C" void vtkCapsuleSource_destructor (vtkCapsuleSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCapsuleSource_get_ptr (vtkCapsuleSource * sself) {return sself ;} +extern "C" void vtk_capsule_source_set_radius(vtkCapsuleSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_capsule_source_get_radius_min_value(vtkCapsuleSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_capsule_source_get_radius_max_value(vtkCapsuleSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_capsule_source_get_radius(vtkCapsuleSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_capsule_source_set_center(vtkCapsuleSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_capsule_source_set_cylinder_length(vtkCapsuleSource* sself, double _arg) { sself->SetCylinderLength(_arg); } +extern "C" double vtk_capsule_source_get_cylinder_length_min_value(vtkCapsuleSource* sself) { return sself->GetCylinderLengthMinValue(); } +extern "C" double vtk_capsule_source_get_cylinder_length_max_value(vtkCapsuleSource* sself) { return sself->GetCylinderLengthMaxValue(); } +extern "C" double vtk_capsule_source_get_cylinder_length(vtkCapsuleSource* sself) { return sself->GetCylinderLength(); } +extern "C" void vtk_capsule_source_set_theta_resolution(vtkCapsuleSource* sself, int _arg) { sself->SetThetaResolution(_arg); } +extern "C" int vtk_capsule_source_get_theta_resolution_min_value(vtkCapsuleSource* sself) { return sself->GetThetaResolutionMinValue(); } +extern "C" int vtk_capsule_source_get_theta_resolution_max_value(vtkCapsuleSource* sself) { return sself->GetThetaResolutionMaxValue(); } +extern "C" int vtk_capsule_source_get_theta_resolution(vtkCapsuleSource* sself) { return sself->GetThetaResolution(); } +extern "C" void vtk_capsule_source_set_phi_resolution(vtkCapsuleSource* sself, int _arg) { sself->SetPhiResolution(_arg); } +extern "C" int vtk_capsule_source_get_phi_resolution_min_value(vtkCapsuleSource* sself) { return sself->GetPhiResolutionMinValue(); } +extern "C" int vtk_capsule_source_get_phi_resolution_max_value(vtkCapsuleSource* sself) { return sself->GetPhiResolutionMaxValue(); } +extern "C" int vtk_capsule_source_get_phi_resolution(vtkCapsuleSource* sself) { return sself->GetPhiResolution(); } +extern "C" void vtk_capsule_source_set_lat_long_tessellation(vtkCapsuleSource* sself, int _arg) { sself->SetLatLongTessellation(_arg); } +extern "C" int vtk_capsule_source_get_lat_long_tessellation(vtkCapsuleSource* sself) { return sself->GetLatLongTessellation(); } +extern "C" void vtk_capsule_source_lat_long_tessellation_on(vtkCapsuleSource* sself) { sself->LatLongTessellationOn(); } +extern "C" void vtk_capsule_source_lat_long_tessellation_off(vtkCapsuleSource* sself) { sself->LatLongTessellationOff(); } +extern "C" void vtk_capsule_source_set_output_points_precision(vtkCapsuleSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_capsule_source_get_output_points_precision(vtkCapsuleSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkCellTypeSource * vtkCellTypeSource_new () {return vtkCellTypeSource :: New () ;} +extern "C" void vtkCellTypeSource_destructor (vtkCellTypeSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCellTypeSource_get_ptr (vtkCellTypeSource * sself) {return sself ;} +extern "C" void vtk_cell_type_source_set_cell_type(vtkCellTypeSource* sself, int cellType) { sself->SetCellType(cellType); } +extern "C" int vtk_cell_type_source_get_cell_type(vtkCellTypeSource* sself) { return sself->GetCellType(); } +extern "C" void vtk_cell_type_source_set_cell_order(vtkCellTypeSource* sself, int _arg) { sself->SetCellOrder(_arg); } +extern "C" int vtk_cell_type_source_get_cell_order(vtkCellTypeSource* sself) { return sself->GetCellOrder(); } +extern "C" void vtk_cell_type_source_set_complete_quadratic_simplicial_elements(vtkCellTypeSource* sself, bool _arg) { sself->SetCompleteQuadraticSimplicialElements(_arg); } +extern "C" bool vtk_cell_type_source_get_complete_quadratic_simplicial_elements(vtkCellTypeSource* sself) { return sself->GetCompleteQuadraticSimplicialElements(); } +extern "C" void vtk_cell_type_source_complete_quadratic_simplicial_elements_on(vtkCellTypeSource* sself) { sself->CompleteQuadraticSimplicialElementsOn(); } +extern "C" void vtk_cell_type_source_complete_quadratic_simplicial_elements_off(vtkCellTypeSource* sself) { sself->CompleteQuadraticSimplicialElementsOff(); } +extern "C" void vtk_cell_type_source_set_polynomial_field_order(vtkCellTypeSource* sself, int _arg) { sself->SetPolynomialFieldOrder(_arg); } +extern "C" int vtk_cell_type_source_get_polynomial_field_order_min_value(vtkCellTypeSource* sself) { return sself->GetPolynomialFieldOrderMinValue(); } +extern "C" int vtk_cell_type_source_get_polynomial_field_order_max_value(vtkCellTypeSource* sself) { return sself->GetPolynomialFieldOrderMaxValue(); } +extern "C" int vtk_cell_type_source_get_polynomial_field_order(vtkCellTypeSource* sself) { return sself->GetPolynomialFieldOrder(); } +extern "C" int vtk_cell_type_source_get_cell_dimension(vtkCellTypeSource* sself) { return sself->GetCellDimension(); } +extern "C" void vtk_cell_type_source_set_output_precision(vtkCellTypeSource* sself, int _arg) { sself->SetOutputPrecision(_arg); } +extern "C" int vtk_cell_type_source_get_output_precision_min_value(vtkCellTypeSource* sself) { return sself->GetOutputPrecisionMinValue(); } +extern "C" int vtk_cell_type_source_get_output_precision_max_value(vtkCellTypeSource* sself) { return sself->GetOutputPrecisionMaxValue(); } +extern "C" int vtk_cell_type_source_get_output_precision(vtkCellTypeSource* sself) { return sself->GetOutputPrecision(); } +extern "C" vtkConeSource * vtkConeSource_new () {return vtkConeSource :: New () ;} +extern "C" void vtkConeSource_destructor (vtkConeSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkConeSource_get_ptr (vtkConeSource * sself) {return sself ;} +extern "C" void vtk_cone_source_set_height(vtkConeSource* sself, double _arg) { sself->SetHeight(_arg); } +extern "C" double vtk_cone_source_get_height_min_value(vtkConeSource* sself) { return sself->GetHeightMinValue(); } +extern "C" double vtk_cone_source_get_height_max_value(vtkConeSource* sself) { return sself->GetHeightMaxValue(); } +extern "C" double vtk_cone_source_get_height(vtkConeSource* sself) { return sself->GetHeight(); } +extern "C" void vtk_cone_source_set_radius(vtkConeSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_cone_source_get_radius_min_value(vtkConeSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_cone_source_get_radius_max_value(vtkConeSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_cone_source_get_radius(vtkConeSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_cone_source_set_resolution(vtkConeSource* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_cone_source_get_resolution_min_value(vtkConeSource* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_cone_source_get_resolution_max_value(vtkConeSource* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_cone_source_get_resolution(vtkConeSource* sself) { return sself->GetResolution(); } +extern "C" void vtk_cone_source_set_center(vtkConeSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_cone_source_set_direction(vtkConeSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetDirection(_arg1, _arg2, _arg3); } +extern "C" void vtk_cone_source_set_angle(vtkConeSource* sself, double angle) { sself->SetAngle(angle); } +extern "C" double vtk_cone_source_get_angle(vtkConeSource* sself) { return sself->GetAngle(); } +extern "C" void vtk_cone_source_set_capping(vtkConeSource* sself, int _arg) { sself->SetCapping(_arg); } +extern "C" int vtk_cone_source_get_capping(vtkConeSource* sself) { return sself->GetCapping(); } +extern "C" void vtk_cone_source_capping_on(vtkConeSource* sself) { sself->CappingOn(); } +extern "C" void vtk_cone_source_capping_off(vtkConeSource* sself) { sself->CappingOff(); } +extern "C" void vtk_cone_source_set_output_points_precision(vtkConeSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_cone_source_get_output_points_precision(vtkConeSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkCubeSource * vtkCubeSource_new () {return vtkCubeSource :: New () ;} +extern "C" void vtkCubeSource_destructor (vtkCubeSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCubeSource_get_ptr (vtkCubeSource * sself) {return sself ;} +extern "C" void vtk_cube_source_set_x_length(vtkCubeSource* sself, double _arg) { sself->SetXLength(_arg); } +extern "C" double vtk_cube_source_get_x_length_min_value(vtkCubeSource* sself) { return sself->GetXLengthMinValue(); } +extern "C" double vtk_cube_source_get_x_length_max_value(vtkCubeSource* sself) { return sself->GetXLengthMaxValue(); } +extern "C" double vtk_cube_source_get_x_length(vtkCubeSource* sself) { return sself->GetXLength(); } +extern "C" void vtk_cube_source_set_y_length(vtkCubeSource* sself, double _arg) { sself->SetYLength(_arg); } +extern "C" double vtk_cube_source_get_y_length_min_value(vtkCubeSource* sself) { return sself->GetYLengthMinValue(); } +extern "C" double vtk_cube_source_get_y_length_max_value(vtkCubeSource* sself) { return sself->GetYLengthMaxValue(); } +extern "C" double vtk_cube_source_get_y_length(vtkCubeSource* sself) { return sself->GetYLength(); } +extern "C" void vtk_cube_source_set_z_length(vtkCubeSource* sself, double _arg) { sself->SetZLength(_arg); } +extern "C" double vtk_cube_source_get_z_length_min_value(vtkCubeSource* sself) { return sself->GetZLengthMinValue(); } +extern "C" double vtk_cube_source_get_z_length_max_value(vtkCubeSource* sself) { return sself->GetZLengthMaxValue(); } +extern "C" double vtk_cube_source_get_z_length(vtkCubeSource* sself) { return sself->GetZLength(); } +extern "C" void vtk_cube_source_set_center(vtkCubeSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_cube_source_set_bounds(vtkCubeSource* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" void vtk_cube_source_set_output_points_precision(vtkCubeSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_cube_source_get_output_points_precision(vtkCubeSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkCylinderSource * vtkCylinderSource_new () {return vtkCylinderSource :: New () ;} +extern "C" void vtkCylinderSource_destructor (vtkCylinderSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkCylinderSource_get_ptr (vtkCylinderSource * sself) {return sself ;} +extern "C" void vtk_cylinder_source_set_height(vtkCylinderSource* sself, double _arg) { sself->SetHeight(_arg); } +extern "C" double vtk_cylinder_source_get_height_min_value(vtkCylinderSource* sself) { return sself->GetHeightMinValue(); } +extern "C" double vtk_cylinder_source_get_height_max_value(vtkCylinderSource* sself) { return sself->GetHeightMaxValue(); } +extern "C" double vtk_cylinder_source_get_height(vtkCylinderSource* sself) { return sself->GetHeight(); } +extern "C" void vtk_cylinder_source_set_radius(vtkCylinderSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_cylinder_source_get_radius_min_value(vtkCylinderSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_cylinder_source_get_radius_max_value(vtkCylinderSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_cylinder_source_get_radius(vtkCylinderSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_cylinder_source_set_center(vtkCylinderSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_cylinder_source_set_resolution(vtkCylinderSource* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_cylinder_source_get_resolution_min_value(vtkCylinderSource* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_cylinder_source_get_resolution_max_value(vtkCylinderSource* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_cylinder_source_get_resolution(vtkCylinderSource* sself) { return sself->GetResolution(); } +extern "C" void vtk_cylinder_source_set_capping(vtkCylinderSource* sself, int _arg) { sself->SetCapping(_arg); } +extern "C" int vtk_cylinder_source_get_capping(vtkCylinderSource* sself) { return sself->GetCapping(); } +extern "C" void vtk_cylinder_source_capping_on(vtkCylinderSource* sself) { sself->CappingOn(); } +extern "C" void vtk_cylinder_source_capping_off(vtkCylinderSource* sself) { sself->CappingOff(); } +extern "C" void vtk_cylinder_source_set_output_points_precision(vtkCylinderSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_cylinder_source_get_output_points_precision(vtkCylinderSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkDiagonalMatrixSource * vtkDiagonalMatrixSource_new () {return vtkDiagonalMatrixSource :: New () ;} +extern "C" void vtkDiagonalMatrixSource_destructor (vtkDiagonalMatrixSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDiagonalMatrixSource_get_ptr (vtkDiagonalMatrixSource * sself) {return sself ;} +extern "C" int vtk_diagonal_matrix_source_get_array_type(vtkDiagonalMatrixSource* sself) { return sself->GetArrayType(); } +extern "C" void vtk_diagonal_matrix_source_set_array_type(vtkDiagonalMatrixSource* sself, int _arg) { sself->SetArrayType(_arg); } +extern "C" long long vtk_diagonal_matrix_source_get_extents(vtkDiagonalMatrixSource* sself) { return sself->GetExtents(); } +extern "C" void vtk_diagonal_matrix_source_set_extents(vtkDiagonalMatrixSource* sself, long long _arg) { sself->SetExtents(_arg); } +extern "C" double vtk_diagonal_matrix_source_get_diagonal(vtkDiagonalMatrixSource* sself) { return sself->GetDiagonal(); } +extern "C" void vtk_diagonal_matrix_source_set_diagonal(vtkDiagonalMatrixSource* sself, double _arg) { sself->SetDiagonal(_arg); } +extern "C" double vtk_diagonal_matrix_source_get_super_diagonal(vtkDiagonalMatrixSource* sself) { return sself->GetSuperDiagonal(); } +extern "C" void vtk_diagonal_matrix_source_set_super_diagonal(vtkDiagonalMatrixSource* sself, double _arg) { sself->SetSuperDiagonal(_arg); } +extern "C" double vtk_diagonal_matrix_source_get_sub_diagonal(vtkDiagonalMatrixSource* sself) { return sself->GetSubDiagonal(); } +extern "C" void vtk_diagonal_matrix_source_set_sub_diagonal(vtkDiagonalMatrixSource* sself, double _arg) { sself->SetSubDiagonal(_arg); } +extern "C" void vtk_diagonal_matrix_source_set_row_label(vtkDiagonalMatrixSource* sself, const char* _arg) { sself->SetRowLabel(_arg); } +extern "C" void vtk_diagonal_matrix_source_set_column_label(vtkDiagonalMatrixSource* sself, const char* _arg) { sself->SetColumnLabel(_arg); } +extern "C" vtkDiskSource * vtkDiskSource_new () {return vtkDiskSource :: New () ;} +extern "C" void vtkDiskSource_destructor (vtkDiskSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkDiskSource_get_ptr (vtkDiskSource * sself) {return sself ;} +extern "C" void vtk_disk_source_set_inner_radius(vtkDiskSource* sself, double _arg) { sself->SetInnerRadius(_arg); } +extern "C" double vtk_disk_source_get_inner_radius_min_value(vtkDiskSource* sself) { return sself->GetInnerRadiusMinValue(); } +extern "C" double vtk_disk_source_get_inner_radius_max_value(vtkDiskSource* sself) { return sself->GetInnerRadiusMaxValue(); } +extern "C" double vtk_disk_source_get_inner_radius(vtkDiskSource* sself) { return sself->GetInnerRadius(); } +extern "C" void vtk_disk_source_set_outer_radius(vtkDiskSource* sself, double _arg) { sself->SetOuterRadius(_arg); } +extern "C" double vtk_disk_source_get_outer_radius_min_value(vtkDiskSource* sself) { return sself->GetOuterRadiusMinValue(); } +extern "C" double vtk_disk_source_get_outer_radius_max_value(vtkDiskSource* sself) { return sself->GetOuterRadiusMaxValue(); } +extern "C" double vtk_disk_source_get_outer_radius(vtkDiskSource* sself) { return sself->GetOuterRadius(); } +extern "C" void vtk_disk_source_set_radial_resolution(vtkDiskSource* sself, int _arg) { sself->SetRadialResolution(_arg); } +extern "C" int vtk_disk_source_get_radial_resolution_min_value(vtkDiskSource* sself) { return sself->GetRadialResolutionMinValue(); } +extern "C" int vtk_disk_source_get_radial_resolution_max_value(vtkDiskSource* sself) { return sself->GetRadialResolutionMaxValue(); } +extern "C" int vtk_disk_source_get_radial_resolution(vtkDiskSource* sself) { return sself->GetRadialResolution(); } +extern "C" void vtk_disk_source_set_circumferential_resolution(vtkDiskSource* sself, int _arg) { sself->SetCircumferentialResolution(_arg); } +extern "C" int vtk_disk_source_get_circumferential_resolution_min_value(vtkDiskSource* sself) { return sself->GetCircumferentialResolutionMinValue(); } +extern "C" int vtk_disk_source_get_circumferential_resolution_max_value(vtkDiskSource* sself) { return sself->GetCircumferentialResolutionMaxValue(); } +extern "C" int vtk_disk_source_get_circumferential_resolution(vtkDiskSource* sself) { return sself->GetCircumferentialResolution(); } +extern "C" void vtk_disk_source_set_output_points_precision(vtkDiskSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_disk_source_get_output_points_precision(vtkDiskSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkEllipseArcSource * vtkEllipseArcSource_new () {return vtkEllipseArcSource :: New () ;} +extern "C" void vtkEllipseArcSource_destructor (vtkEllipseArcSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkEllipseArcSource_get_ptr (vtkEllipseArcSource * sself) {return sself ;} +extern "C" void vtk_ellipse_arc_source_set_center(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_ellipse_arc_source_set_normal(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" void vtk_ellipse_arc_source_set_major_radius_vector(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetMajorRadiusVector(_arg1, _arg2, _arg3); } +extern "C" void vtk_ellipse_arc_source_set_start_angle(vtkEllipseArcSource* sself, double _arg) { sself->SetStartAngle(_arg); } +extern "C" double vtk_ellipse_arc_source_get_start_angle_min_value(vtkEllipseArcSource* sself) { return sself->GetStartAngleMinValue(); } +extern "C" double vtk_ellipse_arc_source_get_start_angle_max_value(vtkEllipseArcSource* sself) { return sself->GetStartAngleMaxValue(); } +extern "C" double vtk_ellipse_arc_source_get_start_angle(vtkEllipseArcSource* sself) { return sself->GetStartAngle(); } +extern "C" void vtk_ellipse_arc_source_set_segment_angle(vtkEllipseArcSource* sself, double _arg) { sself->SetSegmentAngle(_arg); } +extern "C" double vtk_ellipse_arc_source_get_segment_angle_min_value(vtkEllipseArcSource* sself) { return sself->GetSegmentAngleMinValue(); } +extern "C" double vtk_ellipse_arc_source_get_segment_angle_max_value(vtkEllipseArcSource* sself) { return sself->GetSegmentAngleMaxValue(); } +extern "C" double vtk_ellipse_arc_source_get_segment_angle(vtkEllipseArcSource* sself) { return sself->GetSegmentAngle(); } +extern "C" void vtk_ellipse_arc_source_set_resolution(vtkEllipseArcSource* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_ellipse_arc_source_get_resolution_min_value(vtkEllipseArcSource* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_ellipse_arc_source_get_resolution_max_value(vtkEllipseArcSource* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_ellipse_arc_source_get_resolution(vtkEllipseArcSource* sself) { return sself->GetResolution(); } +extern "C" void vtk_ellipse_arc_source_set_close(vtkEllipseArcSource* sself, bool _arg) { sself->SetClose(_arg); } +extern "C" bool vtk_ellipse_arc_source_get_close(vtkEllipseArcSource* sself) { return sself->GetClose(); } +extern "C" void vtk_ellipse_arc_source_close_on(vtkEllipseArcSource* sself) { sself->CloseOn(); } +extern "C" void vtk_ellipse_arc_source_close_off(vtkEllipseArcSource* sself) { sself->CloseOff(); } +extern "C" void vtk_ellipse_arc_source_set_output_points_precision(vtkEllipseArcSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_ellipse_arc_source_get_output_points_precision(vtkEllipseArcSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" void vtk_ellipse_arc_source_set_ratio(vtkEllipseArcSource* sself, double _arg) { sself->SetRatio(_arg); } +extern "C" double vtk_ellipse_arc_source_get_ratio_min_value(vtkEllipseArcSource* sself) { return sself->GetRatioMinValue(); } +extern "C" double vtk_ellipse_arc_source_get_ratio_max_value(vtkEllipseArcSource* sself) { return sself->GetRatioMaxValue(); } +extern "C" double vtk_ellipse_arc_source_get_ratio(vtkEllipseArcSource* sself) { return sself->GetRatio(); } +extern "C" vtkEllipticalButtonSource * vtkEllipticalButtonSource_new () {return vtkEllipticalButtonSource :: New () ;} +extern "C" void vtkEllipticalButtonSource_destructor (vtkEllipticalButtonSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkEllipticalButtonSource_get_ptr (vtkEllipticalButtonSource * sself) {return sself ;} +extern "C" void vtk_elliptical_button_source_set_width(vtkEllipticalButtonSource* sself, double _arg) { sself->SetWidth(_arg); } +extern "C" double vtk_elliptical_button_source_get_width_min_value(vtkEllipticalButtonSource* sself) { return sself->GetWidthMinValue(); } +extern "C" double vtk_elliptical_button_source_get_width_max_value(vtkEllipticalButtonSource* sself) { return sself->GetWidthMaxValue(); } +extern "C" double vtk_elliptical_button_source_get_width(vtkEllipticalButtonSource* sself) { return sself->GetWidth(); } +extern "C" void vtk_elliptical_button_source_set_height(vtkEllipticalButtonSource* sself, double _arg) { sself->SetHeight(_arg); } +extern "C" double vtk_elliptical_button_source_get_height_min_value(vtkEllipticalButtonSource* sself) { return sself->GetHeightMinValue(); } +extern "C" double vtk_elliptical_button_source_get_height_max_value(vtkEllipticalButtonSource* sself) { return sself->GetHeightMaxValue(); } +extern "C" double vtk_elliptical_button_source_get_height(vtkEllipticalButtonSource* sself) { return sself->GetHeight(); } +extern "C" void vtk_elliptical_button_source_set_depth(vtkEllipticalButtonSource* sself, double _arg) { sself->SetDepth(_arg); } +extern "C" double vtk_elliptical_button_source_get_depth_min_value(vtkEllipticalButtonSource* sself) { return sself->GetDepthMinValue(); } +extern "C" double vtk_elliptical_button_source_get_depth_max_value(vtkEllipticalButtonSource* sself) { return sself->GetDepthMaxValue(); } +extern "C" double vtk_elliptical_button_source_get_depth(vtkEllipticalButtonSource* sself) { return sself->GetDepth(); } +extern "C" void vtk_elliptical_button_source_set_circumferential_resolution(vtkEllipticalButtonSource* sself, int _arg) { sself->SetCircumferentialResolution(_arg); } +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution_min_value(vtkEllipticalButtonSource* sself) { return sself->GetCircumferentialResolutionMinValue(); } +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution_max_value(vtkEllipticalButtonSource* sself) { return sself->GetCircumferentialResolutionMaxValue(); } +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution(vtkEllipticalButtonSource* sself) { return sself->GetCircumferentialResolution(); } +extern "C" void vtk_elliptical_button_source_set_texture_resolution(vtkEllipticalButtonSource* sself, int _arg) { sself->SetTextureResolution(_arg); } +extern "C" int vtk_elliptical_button_source_get_texture_resolution_min_value(vtkEllipticalButtonSource* sself) { return sself->GetTextureResolutionMinValue(); } +extern "C" int vtk_elliptical_button_source_get_texture_resolution_max_value(vtkEllipticalButtonSource* sself) { return sself->GetTextureResolutionMaxValue(); } +extern "C" int vtk_elliptical_button_source_get_texture_resolution(vtkEllipticalButtonSource* sself) { return sself->GetTextureResolution(); } +extern "C" void vtk_elliptical_button_source_set_shoulder_resolution(vtkEllipticalButtonSource* sself, int _arg) { sself->SetShoulderResolution(_arg); } +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution_min_value(vtkEllipticalButtonSource* sself) { return sself->GetShoulderResolutionMinValue(); } +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution_max_value(vtkEllipticalButtonSource* sself) { return sself->GetShoulderResolutionMaxValue(); } +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution(vtkEllipticalButtonSource* sself) { return sself->GetShoulderResolution(); } +extern "C" void vtk_elliptical_button_source_set_radial_ratio(vtkEllipticalButtonSource* sself, double _arg) { sself->SetRadialRatio(_arg); } +extern "C" double vtk_elliptical_button_source_get_radial_ratio_min_value(vtkEllipticalButtonSource* sself) { return sself->GetRadialRatioMinValue(); } +extern "C" double vtk_elliptical_button_source_get_radial_ratio_max_value(vtkEllipticalButtonSource* sself) { return sself->GetRadialRatioMaxValue(); } +extern "C" double vtk_elliptical_button_source_get_radial_ratio(vtkEllipticalButtonSource* sself) { return sself->GetRadialRatio(); } +extern "C" void vtk_elliptical_button_source_set_output_points_precision(vtkEllipticalButtonSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_elliptical_button_source_get_output_points_precision(vtkEllipticalButtonSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkFrustumSource * vtkFrustumSource_new () {return vtkFrustumSource :: New () ;} +extern "C" void vtkFrustumSource_destructor (vtkFrustumSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkFrustumSource_get_ptr (vtkFrustumSource * sself) {return sself ;} +extern "C" bool vtk_frustum_source_get_show_lines(vtkFrustumSource* sself) { return sself->GetShowLines(); } +extern "C" void vtk_frustum_source_set_show_lines(vtkFrustumSource* sself, bool _arg) { sself->SetShowLines(_arg); } +extern "C" void vtk_frustum_source_show_lines_on(vtkFrustumSource* sself) { sself->ShowLinesOn(); } +extern "C" void vtk_frustum_source_show_lines_off(vtkFrustumSource* sself) { sself->ShowLinesOff(); } +extern "C" double vtk_frustum_source_get_lines_length(vtkFrustumSource* sself) { return sself->GetLinesLength(); } +extern "C" void vtk_frustum_source_set_lines_length(vtkFrustumSource* sself, double _arg) { sself->SetLinesLength(_arg); } +extern "C" unsigned long vtk_frustum_source_get_m_time(vtkFrustumSource* sself) { return sself->GetMTime(); } +extern "C" void vtk_frustum_source_set_output_points_precision(vtkFrustumSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_frustum_source_get_output_points_precision(vtkFrustumSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkGlyphSource2D * vtkGlyphSource2D_new () {return vtkGlyphSource2D :: New () ;} +extern "C" void vtkGlyphSource2D_destructor (vtkGlyphSource2D * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGlyphSource2D_get_ptr (vtkGlyphSource2D * sself) {return sself ;} +extern "C" void vtk_glyph_source_2_d_set_center(vtkGlyphSource2D* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_glyph_source_2_d_set_scale(vtkGlyphSource2D* sself, double _arg) { sself->SetScale(_arg); } +extern "C" double vtk_glyph_source_2_d_get_scale_min_value(vtkGlyphSource2D* sself) { return sself->GetScaleMinValue(); } +extern "C" double vtk_glyph_source_2_d_get_scale_max_value(vtkGlyphSource2D* sself) { return sself->GetScaleMaxValue(); } +extern "C" double vtk_glyph_source_2_d_get_scale(vtkGlyphSource2D* sself) { return sself->GetScale(); } +extern "C" void vtk_glyph_source_2_d_set_scale_2(vtkGlyphSource2D* sself, double _arg) { sself->SetScale2(_arg); } +extern "C" double vtk_glyph_source_2_d_get_scale_2_min_value(vtkGlyphSource2D* sself) { return sself->GetScale2MinValue(); } +extern "C" double vtk_glyph_source_2_d_get_scale_2_max_value(vtkGlyphSource2D* sself) { return sself->GetScale2MaxValue(); } +extern "C" double vtk_glyph_source_2_d_get_scale_2(vtkGlyphSource2D* sself) { return sself->GetScale2(); } +extern "C" void vtk_glyph_source_2_d_set_color(vtkGlyphSource2D* sself, double _arg1, double _arg2, double _arg3) { sself->SetColor(_arg1, _arg2, _arg3); } +extern "C" void vtk_glyph_source_2_d_set_filled(vtkGlyphSource2D* sself, int _arg) { sself->SetFilled(_arg); } +extern "C" int vtk_glyph_source_2_d_get_filled(vtkGlyphSource2D* sself) { return sself->GetFilled(); } +extern "C" void vtk_glyph_source_2_d_filled_on(vtkGlyphSource2D* sself) { sself->FilledOn(); } +extern "C" void vtk_glyph_source_2_d_filled_off(vtkGlyphSource2D* sself) { sself->FilledOff(); } +extern "C" void vtk_glyph_source_2_d_set_dash(vtkGlyphSource2D* sself, int _arg) { sself->SetDash(_arg); } +extern "C" int vtk_glyph_source_2_d_get_dash(vtkGlyphSource2D* sself) { return sself->GetDash(); } +extern "C" void vtk_glyph_source_2_d_dash_on(vtkGlyphSource2D* sself) { sself->DashOn(); } +extern "C" void vtk_glyph_source_2_d_dash_off(vtkGlyphSource2D* sself) { sself->DashOff(); } +extern "C" void vtk_glyph_source_2_d_set_cross(vtkGlyphSource2D* sself, int _arg) { sself->SetCross(_arg); } +extern "C" int vtk_glyph_source_2_d_get_cross(vtkGlyphSource2D* sself) { return sself->GetCross(); } +extern "C" void vtk_glyph_source_2_d_cross_on(vtkGlyphSource2D* sself) { sself->CrossOn(); } +extern "C" void vtk_glyph_source_2_d_cross_off(vtkGlyphSource2D* sself) { sself->CrossOff(); } +extern "C" void vtk_glyph_source_2_d_set_rotation_angle(vtkGlyphSource2D* sself, double _arg) { sself->SetRotationAngle(_arg); } +extern "C" double vtk_glyph_source_2_d_get_rotation_angle(vtkGlyphSource2D* sself) { return sself->GetRotationAngle(); } +extern "C" void vtk_glyph_source_2_d_set_resolution(vtkGlyphSource2D* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_glyph_source_2_d_get_resolution_min_value(vtkGlyphSource2D* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_glyph_source_2_d_get_resolution_max_value(vtkGlyphSource2D* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_glyph_source_2_d_get_resolution(vtkGlyphSource2D* sself) { return sself->GetResolution(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type(vtkGlyphSource2D* sself, int _arg) { sself->SetGlyphType(_arg); } +extern "C" int vtk_glyph_source_2_d_get_glyph_type_min_value(vtkGlyphSource2D* sself) { return sself->GetGlyphTypeMinValue(); } +extern "C" int vtk_glyph_source_2_d_get_glyph_type_max_value(vtkGlyphSource2D* sself) { return sself->GetGlyphTypeMaxValue(); } +extern "C" int vtk_glyph_source_2_d_get_glyph_type(vtkGlyphSource2D* sself) { return sself->GetGlyphType(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_none(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToNone(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_vertex(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToVertex(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_dash(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToDash(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_cross(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToCross(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_thick_cross(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToThickCross(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_triangle(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToTriangle(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_square(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToSquare(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_circle(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToCircle(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_diamond(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToDiamond(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_arrow(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToArrow(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_thick_arrow(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToThickArrow(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_hooked_arrow(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToHookedArrow(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_edge_arrow(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToEdgeArrow(); } +extern "C" void vtk_glyph_source_2_d_set_output_points_precision(vtkGlyphSource2D* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_glyph_source_2_d_get_output_points_precision(vtkGlyphSource2D* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkGraphToPolyData * vtkGraphToPolyData_new () {return vtkGraphToPolyData :: New () ;} +extern "C" void vtkGraphToPolyData_destructor (vtkGraphToPolyData * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkGraphToPolyData_get_ptr (vtkGraphToPolyData * sself) {return sself ;} +extern "C" void vtk_graph_to_poly_data_set_edge_glyph_output(vtkGraphToPolyData* sself, bool _arg) { sself->SetEdgeGlyphOutput(_arg); } +extern "C" bool vtk_graph_to_poly_data_get_edge_glyph_output(vtkGraphToPolyData* sself) { return sself->GetEdgeGlyphOutput(); } +extern "C" void vtk_graph_to_poly_data_edge_glyph_output_on(vtkGraphToPolyData* sself) { sself->EdgeGlyphOutputOn(); } +extern "C" void vtk_graph_to_poly_data_edge_glyph_output_off(vtkGraphToPolyData* sself) { sself->EdgeGlyphOutputOff(); } +extern "C" void vtk_graph_to_poly_data_set_edge_glyph_position(vtkGraphToPolyData* sself, double _arg) { sself->SetEdgeGlyphPosition(_arg); } +extern "C" double vtk_graph_to_poly_data_get_edge_glyph_position(vtkGraphToPolyData* sself) { return sself->GetEdgeGlyphPosition(); } +extern "C" vtkHyperTreeGridSource * vtkHyperTreeGridSource_new () {return vtkHyperTreeGridSource :: New () ;} +extern "C" void vtkHyperTreeGridSource_destructor (vtkHyperTreeGridSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkHyperTreeGridSource_get_ptr (vtkHyperTreeGridSource * sself) {return sself ;} +extern "C" unsigned int vtk_hyper_tree_grid_source_get_maximum_level(vtkHyperTreeGridSource* sself) { return sself->GetMaximumLevel(); } +extern "C" void vtk_hyper_tree_grid_source_set_maximum_level(vtkHyperTreeGridSource* sself, unsigned int levels) { sself->SetMaximumLevel(levels); } +extern "C" unsigned int vtk_hyper_tree_grid_source_get_max_depth(vtkHyperTreeGridSource* sself) { return sself->GetMaxDepth(); } +extern "C" void vtk_hyper_tree_grid_source_set_max_depth(vtkHyperTreeGridSource* sself, unsigned int levels) { sself->SetMaxDepth(levels); } +extern "C" void vtk_hyper_tree_grid_source_set_origin(vtkHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_hyper_tree_grid_source_set_grid_scale(vtkHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetGridScale(_arg1, _arg2, _arg3); } +extern "C" void vtk_hyper_tree_grid_source_set_transposed_root_indexing(vtkHyperTreeGridSource* sself, bool _arg) { sself->SetTransposedRootIndexing(_arg); } +extern "C" bool vtk_hyper_tree_grid_source_get_transposed_root_indexing(vtkHyperTreeGridSource* sself) { return sself->GetTransposedRootIndexing(); } +extern "C" void vtk_hyper_tree_grid_source_set_indexing_mode_to_kji(vtkHyperTreeGridSource* sself) { sself->SetIndexingModeToKJI(); } +extern "C" void vtk_hyper_tree_grid_source_set_indexing_mode_to_ijk(vtkHyperTreeGridSource* sself) { sself->SetIndexingModeToIJK(); } +extern "C" unsigned int vtk_hyper_tree_grid_source_get_orientation(vtkHyperTreeGridSource* sself) { return sself->GetOrientation(); } +extern "C" void vtk_hyper_tree_grid_source_set_branch_factor(vtkHyperTreeGridSource* sself, unsigned int _arg) { sself->SetBranchFactor(_arg); } +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor_min_value(vtkHyperTreeGridSource* sself) { return sself->GetBranchFactorMinValue(); } +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor_max_value(vtkHyperTreeGridSource* sself) { return sself->GetBranchFactorMaxValue(); } +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor(vtkHyperTreeGridSource* sself) { return sself->GetBranchFactor(); } +extern "C" void vtk_hyper_tree_grid_source_set_use_descriptor(vtkHyperTreeGridSource* sself, bool _arg) { sself->SetUseDescriptor(_arg); } +extern "C" bool vtk_hyper_tree_grid_source_get_use_descriptor(vtkHyperTreeGridSource* sself) { return sself->GetUseDescriptor(); } +extern "C" void vtk_hyper_tree_grid_source_use_descriptor_on(vtkHyperTreeGridSource* sself) { sself->UseDescriptorOn(); } +extern "C" void vtk_hyper_tree_grid_source_use_descriptor_off(vtkHyperTreeGridSource* sself) { sself->UseDescriptorOff(); } +extern "C" void vtk_hyper_tree_grid_source_set_use_mask(vtkHyperTreeGridSource* sself, bool _arg) { sself->SetUseMask(_arg); } +extern "C" bool vtk_hyper_tree_grid_source_get_use_mask(vtkHyperTreeGridSource* sself) { return sself->GetUseMask(); } +extern "C" void vtk_hyper_tree_grid_source_use_mask_on(vtkHyperTreeGridSource* sself) { sself->UseMaskOn(); } +extern "C" void vtk_hyper_tree_grid_source_use_mask_off(vtkHyperTreeGridSource* sself) { sself->UseMaskOff(); } +extern "C" void vtk_hyper_tree_grid_source_set_generate_interface_fields(vtkHyperTreeGridSource* sself, bool _arg) { sself->SetGenerateInterfaceFields(_arg); } +extern "C" bool vtk_hyper_tree_grid_source_get_generate_interface_fields(vtkHyperTreeGridSource* sself) { return sself->GetGenerateInterfaceFields(); } +extern "C" void vtk_hyper_tree_grid_source_generate_interface_fields_on(vtkHyperTreeGridSource* sself) { sself->GenerateInterfaceFieldsOn(); } +extern "C" void vtk_hyper_tree_grid_source_generate_interface_fields_off(vtkHyperTreeGridSource* sself) { sself->GenerateInterfaceFieldsOff(); } +extern "C" void vtk_hyper_tree_grid_source_set_descriptor(vtkHyperTreeGridSource* sself, const char* _arg) { sself->SetDescriptor(_arg); } +extern "C" void vtk_hyper_tree_grid_source_set_mask(vtkHyperTreeGridSource* sself, const char* _arg) { sself->SetMask(_arg); } +extern "C" unsigned long vtk_hyper_tree_grid_source_get_m_time(vtkHyperTreeGridSource* sself) { return sself->GetMTime(); } +extern "C" vtkLineSource * vtkLineSource_new () {return vtkLineSource :: New () ;} +extern "C" void vtkLineSource_destructor (vtkLineSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkLineSource_get_ptr (vtkLineSource * sself) {return sself ;} +extern "C" void vtk_line_source_set_point_1(vtkLineSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint1(_arg1, _arg2, _arg3); } +extern "C" void vtk_line_source_set_point_2(vtkLineSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint2(_arg1, _arg2, _arg3); } +extern "C" void vtk_line_source_set_use_regular_refinement(vtkLineSource* sself, bool _arg) { sself->SetUseRegularRefinement(_arg); } +extern "C" bool vtk_line_source_get_use_regular_refinement(vtkLineSource* sself) { return sself->GetUseRegularRefinement(); } +extern "C" void vtk_line_source_use_regular_refinement_on(vtkLineSource* sself) { sself->UseRegularRefinementOn(); } +extern "C" void vtk_line_source_use_regular_refinement_off(vtkLineSource* sself) { sself->UseRegularRefinementOff(); } +extern "C" void vtk_line_source_set_resolution(vtkLineSource* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_line_source_get_resolution_min_value(vtkLineSource* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_line_source_get_resolution_max_value(vtkLineSource* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_line_source_get_resolution(vtkLineSource* sself) { return sself->GetResolution(); } +extern "C" void vtk_line_source_set_number_of_refinement_ratios(vtkLineSource* sself, int p0) { sself->SetNumberOfRefinementRatios(p0); } +extern "C" void vtk_line_source_set_refinement_ratio(vtkLineSource* sself, int index, double value) { sself->SetRefinementRatio(index, value); } +extern "C" int vtk_line_source_get_number_of_refinement_ratios(vtkLineSource* sself) { return sself->GetNumberOfRefinementRatios(); } +extern "C" double vtk_line_source_get_refinement_ratio(vtkLineSource* sself, int index) { return sself->GetRefinementRatio(index); } +extern "C" void vtk_line_source_set_output_points_precision(vtkLineSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_line_source_get_output_points_precision(vtkLineSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkOutlineCornerFilter * vtkOutlineCornerFilter_new () {return vtkOutlineCornerFilter :: New () ;} +extern "C" void vtkOutlineCornerFilter_destructor (vtkOutlineCornerFilter * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOutlineCornerFilter_get_ptr (vtkOutlineCornerFilter * sself) {return sself ;} +extern "C" void vtk_outline_corner_filter_set_corner_factor(vtkOutlineCornerFilter* sself, double _arg) { sself->SetCornerFactor(_arg); } +extern "C" double vtk_outline_corner_filter_get_corner_factor_min_value(vtkOutlineCornerFilter* sself) { return sself->GetCornerFactorMinValue(); } +extern "C" double vtk_outline_corner_filter_get_corner_factor_max_value(vtkOutlineCornerFilter* sself) { return sself->GetCornerFactorMaxValue(); } +extern "C" double vtk_outline_corner_filter_get_corner_factor(vtkOutlineCornerFilter* sself) { return sself->GetCornerFactor(); } +extern "C" vtkOutlineCornerSource * vtkOutlineCornerSource_new () {return vtkOutlineCornerSource :: New () ;} +extern "C" void vtkOutlineCornerSource_destructor (vtkOutlineCornerSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOutlineCornerSource_get_ptr (vtkOutlineCornerSource * sself) {return sself ;} +extern "C" void vtk_outline_corner_source_set_corner_factor(vtkOutlineCornerSource* sself, double _arg) { sself->SetCornerFactor(_arg); } +extern "C" double vtk_outline_corner_source_get_corner_factor_min_value(vtkOutlineCornerSource* sself) { return sself->GetCornerFactorMinValue(); } +extern "C" double vtk_outline_corner_source_get_corner_factor_max_value(vtkOutlineCornerSource* sself) { return sself->GetCornerFactorMaxValue(); } +extern "C" double vtk_outline_corner_source_get_corner_factor(vtkOutlineCornerSource* sself) { return sself->GetCornerFactor(); } +extern "C" vtkOutlineSource * vtkOutlineSource_new () {return vtkOutlineSource :: New () ;} +extern "C" void vtkOutlineSource_destructor (vtkOutlineSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkOutlineSource_get_ptr (vtkOutlineSource * sself) {return sself ;} +extern "C" void vtk_outline_source_set_box_type(vtkOutlineSource* sself, int _arg) { sself->SetBoxType(_arg); } +extern "C" int vtk_outline_source_get_box_type(vtkOutlineSource* sself) { return sself->GetBoxType(); } +extern "C" void vtk_outline_source_set_box_type_to_axis_aligned(vtkOutlineSource* sself) { sself->SetBoxTypeToAxisAligned(); } +extern "C" void vtk_outline_source_set_box_type_to_oriented(vtkOutlineSource* sself) { sself->SetBoxTypeToOriented(); } +extern "C" void vtk_outline_source_set_bounds(vtkOutlineSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6) { sself->SetBounds(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_outline_source_set_generate_faces(vtkOutlineSource* sself, int _arg) { sself->SetGenerateFaces(_arg); } +extern "C" void vtk_outline_source_generate_faces_on(vtkOutlineSource* sself) { sself->GenerateFacesOn(); } +extern "C" void vtk_outline_source_generate_faces_off(vtkOutlineSource* sself) { sself->GenerateFacesOff(); } +extern "C" int vtk_outline_source_get_generate_faces(vtkOutlineSource* sself) { return sself->GetGenerateFaces(); } +extern "C" void vtk_outline_source_set_output_points_precision(vtkOutlineSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_outline_source_get_output_points_precision(vtkOutlineSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkParametricFunctionSource * vtkParametricFunctionSource_new () {return vtkParametricFunctionSource :: New () ;} +extern "C" void vtkParametricFunctionSource_destructor (vtkParametricFunctionSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkParametricFunctionSource_get_ptr (vtkParametricFunctionSource * sself) {return sself ;} +extern "C" void vtk_parametric_function_source_set_u_resolution(vtkParametricFunctionSource* sself, int _arg) { sself->SetUResolution(_arg); } +extern "C" int vtk_parametric_function_source_get_u_resolution_min_value(vtkParametricFunctionSource* sself) { return sself->GetUResolutionMinValue(); } +extern "C" int vtk_parametric_function_source_get_u_resolution_max_value(vtkParametricFunctionSource* sself) { return sself->GetUResolutionMaxValue(); } +extern "C" int vtk_parametric_function_source_get_u_resolution(vtkParametricFunctionSource* sself) { return sself->GetUResolution(); } +extern "C" void vtk_parametric_function_source_set_v_resolution(vtkParametricFunctionSource* sself, int _arg) { sself->SetVResolution(_arg); } +extern "C" int vtk_parametric_function_source_get_v_resolution_min_value(vtkParametricFunctionSource* sself) { return sself->GetVResolutionMinValue(); } +extern "C" int vtk_parametric_function_source_get_v_resolution_max_value(vtkParametricFunctionSource* sself) { return sself->GetVResolutionMaxValue(); } +extern "C" int vtk_parametric_function_source_get_v_resolution(vtkParametricFunctionSource* sself) { return sself->GetVResolution(); } +extern "C" void vtk_parametric_function_source_set_w_resolution(vtkParametricFunctionSource* sself, int _arg) { sself->SetWResolution(_arg); } +extern "C" int vtk_parametric_function_source_get_w_resolution_min_value(vtkParametricFunctionSource* sself) { return sself->GetWResolutionMinValue(); } +extern "C" int vtk_parametric_function_source_get_w_resolution_max_value(vtkParametricFunctionSource* sself) { return sself->GetWResolutionMaxValue(); } +extern "C" int vtk_parametric_function_source_get_w_resolution(vtkParametricFunctionSource* sself) { return sself->GetWResolution(); } +extern "C" void vtk_parametric_function_source_generate_texture_coordinates_on(vtkParametricFunctionSource* sself) { sself->GenerateTextureCoordinatesOn(); } +extern "C" void vtk_parametric_function_source_generate_texture_coordinates_off(vtkParametricFunctionSource* sself) { sself->GenerateTextureCoordinatesOff(); } +extern "C" void vtk_parametric_function_source_set_generate_texture_coordinates(vtkParametricFunctionSource* sself, int _arg) { sself->SetGenerateTextureCoordinates(_arg); } +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates_min_value(vtkParametricFunctionSource* sself) { return sself->GetGenerateTextureCoordinatesMinValue(); } +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates_max_value(vtkParametricFunctionSource* sself) { return sself->GetGenerateTextureCoordinatesMaxValue(); } +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates(vtkParametricFunctionSource* sself) { return sself->GetGenerateTextureCoordinates(); } +extern "C" void vtk_parametric_function_source_generate_normals_on(vtkParametricFunctionSource* sself) { sself->GenerateNormalsOn(); } +extern "C" void vtk_parametric_function_source_generate_normals_off(vtkParametricFunctionSource* sself) { sself->GenerateNormalsOff(); } +extern "C" void vtk_parametric_function_source_set_generate_normals(vtkParametricFunctionSource* sself, int _arg) { sself->SetGenerateNormals(_arg); } +extern "C" int vtk_parametric_function_source_get_generate_normals_min_value(vtkParametricFunctionSource* sself) { return sself->GetGenerateNormalsMinValue(); } +extern "C" int vtk_parametric_function_source_get_generate_normals_max_value(vtkParametricFunctionSource* sself) { return sself->GetGenerateNormalsMaxValue(); } +extern "C" int vtk_parametric_function_source_get_generate_normals(vtkParametricFunctionSource* sself) { return sself->GetGenerateNormals(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode(vtkParametricFunctionSource* sself, int _arg) { sself->SetScalarMode(_arg); } +extern "C" int vtk_parametric_function_source_get_scalar_mode_min_value(vtkParametricFunctionSource* sself) { return sself->GetScalarModeMinValue(); } +extern "C" int vtk_parametric_function_source_get_scalar_mode_max_value(vtkParametricFunctionSource* sself) { return sself->GetScalarModeMaxValue(); } +extern "C" int vtk_parametric_function_source_get_scalar_mode(vtkParametricFunctionSource* sself) { return sself->GetScalarMode(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_none(vtkParametricFunctionSource* sself) { sself->SetScalarModeToNone(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u(vtkParametricFunctionSource* sself) { sself->SetScalarModeToU(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_v(vtkParametricFunctionSource* sself) { sself->SetScalarModeToV(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u_0(vtkParametricFunctionSource* sself) { sself->SetScalarModeToU0(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_v_0(vtkParametricFunctionSource* sself) { sself->SetScalarModeToV0(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u_0_v_0(vtkParametricFunctionSource* sself) { sself->SetScalarModeToU0V0(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_modulus(vtkParametricFunctionSource* sself) { sself->SetScalarModeToModulus(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_phase(vtkParametricFunctionSource* sself) { sself->SetScalarModeToPhase(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_quadrant(vtkParametricFunctionSource* sself) { sself->SetScalarModeToQuadrant(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_x(vtkParametricFunctionSource* sself) { sself->SetScalarModeToX(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_y(vtkParametricFunctionSource* sself) { sself->SetScalarModeToY(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_z(vtkParametricFunctionSource* sself) { sself->SetScalarModeToZ(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_distance(vtkParametricFunctionSource* sself) { sself->SetScalarModeToDistance(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_function_defined(vtkParametricFunctionSource* sself) { sself->SetScalarModeToFunctionDefined(); } +extern "C" unsigned long vtk_parametric_function_source_get_m_time(vtkParametricFunctionSource* sself) { return sself->GetMTime(); } +extern "C" void vtk_parametric_function_source_set_output_points_precision(vtkParametricFunctionSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_parametric_function_source_get_output_points_precision(vtkParametricFunctionSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkPartitionedDataSetCollectionSource * vtkPartitionedDataSetCollectionSource_new () {return vtkPartitionedDataSetCollectionSource :: New () ;} +extern "C" void vtkPartitionedDataSetCollectionSource_destructor (vtkPartitionedDataSetCollectionSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPartitionedDataSetCollectionSource_get_ptr (vtkPartitionedDataSetCollectionSource * sself) {return sself ;} +extern "C" void vtk_partitioned_data_set_collection_source_set_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself, int _arg) { sself->SetNumberOfShapes(_arg); } +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_min_value(vtkPartitionedDataSetCollectionSource* sself) { return sself->GetNumberOfShapesMinValue(); } +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_max_value(vtkPartitionedDataSetCollectionSource* sself) { return sself->GetNumberOfShapesMaxValue(); } +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself) { return sself->GetNumberOfShapes(); } +extern "C" vtkPartitionedDataSetSource * vtkPartitionedDataSetSource_new () {return vtkPartitionedDataSetSource :: New () ;} +extern "C" void vtkPartitionedDataSetSource_destructor (vtkPartitionedDataSetSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPartitionedDataSetSource_get_ptr (vtkPartitionedDataSetSource * sself) {return sself ;} +extern "C" void vtk_partitioned_data_set_source_enable_rank(vtkPartitionedDataSetSource* sself, int rank) { sself->EnableRank(rank); } +extern "C" void vtk_partitioned_data_set_source_enable_all_ranks(vtkPartitionedDataSetSource* sself) { sself->EnableAllRanks(); } +extern "C" void vtk_partitioned_data_set_source_disable_rank(vtkPartitionedDataSetSource* sself, int rank) { sself->DisableRank(rank); } +extern "C" void vtk_partitioned_data_set_source_disable_all_ranks(vtkPartitionedDataSetSource* sself) { sself->DisableAllRanks(); } +extern "C" bool vtk_partitioned_data_set_source_is_enabled_rank(vtkPartitionedDataSetSource* sself, int rank) { return sself->IsEnabledRank(rank); } +extern "C" void vtk_partitioned_data_set_source_set_number_of_partitions(vtkPartitionedDataSetSource* sself, int _arg) { sself->SetNumberOfPartitions(_arg); } +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions_min_value(vtkPartitionedDataSetSource* sself) { return sself->GetNumberOfPartitionsMinValue(); } +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions_max_value(vtkPartitionedDataSetSource* sself) { return sself->GetNumberOfPartitionsMaxValue(); } +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions(vtkPartitionedDataSetSource* sself) { return sself->GetNumberOfPartitions(); } +extern "C" vtkPlaneSource * vtkPlaneSource_new () {return vtkPlaneSource :: New () ;} +extern "C" void vtkPlaneSource_destructor (vtkPlaneSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPlaneSource_get_ptr (vtkPlaneSource * sself) {return sself ;} +extern "C" void vtk_plane_source_set_x_resolution(vtkPlaneSource* sself, int _arg) { sself->SetXResolution(_arg); } +extern "C" int vtk_plane_source_get_x_resolution(vtkPlaneSource* sself) { return sself->GetXResolution(); } +extern "C" void vtk_plane_source_set_y_resolution(vtkPlaneSource* sself, int _arg) { sself->SetYResolution(_arg); } +extern "C" int vtk_plane_source_get_y_resolution(vtkPlaneSource* sself) { return sself->GetYResolution(); } +extern "C" void vtk_plane_source_set_resolution(vtkPlaneSource* sself, const int xR, const int yR) { sself->SetResolution(xR, yR); } +extern "C" void vtk_plane_source_get_resolution(vtkPlaneSource* sself, int& xR, int& yR) { sself->GetResolution(xR, yR); } +extern "C" void vtk_plane_source_set_origin(vtkPlaneSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_plane_source_set_point_1(vtkPlaneSource* sself, double x, double y, double z) { sself->SetPoint1(x, y, z); } +extern "C" void vtk_plane_source_set_point_2(vtkPlaneSource* sself, double x, double y, double z) { sself->SetPoint2(x, y, z); } +extern "C" void vtk_plane_source_set_center(vtkPlaneSource* sself, double x, double y, double z) { sself->SetCenter(x, y, z); } +extern "C" void vtk_plane_source_set_normal(vtkPlaneSource* sself, double nx, double ny, double nz) { sself->SetNormal(nx, ny, nz); } +extern "C" void vtk_plane_source_push(vtkPlaneSource* sself, double distance) { sself->Push(distance); } +extern "C" void vtk_plane_source_set_output_points_precision(vtkPlaneSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_plane_source_get_output_points_precision(vtkPlaneSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkPlatonicSolidSource * vtkPlatonicSolidSource_new () {return vtkPlatonicSolidSource :: New () ;} +extern "C" void vtkPlatonicSolidSource_destructor (vtkPlatonicSolidSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPlatonicSolidSource_get_ptr (vtkPlatonicSolidSource * sself) {return sself ;} +extern "C" void vtk_platonic_solid_source_set_solid_type(vtkPlatonicSolidSource* sself, int _arg) { sself->SetSolidType(_arg); } +extern "C" int vtk_platonic_solid_source_get_solid_type_min_value(vtkPlatonicSolidSource* sself) { return sself->GetSolidTypeMinValue(); } +extern "C" int vtk_platonic_solid_source_get_solid_type_max_value(vtkPlatonicSolidSource* sself) { return sself->GetSolidTypeMaxValue(); } +extern "C" int vtk_platonic_solid_source_get_solid_type(vtkPlatonicSolidSource* sself) { return sself->GetSolidType(); } +extern "C" void vtk_platonic_solid_source_set_solid_type_to_tetrahedron(vtkPlatonicSolidSource* sself) { sself->SetSolidTypeToTetrahedron(); } +extern "C" void vtk_platonic_solid_source_set_solid_type_to_cube(vtkPlatonicSolidSource* sself) { sself->SetSolidTypeToCube(); } +extern "C" void vtk_platonic_solid_source_set_solid_type_to_octahedron(vtkPlatonicSolidSource* sself) { sself->SetSolidTypeToOctahedron(); } +extern "C" void vtk_platonic_solid_source_set_solid_type_to_icosahedron(vtkPlatonicSolidSource* sself) { sself->SetSolidTypeToIcosahedron(); } +extern "C" void vtk_platonic_solid_source_set_solid_type_to_dodecahedron(vtkPlatonicSolidSource* sself) { sself->SetSolidTypeToDodecahedron(); } +extern "C" void vtk_platonic_solid_source_set_output_points_precision(vtkPlatonicSolidSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_platonic_solid_source_get_output_points_precision(vtkPlatonicSolidSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkPointHandleSource * vtkPointHandleSource_new () {return vtkPointHandleSource :: New () ;} +extern "C" void vtkPointHandleSource_destructor (vtkPointHandleSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPointHandleSource_get_ptr (vtkPointHandleSource * sself) {return sself ;} +extern "C" void vtk_point_handle_source_set_position(vtkPointHandleSource* sself, double xPos, double yPos, double zPos) { sself->SetPosition(xPos, yPos, zPos); } +extern "C" void vtk_point_handle_source_set_direction(vtkPointHandleSource* sself, double xDir, double yDir, double zDir) { sself->SetDirection(xDir, yDir, zDir); } +extern "C" vtkPointSource * vtkPointSource_new () {return vtkPointSource :: New () ;} +extern "C" void vtkPointSource_destructor (vtkPointSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPointSource_get_ptr (vtkPointSource * sself) {return sself ;} +extern "C" void vtk_point_source_set_number_of_points(vtkPointSource* sself, long long _arg) { sself->SetNumberOfPoints(_arg); } +extern "C" long long vtk_point_source_get_number_of_points_min_value(vtkPointSource* sself) { return sself->GetNumberOfPointsMinValue(); } +extern "C" long long vtk_point_source_get_number_of_points_max_value(vtkPointSource* sself) { return sself->GetNumberOfPointsMaxValue(); } +extern "C" long long vtk_point_source_get_number_of_points(vtkPointSource* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_point_source_set_center(vtkPointSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_point_source_set_radius(vtkPointSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_point_source_get_radius_min_value(vtkPointSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_point_source_get_radius_max_value(vtkPointSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_point_source_get_radius(vtkPointSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_point_source_set_distribution(vtkPointSource* sself, int _arg) { sself->SetDistribution(_arg); } +extern "C" void vtk_point_source_set_distribution_to_uniform(vtkPointSource* sself) { sself->SetDistributionToUniform(); } +extern "C" void vtk_point_source_set_distribution_to_shell(vtkPointSource* sself) { sself->SetDistributionToShell(); } +extern "C" int vtk_point_source_get_distribution(vtkPointSource* sself) { return sself->GetDistribution(); } +extern "C" void vtk_point_source_set_output_points_precision(vtkPointSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_point_source_get_output_points_precision(vtkPointSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkPolyLineSource * vtkPolyLineSource_new () {return vtkPolyLineSource :: New () ;} +extern "C" void vtkPolyLineSource_destructor (vtkPolyLineSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolyLineSource_get_ptr (vtkPolyLineSource * sself) {return sself ;} +extern "C" void vtk_poly_line_source_set_closed(vtkPolyLineSource* sself, int _arg) { sself->SetClosed(_arg); } +extern "C" int vtk_poly_line_source_get_closed(vtkPolyLineSource* sself) { return sself->GetClosed(); } +extern "C" void vtk_poly_line_source_closed_on(vtkPolyLineSource* sself) { sself->ClosedOn(); } +extern "C" void vtk_poly_line_source_closed_off(vtkPolyLineSource* sself) { sself->ClosedOff(); } +extern "C" vtkPolyPointSource * vtkPolyPointSource_new () {return vtkPolyPointSource :: New () ;} +extern "C" void vtkPolyPointSource_destructor (vtkPolyPointSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkPolyPointSource_get_ptr (vtkPolyPointSource * sself) {return sself ;} +extern "C" void vtk_poly_point_source_set_number_of_points(vtkPolyPointSource* sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } +extern "C" long long vtk_poly_point_source_get_number_of_points(vtkPolyPointSource* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_poly_point_source_resize(vtkPolyPointSource* sself, long long numPoints) { sself->Resize(numPoints); } +extern "C" void vtk_poly_point_source_set_point(vtkPolyPointSource* sself, long long id, double x, double y, double z) { sself->SetPoint(id, x, y, z); } +extern "C" unsigned long vtk_poly_point_source_get_m_time(vtkPolyPointSource* sself) { return sself->GetMTime(); } +extern "C" vtkProgrammableDataObjectSource * vtkProgrammableDataObjectSource_new () {return vtkProgrammableDataObjectSource :: New () ;} +extern "C" void vtkProgrammableDataObjectSource_destructor (vtkProgrammableDataObjectSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkProgrammableDataObjectSource_get_ptr (vtkProgrammableDataObjectSource * sself) {return sself ;} +extern "C" vtkProgrammableSource * vtkProgrammableSource_new () {return vtkProgrammableSource :: New () ;} +extern "C" void vtkProgrammableSource_destructor (vtkProgrammableSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkProgrammableSource_get_ptr (vtkProgrammableSource * sself) {return sself ;} +extern "C" vtkRandomHyperTreeGridSource * vtkRandomHyperTreeGridSource_new () {return vtkRandomHyperTreeGridSource :: New () ;} +extern "C" void vtkRandomHyperTreeGridSource_destructor (vtkRandomHyperTreeGridSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkRandomHyperTreeGridSource_get_ptr (vtkRandomHyperTreeGridSource * sself) {return sself ;} +extern "C" void vtk_random_hyper_tree_grid_source_set_dimensions(vtkRandomHyperTreeGridSource* sself, unsigned int _arg1, unsigned int _arg2, unsigned int _arg3) { sself->SetDimensions(_arg1, _arg2, _arg3); } +extern "C" void vtk_random_hyper_tree_grid_source_set_output_bounds(vtkRandomHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6) { sself->SetOutputBounds(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" unsigned int vtk_random_hyper_tree_grid_source_get_seed(vtkRandomHyperTreeGridSource* sself) { return sself->GetSeed(); } +extern "C" void vtk_random_hyper_tree_grid_source_set_seed(vtkRandomHyperTreeGridSource* sself, unsigned int _arg) { sself->SetSeed(_arg); } +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth(vtkRandomHyperTreeGridSource* sself) { return sself->GetMaxDepth(); } +extern "C" void vtk_random_hyper_tree_grid_source_set_max_depth(vtkRandomHyperTreeGridSource* sself, long long _arg) { sself->SetMaxDepth(_arg); } +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth_min_value(vtkRandomHyperTreeGridSource* sself) { return sself->GetMaxDepthMinValue(); } +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth_max_value(vtkRandomHyperTreeGridSource* sself) { return sself->GetMaxDepthMaxValue(); } +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction(vtkRandomHyperTreeGridSource* sself) { return sself->GetSplitFraction(); } +extern "C" void vtk_random_hyper_tree_grid_source_set_split_fraction(vtkRandomHyperTreeGridSource* sself, double _arg) { sself->SetSplitFraction(_arg); } +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_min_value(vtkRandomHyperTreeGridSource* sself) { return sself->GetSplitFractionMinValue(); } +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_max_value(vtkRandomHyperTreeGridSource* sself) { return sself->GetSplitFractionMaxValue(); } +extern "C" vtkRectangularButtonSource * vtkRectangularButtonSource_new () {return vtkRectangularButtonSource :: New () ;} +extern "C" void vtkRectangularButtonSource_destructor (vtkRectangularButtonSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkRectangularButtonSource_get_ptr (vtkRectangularButtonSource * sself) {return sself ;} +extern "C" void vtk_rectangular_button_source_set_width(vtkRectangularButtonSource* sself, double _arg) { sself->SetWidth(_arg); } +extern "C" double vtk_rectangular_button_source_get_width_min_value(vtkRectangularButtonSource* sself) { return sself->GetWidthMinValue(); } +extern "C" double vtk_rectangular_button_source_get_width_max_value(vtkRectangularButtonSource* sself) { return sself->GetWidthMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_width(vtkRectangularButtonSource* sself) { return sself->GetWidth(); } +extern "C" void vtk_rectangular_button_source_set_height(vtkRectangularButtonSource* sself, double _arg) { sself->SetHeight(_arg); } +extern "C" double vtk_rectangular_button_source_get_height_min_value(vtkRectangularButtonSource* sself) { return sself->GetHeightMinValue(); } +extern "C" double vtk_rectangular_button_source_get_height_max_value(vtkRectangularButtonSource* sself) { return sself->GetHeightMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_height(vtkRectangularButtonSource* sself) { return sself->GetHeight(); } +extern "C" void vtk_rectangular_button_source_set_depth(vtkRectangularButtonSource* sself, double _arg) { sself->SetDepth(_arg); } +extern "C" double vtk_rectangular_button_source_get_depth_min_value(vtkRectangularButtonSource* sself) { return sself->GetDepthMinValue(); } +extern "C" double vtk_rectangular_button_source_get_depth_max_value(vtkRectangularButtonSource* sself) { return sself->GetDepthMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_depth(vtkRectangularButtonSource* sself) { return sself->GetDepth(); } +extern "C" void vtk_rectangular_button_source_set_box_ratio(vtkRectangularButtonSource* sself, double _arg) { sself->SetBoxRatio(_arg); } +extern "C" double vtk_rectangular_button_source_get_box_ratio_min_value(vtkRectangularButtonSource* sself) { return sself->GetBoxRatioMinValue(); } +extern "C" double vtk_rectangular_button_source_get_box_ratio_max_value(vtkRectangularButtonSource* sself) { return sself->GetBoxRatioMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_box_ratio(vtkRectangularButtonSource* sself) { return sself->GetBoxRatio(); } +extern "C" void vtk_rectangular_button_source_set_texture_ratio(vtkRectangularButtonSource* sself, double _arg) { sself->SetTextureRatio(_arg); } +extern "C" double vtk_rectangular_button_source_get_texture_ratio_min_value(vtkRectangularButtonSource* sself) { return sself->GetTextureRatioMinValue(); } +extern "C" double vtk_rectangular_button_source_get_texture_ratio_max_value(vtkRectangularButtonSource* sself) { return sself->GetTextureRatioMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_texture_ratio(vtkRectangularButtonSource* sself) { return sself->GetTextureRatio(); } +extern "C" void vtk_rectangular_button_source_set_texture_height_ratio(vtkRectangularButtonSource* sself, double _arg) { sself->SetTextureHeightRatio(_arg); } +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio_min_value(vtkRectangularButtonSource* sself) { return sself->GetTextureHeightRatioMinValue(); } +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio_max_value(vtkRectangularButtonSource* sself) { return sself->GetTextureHeightRatioMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio(vtkRectangularButtonSource* sself) { return sself->GetTextureHeightRatio(); } +extern "C" void vtk_rectangular_button_source_set_output_points_precision(vtkRectangularButtonSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_rectangular_button_source_get_output_points_precision(vtkRectangularButtonSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkRegularPolygonSource * vtkRegularPolygonSource_new () {return vtkRegularPolygonSource :: New () ;} +extern "C" void vtkRegularPolygonSource_destructor (vtkRegularPolygonSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkRegularPolygonSource_get_ptr (vtkRegularPolygonSource * sself) {return sself ;} +extern "C" void vtk_regular_polygon_source_set_number_of_sides(vtkRegularPolygonSource* sself, int _arg) { sself->SetNumberOfSides(_arg); } +extern "C" int vtk_regular_polygon_source_get_number_of_sides_min_value(vtkRegularPolygonSource* sself) { return sself->GetNumberOfSidesMinValue(); } +extern "C" int vtk_regular_polygon_source_get_number_of_sides_max_value(vtkRegularPolygonSource* sself) { return sself->GetNumberOfSidesMaxValue(); } +extern "C" int vtk_regular_polygon_source_get_number_of_sides(vtkRegularPolygonSource* sself) { return sself->GetNumberOfSides(); } +extern "C" void vtk_regular_polygon_source_set_center(vtkRegularPolygonSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_regular_polygon_source_set_normal(vtkRegularPolygonSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" void vtk_regular_polygon_source_set_radius(vtkRegularPolygonSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_regular_polygon_source_get_radius(vtkRegularPolygonSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_regular_polygon_source_set_generate_polygon(vtkRegularPolygonSource* sself, int _arg) { sself->SetGeneratePolygon(_arg); } +extern "C" int vtk_regular_polygon_source_get_generate_polygon(vtkRegularPolygonSource* sself) { return sself->GetGeneratePolygon(); } +extern "C" void vtk_regular_polygon_source_generate_polygon_on(vtkRegularPolygonSource* sself) { sself->GeneratePolygonOn(); } +extern "C" void vtk_regular_polygon_source_generate_polygon_off(vtkRegularPolygonSource* sself) { sself->GeneratePolygonOff(); } +extern "C" void vtk_regular_polygon_source_set_generate_polyline(vtkRegularPolygonSource* sself, int _arg) { sself->SetGeneratePolyline(_arg); } +extern "C" int vtk_regular_polygon_source_get_generate_polyline(vtkRegularPolygonSource* sself) { return sself->GetGeneratePolyline(); } +extern "C" void vtk_regular_polygon_source_generate_polyline_on(vtkRegularPolygonSource* sself) { sself->GeneratePolylineOn(); } +extern "C" void vtk_regular_polygon_source_generate_polyline_off(vtkRegularPolygonSource* sself) { sself->GeneratePolylineOff(); } +extern "C" void vtk_regular_polygon_source_set_output_points_precision(vtkRegularPolygonSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_regular_polygon_source_get_output_points_precision(vtkRegularPolygonSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkSelectionSource * vtkSelectionSource_new () {return vtkSelectionSource :: New () ;} +extern "C" void vtkSelectionSource_destructor (vtkSelectionSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSelectionSource_get_ptr (vtkSelectionSource * sself) {return sself ;} +extern "C" void vtk_selection_source_add_id(vtkSelectionSource* sself, long long piece, long long id) { sself->AddID(piece, id); } +extern "C" void vtk_selection_source_add_string_id(vtkSelectionSource* sself, long long piece, const char* id) { sself->AddStringID(piece, id); } +extern "C" void vtk_selection_source_add_location(vtkSelectionSource* sself, double x, double y, double z) { sself->AddLocation(x, y, z); } +extern "C" void vtk_selection_source_add_threshold(vtkSelectionSource* sself, double min, double max) { sself->AddThreshold(min, max); } +extern "C" void vtk_selection_source_add_block(vtkSelectionSource* sself, long long blockno) { sself->AddBlock(blockno); } +extern "C" void vtk_selection_source_add_block_selector(vtkSelectionSource* sself, const char* selector) { sself->AddBlockSelector(selector); } +extern "C" void vtk_selection_source_remove_all_block_selectors(vtkSelectionSource* sself) { sself->RemoveAllBlockSelectors(); } +extern "C" void vtk_selection_source_remove_all_i_ds(vtkSelectionSource* sself) { sself->RemoveAllIDs(); } +extern "C" void vtk_selection_source_remove_all_string_i_ds(vtkSelectionSource* sself) { sself->RemoveAllStringIDs(); } +extern "C" void vtk_selection_source_remove_all_thresholds(vtkSelectionSource* sself) { sself->RemoveAllThresholds(); } +extern "C" void vtk_selection_source_remove_all_locations(vtkSelectionSource* sself) { sself->RemoveAllLocations(); } +extern "C" void vtk_selection_source_remove_all_blocks(vtkSelectionSource* sself) { sself->RemoveAllBlocks(); } +extern "C" void vtk_selection_source_set_content_type(vtkSelectionSource* sself, int _arg) { sself->SetContentType(_arg); } +extern "C" int vtk_selection_source_get_content_type(vtkSelectionSource* sself) { return sself->GetContentType(); } +extern "C" void vtk_selection_source_set_field_type(vtkSelectionSource* sself, int _arg) { sself->SetFieldType(_arg); } +extern "C" int vtk_selection_source_get_field_type(vtkSelectionSource* sself) { return sself->GetFieldType(); } +extern "C" void vtk_selection_source_set_containing_cells(vtkSelectionSource* sself, int _arg) { sself->SetContainingCells(_arg); } +extern "C" int vtk_selection_source_get_containing_cells(vtkSelectionSource* sself) { return sself->GetContainingCells(); } +extern "C" void vtk_selection_source_set_number_of_layers(vtkSelectionSource* sself, int _arg) { sself->SetNumberOfLayers(_arg); } +extern "C" int vtk_selection_source_get_number_of_layers_min_value(vtkSelectionSource* sself) { return sself->GetNumberOfLayersMinValue(); } +extern "C" int vtk_selection_source_get_number_of_layers_max_value(vtkSelectionSource* sself) { return sself->GetNumberOfLayersMaxValue(); } +extern "C" int vtk_selection_source_get_number_of_layers(vtkSelectionSource* sself) { return sself->GetNumberOfLayers(); } +extern "C" void vtk_selection_source_set_inverse(vtkSelectionSource* sself, int _arg) { sself->SetInverse(_arg); } +extern "C" int vtk_selection_source_get_inverse(vtkSelectionSource* sself) { return sself->GetInverse(); } +extern "C" void vtk_selection_source_set_array_name(vtkSelectionSource* sself, const char* _arg) { sself->SetArrayName(_arg); } +extern "C" void vtk_selection_source_set_array_component(vtkSelectionSource* sself, int _arg) { sself->SetArrayComponent(_arg); } +extern "C" int vtk_selection_source_get_array_component(vtkSelectionSource* sself) { return sself->GetArrayComponent(); } +extern "C" void vtk_selection_source_set_composite_index(vtkSelectionSource* sself, int _arg) { sself->SetCompositeIndex(_arg); } +extern "C" int vtk_selection_source_get_composite_index(vtkSelectionSource* sself) { return sself->GetCompositeIndex(); } +extern "C" void vtk_selection_source_set_hierarchical_level(vtkSelectionSource* sself, int _arg) { sself->SetHierarchicalLevel(_arg); } +extern "C" int vtk_selection_source_get_hierarchical_level(vtkSelectionSource* sself) { return sself->GetHierarchicalLevel(); } +extern "C" void vtk_selection_source_set_hierarchical_index(vtkSelectionSource* sself, int _arg) { sself->SetHierarchicalIndex(_arg); } +extern "C" int vtk_selection_source_get_hierarchical_index(vtkSelectionSource* sself) { return sself->GetHierarchicalIndex(); } +extern "C" void vtk_selection_source_set_assembly_name(vtkSelectionSource* sself, const char* _arg) { sself->SetAssemblyName(_arg); } +extern "C" void vtk_selection_source_add_selector(vtkSelectionSource* sself, const char* selector) { sself->AddSelector(selector); } +extern "C" void vtk_selection_source_remove_all_selectors(vtkSelectionSource* sself) { sself->RemoveAllSelectors(); } +extern "C" void vtk_selection_source_set_query_string(vtkSelectionSource* sself, const char* _arg) { sself->SetQueryString(_arg); } +extern "C" vtkSphereSource * vtkSphereSource_new () {return vtkSphereSource :: New () ;} +extern "C" void vtkSphereSource_destructor (vtkSphereSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSphereSource_get_ptr (vtkSphereSource * sself) {return sself ;} +extern "C" void vtk_sphere_source_set_radius(vtkSphereSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_sphere_source_get_radius_min_value(vtkSphereSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_sphere_source_get_radius_max_value(vtkSphereSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_sphere_source_get_radius(vtkSphereSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_sphere_source_set_center(vtkSphereSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_sphere_source_set_theta_resolution(vtkSphereSource* sself, int _arg) { sself->SetThetaResolution(_arg); } +extern "C" int vtk_sphere_source_get_theta_resolution_min_value(vtkSphereSource* sself) { return sself->GetThetaResolutionMinValue(); } +extern "C" int vtk_sphere_source_get_theta_resolution_max_value(vtkSphereSource* sself) { return sself->GetThetaResolutionMaxValue(); } +extern "C" int vtk_sphere_source_get_theta_resolution(vtkSphereSource* sself) { return sself->GetThetaResolution(); } +extern "C" void vtk_sphere_source_set_phi_resolution(vtkSphereSource* sself, int _arg) { sself->SetPhiResolution(_arg); } +extern "C" int vtk_sphere_source_get_phi_resolution_min_value(vtkSphereSource* sself) { return sself->GetPhiResolutionMinValue(); } +extern "C" int vtk_sphere_source_get_phi_resolution_max_value(vtkSphereSource* sself) { return sself->GetPhiResolutionMaxValue(); } +extern "C" int vtk_sphere_source_get_phi_resolution(vtkSphereSource* sself) { return sself->GetPhiResolution(); } +extern "C" void vtk_sphere_source_set_start_theta(vtkSphereSource* sself, double _arg) { sself->SetStartTheta(_arg); } +extern "C" double vtk_sphere_source_get_start_theta_min_value(vtkSphereSource* sself) { return sself->GetStartThetaMinValue(); } +extern "C" double vtk_sphere_source_get_start_theta_max_value(vtkSphereSource* sself) { return sself->GetStartThetaMaxValue(); } +extern "C" double vtk_sphere_source_get_start_theta(vtkSphereSource* sself) { return sself->GetStartTheta(); } +extern "C" void vtk_sphere_source_set_end_theta(vtkSphereSource* sself, double _arg) { sself->SetEndTheta(_arg); } +extern "C" double vtk_sphere_source_get_end_theta_min_value(vtkSphereSource* sself) { return sself->GetEndThetaMinValue(); } +extern "C" double vtk_sphere_source_get_end_theta_max_value(vtkSphereSource* sself) { return sself->GetEndThetaMaxValue(); } +extern "C" double vtk_sphere_source_get_end_theta(vtkSphereSource* sself) { return sself->GetEndTheta(); } +extern "C" void vtk_sphere_source_set_start_phi(vtkSphereSource* sself, double _arg) { sself->SetStartPhi(_arg); } +extern "C" double vtk_sphere_source_get_start_phi_min_value(vtkSphereSource* sself) { return sself->GetStartPhiMinValue(); } +extern "C" double vtk_sphere_source_get_start_phi_max_value(vtkSphereSource* sself) { return sself->GetStartPhiMaxValue(); } +extern "C" double vtk_sphere_source_get_start_phi(vtkSphereSource* sself) { return sself->GetStartPhi(); } +extern "C" void vtk_sphere_source_set_end_phi(vtkSphereSource* sself, double _arg) { sself->SetEndPhi(_arg); } +extern "C" double vtk_sphere_source_get_end_phi_min_value(vtkSphereSource* sself) { return sself->GetEndPhiMinValue(); } +extern "C" double vtk_sphere_source_get_end_phi_max_value(vtkSphereSource* sself) { return sself->GetEndPhiMaxValue(); } +extern "C" double vtk_sphere_source_get_end_phi(vtkSphereSource* sself) { return sself->GetEndPhi(); } +extern "C" void vtk_sphere_source_set_lat_long_tessellation(vtkSphereSource* sself, int _arg) { sself->SetLatLongTessellation(_arg); } +extern "C" int vtk_sphere_source_get_lat_long_tessellation(vtkSphereSource* sself) { return sself->GetLatLongTessellation(); } +extern "C" void vtk_sphere_source_lat_long_tessellation_on(vtkSphereSource* sself) { sself->LatLongTessellationOn(); } +extern "C" void vtk_sphere_source_lat_long_tessellation_off(vtkSphereSource* sself) { sself->LatLongTessellationOff(); } +extern "C" void vtk_sphere_source_set_output_points_precision(vtkSphereSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_sphere_source_get_output_points_precision(vtkSphereSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" void vtk_sphere_source_set_generate_normals(vtkSphereSource* sself, int _arg) { sself->SetGenerateNormals(_arg); } +extern "C" int vtk_sphere_source_get_generate_normals(vtkSphereSource* sself) { return sself->GetGenerateNormals(); } +extern "C" void vtk_sphere_source_generate_normals_on(vtkSphereSource* sself) { sself->GenerateNormalsOn(); } +extern "C" void vtk_sphere_source_generate_normals_off(vtkSphereSource* sself) { sself->GenerateNormalsOff(); } +extern "C" vtkSuperquadricSource * vtkSuperquadricSource_new () {return vtkSuperquadricSource :: New () ;} +extern "C" void vtkSuperquadricSource_destructor (vtkSuperquadricSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkSuperquadricSource_get_ptr (vtkSuperquadricSource * sself) {return sself ;} +extern "C" void vtk_superquadric_source_set_center(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_superquadric_source_set_scale(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetScale(_arg1, _arg2, _arg3); } +extern "C" int vtk_superquadric_source_get_theta_resolution(vtkSuperquadricSource* sself) { return sself->GetThetaResolution(); } +extern "C" void vtk_superquadric_source_set_theta_resolution(vtkSuperquadricSource* sself, int i) { sself->SetThetaResolution(i); } +extern "C" int vtk_superquadric_source_get_phi_resolution(vtkSuperquadricSource* sself) { return sself->GetPhiResolution(); } +extern "C" void vtk_superquadric_source_set_phi_resolution(vtkSuperquadricSource* sself, int i) { sself->SetPhiResolution(i); } +extern "C" double vtk_superquadric_source_get_thickness(vtkSuperquadricSource* sself) { return sself->GetThickness(); } +extern "C" void vtk_superquadric_source_set_thickness(vtkSuperquadricSource* sself, double _arg) { sself->SetThickness(_arg); } +extern "C" double vtk_superquadric_source_get_thickness_min_value(vtkSuperquadricSource* sself) { return sself->GetThicknessMinValue(); } +extern "C" double vtk_superquadric_source_get_thickness_max_value(vtkSuperquadricSource* sself) { return sself->GetThicknessMaxValue(); } +extern "C" double vtk_superquadric_source_get_phi_roundness(vtkSuperquadricSource* sself) { return sself->GetPhiRoundness(); } +extern "C" void vtk_superquadric_source_set_phi_roundness(vtkSuperquadricSource* sself, double e) { sself->SetPhiRoundness(e); } +extern "C" double vtk_superquadric_source_get_theta_roundness(vtkSuperquadricSource* sself) { return sself->GetThetaRoundness(); } +extern "C" void vtk_superquadric_source_set_theta_roundness(vtkSuperquadricSource* sself, double e) { sself->SetThetaRoundness(e); } +extern "C" void vtk_superquadric_source_set_size(vtkSuperquadricSource* sself, double _arg) { sself->SetSize(_arg); } +extern "C" double vtk_superquadric_source_get_size(vtkSuperquadricSource* sself) { return sself->GetSize(); } +extern "C" void vtk_superquadric_source_set_axis_of_symmetry(vtkSuperquadricSource* sself, int _arg) { sself->SetAxisOfSymmetry(_arg); } +extern "C" int vtk_superquadric_source_get_axis_of_symmetry(vtkSuperquadricSource* sself) { return sself->GetAxisOfSymmetry(); } +extern "C" void vtk_superquadric_source_set_x_axis_of_symmetry(vtkSuperquadricSource* sself) { sself->SetXAxisOfSymmetry(); } +extern "C" void vtk_superquadric_source_set_y_axis_of_symmetry(vtkSuperquadricSource* sself) { sself->SetYAxisOfSymmetry(); } +extern "C" void vtk_superquadric_source_set_z_axis_of_symmetry(vtkSuperquadricSource* sself) { sself->SetZAxisOfSymmetry(); } +extern "C" void vtk_superquadric_source_toroidal_on(vtkSuperquadricSource* sself) { sself->ToroidalOn(); } +extern "C" void vtk_superquadric_source_toroidal_off(vtkSuperquadricSource* sself) { sself->ToroidalOff(); } +extern "C" int vtk_superquadric_source_get_toroidal(vtkSuperquadricSource* sself) { return sself->GetToroidal(); } +extern "C" void vtk_superquadric_source_set_toroidal(vtkSuperquadricSource* sself, int _arg) { sself->SetToroidal(_arg); } +extern "C" void vtk_superquadric_source_set_output_points_precision(vtkSuperquadricSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_superquadric_source_get_output_points_precision(vtkSuperquadricSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkTessellatedBoxSource * vtkTessellatedBoxSource_new () {return vtkTessellatedBoxSource :: New () ;} +extern "C" void vtkTessellatedBoxSource_destructor (vtkTessellatedBoxSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTessellatedBoxSource_get_ptr (vtkTessellatedBoxSource * sself) {return sself ;} +extern "C" void vtk_tessellated_box_source_set_bounds(vtkTessellatedBoxSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6) { sself->SetBounds(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_tessellated_box_source_set_level(vtkTessellatedBoxSource* sself, int _arg) { sself->SetLevel(_arg); } +extern "C" int vtk_tessellated_box_source_get_level(vtkTessellatedBoxSource* sself) { return sself->GetLevel(); } +extern "C" void vtk_tessellated_box_source_set_duplicate_shared_points(vtkTessellatedBoxSource* sself, int _arg) { sself->SetDuplicateSharedPoints(_arg); } +extern "C" int vtk_tessellated_box_source_get_duplicate_shared_points(vtkTessellatedBoxSource* sself) { return sself->GetDuplicateSharedPoints(); } +extern "C" void vtk_tessellated_box_source_duplicate_shared_points_on(vtkTessellatedBoxSource* sself) { sself->DuplicateSharedPointsOn(); } +extern "C" void vtk_tessellated_box_source_duplicate_shared_points_off(vtkTessellatedBoxSource* sself) { sself->DuplicateSharedPointsOff(); } +extern "C" void vtk_tessellated_box_source_set_quads(vtkTessellatedBoxSource* sself, int _arg) { sself->SetQuads(_arg); } +extern "C" int vtk_tessellated_box_source_get_quads(vtkTessellatedBoxSource* sself) { return sself->GetQuads(); } +extern "C" void vtk_tessellated_box_source_quads_on(vtkTessellatedBoxSource* sself) { sself->QuadsOn(); } +extern "C" void vtk_tessellated_box_source_quads_off(vtkTessellatedBoxSource* sself) { sself->QuadsOff(); } +extern "C" void vtk_tessellated_box_source_set_output_points_precision(vtkTessellatedBoxSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_tessellated_box_source_get_output_points_precision(vtkTessellatedBoxSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkTextSource * vtkTextSource_new () {return vtkTextSource :: New () ;} +extern "C" void vtkTextSource_destructor (vtkTextSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTextSource_get_ptr (vtkTextSource * sself) {return sself ;} +extern "C" void vtk_text_source_set_text(vtkTextSource* sself, const char* _arg) { sself->SetText(_arg); } +extern "C" void vtk_text_source_set_backing(vtkTextSource* sself, int _arg) { sself->SetBacking(_arg); } +extern "C" int vtk_text_source_get_backing(vtkTextSource* sself) { return sself->GetBacking(); } +extern "C" void vtk_text_source_backing_on(vtkTextSource* sself) { sself->BackingOn(); } +extern "C" void vtk_text_source_backing_off(vtkTextSource* sself) { sself->BackingOff(); } +extern "C" void vtk_text_source_set_foreground_color(vtkTextSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetForegroundColor(_arg1, _arg2, _arg3); } +extern "C" void vtk_text_source_set_background_color(vtkTextSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetBackgroundColor(_arg1, _arg2, _arg3); } +extern "C" void vtk_text_source_set_output_points_precision(vtkTextSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_text_source_get_output_points_precision(vtkTextSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkTexturedSphereSource * vtkTexturedSphereSource_new () {return vtkTexturedSphereSource :: New () ;} +extern "C" void vtkTexturedSphereSource_destructor (vtkTexturedSphereSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkTexturedSphereSource_get_ptr (vtkTexturedSphereSource * sself) {return sself ;} +extern "C" void vtk_textured_sphere_source_set_radius(vtkTexturedSphereSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_textured_sphere_source_get_radius_min_value(vtkTexturedSphereSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_textured_sphere_source_get_radius_max_value(vtkTexturedSphereSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_textured_sphere_source_get_radius(vtkTexturedSphereSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_textured_sphere_source_set_theta_resolution(vtkTexturedSphereSource* sself, int _arg) { sself->SetThetaResolution(_arg); } +extern "C" int vtk_textured_sphere_source_get_theta_resolution_min_value(vtkTexturedSphereSource* sself) { return sself->GetThetaResolutionMinValue(); } +extern "C" int vtk_textured_sphere_source_get_theta_resolution_max_value(vtkTexturedSphereSource* sself) { return sself->GetThetaResolutionMaxValue(); } +extern "C" int vtk_textured_sphere_source_get_theta_resolution(vtkTexturedSphereSource* sself) { return sself->GetThetaResolution(); } +extern "C" void vtk_textured_sphere_source_set_phi_resolution(vtkTexturedSphereSource* sself, int _arg) { sself->SetPhiResolution(_arg); } +extern "C" int vtk_textured_sphere_source_get_phi_resolution_min_value(vtkTexturedSphereSource* sself) { return sself->GetPhiResolutionMinValue(); } +extern "C" int vtk_textured_sphere_source_get_phi_resolution_max_value(vtkTexturedSphereSource* sself) { return sself->GetPhiResolutionMaxValue(); } +extern "C" int vtk_textured_sphere_source_get_phi_resolution(vtkTexturedSphereSource* sself) { return sself->GetPhiResolution(); } +extern "C" void vtk_textured_sphere_source_set_theta(vtkTexturedSphereSource* sself, double _arg) { sself->SetTheta(_arg); } +extern "C" double vtk_textured_sphere_source_get_theta_min_value(vtkTexturedSphereSource* sself) { return sself->GetThetaMinValue(); } +extern "C" double vtk_textured_sphere_source_get_theta_max_value(vtkTexturedSphereSource* sself) { return sself->GetThetaMaxValue(); } +extern "C" double vtk_textured_sphere_source_get_theta(vtkTexturedSphereSource* sself) { return sself->GetTheta(); } +extern "C" void vtk_textured_sphere_source_set_phi(vtkTexturedSphereSource* sself, double _arg) { sself->SetPhi(_arg); } +extern "C" double vtk_textured_sphere_source_get_phi_min_value(vtkTexturedSphereSource* sself) { return sself->GetPhiMinValue(); } +extern "C" double vtk_textured_sphere_source_get_phi_max_value(vtkTexturedSphereSource* sself) { return sself->GetPhiMaxValue(); } +extern "C" double vtk_textured_sphere_source_get_phi(vtkTexturedSphereSource* sself) { return sself->GetPhi(); } +extern "C" void vtk_textured_sphere_source_set_output_points_precision(vtkTexturedSphereSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_textured_sphere_source_get_output_points_precision(vtkTexturedSphereSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkUniformHyperTreeGridSource * vtkUniformHyperTreeGridSource_new () {return vtkUniformHyperTreeGridSource :: New () ;} +extern "C" void vtkUniformHyperTreeGridSource_destructor (vtkUniformHyperTreeGridSource * sself) {sself -> Delete () ; return ;} +extern "C" void * vtkUniformHyperTreeGridSource_get_ptr (vtkUniformHyperTreeGridSource * sself) {return sself ;} diff --git a/vtk-rs-9.1/src/lib.rs b/vtk-rs-9.1/src/lib.rs index 93331ba..536b51e 100644 --- a/vtk-rs-9.1/src/lib.rs +++ b/vtk-rs-9.1/src/lib.rs @@ -9,3 +9,429 @@ pub mod vtkCommonMath; pub mod vtkCommonMisc; pub mod vtkCommonSystem; pub mod vtkCommonTransforms; +pub mod vtkFiltersSources; +pub use vtkCommonColor::vtkColorSeries as ColorSeries; +pub use vtkCommonColor::vtkNamedColors as NamedColors; +pub use vtkCommonComputationalGeometry::vtkCardinalSpline as CardinalSpline; +pub use vtkCommonComputationalGeometry::vtkKochanekSpline as KochanekSpline; +pub use vtkCommonComputationalGeometry::vtkParametricBohemianDome as ParametricBohemianDome; +pub use vtkCommonComputationalGeometry::vtkParametricBour as ParametricBour; +pub use vtkCommonComputationalGeometry::vtkParametricBoy as ParametricBoy; +pub use vtkCommonComputationalGeometry::vtkParametricCatalanMinimal as ParametricCatalanMinimal; +pub use vtkCommonComputationalGeometry::vtkParametricConicSpiral as ParametricConicSpiral; +pub use vtkCommonComputationalGeometry::vtkParametricCrossCap as ParametricCrossCap; +pub use vtkCommonComputationalGeometry::vtkParametricDini as ParametricDini; +pub use vtkCommonComputationalGeometry::vtkParametricEllipsoid as ParametricEllipsoid; +pub use vtkCommonComputationalGeometry::vtkParametricEnneper as ParametricEnneper; +pub use vtkCommonComputationalGeometry::vtkParametricFigure8Klein as ParametricFigure8Klein; +pub use vtkCommonComputationalGeometry::vtkParametricHenneberg as ParametricHenneberg; +pub use vtkCommonComputationalGeometry::vtkParametricKlein as ParametricKlein; +pub use vtkCommonComputationalGeometry::vtkParametricKuen as ParametricKuen; +pub use vtkCommonComputationalGeometry::vtkParametricMobius as ParametricMobius; +pub use vtkCommonComputationalGeometry::vtkParametricPluckerConoid as ParametricPluckerConoid; +pub use vtkCommonComputationalGeometry::vtkParametricPseudosphere as ParametricPseudosphere; +pub use vtkCommonComputationalGeometry::vtkParametricRandomHills as ParametricRandomHills; +pub use vtkCommonComputationalGeometry::vtkParametricRoman as ParametricRoman; +pub use vtkCommonComputationalGeometry::vtkParametricSpline as ParametricSpline; +pub use vtkCommonComputationalGeometry::vtkParametricSuperEllipsoid as ParametricSuperEllipsoid; +pub use vtkCommonComputationalGeometry::vtkParametricSuperToroid as ParametricSuperToroid; +pub use vtkCommonComputationalGeometry::vtkParametricTorus as ParametricTorus; +pub use vtkCommonCore::vtkAnimationCue as AnimationCue; +pub use vtkCommonCore::vtkArchiver as Archiver; +pub use vtkCommonCore::vtkBitArray as BitArray; +pub use vtkCommonCore::vtkBitArrayIterator as BitArrayIterator; +pub use vtkCommonCore::vtkBoxMuellerRandomSequence as BoxMuellerRandomSequence; +pub use vtkCommonCore::vtkByteSwap as ByteSwap; +pub use vtkCommonCore::vtkCallbackCommand as CallbackCommand; +pub use vtkCommonCore::vtkCharArray as CharArray; +pub use vtkCommonCore::vtkCollection as Collection; +pub use vtkCommonCore::vtkCollectionIterator as CollectionIterator; +pub use vtkCommonCore::vtkCriticalSection as CriticalSection; +pub use vtkCommonCore::vtkDataArrayCollection as DataArrayCollection; +pub use vtkCommonCore::vtkDataArrayCollectionIterator as DataArrayCollectionIterator; +pub use vtkCommonCore::vtkDataArraySelection as DataArraySelection; +pub use vtkCommonCore::vtkDebugLeaks as DebugLeaks; +pub use vtkCommonCore::vtkDoubleArray as DoubleArray; +pub use vtkCommonCore::vtkDynamicLoader as DynamicLoader; +pub use vtkCommonCore::vtkEventDataDevice3D as EventDataDevice3D; +pub use vtkCommonCore::vtkEventDataForDevice as EventDataForDevice; +pub use vtkCommonCore::vtkEventForwarderCommand as EventForwarderCommand; +pub use vtkCommonCore::vtkFileOutputWindow as FileOutputWindow; +pub use vtkCommonCore::vtkFloatArray as FloatArray; +pub use vtkCommonCore::vtkGarbageCollector as GarbageCollector; +pub use vtkCommonCore::vtkIdList as IdList; +pub use vtkCommonCore::vtkIdListCollection as IdListCollection; +pub use vtkCommonCore::vtkIdTypeArray as IdTypeArray; +pub use vtkCommonCore::vtkInformation as Information; +pub use vtkCommonCore::vtkInformationIterator as InformationIterator; +pub use vtkCommonCore::vtkInformationKeyLookup as InformationKeyLookup; +pub use vtkCommonCore::vtkInformationVector as InformationVector; +pub use vtkCommonCore::vtkIntArray as IntArray; +pub use vtkCommonCore::vtkLongArray as LongArray; +pub use vtkCommonCore::vtkLongLongArray as LongLongArray; +pub use vtkCommonCore::vtkLookupTable as LookupTable; +pub use vtkCommonCore::vtkMath as Math; +pub use vtkCommonCore::vtkMersenneTwister as MersenneTwister; +pub use vtkCommonCore::vtkMinimalStandardRandomSequence as MinimalStandardRandomSequence; +pub use vtkCommonCore::vtkMultiThreader as MultiThreader; +pub use vtkCommonCore::vtkObject as Object; +pub use vtkCommonCore::vtkObjectFactoryCollection as ObjectFactoryCollection; +pub use vtkCommonCore::vtkOldStyleCallbackCommand as OldStyleCallbackCommand; +pub use vtkCommonCore::vtkOutputWindow as OutputWindow; +pub use vtkCommonCore::vtkOverrideInformationCollection as OverrideInformationCollection; +pub use vtkCommonCore::vtkPoints as Points; +pub use vtkCommonCore::vtkPoints2D as Points2D; +pub use vtkCommonCore::vtkPriorityQueue as PriorityQueue; +pub use vtkCommonCore::vtkRandomPool as RandomPool; +pub use vtkCommonCore::vtkReferenceCount as ReferenceCount; +pub use vtkCommonCore::vtkScalarsToColors as ScalarsToColors; +pub use vtkCommonCore::vtkShortArray as ShortArray; +pub use vtkCommonCore::vtkSignedCharArray as SignedCharArray; +pub use vtkCommonCore::vtkSortDataArray as SortDataArray; +pub use vtkCommonCore::vtkStringArray as StringArray; +pub use vtkCommonCore::vtkStringOutputWindow as StringOutputWindow; +pub use vtkCommonCore::vtkTimePointUtility as TimePointUtility; +pub use vtkCommonCore::vtkTypeFloat32Array as TypeFloat32Array; +pub use vtkCommonCore::vtkTypeFloat64Array as TypeFloat64Array; +pub use vtkCommonCore::vtkTypeInt16Array as TypeInt16Array; +pub use vtkCommonCore::vtkTypeInt32Array as TypeInt32Array; +pub use vtkCommonCore::vtkTypeInt64Array as TypeInt64Array; +pub use vtkCommonCore::vtkTypeInt8Array as TypeInt8Array; +pub use vtkCommonCore::vtkTypeUInt16Array as TypeUInt16Array; +pub use vtkCommonCore::vtkTypeUInt32Array as TypeUInt32Array; +pub use vtkCommonCore::vtkTypeUInt64Array as TypeUInt64Array; +pub use vtkCommonCore::vtkTypeUInt8Array as TypeUInt8Array; +pub use vtkCommonCore::vtkUnicodeStringArray as UnicodeStringArray; +pub use vtkCommonCore::vtkUnsignedCharArray as UnsignedCharArray; +pub use vtkCommonCore::vtkUnsignedIntArray as UnsignedIntArray; +pub use vtkCommonCore::vtkUnsignedLongArray as UnsignedLongArray; +pub use vtkCommonCore::vtkUnsignedLongLongArray as UnsignedLongLongArray; +pub use vtkCommonCore::vtkUnsignedShortArray as UnsignedShortArray; +pub use vtkCommonCore::vtkVariantArray as VariantArray; +pub use vtkCommonCore::vtkVersion as Version; +pub use vtkCommonCore::vtkVoidArray as VoidArray; +pub use vtkCommonCore::vtkWeakReference as WeakReference; +pub use vtkCommonCore::vtkXMLFileOutputWindow as XMLFileOutputWindow; +pub use vtkCommonDataModel::vtkAMRDataInternals as AMRDataInternals; +pub use vtkCommonDataModel::vtkAdjacentVertexIterator as AdjacentVertexIterator; +pub use vtkCommonDataModel::vtkAnimationScene as AnimationScene; +pub use vtkCommonDataModel::vtkAnnotation as Annotation; +pub use vtkCommonDataModel::vtkAnnotationLayers as AnnotationLayers; +pub use vtkCommonDataModel::vtkArrayData as ArrayData; +pub use vtkCommonDataModel::vtkAttributesErrorMetric as AttributesErrorMetric; +pub use vtkCommonDataModel::vtkBSPCuts as BSPCuts; +pub use vtkCommonDataModel::vtkBSPIntersections as BSPIntersections; +pub use vtkCommonDataModel::vtkBezierCurve as BezierCurve; +pub use vtkCommonDataModel::vtkBezierHexahedron as BezierHexahedron; +pub use vtkCommonDataModel::vtkBezierInterpolation as BezierInterpolation; +pub use vtkCommonDataModel::vtkBezierQuadrilateral as BezierQuadrilateral; +pub use vtkCommonDataModel::vtkBezierTetra as BezierTetra; +pub use vtkCommonDataModel::vtkBezierTriangle as BezierTriangle; +pub use vtkCommonDataModel::vtkBezierWedge as BezierWedge; +pub use vtkCommonDataModel::vtkBiQuadraticQuad as BiQuadraticQuad; +pub use vtkCommonDataModel::vtkBiQuadraticQuadraticHexahedron as BiQuadraticQuadraticHexahedron; +pub use vtkCommonDataModel::vtkBiQuadraticQuadraticWedge as BiQuadraticQuadraticWedge; +pub use vtkCommonDataModel::vtkBiQuadraticTriangle as BiQuadraticTriangle; +pub use vtkCommonDataModel::vtkBox as Box; +pub use vtkCommonDataModel::vtkCellArray as CellArray; +pub use vtkCommonDataModel::vtkCellArrayIterator as CellArrayIterator; +pub use vtkCommonDataModel::vtkCellData as CellData; +pub use vtkCommonDataModel::vtkCellLinks as CellLinks; +pub use vtkCommonDataModel::vtkCellLocator as CellLocator; +pub use vtkCommonDataModel::vtkCellLocatorStrategy as CellLocatorStrategy; +pub use vtkCommonDataModel::vtkCellTypes as CellTypes; +pub use vtkCommonDataModel::vtkClosestNPointsStrategy as ClosestNPointsStrategy; +pub use vtkCommonDataModel::vtkClosestPointStrategy as ClosestPointStrategy; +pub use vtkCommonDataModel::vtkCone as Cone; +pub use vtkCommonDataModel::vtkConvexPointSet as ConvexPointSet; +pub use vtkCommonDataModel::vtkCubicLine as CubicLine; +pub use vtkCommonDataModel::vtkCylinder as Cylinder; +pub use vtkCommonDataModel::vtkDataAssembly as DataAssembly; +pub use vtkCommonDataModel::vtkDataAssemblyUtilities as DataAssemblyUtilities; +pub use vtkCommonDataModel::vtkDataObject as DataObject; +pub use vtkCommonDataModel::vtkDataObjectCollection as DataObjectCollection; +pub use vtkCommonDataModel::vtkDataObjectTreeIterator as DataObjectTreeIterator; +pub use vtkCommonDataModel::vtkDataObjectTypes as DataObjectTypes; +pub use vtkCommonDataModel::vtkDataSetAttributes as DataSetAttributes; +pub use vtkCommonDataModel::vtkDataSetCellIterator as DataSetCellIterator; +pub use vtkCommonDataModel::vtkDataSetCollection as DataSetCollection; +pub use vtkCommonDataModel::vtkDirectedAcyclicGraph as DirectedAcyclicGraph; +pub use vtkCommonDataModel::vtkDirectedGraph as DirectedGraph; +pub use vtkCommonDataModel::vtkEdgeListIterator as EdgeListIterator; +pub use vtkCommonDataModel::vtkEdgeTable as EdgeTable; +pub use vtkCommonDataModel::vtkEmptyCell as EmptyCell; +pub use vtkCommonDataModel::vtkExplicitStructuredGrid as ExplicitStructuredGrid; +pub use vtkCommonDataModel::vtkExtractStructuredGridHelper as ExtractStructuredGridHelper; +pub use vtkCommonDataModel::vtkFieldData as FieldData; +pub use vtkCommonDataModel::vtkGenericAttributeCollection as GenericAttributeCollection; +pub use vtkCommonDataModel::vtkGenericCell as GenericCell; +pub use vtkCommonDataModel::vtkGenericEdgeTable as GenericEdgeTable; +pub use vtkCommonDataModel::vtkGenericInterpolatedVelocityField as GenericInterpolatedVelocityField; +pub use vtkCommonDataModel::vtkGeometricErrorMetric as GeometricErrorMetric; +pub use vtkCommonDataModel::vtkGraphEdge as GraphEdge; +pub use vtkCommonDataModel::vtkGraphInternals as GraphInternals; +pub use vtkCommonDataModel::vtkHexagonalPrism as HexagonalPrism; +pub use vtkCommonDataModel::vtkHexahedron as Hexahedron; +pub use vtkCommonDataModel::vtkHierarchicalBoxDataIterator as HierarchicalBoxDataIterator; +pub use vtkCommonDataModel::vtkHierarchicalBoxDataSet as HierarchicalBoxDataSet; +pub use vtkCommonDataModel::vtkHyperTreeGrid as HyperTreeGrid; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedCursor as HyperTreeGridNonOrientedCursor; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedGeometryCursor as HyperTreeGridNonOrientedGeometryCursor; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedMooreSuperCursor as HyperTreeGridNonOrientedMooreSuperCursor; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedMooreSuperCursorLight as HyperTreeGridNonOrientedMooreSuperCursorLight; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedVonNeumannSuperCursor as HyperTreeGridNonOrientedVonNeumannSuperCursor; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight as HyperTreeGridNonOrientedVonNeumannSuperCursorLight; +pub use vtkCommonDataModel::vtkHyperTreeGridOrientedCursor as HyperTreeGridOrientedCursor; +pub use vtkCommonDataModel::vtkHyperTreeGridOrientedGeometryCursor as HyperTreeGridOrientedGeometryCursor; +pub use vtkCommonDataModel::vtkImageData as ImageData; +pub use vtkCommonDataModel::vtkImageTransform as ImageTransform; +pub use vtkCommonDataModel::vtkImplicitBoolean as ImplicitBoolean; +pub use vtkCommonDataModel::vtkImplicitDataSet as ImplicitDataSet; +pub use vtkCommonDataModel::vtkImplicitFunctionCollection as ImplicitFunctionCollection; +pub use vtkCommonDataModel::vtkImplicitHalo as ImplicitHalo; +pub use vtkCommonDataModel::vtkImplicitSelectionLoop as ImplicitSelectionLoop; +pub use vtkCommonDataModel::vtkImplicitSum as ImplicitSum; +pub use vtkCommonDataModel::vtkImplicitVolume as ImplicitVolume; +pub use vtkCommonDataModel::vtkImplicitWindowFunction as ImplicitWindowFunction; +pub use vtkCommonDataModel::vtkInEdgeIterator as InEdgeIterator; +pub use vtkCommonDataModel::vtkIncrementalOctreeNode as IncrementalOctreeNode; +pub use vtkCommonDataModel::vtkIncrementalOctreePointLocator as IncrementalOctreePointLocator; +pub use vtkCommonDataModel::vtkIterativeClosestPointTransform as IterativeClosestPointTransform; +pub use vtkCommonDataModel::vtkKdNode as KdNode; +pub use vtkCommonDataModel::vtkKdTree as KdTree; +pub use vtkCommonDataModel::vtkKdTreePointLocator as KdTreePointLocator; +pub use vtkCommonDataModel::vtkLagrangeCurve as LagrangeCurve; +pub use vtkCommonDataModel::vtkLagrangeHexahedron as LagrangeHexahedron; +pub use vtkCommonDataModel::vtkLagrangeInterpolation as LagrangeInterpolation; +pub use vtkCommonDataModel::vtkLagrangeQuadrilateral as LagrangeQuadrilateral; +pub use vtkCommonDataModel::vtkLagrangeTetra as LagrangeTetra; +pub use vtkCommonDataModel::vtkLagrangeTriangle as LagrangeTriangle; +pub use vtkCommonDataModel::vtkLagrangeWedge as LagrangeWedge; +pub use vtkCommonDataModel::vtkLine as Line; +pub use vtkCommonDataModel::vtkMeanValueCoordinatesInterpolator as MeanValueCoordinatesInterpolator; +pub use vtkCommonDataModel::vtkMergePoints as MergePoints; +pub use vtkCommonDataModel::vtkMolecule as Molecule; +pub use vtkCommonDataModel::vtkMultiBlockDataSet as MultiBlockDataSet; +pub use vtkCommonDataModel::vtkMultiPieceDataSet as MultiPieceDataSet; +pub use vtkCommonDataModel::vtkMutableDirectedGraph as MutableDirectedGraph; +pub use vtkCommonDataModel::vtkMutableUndirectedGraph as MutableUndirectedGraph; +pub use vtkCommonDataModel::vtkNonMergingPointLocator as NonMergingPointLocator; +pub use vtkCommonDataModel::vtkNonOverlappingAMR as NonOverlappingAMR; +pub use vtkCommonDataModel::vtkOctreePointLocator as OctreePointLocator; +pub use vtkCommonDataModel::vtkOctreePointLocatorNode as OctreePointLocatorNode; +pub use vtkCommonDataModel::vtkOrderedTriangulator as OrderedTriangulator; +pub use vtkCommonDataModel::vtkOutEdgeIterator as OutEdgeIterator; +pub use vtkCommonDataModel::vtkOverlappingAMR as OverlappingAMR; +pub use vtkCommonDataModel::vtkPartitionedDataSet as PartitionedDataSet; +pub use vtkCommonDataModel::vtkPartitionedDataSetCollection as PartitionedDataSetCollection; +pub use vtkCommonDataModel::vtkPath as Path; +pub use vtkCommonDataModel::vtkPentagonalPrism as PentagonalPrism; +pub use vtkCommonDataModel::vtkPerlinNoise as PerlinNoise; +pub use vtkCommonDataModel::vtkPiecewiseFunction as PiecewiseFunction; +pub use vtkCommonDataModel::vtkPixel as Pixel; +pub use vtkCommonDataModel::vtkPlane as Plane; +pub use vtkCommonDataModel::vtkPlaneCollection as PlaneCollection; +pub use vtkCommonDataModel::vtkPlanes as Planes; +pub use vtkCommonDataModel::vtkPlanesIntersection as PlanesIntersection; +pub use vtkCommonDataModel::vtkPointData as PointData; +pub use vtkCommonDataModel::vtkPointLocator as PointLocator; +pub use vtkCommonDataModel::vtkPointSet as PointSet; +pub use vtkCommonDataModel::vtkPointSetCellIterator as PointSetCellIterator; +pub use vtkCommonDataModel::vtkPointsProjectedHull as PointsProjectedHull; +pub use vtkCommonDataModel::vtkPolyData as PolyData; +pub use vtkCommonDataModel::vtkPolyDataCollection as PolyDataCollection; +pub use vtkCommonDataModel::vtkPolyLine as PolyLine; +pub use vtkCommonDataModel::vtkPolyPlane as PolyPlane; +pub use vtkCommonDataModel::vtkPolyVertex as PolyVertex; +pub use vtkCommonDataModel::vtkPolygon as Polygon; +pub use vtkCommonDataModel::vtkPolyhedron as Polyhedron; +pub use vtkCommonDataModel::vtkPyramid as Pyramid; +pub use vtkCommonDataModel::vtkQuad as Quad; +pub use vtkCommonDataModel::vtkQuadraticEdge as QuadraticEdge; +pub use vtkCommonDataModel::vtkQuadraticHexahedron as QuadraticHexahedron; +pub use vtkCommonDataModel::vtkQuadraticLinearQuad as QuadraticLinearQuad; +pub use vtkCommonDataModel::vtkQuadraticLinearWedge as QuadraticLinearWedge; +pub use vtkCommonDataModel::vtkQuadraticPolygon as QuadraticPolygon; +pub use vtkCommonDataModel::vtkQuadraticPyramid as QuadraticPyramid; +pub use vtkCommonDataModel::vtkQuadraticQuad as QuadraticQuad; +pub use vtkCommonDataModel::vtkQuadraticTetra as QuadraticTetra; +pub use vtkCommonDataModel::vtkQuadraticTriangle as QuadraticTriangle; +pub use vtkCommonDataModel::vtkQuadraticWedge as QuadraticWedge; +pub use vtkCommonDataModel::vtkQuadratureSchemeDefinition as QuadratureSchemeDefinition; +pub use vtkCommonDataModel::vtkQuadric as Quadric; +pub use vtkCommonDataModel::vtkRectilinearGrid as RectilinearGrid; +pub use vtkCommonDataModel::vtkReebGraph as ReebGraph; +pub use vtkCommonDataModel::vtkReebGraphSimplificationMetric as ReebGraphSimplificationMetric; +pub use vtkCommonDataModel::vtkSelection as Selection; +pub use vtkCommonDataModel::vtkSelectionNode as SelectionNode; +pub use vtkCommonDataModel::vtkSimpleCellTessellator as SimpleCellTessellator; +pub use vtkCommonDataModel::vtkSmoothErrorMetric as SmoothErrorMetric; +pub use vtkCommonDataModel::vtkSortFieldData as SortFieldData; +pub use vtkCommonDataModel::vtkSphere as Sphere; +pub use vtkCommonDataModel::vtkSpheres as Spheres; +pub use vtkCommonDataModel::vtkStaticCellLinks as StaticCellLinks; +pub use vtkCommonDataModel::vtkStaticCellLocator as StaticCellLocator; +pub use vtkCommonDataModel::vtkStaticPointLocator as StaticPointLocator; +pub use vtkCommonDataModel::vtkStaticPointLocator2D as StaticPointLocator2D; +pub use vtkCommonDataModel::vtkStructuredExtent as StructuredExtent; +pub use vtkCommonDataModel::vtkStructuredGrid as StructuredGrid; +pub use vtkCommonDataModel::vtkStructuredPoints as StructuredPoints; +pub use vtkCommonDataModel::vtkStructuredPointsCollection as StructuredPointsCollection; +pub use vtkCommonDataModel::vtkSuperquadric as Superquadric; +pub use vtkCommonDataModel::vtkTable as Table; +pub use vtkCommonDataModel::vtkTetra as Tetra; +pub use vtkCommonDataModel::vtkTree as Tree; +pub use vtkCommonDataModel::vtkTreeBFSIterator as TreeBFSIterator; +pub use vtkCommonDataModel::vtkTreeDFSIterator as TreeDFSIterator; +pub use vtkCommonDataModel::vtkTriQuadraticHexahedron as TriQuadraticHexahedron; +pub use vtkCommonDataModel::vtkTriQuadraticPyramid as TriQuadraticPyramid; +pub use vtkCommonDataModel::vtkTriangle as Triangle; +pub use vtkCommonDataModel::vtkTriangleStrip as TriangleStrip; +pub use vtkCommonDataModel::vtkUndirectedGraph as UndirectedGraph; +pub use vtkCommonDataModel::vtkUniformGrid as UniformGrid; +pub use vtkCommonDataModel::vtkUniformGridAMR as UniformGridAMR; +pub use vtkCommonDataModel::vtkUniformGridAMRDataIterator as UniformGridAMRDataIterator; +pub use vtkCommonDataModel::vtkUniformHyperTreeGrid as UniformHyperTreeGrid; +pub use vtkCommonDataModel::vtkUnstructuredGrid as UnstructuredGrid; +pub use vtkCommonDataModel::vtkUnstructuredGridCellIterator as UnstructuredGridCellIterator; +pub use vtkCommonDataModel::vtkVertex as Vertex; +pub use vtkCommonDataModel::vtkVertexListIterator as VertexListIterator; +pub use vtkCommonDataModel::vtkVoxel as Voxel; +pub use vtkCommonDataModel::vtkWedge as Wedge; +pub use vtkCommonDataModel::vtkXMLDataElement as XMLDataElement; +pub use vtkCommonExecutionModel::vtkAlgorithm as Algorithm; +pub use vtkCommonExecutionModel::vtkAlgorithmOutput as AlgorithmOutput; +pub use vtkCommonExecutionModel::vtkAnnotationLayersAlgorithm as AnnotationLayersAlgorithm; +pub use vtkCommonExecutionModel::vtkArrayDataAlgorithm as ArrayDataAlgorithm; +pub use vtkCommonExecutionModel::vtkCachedStreamingDemandDrivenPipeline as CachedStreamingDemandDrivenPipeline; +pub use vtkCommonExecutionModel::vtkCastToConcrete as CastToConcrete; +pub use vtkCommonExecutionModel::vtkCompositeDataPipeline as CompositeDataPipeline; +pub use vtkCommonExecutionModel::vtkCompositeDataSetAlgorithm as CompositeDataSetAlgorithm; +pub use vtkCommonExecutionModel::vtkDataObjectAlgorithm as DataObjectAlgorithm; +pub use vtkCommonExecutionModel::vtkDataSetAlgorithm as DataSetAlgorithm; +pub use vtkCommonExecutionModel::vtkDemandDrivenPipeline as DemandDrivenPipeline; +pub use vtkCommonExecutionModel::vtkDirectedGraphAlgorithm as DirectedGraphAlgorithm; +pub use vtkCommonExecutionModel::vtkEnsembleSource as EnsembleSource; +pub use vtkCommonExecutionModel::vtkExplicitStructuredGridAlgorithm as ExplicitStructuredGridAlgorithm; +pub use vtkCommonExecutionModel::vtkExtentRCBPartitioner as ExtentRCBPartitioner; +pub use vtkCommonExecutionModel::vtkExtentSplitter as ExtentSplitter; +pub use vtkCommonExecutionModel::vtkExtentTranslator as ExtentTranslator; +pub use vtkCommonExecutionModel::vtkGraphAlgorithm as GraphAlgorithm; +pub use vtkCommonExecutionModel::vtkHierarchicalBoxDataSetAlgorithm as HierarchicalBoxDataSetAlgorithm; +pub use vtkCommonExecutionModel::vtkImageToStructuredGrid as ImageToStructuredGrid; +pub use vtkCommonExecutionModel::vtkImageToStructuredPoints as ImageToStructuredPoints; +pub use vtkCommonExecutionModel::vtkMoleculeAlgorithm as MoleculeAlgorithm; +pub use vtkCommonExecutionModel::vtkMultiBlockDataSetAlgorithm as MultiBlockDataSetAlgorithm; +pub use vtkCommonExecutionModel::vtkMultiTimeStepAlgorithm as MultiTimeStepAlgorithm; +pub use vtkCommonExecutionModel::vtkNonOverlappingAMRAlgorithm as NonOverlappingAMRAlgorithm; +pub use vtkCommonExecutionModel::vtkOverlappingAMRAlgorithm as OverlappingAMRAlgorithm; +pub use vtkCommonExecutionModel::vtkPassInputTypeAlgorithm as PassInputTypeAlgorithm; +pub use vtkCommonExecutionModel::vtkPiecewiseFunctionAlgorithm as PiecewiseFunctionAlgorithm; +pub use vtkCommonExecutionModel::vtkPiecewiseFunctionShiftScale as PiecewiseFunctionShiftScale; +pub use vtkCommonExecutionModel::vtkPointSetAlgorithm as PointSetAlgorithm; +pub use vtkCommonExecutionModel::vtkPolyDataAlgorithm as PolyDataAlgorithm; +pub use vtkCommonExecutionModel::vtkProgressObserver as ProgressObserver; +pub use vtkCommonExecutionModel::vtkReaderExecutive as ReaderExecutive; +pub use vtkCommonExecutionModel::vtkRectilinearGridAlgorithm as RectilinearGridAlgorithm; +pub use vtkCommonExecutionModel::vtkSMPProgressObserver as SMPProgressObserver; +pub use vtkCommonExecutionModel::vtkSelectionAlgorithm as SelectionAlgorithm; +pub use vtkCommonExecutionModel::vtkSimpleScalarTree as SimpleScalarTree; +pub use vtkCommonExecutionModel::vtkSpanSpace as SpanSpace; +pub use vtkCommonExecutionModel::vtkSphereTree as SphereTree; +pub use vtkCommonExecutionModel::vtkStreamingDemandDrivenPipeline as StreamingDemandDrivenPipeline; +pub use vtkCommonExecutionModel::vtkStructuredGridAlgorithm as StructuredGridAlgorithm; +pub use vtkCommonExecutionModel::vtkTableAlgorithm as TableAlgorithm; +pub use vtkCommonExecutionModel::vtkThreadedCompositeDataPipeline as ThreadedCompositeDataPipeline; +pub use vtkCommonExecutionModel::vtkTreeAlgorithm as TreeAlgorithm; +pub use vtkCommonExecutionModel::vtkTrivialConsumer as TrivialConsumer; +pub use vtkCommonExecutionModel::vtkTrivialProducer as TrivialProducer; +pub use vtkCommonExecutionModel::vtkUndirectedGraphAlgorithm as UndirectedGraphAlgorithm; +pub use vtkCommonExecutionModel::vtkUniformGridAMRAlgorithm as UniformGridAMRAlgorithm; +pub use vtkCommonExecutionModel::vtkUniformGridPartitioner as UniformGridPartitioner; +pub use vtkCommonExecutionModel::vtkUnstructuredGridAlgorithm as UnstructuredGridAlgorithm; +pub use vtkCommonExecutionModel::vtkUnstructuredGridBaseAlgorithm as UnstructuredGridBaseAlgorithm; +pub use vtkCommonMath::vtkAmoebaMinimizer as AmoebaMinimizer; +pub use vtkCommonMath::vtkFFT as FFT; +pub use vtkCommonMath::vtkMatrix3x3 as Matrix3x3; +pub use vtkCommonMath::vtkMatrix4x4 as Matrix4x4; +pub use vtkCommonMath::vtkPolynomialSolversUnivariate as PolynomialSolversUnivariate; +pub use vtkCommonMath::vtkQuaternionInterpolator as QuaternionInterpolator; +pub use vtkCommonMath::vtkRungeKutta2 as RungeKutta2; +pub use vtkCommonMath::vtkRungeKutta4 as RungeKutta4; +pub use vtkCommonMath::vtkRungeKutta45 as RungeKutta45; +pub use vtkCommonMisc::vtkContourValues as ContourValues; +pub use vtkCommonMisc::vtkExprTkFunctionParser as ExprTkFunctionParser; +pub use vtkCommonMisc::vtkFunctionParser as FunctionParser; +pub use vtkCommonMisc::vtkHeap as Heap; +pub use vtkCommonMisc::vtkResourceFileLocator as ResourceFileLocator; +pub use vtkCommonSystem::vtkClientSocket as ClientSocket; +pub use vtkCommonSystem::vtkDirectory as Directory; +pub use vtkCommonSystem::vtkExecutableRunner as ExecutableRunner; +pub use vtkCommonSystem::vtkServerSocket as ServerSocket; +pub use vtkCommonSystem::vtkSocketCollection as SocketCollection; +pub use vtkCommonSystem::vtkThreadMessager as ThreadMessager; +pub use vtkCommonSystem::vtkTimerLog as TimerLog; +pub use vtkCommonTransforms::vtkCylindricalTransform as CylindricalTransform; +pub use vtkCommonTransforms::vtkGeneralTransform as GeneralTransform; +pub use vtkCommonTransforms::vtkIdentityTransform as IdentityTransform; +pub use vtkCommonTransforms::vtkLandmarkTransform as LandmarkTransform; +pub use vtkCommonTransforms::vtkMatrixToHomogeneousTransform as MatrixToHomogeneousTransform; +pub use vtkCommonTransforms::vtkMatrixToLinearTransform as MatrixToLinearTransform; +pub use vtkCommonTransforms::vtkPerspectiveTransform as PerspectiveTransform; +pub use vtkCommonTransforms::vtkSphericalTransform as SphericalTransform; +pub use vtkCommonTransforms::vtkThinPlateSplineTransform as ThinPlateSplineTransform; +pub use vtkCommonTransforms::vtkTransform as Transform; +pub use vtkCommonTransforms::vtkTransform2D as Transform2D; +pub use vtkCommonTransforms::vtkTransformCollection as TransformCollection; +pub use vtkFiltersSources::vtkArcSource as ArcSource; +pub use vtkFiltersSources::vtkArrowSource as ArrowSource; +pub use vtkFiltersSources::vtkCapsuleSource as CapsuleSource; +pub use vtkFiltersSources::vtkCellTypeSource as CellTypeSource; +pub use vtkFiltersSources::vtkConeSource as ConeSource; +pub use vtkFiltersSources::vtkCubeSource as CubeSource; +pub use vtkFiltersSources::vtkCylinderSource as CylinderSource; +pub use vtkFiltersSources::vtkDiagonalMatrixSource as DiagonalMatrixSource; +pub use vtkFiltersSources::vtkDiskSource as DiskSource; +pub use vtkFiltersSources::vtkEllipseArcSource as EllipseArcSource; +pub use vtkFiltersSources::vtkEllipticalButtonSource as EllipticalButtonSource; +pub use vtkFiltersSources::vtkFrustumSource as FrustumSource; +pub use vtkFiltersSources::vtkGlyphSource2D as GlyphSource2D; +pub use vtkFiltersSources::vtkGraphToPolyData as GraphToPolyData; +pub use vtkFiltersSources::vtkHyperTreeGridSource as HyperTreeGridSource; +pub use vtkFiltersSources::vtkLineSource as LineSource; +pub use vtkFiltersSources::vtkOutlineCornerFilter as OutlineCornerFilter; +pub use vtkFiltersSources::vtkOutlineCornerSource as OutlineCornerSource; +pub use vtkFiltersSources::vtkOutlineSource as OutlineSource; +pub use vtkFiltersSources::vtkParametricFunctionSource as ParametricFunctionSource; +pub use vtkFiltersSources::vtkPartitionedDataSetCollectionSource as PartitionedDataSetCollectionSource; +pub use vtkFiltersSources::vtkPartitionedDataSetSource as PartitionedDataSetSource; +pub use vtkFiltersSources::vtkPlaneSource as PlaneSource; +pub use vtkFiltersSources::vtkPlatonicSolidSource as PlatonicSolidSource; +pub use vtkFiltersSources::vtkPointHandleSource as PointHandleSource; +pub use vtkFiltersSources::vtkPointSource as PointSource; +pub use vtkFiltersSources::vtkPolyLineSource as PolyLineSource; +pub use vtkFiltersSources::vtkPolyPointSource as PolyPointSource; +pub use vtkFiltersSources::vtkProgrammableDataObjectSource as ProgrammableDataObjectSource; +pub use vtkFiltersSources::vtkProgrammableSource as ProgrammableSource; +pub use vtkFiltersSources::vtkRandomHyperTreeGridSource as RandomHyperTreeGridSource; +pub use vtkFiltersSources::vtkRectangularButtonSource as RectangularButtonSource; +pub use vtkFiltersSources::vtkRegularPolygonSource as RegularPolygonSource; +pub use vtkFiltersSources::vtkSelectionSource as SelectionSource; +pub use vtkFiltersSources::vtkSphereSource as SphereSource; +pub use vtkFiltersSources::vtkSuperquadricSource as SuperquadricSource; +pub use vtkFiltersSources::vtkTessellatedBoxSource as TessellatedBoxSource; +pub use vtkFiltersSources::vtkTextSource as TextSource; +pub use vtkFiltersSources::vtkTexturedSphereSource as TexturedSphereSource; +pub use vtkFiltersSources::vtkUniformHyperTreeGridSource as UniformHyperTreeGridSource; +pub mod prelude { + pub use crate::vtkCommonColor::*; + pub use crate::vtkCommonComputationalGeometry::*; + pub use crate::vtkCommonCore::*; + pub use crate::vtkCommonDataModel::*; + pub use crate::vtkCommonExecutionModel::*; + pub use crate::vtkCommonMath::*; + pub use crate::vtkCommonMisc::*; + pub use crate::vtkCommonSystem::*; + pub use crate::vtkCommonTransforms::*; + pub use crate::vtkFiltersSources::*; +} diff --git a/vtk-rs-9.1/src/vtkCommonColor.rs b/vtk-rs-9.1/src/vtkCommonColor.rs index 10f51f5..86859a6 100644 --- a/vtk-rs-9.1/src/vtkCommonColor.rs +++ b/vtk-rs-9.1/src/vtkCommonColor.rs @@ -3,18 +3,10 @@ pub trait VtkColorSeries { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn set_color_scheme(&mut self, scheme: core::ffi::c_int) -> (); - fn set_color_scheme_by_name(&mut self, schemeName: vtkStdString) -> core::ffi::c_int; fn get_number_of_color_schemes(&mut self) -> core::ffi::c_int; - fn get_color_scheme_name(&mut self) -> *mut core::ffi::c_void; - fn set_color_scheme_name(&mut self, name: vtkStdString) -> (); fn get_color_scheme(&mut self) -> core::ffi::c_int; fn get_number_of_colors(&mut self) -> core::ffi::c_int; fn set_number_of_colors(&mut self, numColors: core::ffi::c_int) -> (); - fn get_color(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_color_repeating(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; - fn set_color(&mut self, index: core::ffi::c_int, color: vtkColor3ub) -> (); - fn add_color(&mut self, color: vtkColor3ub) -> (); - fn insert_color(&mut self, index: core::ffi::c_int, color: vtkColor3ub) -> (); fn remove_color(&mut self, index: core::ffi::c_int) -> (); fn clear_colors(&mut self) -> (); fn deep_copy(&mut self, chartColors: *mut core::ffi::c_void) -> (); @@ -34,75 +26,6 @@ pub trait VtkNamedColors { fn new(&mut self) -> *mut core::ffi::c_void; fn get_number_of_colors(&mut self) -> core::ffi::c_int; fn reset_colors(&mut self) -> (); - fn color_exists(&mut self, name: vtkStdString) -> bool; - fn get_color_4_ub(&mut self, name: vtkStdString) -> *mut core::ffi::c_void; - fn get_color( - &mut self, - name: vtkStdString, - r: core::ffi::c_uchar, - g: core::ffi::c_uchar, - b: core::ffi::c_uchar, - a: core::ffi::c_uchar, - ) -> (); - fn get_color(&mut self, name: vtkStdString, rgba: core::ffi::c_uchar) -> (); - fn get_color(&mut self, name: vtkStdString, rgba: *mut core::ffi::c_void) -> (); - fn get_color_4_d(&mut self, name: vtkStdString) -> *mut core::ffi::c_void; - fn get_color( - &mut self, - name: vtkStdString, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - a: core::ffi::c_double, - ) -> (); - fn get_color(&mut self, name: vtkStdString, rgba: core::ffi::c_double) -> (); - fn get_color(&mut self, name: vtkStdString, rgba: *mut core::ffi::c_void) -> (); - fn get_color_3_ub(&mut self, name: vtkStdString) -> *mut core::ffi::c_void; - fn get_color_3_d(&mut self, name: vtkStdString) -> *mut core::ffi::c_void; - fn get_color( - &mut self, - name: vtkStdString, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - ) -> (); - fn get_color_rgb(&mut self, name: vtkStdString, rgb: core::ffi::c_double) -> (); - fn get_color(&mut self, name: vtkStdString, rgb: *mut core::ffi::c_void) -> (); - fn get_color(&mut self, name: vtkStdString, rgb: *mut core::ffi::c_void) -> (); - fn set_color( - &mut self, - name: vtkStdString, - r: core::ffi::c_uchar, - g: core::ffi::c_uchar, - b: core::ffi::c_uchar, - a: core::ffi::c_uchar, - ) -> (); - fn set_color( - &mut self, - name: vtkStdString, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - a: core::ffi::c_double, - ) -> (); - fn set_color(&mut self, name: vtkStdString, rgba: core::ffi::c_uchar) -> (); - fn set_color(&mut self, name: vtkStdString, rgba: vtkColor4ub) -> (); - fn set_color(&mut self, name: vtkStdString, rgb: vtkColor3ub) -> (); - fn set_color(&mut self, name: vtkStdString, rgba: core::ffi::c_double) -> (); - fn set_color(&mut self, name: vtkStdString, rgba: vtkColor4d) -> (); - fn set_color(&mut self, name: vtkStdString, rgb: vtkColor3d) -> (); - fn remove_color(&mut self, name: vtkStdString) -> (); - fn get_color_names(&mut self) -> *mut core::ffi::c_void; - fn get_color_names(&mut self, colorNames: *mut core::ffi::c_void) -> (); - fn get_synonyms(&mut self) -> *mut core::ffi::c_void; - fn html_color_to_rgba( - &mut self, - colorString: vtkStdString, - ) -> *mut core::ffi::c_void; - fn html_color_to_rgb(&mut self, colorString: vtkStdString) -> *mut core::ffi::c_void; - fn rgb_to_html_color(&mut self, rgb: vtkColor3ub) -> *mut core::ffi::c_void; - fn rgba_to_html_color(&mut self, rgba: vtkColor4ub) -> *mut core::ffi::c_void; - fn set_color(&mut self, name: vtkStdString, htmlString: vtkStdString) -> (); } impl VtkColorSeries for vtkColorSeries { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -139,18 +62,6 @@ impl VtkColorSeries for vtkColorSeries { } unsafe { vtk_color_series_set_color_scheme(self.0, scheme) } } - fn set_color_scheme_by_name( - &mut self, - schemeName: vtkStdString, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_color_series_set_color_scheme_by_name( - sself: *mut core::ffi::c_void, - schemeName: vtkStdString, - ) -> core::ffi::c_int; - } - unsafe { vtk_color_series_set_color_scheme_by_name(self.0, schemeName) } - } fn get_number_of_color_schemes(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_color_series_get_number_of_color_schemes( @@ -159,23 +70,6 @@ impl VtkColorSeries for vtkColorSeries { } unsafe { vtk_color_series_get_number_of_color_schemes(self.0) } } - fn get_color_scheme_name(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_color_series_get_color_scheme_name( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_color_series_get_color_scheme_name(self.0) } - } - fn set_color_scheme_name(&mut self, name: vtkStdString) -> () { - unsafe extern "C" { - fn vtk_color_series_set_color_scheme_name( - sself: *mut core::ffi::c_void, - name: vtkStdString, - ); - } - unsafe { vtk_color_series_set_color_scheme_name(self.0, name) } - } fn get_color_scheme(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_color_series_get_color_scheme( @@ -201,56 +95,6 @@ impl VtkColorSeries for vtkColorSeries { } unsafe { vtk_color_series_set_number_of_colors(self.0, numColors) } } - fn get_color(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_color_series_get_color( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_color_series_get_color(self.0, index) } - } - fn get_color_repeating( - &mut self, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_color_series_get_color_repeating( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_color_series_get_color_repeating(self.0, index) } - } - fn set_color(&mut self, index: core::ffi::c_int, color: vtkColor3ub) -> () { - unsafe extern "C" { - fn vtk_color_series_set_color( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - color: vtkColor3ub, - ); - } - unsafe { vtk_color_series_set_color(self.0, index, color) } - } - fn add_color(&mut self, color: vtkColor3ub) -> () { - unsafe extern "C" { - fn vtk_color_series_add_color( - sself: *mut core::ffi::c_void, - color: vtkColor3ub, - ); - } - unsafe { vtk_color_series_add_color(self.0, color) } - } - fn insert_color(&mut self, index: core::ffi::c_int, color: vtkColor3ub) -> () { - unsafe extern "C" { - fn vtk_color_series_insert_color( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - color: vtkColor3ub, - ); - } - unsafe { vtk_color_series_insert_color(self.0, index, color) } - } fn remove_color(&mut self, index: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_color_series_remove_color( @@ -342,365 +186,6 @@ impl VtkNamedColors for vtkNamedColors { } unsafe { vtk_named_colors_reset_colors(self.0) } } - fn color_exists(&mut self, name: vtkStdString) -> bool { - unsafe extern "C" { - fn vtk_named_colors_color_exists( - sself: *mut core::ffi::c_void, - name: vtkStdString, - ) -> bool; - } - unsafe { vtk_named_colors_color_exists(self.0, name) } - } - fn get_color_4_ub(&mut self, name: vtkStdString) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_named_colors_get_color_4_ub( - sself: *mut core::ffi::c_void, - name: vtkStdString, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_named_colors_get_color_4_ub(self.0, name) } - } - fn get_color( - &mut self, - name: vtkStdString, - r: core::ffi::c_uchar, - g: core::ffi::c_uchar, - b: core::ffi::c_uchar, - a: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - r: core::ffi::c_uchar, - g: core::ffi::c_uchar, - b: core::ffi::c_uchar, - a: core::ffi::c_uchar, - ); - } - unsafe { vtk_named_colors_get_color(self.0, name, r, g, b, a) } - } - fn get_color(&mut self, name: vtkStdString, rgba: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgba: core::ffi::c_uchar, - ); - } - unsafe { vtk_named_colors_get_color(self.0, name, rgba) } - } - fn get_color(&mut self, name: vtkStdString, rgba: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgba: *mut core::ffi::c_void, - ); - } - unsafe { vtk_named_colors_get_color(self.0, name, rgba) } - } - fn get_color_4_d(&mut self, name: vtkStdString) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_named_colors_get_color_4_d( - sself: *mut core::ffi::c_void, - name: vtkStdString, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_named_colors_get_color_4_d(self.0, name) } - } - fn get_color( - &mut self, - name: vtkStdString, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - a: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - a: core::ffi::c_double, - ); - } - unsafe { vtk_named_colors_get_color(self.0, name, r, g, b, a) } - } - fn get_color(&mut self, name: vtkStdString, rgba: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgba: core::ffi::c_double, - ); - } - unsafe { vtk_named_colors_get_color(self.0, name, rgba) } - } - fn get_color(&mut self, name: vtkStdString, rgba: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgba: *mut core::ffi::c_void, - ); - } - unsafe { vtk_named_colors_get_color(self.0, name, rgba) } - } - fn get_color_3_ub(&mut self, name: vtkStdString) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_named_colors_get_color_3_ub( - sself: *mut core::ffi::c_void, - name: vtkStdString, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_named_colors_get_color_3_ub(self.0, name) } - } - fn get_color_3_d(&mut self, name: vtkStdString) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_named_colors_get_color_3_d( - sself: *mut core::ffi::c_void, - name: vtkStdString, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_named_colors_get_color_3_d(self.0, name) } - } - fn get_color( - &mut self, - name: vtkStdString, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - ); - } - unsafe { vtk_named_colors_get_color(self.0, name, r, g, b) } - } - fn get_color_rgb(&mut self, name: vtkStdString, rgb: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color_rgb( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgb: core::ffi::c_double, - ); - } - unsafe { vtk_named_colors_get_color_rgb(self.0, name, rgb) } - } - fn get_color(&mut self, name: vtkStdString, rgb: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgb: *mut core::ffi::c_void, - ); - } - unsafe { vtk_named_colors_get_color(self.0, name, rgb) } - } - fn get_color(&mut self, name: vtkStdString, rgb: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgb: *mut core::ffi::c_void, - ); - } - unsafe { vtk_named_colors_get_color(self.0, name, rgb) } - } - fn set_color( - &mut self, - name: vtkStdString, - r: core::ffi::c_uchar, - g: core::ffi::c_uchar, - b: core::ffi::c_uchar, - a: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_named_colors_set_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - r: core::ffi::c_uchar, - g: core::ffi::c_uchar, - b: core::ffi::c_uchar, - a: core::ffi::c_uchar, - ); - } - unsafe { vtk_named_colors_set_color(self.0, name, r, g, b, a) } - } - fn set_color( - &mut self, - name: vtkStdString, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - a: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_named_colors_set_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - a: core::ffi::c_double, - ); - } - unsafe { vtk_named_colors_set_color(self.0, name, r, g, b, a) } - } - fn set_color(&mut self, name: vtkStdString, rgba: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_named_colors_set_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgba: core::ffi::c_uchar, - ); - } - unsafe { vtk_named_colors_set_color(self.0, name, rgba) } - } - fn set_color(&mut self, name: vtkStdString, rgba: vtkColor4ub) -> () { - unsafe extern "C" { - fn vtk_named_colors_set_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgba: vtkColor4ub, - ); - } - unsafe { vtk_named_colors_set_color(self.0, name, rgba) } - } - fn set_color(&mut self, name: vtkStdString, rgb: vtkColor3ub) -> () { - unsafe extern "C" { - fn vtk_named_colors_set_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgb: vtkColor3ub, - ); - } - unsafe { vtk_named_colors_set_color(self.0, name, rgb) } - } - fn set_color(&mut self, name: vtkStdString, rgba: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_named_colors_set_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgba: core::ffi::c_double, - ); - } - unsafe { vtk_named_colors_set_color(self.0, name, rgba) } - } - fn set_color(&mut self, name: vtkStdString, rgba: vtkColor4d) -> () { - unsafe extern "C" { - fn vtk_named_colors_set_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgba: vtkColor4d, - ); - } - unsafe { vtk_named_colors_set_color(self.0, name, rgba) } - } - fn set_color(&mut self, name: vtkStdString, rgb: vtkColor3d) -> () { - unsafe extern "C" { - fn vtk_named_colors_set_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - rgb: vtkColor3d, - ); - } - unsafe { vtk_named_colors_set_color(self.0, name, rgb) } - } - fn remove_color(&mut self, name: vtkStdString) -> () { - unsafe extern "C" { - fn vtk_named_colors_remove_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - ); - } - unsafe { vtk_named_colors_remove_color(self.0, name) } - } - fn get_color_names(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_named_colors_get_color_names( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_named_colors_get_color_names(self.0) } - } - fn get_color_names(&mut self, colorNames: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_named_colors_get_color_names( - sself: *mut core::ffi::c_void, - colorNames: *mut core::ffi::c_void, - ); - } - unsafe { vtk_named_colors_get_color_names(self.0, colorNames) } - } - fn get_synonyms(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_named_colors_get_synonyms( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_named_colors_get_synonyms(self.0) } - } - fn html_color_to_rgba( - &mut self, - colorString: vtkStdString, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_named_colors_html_color_to_rgba( - sself: *mut core::ffi::c_void, - colorString: vtkStdString, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_named_colors_html_color_to_rgba(self.0, colorString) } - } - fn html_color_to_rgb( - &mut self, - colorString: vtkStdString, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_named_colors_html_color_to_rgb( - sself: *mut core::ffi::c_void, - colorString: vtkStdString, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_named_colors_html_color_to_rgb(self.0, colorString) } - } - fn rgb_to_html_color(&mut self, rgb: vtkColor3ub) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_named_colors_rgb_to_html_color( - sself: *mut core::ffi::c_void, - rgb: vtkColor3ub, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_named_colors_rgb_to_html_color(self.0, rgb) } - } - fn rgba_to_html_color(&mut self, rgba: vtkColor4ub) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_named_colors_rgba_to_html_color( - sself: *mut core::ffi::c_void, - rgba: vtkColor4ub, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_named_colors_rgba_to_html_color(self.0, rgba) } - } - fn set_color(&mut self, name: vtkStdString, htmlString: vtkStdString) -> () { - unsafe extern "C" { - fn vtk_named_colors_set_color( - sself: *mut core::ffi::c_void, - name: vtkStdString, - htmlString: vtkStdString, - ); - } - unsafe { vtk_named_colors_set_color(self.0, name, htmlString) } - } } /// stores a list of colors. /// @@ -734,22 +219,13 @@ impl VtkNamedColors for vtkNamedColors { #[allow(non_camel_case_types)] pub struct vtkColorSeries(*mut core::ffi::c_void); impl vtkColorSeries { - /// Creates a new [vtkColorSeries] wrapped inside `vtkNew` + /// Creates a new [vtkColorSeries] via `vtkColorSeries::New()` #[doc(alias = "vtkColorSeries")] pub fn new() -> Self { unsafe extern "C" { fn vtkColorSeries_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkColorSeries_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkColorSeries_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkColorSeries_get_ptr(self.0) } + Self(unsafe { vtkColorSeries_new() }) } } impl std::default::Default for vtkColorSeries { @@ -769,12 +245,8 @@ impl Drop for vtkColorSeries { #[test] fn test_vtkColorSeries_create_drop() { let obj = vtkColorSeries::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkColorSeries(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A class holding colors and their names. /// @@ -829,22 +301,13 @@ fn test_vtkColorSeries_create_drop() { #[allow(non_camel_case_types)] pub struct vtkNamedColors(*mut core::ffi::c_void); impl vtkNamedColors { - /// Creates a new [vtkNamedColors] wrapped inside `vtkNew` + /// Creates a new [vtkNamedColors] via `vtkNamedColors::New()` #[doc(alias = "vtkNamedColors")] pub fn new() -> Self { unsafe extern "C" { fn vtkNamedColors_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkNamedColors_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkNamedColors_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkNamedColors_get_ptr(self.0) } + Self(unsafe { vtkNamedColors_new() }) } } impl std::default::Default for vtkNamedColors { @@ -864,10 +327,6 @@ impl Drop for vtkNamedColors { #[test] fn test_vtkNamedColors_create_drop() { let obj = vtkNamedColors::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkNamedColors(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs b/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs index 37dac7c..f9094b1 100644 --- a/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs +++ b/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs @@ -1,20 +1,4 @@ -pub trait VtkBilinearQuadIntersection { - fn get_p_00_data(&mut self) -> *mut core::ffi::c_double; - fn get_p_01_data(&mut self) -> *mut core::ffi::c_double; - fn get_p_10_data(&mut self) -> *mut core::ffi::c_double; - fn get_p_11_data(&mut self) -> *mut core::ffi::c_double; - fn compute_cartesian_coordinates( - &mut self, - u: core::ffi::c_double, - v: core::ffi::c_double, - ) -> *mut core::ffi::c_void; - fn ray_intersection( - &mut self, - r: vtkVector3d, - q: vtkVector3d, - uv: *mut core::ffi::c_void, - ) -> bool; -} +pub trait VtkBilinearQuadIntersection {} pub trait VtkCardinalSpline { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -37,7 +21,7 @@ pub trait VtkKochanekSpline { fn get_default_continuity(&mut self) -> core::ffi::c_double; fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> (); } -pub trait VtkParametricBohemianDome: VtkParametricFunction { +pub trait VtkParametricBohemianDome { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_a(&mut self) -> core::ffi::c_double; @@ -48,76 +32,28 @@ pub trait VtkParametricBohemianDome: VtkParametricFunction { fn set_c(&mut self, _arg: core::ffi::c_double) -> (); fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricBour: VtkParametricFunction { +pub trait VtkParametricBour { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricBoy: VtkParametricFunction { +pub trait VtkParametricBoy { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; fn set_z_scale(&mut self, _arg: core::ffi::c_double) -> (); fn get_z_scale(&mut self) -> core::ffi::c_double; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricCatalanMinimal: VtkParametricFunction { +pub trait VtkParametricCatalanMinimal { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricConicSpiral: VtkParametricFunction { +pub trait VtkParametricConicSpiral { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -130,38 +66,14 @@ pub trait VtkParametricConicSpiral: VtkParametricFunction { fn get_c(&mut self) -> core::ffi::c_double; fn set_n(&mut self, _arg: core::ffi::c_double) -> (); fn get_n(&mut self) -> core::ffi::c_double; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricCrossCap: VtkParametricFunction { +pub trait VtkParametricCrossCap { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricDini: VtkParametricFunction { +pub trait VtkParametricDini { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -170,20 +82,8 @@ pub trait VtkParametricDini: VtkParametricFunction { fn get_a(&mut self) -> core::ffi::c_double; fn set_b(&mut self, _arg: core::ffi::c_double) -> (); fn get_b(&mut self) -> core::ffi::c_double; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricEllipsoid: VtkParametricFunction { +pub trait VtkParametricEllipsoid { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -194,73 +94,25 @@ pub trait VtkParametricEllipsoid: VtkParametricFunction { fn get_y_radius(&mut self) -> core::ffi::c_double; fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> (); fn get_z_radius(&mut self) -> core::ffi::c_double; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricEnneper: VtkParametricFunction { +pub trait VtkParametricEnneper { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricFigure8Klein: VtkParametricFunction { +pub trait VtkParametricFigure8Klein { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); fn get_radius(&mut self) -> core::ffi::c_double; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } pub trait VtkParametricFunction { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; fn set_minimum_u(&mut self, _arg: core::ffi::c_double) -> (); fn get_minimum_u(&mut self) -> core::ffi::c_double; fn set_maximum_u(&mut self, _arg: core::ffi::c_double) -> (); @@ -322,121 +174,49 @@ pub trait VtkParametricFunction { fn derivatives_available_on(&mut self) -> (); fn derivatives_available_off(&mut self) -> (); } -pub trait VtkParametricHenneberg: VtkParametricFunction { +pub trait VtkParametricHenneberg { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricKlein: VtkParametricFunction { +pub trait VtkParametricKlein { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricKuen: VtkParametricFunction { +pub trait VtkParametricKuen { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; fn set_delta_v_0(&mut self, _arg: core::ffi::c_double) -> (); fn get_delta_v_0(&mut self) -> core::ffi::c_double; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricMobius: VtkParametricFunction { +pub trait VtkParametricMobius { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); fn get_radius(&mut self) -> core::ffi::c_double; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricPluckerConoid: VtkParametricFunction { +pub trait VtkParametricPluckerConoid { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_n(&mut self) -> core::ffi::c_int; fn set_n(&mut self, _arg: core::ffi::c_int) -> (); fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricPseudosphere: VtkParametricFunction { +pub trait VtkParametricPseudosphere { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricRandomHills: VtkParametricFunction { +pub trait VtkParametricRandomHills { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; @@ -463,56 +243,20 @@ pub trait VtkParametricRandomHills: VtkParametricFunction { fn get_y_variance_scale_factor(&mut self) -> core::ffi::c_double; fn set_amplitude_scale_factor(&mut self, _arg: core::ffi::c_double) -> (); fn get_amplitude_scale_factor(&mut self) -> core::ffi::c_double; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricRoman: VtkParametricFunction { +pub trait VtkParametricRoman { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; fn new(&mut self) -> *mut core::ffi::c_void; fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); fn get_radius(&mut self) -> core::ffi::c_double; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricSpline: VtkParametricFunction { +pub trait VtkParametricSpline { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - u: core::ffi::c_double, - Pt: core::ffi::c_double, - Du: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - u: core::ffi::c_double, - Pt: core::ffi::c_double, - Du: core::ffi::c_double, - ) -> core::ffi::c_double; fn set_x_spline(&mut self, p0: *mut core::ffi::c_void) -> (); fn set_y_spline(&mut self, p0: *mut core::ffi::c_void) -> (); fn set_z_spline(&mut self, p0: *mut core::ffi::c_void) -> (); @@ -521,10 +265,10 @@ pub trait VtkParametricSpline: VtkParametricFunction { fn get_z_spline(&mut self) -> *mut core::ffi::c_void; fn set_points(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_points(&mut self) -> *mut core::ffi::c_void; - fn set_number_of_points(&mut self, numPts: core::ffi::c_uchar) -> (); + fn set_number_of_points(&mut self, numPts: core::ffi::c_longlong) -> (); fn set_point( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, @@ -550,7 +294,7 @@ pub trait VtkParametricSpline: VtkParametricFunction { fn set_right_value(&mut self, _arg: core::ffi::c_double) -> (); fn get_right_value(&mut self) -> core::ffi::c_double; } -pub trait VtkParametricSuperEllipsoid: VtkParametricFunction { +pub trait VtkParametricSuperEllipsoid { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -565,20 +309,8 @@ pub trait VtkParametricSuperEllipsoid: VtkParametricFunction { fn get_n_1(&mut self) -> core::ffi::c_double; fn set_n_2(&mut self, _arg: core::ffi::c_double) -> (); fn get_n_2(&mut self) -> core::ffi::c_double; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricSuperToroid: VtkParametricFunction { +pub trait VtkParametricSuperToroid { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -597,20 +329,8 @@ pub trait VtkParametricSuperToroid: VtkParametricFunction { fn get_n_1(&mut self) -> core::ffi::c_double; fn set_n_2(&mut self, _arg: core::ffi::c_double) -> (); fn get_n_2(&mut self) -> core::ffi::c_double; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkParametricTorus: VtkParametricFunction { +pub trait VtkParametricTorus { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -619,18 +339,6 @@ pub trait VtkParametricTorus: VtkParametricFunction { fn set_cross_section_radius(&mut self, _arg: core::ffi::c_double) -> (); fn get_cross_section_radius(&mut self) -> core::ffi::c_double; fn get_dimension(&mut self) -> core::ffi::c_int; - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> (); - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; } impl VtkCardinalSpline for vtkCardinalSpline { fn new(&mut self) -> *mut core::ffi::c_void { @@ -870,38 +578,6 @@ impl VtkParametricBohemianDome for vtkParametricBohemianDome { } unsafe { vtk_parametric_bohemian_dome_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_bohemian_dome_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_bohemian_dome_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_bohemian_dome_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_bohemian_dome_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricBour for vtkParametricBour { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -937,38 +613,6 @@ impl VtkParametricBour for vtkParametricBour { } unsafe { vtk_parametric_bour_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_bour_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_bour_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_bour_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_bour_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricBoy for vtkParametricBoy { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1021,38 +665,6 @@ impl VtkParametricBoy for vtkParametricBoy { } unsafe { vtk_parametric_boy_get_z_scale(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_boy_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_boy_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_boy_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_boy_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricCatalanMinimal for vtkParametricCatalanMinimal { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1088,38 +700,6 @@ impl VtkParametricCatalanMinimal for vtkParametricCatalanMinimal { } unsafe { vtk_parametric_catalan_minimal_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_catalan_minimal_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_catalan_minimal_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_catalan_minimal_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_catalan_minimal_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricConicSpiral for vtkParametricConicSpiral { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1223,38 +803,6 @@ impl VtkParametricConicSpiral for vtkParametricConicSpiral { } unsafe { vtk_parametric_conic_spiral_get_n(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_conic_spiral_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_conic_spiral_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_conic_spiral_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_conic_spiral_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricCrossCap for vtkParametricCrossCap { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1290,38 +838,6 @@ impl VtkParametricCrossCap for vtkParametricCrossCap { } unsafe { vtk_parametric_cross_cap_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_cross_cap_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_cross_cap_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_cross_cap_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_cross_cap_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricDini for vtkParametricDini { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1391,38 +907,6 @@ impl VtkParametricDini for vtkParametricDini { } unsafe { vtk_parametric_dini_get_b(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_dini_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_dini_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_dini_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_dini_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricEllipsoid for vtkParametricEllipsoid { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1509,38 +993,6 @@ impl VtkParametricEllipsoid for vtkParametricEllipsoid { } unsafe { vtk_parametric_ellipsoid_get_z_radius(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_ellipsoid_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_ellipsoid_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_ellipsoid_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_ellipsoid_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricEnneper for vtkParametricEnneper { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1576,38 +1028,6 @@ impl VtkParametricEnneper for vtkParametricEnneper { } unsafe { vtk_parametric_enneper_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_enneper_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_enneper_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_enneper_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_enneper_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricFigure8Klein for vtkParametricFigure8Klein { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1660,38 +1080,6 @@ impl VtkParametricFigure8Klein for vtkParametricFigure8Klein { } unsafe { vtk_parametric_figure_8_klein_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_figure_8_klein_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_figure_8_klein_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_figure_8_klein_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_figure_8_klein_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricHenneberg for vtkParametricHenneberg { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1727,38 +1115,6 @@ impl VtkParametricHenneberg for vtkParametricHenneberg { } unsafe { vtk_parametric_henneberg_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_henneberg_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_henneberg_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_henneberg_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_henneberg_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricKlein for vtkParametricKlein { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1794,38 +1150,6 @@ impl VtkParametricKlein for vtkParametricKlein { } unsafe { vtk_parametric_klein_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_klein_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_klein_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_klein_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_klein_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricKuen for vtkParametricKuen { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1878,38 +1202,6 @@ impl VtkParametricKuen for vtkParametricKuen { } unsafe { vtk_parametric_kuen_get_delta_v_0(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_kuen_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_kuen_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_kuen_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_kuen_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricMobius for vtkParametricMobius { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -1962,38 +1254,6 @@ impl VtkParametricMobius for vtkParametricMobius { } unsafe { vtk_parametric_mobius_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_mobius_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_mobius_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_mobius_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_mobius_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricPluckerConoid for vtkParametricPluckerConoid { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -2046,38 +1306,6 @@ impl VtkParametricPluckerConoid for vtkParametricPluckerConoid { } unsafe { vtk_parametric_plucker_conoid_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_plucker_conoid_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_plucker_conoid_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_plucker_conoid_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_plucker_conoid_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricPseudosphere for vtkParametricPseudosphere { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -2113,38 +1341,6 @@ impl VtkParametricPseudosphere for vtkParametricPseudosphere { } unsafe { vtk_parametric_pseudosphere_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_pseudosphere_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_pseudosphere_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_pseudosphere_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_pseudosphere_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricRandomHills for vtkParametricRandomHills { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -2369,38 +1565,6 @@ impl VtkParametricRandomHills for vtkParametricRandomHills { } unsafe { vtk_parametric_random_hills_get_amplitude_scale_factor(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_random_hills_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_random_hills_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_random_hills_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_random_hills_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricRoman for vtkParametricRoman { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -2453,38 +1617,6 @@ impl VtkParametricRoman for vtkParametricRoman { } unsafe { vtk_parametric_roman_get_radius(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_roman_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_roman_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_roman_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_roman_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricSpline for vtkParametricSpline { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -2520,38 +1652,6 @@ impl VtkParametricSpline for vtkParametricSpline { } unsafe { vtk_parametric_spline_get_dimension(self.0) } } - fn evaluate( - &mut self, - u: core::ffi::c_double, - Pt: core::ffi::c_double, - Du: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_spline_evaluate( - sself: *mut core::ffi::c_void, - u: core::ffi::c_double, - Pt: core::ffi::c_double, - Du: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_spline_evaluate(self.0, u, Pt, Du) } - } - fn evaluate_scalar( - &mut self, - u: core::ffi::c_double, - Pt: core::ffi::c_double, - Du: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_spline_evaluate_scalar( - sself: *mut core::ffi::c_void, - u: core::ffi::c_double, - Pt: core::ffi::c_double, - Du: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_spline_evaluate_scalar(self.0, u, Pt, Du) } - } fn set_x_spline(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_parametric_spline_set_x_spline( @@ -2620,18 +1720,18 @@ impl VtkParametricSpline for vtkParametricSpline { } unsafe { vtk_parametric_spline_get_points(self.0) } } - fn set_number_of_points(&mut self, numPts: core::ffi::c_uchar) -> () { + fn set_number_of_points(&mut self, numPts: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_parametric_spline_set_number_of_points( sself: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ); } unsafe { vtk_parametric_spline_set_number_of_points(self.0, numPts) } } fn set_point( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, @@ -2639,7 +1739,7 @@ impl VtkParametricSpline for vtkParametricSpline { unsafe extern "C" { fn vtk_parametric_spline_set_point( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, @@ -2929,38 +2029,6 @@ impl VtkParametricSuperEllipsoid for vtkParametricSuperEllipsoid { } unsafe { vtk_parametric_super_ellipsoid_get_n_2(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_super_ellipsoid_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_super_ellipsoid_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_super_ellipsoid_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_super_ellipsoid_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricSuperToroid for vtkParametricSuperToroid { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -3115,38 +2183,6 @@ impl VtkParametricSuperToroid for vtkParametricSuperToroid { } unsafe { vtk_parametric_super_toroid_get_n_2(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_super_toroid_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_super_toroid_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_super_toroid_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_super_toroid_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } impl VtkParametricTorus for vtkParametricTorus { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -3216,38 +2252,6 @@ impl VtkParametricTorus for vtkParametricTorus { } unsafe { vtk_parametric_torus_get_dimension(self.0) } } - fn evaluate( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_parametric_torus_evaluate( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ); - } - unsafe { vtk_parametric_torus_evaluate(self.0, uvw, Pt, Duvw) } - } - fn evaluate_scalar( - &mut self, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_parametric_torus_evaluate_scalar( - sself: *mut core::ffi::c_void, - uvw: core::ffi::c_double, - Pt: core::ffi::c_double, - Duvw: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_parametric_torus_evaluate_scalar(self.0, uvw, Pt, Duvw) } - } } /// computes an interpolating spline using a /// @@ -3262,22 +2266,13 @@ impl VtkParametricTorus for vtkParametricTorus { #[allow(non_camel_case_types)] pub struct vtkCardinalSpline(*mut core::ffi::c_void); impl vtkCardinalSpline { - /// Creates a new [vtkCardinalSpline] wrapped inside `vtkNew` + /// Creates a new [vtkCardinalSpline] via `vtkCardinalSpline::New()` #[doc(alias = "vtkCardinalSpline")] pub fn new() -> Self { unsafe extern "C" { fn vtkCardinalSpline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCardinalSpline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCardinalSpline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCardinalSpline_get_ptr(self.0) } + Self(unsafe { vtkCardinalSpline_new() }) } } impl std::default::Default for vtkCardinalSpline { @@ -3297,12 +2292,8 @@ impl Drop for vtkCardinalSpline { #[test] fn test_vtkCardinalSpline_create_drop() { let obj = vtkCardinalSpline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCardinalSpline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// computes an interpolating spline using a Kochanek basis. /// @@ -3334,22 +2325,13 @@ fn test_vtkCardinalSpline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkKochanekSpline(*mut core::ffi::c_void); impl vtkKochanekSpline { - /// Creates a new [vtkKochanekSpline] wrapped inside `vtkNew` + /// Creates a new [vtkKochanekSpline] via `vtkKochanekSpline::New()` #[doc(alias = "vtkKochanekSpline")] pub fn new() -> Self { unsafe extern "C" { fn vtkKochanekSpline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkKochanekSpline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkKochanekSpline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkKochanekSpline_get_ptr(self.0) } + Self(unsafe { vtkKochanekSpline_new() }) } } impl std::default::Default for vtkKochanekSpline { @@ -3369,12 +2351,8 @@ impl Drop for vtkKochanekSpline { #[test] fn test_vtkKochanekSpline_create_drop() { let obj = vtkKochanekSpline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkKochanekSpline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a Bohemian dome. /// @@ -3390,22 +2368,13 @@ fn test_vtkKochanekSpline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricBohemianDome(*mut core::ffi::c_void); impl vtkParametricBohemianDome { - /// Creates a new [vtkParametricBohemianDome] wrapped inside `vtkNew` + /// Creates a new [vtkParametricBohemianDome] via `vtkParametricBohemianDome::New()` #[doc(alias = "vtkParametricBohemianDome")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricBohemianDome_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricBohemianDome_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricBohemianDome_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricBohemianDome_get_ptr(self.0) } + Self(unsafe { vtkParametricBohemianDome_new() }) } } impl std::default::Default for vtkParametricBohemianDome { @@ -3425,12 +2394,8 @@ impl Drop for vtkParametricBohemianDome { #[test] fn test_vtkParametricBohemianDome_create_drop() { let obj = vtkParametricBohemianDome::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricBohemianDome(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Bour's minimal surface. /// @@ -3443,22 +2408,13 @@ fn test_vtkParametricBohemianDome_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricBour(*mut core::ffi::c_void); impl vtkParametricBour { - /// Creates a new [vtkParametricBour] wrapped inside `vtkNew` + /// Creates a new [vtkParametricBour] via `vtkParametricBour::New()` #[doc(alias = "vtkParametricBour")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricBour_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricBour_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricBour_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricBour_get_ptr(self.0) } + Self(unsafe { vtkParametricBour_new() }) } } impl std::default::Default for vtkParametricBour { @@ -3478,12 +2434,8 @@ impl Drop for vtkParametricBour { #[test] fn test_vtkParametricBour_create_drop() { let obj = vtkParametricBour::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricBour(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Boy's surface. /// @@ -3502,22 +2454,13 @@ fn test_vtkParametricBour_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricBoy(*mut core::ffi::c_void); impl vtkParametricBoy { - /// Creates a new [vtkParametricBoy] wrapped inside `vtkNew` + /// Creates a new [vtkParametricBoy] via `vtkParametricBoy::New()` #[doc(alias = "vtkParametricBoy")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricBoy_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricBoy_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricBoy_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricBoy_get_ptr(self.0) } + Self(unsafe { vtkParametricBoy_new() }) } } impl std::default::Default for vtkParametricBoy { @@ -3537,12 +2480,8 @@ impl Drop for vtkParametricBoy { #[test] fn test_vtkParametricBoy_create_drop() { let obj = vtkParametricBoy::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricBoy(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Catalan's minimal surface. /// @@ -3556,22 +2495,13 @@ fn test_vtkParametricBoy_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricCatalanMinimal(*mut core::ffi::c_void); impl vtkParametricCatalanMinimal { - /// Creates a new [vtkParametricCatalanMinimal] wrapped inside `vtkNew` + /// Creates a new [vtkParametricCatalanMinimal] via `vtkParametricCatalanMinimal::New()` #[doc(alias = "vtkParametricCatalanMinimal")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricCatalanMinimal_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricCatalanMinimal_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricCatalanMinimal_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricCatalanMinimal_get_ptr(self.0) } + Self(unsafe { vtkParametricCatalanMinimal_new() }) } } impl std::default::Default for vtkParametricCatalanMinimal { @@ -3591,12 +2521,8 @@ impl Drop for vtkParametricCatalanMinimal { #[test] fn test_vtkParametricCatalanMinimal_create_drop() { let obj = vtkParametricCatalanMinimal::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricCatalanMinimal(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate conic spiral surfaces that resemble sea-shells. /// @@ -3614,22 +2540,13 @@ fn test_vtkParametricCatalanMinimal_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricConicSpiral(*mut core::ffi::c_void); impl vtkParametricConicSpiral { - /// Creates a new [vtkParametricConicSpiral] wrapped inside `vtkNew` + /// Creates a new [vtkParametricConicSpiral] via `vtkParametricConicSpiral::New()` #[doc(alias = "vtkParametricConicSpiral")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricConicSpiral_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricConicSpiral_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricConicSpiral_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricConicSpiral_get_ptr(self.0) } + Self(unsafe { vtkParametricConicSpiral_new() }) } } impl std::default::Default for vtkParametricConicSpiral { @@ -3649,12 +2566,8 @@ impl Drop for vtkParametricConicSpiral { #[test] fn test_vtkParametricConicSpiral_create_drop() { let obj = vtkParametricConicSpiral::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricConicSpiral(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a cross-cap. /// @@ -3673,22 +2586,13 @@ fn test_vtkParametricConicSpiral_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricCrossCap(*mut core::ffi::c_void); impl vtkParametricCrossCap { - /// Creates a new [vtkParametricCrossCap] wrapped inside `vtkNew` + /// Creates a new [vtkParametricCrossCap] via `vtkParametricCrossCap::New()` #[doc(alias = "vtkParametricCrossCap")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricCrossCap_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricCrossCap_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricCrossCap_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricCrossCap_get_ptr(self.0) } + Self(unsafe { vtkParametricCrossCap_new() }) } } impl std::default::Default for vtkParametricCrossCap { @@ -3708,12 +2612,8 @@ impl Drop for vtkParametricCrossCap { #[test] fn test_vtkParametricCrossCap_create_drop() { let obj = vtkParametricCrossCap::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricCrossCap(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Dini's surface. /// @@ -3731,22 +2631,13 @@ fn test_vtkParametricCrossCap_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricDini(*mut core::ffi::c_void); impl vtkParametricDini { - /// Creates a new [vtkParametricDini] wrapped inside `vtkNew` + /// Creates a new [vtkParametricDini] via `vtkParametricDini::New()` #[doc(alias = "vtkParametricDini")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricDini_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricDini_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricDini_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricDini_get_ptr(self.0) } + Self(unsafe { vtkParametricDini_new() }) } } impl std::default::Default for vtkParametricDini { @@ -3766,12 +2657,8 @@ impl Drop for vtkParametricDini { #[test] fn test_vtkParametricDini_create_drop() { let obj = vtkParametricDini::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricDini(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate an ellipsoid. /// @@ -3793,22 +2680,13 @@ fn test_vtkParametricDini_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricEllipsoid(*mut core::ffi::c_void); impl vtkParametricEllipsoid { - /// Creates a new [vtkParametricEllipsoid] wrapped inside `vtkNew` + /// Creates a new [vtkParametricEllipsoid] via `vtkParametricEllipsoid::New()` #[doc(alias = "vtkParametricEllipsoid")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricEllipsoid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricEllipsoid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricEllipsoid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricEllipsoid_get_ptr(self.0) } + Self(unsafe { vtkParametricEllipsoid_new() }) } } impl std::default::Default for vtkParametricEllipsoid { @@ -3828,12 +2706,8 @@ impl Drop for vtkParametricEllipsoid { #[test] fn test_vtkParametricEllipsoid_create_drop() { let obj = vtkParametricEllipsoid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricEllipsoid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Enneper's surface. /// @@ -3852,22 +2726,13 @@ fn test_vtkParametricEllipsoid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricEnneper(*mut core::ffi::c_void); impl vtkParametricEnneper { - /// Creates a new [vtkParametricEnneper] wrapped inside `vtkNew` + /// Creates a new [vtkParametricEnneper] via `vtkParametricEnneper::New()` #[doc(alias = "vtkParametricEnneper")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricEnneper_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricEnneper_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricEnneper_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricEnneper_get_ptr(self.0) } + Self(unsafe { vtkParametricEnneper_new() }) } } impl std::default::Default for vtkParametricEnneper { @@ -3887,12 +2752,8 @@ impl Drop for vtkParametricEnneper { #[test] fn test_vtkParametricEnneper_create_drop() { let obj = vtkParametricEnneper::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricEnneper(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a figure-8 Klein bottle. /// @@ -3918,22 +2779,13 @@ fn test_vtkParametricEnneper_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricFigure8Klein(*mut core::ffi::c_void); impl vtkParametricFigure8Klein { - /// Creates a new [vtkParametricFigure8Klein] wrapped inside `vtkNew` + /// Creates a new [vtkParametricFigure8Klein] via `vtkParametricFigure8Klein::New()` #[doc(alias = "vtkParametricFigure8Klein")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricFigure8Klein_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricFigure8Klein_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricFigure8Klein_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricFigure8Klein_get_ptr(self.0) } + Self(unsafe { vtkParametricFigure8Klein_new() }) } } impl std::default::Default for vtkParametricFigure8Klein { @@ -3953,12 +2805,8 @@ impl Drop for vtkParametricFigure8Klein { #[test] fn test_vtkParametricFigure8Klein_create_drop() { let obj = vtkParametricFigure8Klein::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricFigure8Klein(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Henneberg's minimal surface. /// @@ -3971,22 +2819,13 @@ fn test_vtkParametricFigure8Klein_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricHenneberg(*mut core::ffi::c_void); impl vtkParametricHenneberg { - /// Creates a new [vtkParametricHenneberg] wrapped inside `vtkNew` + /// Creates a new [vtkParametricHenneberg] via `vtkParametricHenneberg::New()` #[doc(alias = "vtkParametricHenneberg")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricHenneberg_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricHenneberg_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricHenneberg_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricHenneberg_get_ptr(self.0) } + Self(unsafe { vtkParametricHenneberg_new() }) } } impl std::default::Default for vtkParametricHenneberg { @@ -4006,12 +2845,8 @@ impl Drop for vtkParametricHenneberg { #[test] fn test_vtkParametricHenneberg_create_drop() { let obj = vtkParametricHenneberg::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricHenneberg(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generates a "classical" representation of a Klein bottle. /// @@ -4037,22 +2872,13 @@ fn test_vtkParametricHenneberg_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricKlein(*mut core::ffi::c_void); impl vtkParametricKlein { - /// Creates a new [vtkParametricKlein] wrapped inside `vtkNew` + /// Creates a new [vtkParametricKlein] via `vtkParametricKlein::New()` #[doc(alias = "vtkParametricKlein")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricKlein_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricKlein_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricKlein_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricKlein_get_ptr(self.0) } + Self(unsafe { vtkParametricKlein_new() }) } } impl std::default::Default for vtkParametricKlein { @@ -4072,12 +2898,8 @@ impl Drop for vtkParametricKlein { #[test] fn test_vtkParametricKlein_create_drop() { let obj = vtkParametricKlein::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricKlein(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Kuens' surface. /// @@ -4091,22 +2913,13 @@ fn test_vtkParametricKlein_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricKuen(*mut core::ffi::c_void); impl vtkParametricKuen { - /// Creates a new [vtkParametricKuen] wrapped inside `vtkNew` + /// Creates a new [vtkParametricKuen] via `vtkParametricKuen::New()` #[doc(alias = "vtkParametricKuen")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricKuen_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricKuen_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricKuen_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricKuen_get_ptr(self.0) } + Self(unsafe { vtkParametricKuen_new() }) } } impl std::default::Default for vtkParametricKuen { @@ -4126,12 +2939,8 @@ impl Drop for vtkParametricKuen { #[test] fn test_vtkParametricKuen_create_drop() { let obj = vtkParametricKuen::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricKuen(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a Mobius strip. /// @@ -4148,22 +2957,13 @@ fn test_vtkParametricKuen_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricMobius(*mut core::ffi::c_void); impl vtkParametricMobius { - /// Creates a new [vtkParametricMobius] wrapped inside `vtkNew` + /// Creates a new [vtkParametricMobius] via `vtkParametricMobius::New()` #[doc(alias = "vtkParametricMobius")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricMobius_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricMobius_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricMobius_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricMobius_get_ptr(self.0) } + Self(unsafe { vtkParametricMobius_new() }) } } impl std::default::Default for vtkParametricMobius { @@ -4183,12 +2983,8 @@ impl Drop for vtkParametricMobius { #[test] fn test_vtkParametricMobius_create_drop() { let obj = vtkParametricMobius::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricMobius(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Plucker's conoid surface. /// @@ -4206,22 +3002,13 @@ fn test_vtkParametricMobius_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricPluckerConoid(*mut core::ffi::c_void); impl vtkParametricPluckerConoid { - /// Creates a new [vtkParametricPluckerConoid] wrapped inside `vtkNew` + /// Creates a new [vtkParametricPluckerConoid] via `vtkParametricPluckerConoid::New()` #[doc(alias = "vtkParametricPluckerConoid")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricPluckerConoid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricPluckerConoid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricPluckerConoid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricPluckerConoid_get_ptr(self.0) } + Self(unsafe { vtkParametricPluckerConoid_new() }) } } impl std::default::Default for vtkParametricPluckerConoid { @@ -4241,12 +3028,8 @@ impl Drop for vtkParametricPluckerConoid { #[test] fn test_vtkParametricPluckerConoid_create_drop() { let obj = vtkParametricPluckerConoid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricPluckerConoid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a pseudosphere. /// @@ -4261,22 +3044,13 @@ fn test_vtkParametricPluckerConoid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricPseudosphere(*mut core::ffi::c_void); impl vtkParametricPseudosphere { - /// Creates a new [vtkParametricPseudosphere] wrapped inside `vtkNew` + /// Creates a new [vtkParametricPseudosphere] via `vtkParametricPseudosphere::New()` #[doc(alias = "vtkParametricPseudosphere")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricPseudosphere_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricPseudosphere_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricPseudosphere_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricPseudosphere_get_ptr(self.0) } + Self(unsafe { vtkParametricPseudosphere_new() }) } } impl std::default::Default for vtkParametricPseudosphere { @@ -4296,12 +3070,8 @@ impl Drop for vtkParametricPseudosphere { #[test] fn test_vtkParametricPseudosphere_create_drop() { let obj = vtkParametricPseudosphere::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricPseudosphere(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a surface covered with randomly placed hills. /// @@ -4322,22 +3092,13 @@ fn test_vtkParametricPseudosphere_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricRandomHills(*mut core::ffi::c_void); impl vtkParametricRandomHills { - /// Creates a new [vtkParametricRandomHills] wrapped inside `vtkNew` + /// Creates a new [vtkParametricRandomHills] via `vtkParametricRandomHills::New()` #[doc(alias = "vtkParametricRandomHills")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricRandomHills_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricRandomHills_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricRandomHills_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricRandomHills_get_ptr(self.0) } + Self(unsafe { vtkParametricRandomHills_new() }) } } impl std::default::Default for vtkParametricRandomHills { @@ -4357,12 +3118,8 @@ impl Drop for vtkParametricRandomHills { #[test] fn test_vtkParametricRandomHills_create_drop() { let obj = vtkParametricRandomHills::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricRandomHills(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Steiner's Roman Surface. /// @@ -4379,22 +3136,13 @@ fn test_vtkParametricRandomHills_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricRoman(*mut core::ffi::c_void); impl vtkParametricRoman { - /// Creates a new [vtkParametricRoman] wrapped inside `vtkNew` + /// Creates a new [vtkParametricRoman] via `vtkParametricRoman::New()` #[doc(alias = "vtkParametricRoman")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricRoman_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricRoman_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricRoman_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricRoman_get_ptr(self.0) } + Self(unsafe { vtkParametricRoman_new() }) } } impl std::default::Default for vtkParametricRoman { @@ -4414,12 +3162,8 @@ impl Drop for vtkParametricRoman { #[test] fn test_vtkParametricRoman_create_drop() { let obj = vtkParametricRoman::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricRoman(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// parametric function for 1D interpolating splines /// @@ -4444,22 +3188,13 @@ fn test_vtkParametricRoman_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricSpline(*mut core::ffi::c_void); impl vtkParametricSpline { - /// Creates a new [vtkParametricSpline] wrapped inside `vtkNew` + /// Creates a new [vtkParametricSpline] via `vtkParametricSpline::New()` #[doc(alias = "vtkParametricSpline")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricSpline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricSpline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricSpline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricSpline_get_ptr(self.0) } + Self(unsafe { vtkParametricSpline_new() }) } } impl std::default::Default for vtkParametricSpline { @@ -4479,12 +3214,8 @@ impl Drop for vtkParametricSpline { #[test] fn test_vtkParametricSpline_create_drop() { let obj = vtkParametricSpline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricSpline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a superellipsoid. /// @@ -4510,22 +3241,13 @@ fn test_vtkParametricSpline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricSuperEllipsoid(*mut core::ffi::c_void); impl vtkParametricSuperEllipsoid { - /// Creates a new [vtkParametricSuperEllipsoid] wrapped inside `vtkNew` + /// Creates a new [vtkParametricSuperEllipsoid] via `vtkParametricSuperEllipsoid::New()` #[doc(alias = "vtkParametricSuperEllipsoid")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricSuperEllipsoid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricSuperEllipsoid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricSuperEllipsoid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricSuperEllipsoid_get_ptr(self.0) } + Self(unsafe { vtkParametricSuperEllipsoid_new() }) } } impl std::default::Default for vtkParametricSuperEllipsoid { @@ -4545,12 +3267,8 @@ impl Drop for vtkParametricSuperEllipsoid { #[test] fn test_vtkParametricSuperEllipsoid_create_drop() { let obj = vtkParametricSuperEllipsoid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricSuperEllipsoid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a supertoroid. /// @@ -4580,22 +3298,13 @@ fn test_vtkParametricSuperEllipsoid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricSuperToroid(*mut core::ffi::c_void); impl vtkParametricSuperToroid { - /// Creates a new [vtkParametricSuperToroid] wrapped inside `vtkNew` + /// Creates a new [vtkParametricSuperToroid] via `vtkParametricSuperToroid::New()` #[doc(alias = "vtkParametricSuperToroid")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricSuperToroid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricSuperToroid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricSuperToroid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricSuperToroid_get_ptr(self.0) } + Self(unsafe { vtkParametricSuperToroid_new() }) } } impl std::default::Default for vtkParametricSuperToroid { @@ -4615,12 +3324,8 @@ impl Drop for vtkParametricSuperToroid { #[test] fn test_vtkParametricSuperToroid_create_drop() { let obj = vtkParametricSuperToroid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricSuperToroid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a torus. /// @@ -4637,22 +3342,13 @@ fn test_vtkParametricSuperToroid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricTorus(*mut core::ffi::c_void); impl vtkParametricTorus { - /// Creates a new [vtkParametricTorus] wrapped inside `vtkNew` + /// Creates a new [vtkParametricTorus] via `vtkParametricTorus::New()` #[doc(alias = "vtkParametricTorus")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricTorus_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricTorus_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricTorus_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricTorus_get_ptr(self.0) } + Self(unsafe { vtkParametricTorus_new() }) } } impl std::default::Default for vtkParametricTorus { @@ -4672,10 +3368,6 @@ impl Drop for vtkParametricTorus { #[test] fn test_vtkParametricTorus_create_drop() { let obj = vtkParametricTorus::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricTorus(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonCore.rs b/vtk-rs-9.1/src/vtkCommonCore.rs index 0b61290..08294de 100644 --- a/vtk-rs-9.1/src/vtkCommonCore.rs +++ b/vtk-rs-9.1/src/vtkCommonCore.rs @@ -1,100 +1,62 @@ -pub trait VtkAOSDataArrayTemplate: VtkGenericDataArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { +pub trait VtkAOSDataArrayTemplate { fn new(&mut self) -> *mut core::ffi::c_void; - fn get_value(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_value( - &mut self, - valueIdx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); fn get_typed_tuple( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, tuple: *mut core::ffi::c_void, ) -> (); - fn set_typed_tuple(&mut self, tupleIdx: core::ffi::c_uchar, tuple: ValueTypeT) -> (); - fn get_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn set_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - comp: core::ffi::c_int, - value: *mut core::ffi::c_void, - ) -> (); fn write_pointer( &mut self, - valueIdx: core::ffi::c_uchar, - numValues: core::ffi::c_uchar, + valueIdx: core::ffi::c_longlong, + numValues: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; - fn get_pointer(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_pointer(&mut self, valueIdx: core::ffi::c_longlong) -> *mut core::ffi::c_void; fn set_array( &mut self, array: *mut core::ffi::c_void, - size: core::ffi::c_uchar, + size: core::ffi::c_longlong, save: core::ffi::c_int, deleteMethod: core::ffi::c_int, ) -> (); - fn set_array( - &mut self, - array: *mut core::ffi::c_void, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_void_array( - &mut self, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); - fn data_element_changed(&mut self, p0: core::ffi::c_uchar) -> (); + fn data_element_changed(&mut self, p0: core::ffi::c_longlong) -> (); fn begin(&mut self) -> *mut core::ffi::c_void; fn end(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkAbstractArray: VtkObject + VtkObjectBase { +pub trait VtkAbstractArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn allocate( &mut self, - numValues: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + numValues: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; fn initialize(&mut self) -> (); fn get_data_type(&mut self) -> core::ffi::c_int; fn get_data_type_size(&mut self) -> core::ffi::c_int; - fn get_data_type_size(&mut self, type_: core::ffi::c_int) -> core::ffi::c_int; fn get_element_component_size(&mut self) -> core::ffi::c_int; fn set_number_of_components(&mut self, _arg: core::ffi::c_int) -> (); fn get_number_of_components_min_value(&mut self) -> core::ffi::c_int; fn get_number_of_components_max_value(&mut self) -> core::ffi::c_int; fn get_number_of_components(&mut self) -> core::ffi::c_int; - fn set_component_name( - &mut self, - component: core::ffi::c_uchar, - name: core::ffi::c_char, - ) -> (); - fn get_component_name( - &mut self, - component: core::ffi::c_uchar, - ) -> *const core::ffi::c_char; + fn set_component_name(&mut self, component: core::ffi::c_longlong, name: &str) -> (); + fn get_component_name(&mut self, component: core::ffi::c_longlong) -> &str; fn has_a_component_name(&mut self) -> bool; fn copy_component_names(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set_number_of_tuples(&mut self, numTuples: core::ffi::c_uchar) -> (); - fn set_number_of_values(&mut self, numValues: core::ffi::c_uchar) -> bool; - fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar; - fn get_number_of_values(&mut self) -> core::ffi::c_uchar; + fn set_number_of_tuples(&mut self, numTuples: core::ffi::c_longlong) -> (); + fn set_number_of_values(&mut self, numValues: core::ffi::c_longlong) -> bool; + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong; + fn get_number_of_values(&mut self) -> core::ffi::c_longlong; fn set_tuple( &mut self, - dstTupleIdx: core::ffi::c_uchar, - srcTupleIdx: core::ffi::c_uchar, + dstTupleIdx: core::ffi::c_longlong, + srcTupleIdx: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> (); fn insert_tuple( &mut self, - dstTupleIdx: core::ffi::c_uchar, - srcTupleIdx: core::ffi::c_uchar, + dstTupleIdx: core::ffi::c_longlong, + srcTupleIdx: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> (); fn insert_tuples( @@ -103,96 +65,31 @@ pub trait VtkAbstractArray: VtkObject + VtkObjectBase { srcIds: *mut core::ffi::c_void, source: *mut core::ffi::c_void, ) -> (); - fn insert_tuples( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); fn insert_next_tuple( &mut self, - srcTupleIdx: core::ffi::c_uchar, + srcTupleIdx: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn get_tuples( &mut self, tupleIds: *mut core::ffi::c_void, output: *mut core::ffi::c_void, ) -> (); - fn get_tuples( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - output: *mut core::ffi::c_void, - ) -> (); fn has_standard_memory_layout(&mut self) -> bool; - fn get_void_pointer(&mut self, valueIdx: core::ffi::c_uchar) -> *mut (); fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); - fn interpolate_tuple( - &mut self, - dstTupleIdx: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_tuple( - &mut self, - dstTupleIdx: core::ffi::c_uchar, - srcTupleIdx1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - srcTupleIdx2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ) -> (); fn squeeze(&mut self) -> (); - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; fn reset(&mut self) -> (); - fn get_size(&mut self) -> core::ffi::c_uchar; - fn get_max_id(&mut self) -> core::ffi::c_uchar; - fn set_void_array( - &mut self, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_void_array( - &mut self, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); + fn get_size(&mut self) -> core::ffi::c_longlong; + fn get_max_id(&mut self) -> core::ffi::c_longlong; fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); - fn export_to_void_pointer(&mut self, out_ptr: ()) -> (); fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; - fn set_name(&mut self, _arg: core::ffi::c_char) -> (); - fn get_name(&mut self) -> *mut core::ffi::c_char; - fn get_data_type_as_string(&mut self) -> *const core::ffi::c_char; + fn set_name(&mut self, _arg: &str) -> (); + fn get_data_type_as_string(&mut self) -> &str; fn create_array(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; fn is_numeric(&mut self) -> core::ffi::c_int; fn new_iterator(&mut self) -> *mut core::ffi::c_void; - fn get_data_size(&mut self) -> core::ffi::c_uchar; - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - valueIds: *mut core::ffi::c_void, - ) -> (); - fn get_variant_value( - &mut self, - valueIdx: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn insert_variant_value( - &mut self, - valueIdx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn set_variant_value( - &mut self, - valueIdx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); + fn get_data_size(&mut self) -> core::ffi::c_longlong; fn data_changed(&mut self) -> (); fn clear_lookup(&mut self) -> (); fn get_prominent_component_values( @@ -219,7 +116,7 @@ pub trait VtkAbstractArray: VtkObject + VtkObjectBase { fn set_max_discrete_values(&mut self, _arg: core::ffi::c_uint) -> (); fn get_array_type(&mut self) -> core::ffi::c_int; } -pub trait VtkAnimationCue: VtkObject + VtkObjectBase { +pub trait VtkAnimationCue { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -243,23 +140,17 @@ pub trait VtkAnimationCue: VtkObject + VtkObjectBase { fn get_delta_time(&mut self) -> core::ffi::c_double; fn get_clock_time(&mut self) -> core::ffi::c_double; } -pub trait VtkArchiver: VtkObject + VtkObjectBase { +pub trait VtkArchiver { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_archive_name(&mut self) -> *mut core::ffi::c_char; - fn set_archive_name(&mut self, _arg: core::ffi::c_char) -> (); + fn set_archive_name(&mut self, _arg: &str) -> (); fn open_archive(&mut self) -> (); fn close_archive(&mut self) -> (); - fn insert_into_archive( - &mut self, - relativePath: &str, - data: core::ffi::c_char, - size: usize, - ) -> (); + fn insert_into_archive(&mut self, relativePath: &str, data: &str, size: usize) -> (); fn contains(&mut self, relativePath: &str) -> bool; } -pub trait VtkArray: VtkObject + VtkObjectBase { +pub trait VtkArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn create_array( @@ -268,286 +159,132 @@ pub trait VtkArray: VtkObject + VtkObjectBase { ValueType: core::ffi::c_int, ) -> *mut core::ffi::c_void; fn is_dense(&mut self) -> bool; - fn resize(&mut self, i: core::ffi::c_uchar) -> (); - fn resize(&mut self, i: core::ffi::c_uchar, j: core::ffi::c_uchar) -> (); - fn resize( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - k: core::ffi::c_uchar, - ) -> (); - fn resize(&mut self, i: vtkArrayRange) -> (); - fn resize(&mut self, i: vtkArrayRange, j: vtkArrayRange) -> (); - fn resize(&mut self, i: vtkArrayRange, j: vtkArrayRange, k: vtkArrayRange) -> (); - fn resize(&mut self, extents: vtkArrayExtents) -> (); - fn get_extent(&mut self, dimension: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_extents(&mut self) -> vtkArrayExtents; - fn get_dimensions(&mut self) -> core::ffi::c_uchar; + fn resize(&mut self, i: core::ffi::c_longlong) -> (); + fn get_dimensions(&mut self) -> core::ffi::c_longlong; fn get_size(&mut self) -> core::ffi::c_ulonglong; fn get_non_null_size(&mut self) -> core::ffi::c_ulonglong; - fn set_name(&mut self, name: vtkStdString) -> (); - fn get_name(&mut self) -> *mut core::ffi::c_void; - fn set_dimension_label(&mut self, i: core::ffi::c_uchar, label: vtkStdString) -> (); - fn get_dimension_label(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_coordinates_n( - &mut self, - n: core::ffi::c_ulonglong, - coordinates: *mut core::ffi::c_void, - ) -> (); - fn get_variant_value(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_variant_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn get_variant_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - k: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn get_variant_value( - &mut self, - coordinates: vtkArrayCoordinates, - ) -> *mut core::ffi::c_void; - fn get_variant_value_n( - &mut self, - n: core::ffi::c_ulonglong, - ) -> *mut core::ffi::c_void; - fn set_variant_value(&mut self, i: core::ffi::c_uchar, value: vtkVariant) -> (); - fn set_variant_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - value: vtkVariant, - ) -> (); - fn set_variant_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - k: core::ffi::c_uchar, - value: vtkVariant, - ) -> (); - fn set_variant_value( - &mut self, - coordinates: vtkArrayCoordinates, - value: vtkVariant, - ) -> (); - fn set_variant_value_n( - &mut self, - n: core::ffi::c_ulonglong, - value: vtkVariant, - ) -> (); - fn copy_value( - &mut self, - source: *mut core::ffi::c_void, - source_coordinates: vtkArrayCoordinates, - target_coordinates: vtkArrayCoordinates, - ) -> (); - fn copy_value( - &mut self, - source: *mut core::ffi::c_void, - source_index: core::ffi::c_ulonglong, - target_coordinates: vtkArrayCoordinates, - ) -> (); - fn copy_value( - &mut self, - source: *mut core::ffi::c_void, - source_coordinates: vtkArrayCoordinates, - target_index: core::ffi::c_ulonglong, - ) -> (); fn deep_copy(&mut self) -> *mut core::ffi::c_void; } pub trait VtkArrayCoordinates { - fn get_dimensions(&mut self) -> core::ffi::c_uchar; - fn set_dimensions(&mut self, dimensions: core::ffi::c_uchar) -> (); - fn get_coordinate(&mut self, i: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn set_coordinate(&mut self, i: core::ffi::c_uchar, p1: core::ffi::c_uchar) -> (); + fn get_dimensions(&mut self) -> core::ffi::c_longlong; + fn set_dimensions(&mut self, dimensions: core::ffi::c_longlong) -> (); + fn get_coordinate(&mut self, i: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn set_coordinate( + &mut self, + i: core::ffi::c_longlong, + p1: &core::ffi::c_longlong, + ) -> (); } pub trait VtkArrayExtents { - fn uniform( - &mut self, - n: core::ffi::c_uchar, - m: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn append(&mut self, extent: vtkArrayRange) -> (); - fn get_dimensions(&mut self) -> core::ffi::c_uchar; + fn get_dimensions(&mut self) -> core::ffi::c_longlong; fn get_size(&mut self) -> core::ffi::c_ulonglong; - fn set_dimensions(&mut self, dimensions: core::ffi::c_uchar) -> (); - fn get_extent(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_extent(&mut self, i: core::ffi::c_uchar, p1: vtkArrayRange) -> (); + fn set_dimensions(&mut self, dimensions: core::ffi::c_longlong) -> (); fn zero_based(&mut self) -> bool; - fn same_shape(&mut self, rhs: vtkArrayExtents) -> bool; - fn get_left_to_right_coordinates_n( - &mut self, - n: core::ffi::c_ulonglong, - coordinates: *mut core::ffi::c_void, - ) -> (); - fn get_right_to_left_coordinates_n( - &mut self, - n: core::ffi::c_ulonglong, - coordinates: *mut core::ffi::c_void, - ) -> (); - fn contains(&mut self, extents: vtkArrayExtents) -> bool; - fn contains(&mut self, coordinates: vtkArrayCoordinates) -> bool; } pub trait VtkArrayExtentsList { - fn get_count(&mut self) -> core::ffi::c_uchar; - fn set_count(&mut self, count: core::ffi::c_uchar) -> (); + fn get_count(&mut self) -> core::ffi::c_longlong; + fn set_count(&mut self, count: core::ffi::c_longlong) -> (); } -pub trait VtkArrayIterator: VtkObject + VtkObjectBase { +pub trait VtkArrayIterator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn initialize(&mut self, array: *mut core::ffi::c_void) -> (); fn get_data_type(&mut self) -> core::ffi::c_int; } -pub trait VtkArrayIteratorTemplate: VtkArrayIterator + VtkObject + VtkObjectBase { +pub trait VtkArrayIteratorTemplate { fn initialize(&mut self, array: *mut core::ffi::c_void) -> (); fn get_array(&mut self) -> *mut core::ffi::c_void; - fn get_tuple(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_value(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_value(&mut self, id: core::ffi::c_uchar, value: *mut core::ffi::c_void) -> (); - fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar; - fn get_number_of_values(&mut self) -> core::ffi::c_uchar; + fn get_tuple(&mut self, id: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong; + fn get_number_of_values(&mut self) -> core::ffi::c_longlong; fn get_number_of_components(&mut self) -> core::ffi::c_int; fn get_data_type(&mut self) -> core::ffi::c_int; fn get_data_type_size(&mut self) -> core::ffi::c_int; } pub trait VtkArrayRange { - fn get_begin(&mut self) -> core::ffi::c_uchar; - fn get_end(&mut self) -> core::ffi::c_uchar; - fn get_size(&mut self) -> core::ffi::c_uchar; - fn contains(&mut self, range: vtkArrayRange) -> bool; - fn contains(&mut self, coordinate: core::ffi::c_uchar) -> bool; + fn get_begin(&mut self) -> core::ffi::c_longlong; + fn get_end(&mut self) -> core::ffi::c_longlong; + fn get_size(&mut self) -> core::ffi::c_longlong; } pub trait VtkArraySort { - fn get_dimensions(&mut self) -> core::ffi::c_uchar; - fn set_dimensions(&mut self, dimensions: core::ffi::c_uchar) -> (); + fn get_dimensions(&mut self) -> core::ffi::c_longlong; + fn set_dimensions(&mut self, dimensions: core::ffi::c_longlong) -> (); } pub trait VtkArrayWeights { - fn get_count(&mut self) -> core::ffi::c_uchar; - fn set_count(&mut self, count: core::ffi::c_uchar) -> (); + fn get_count(&mut self) -> core::ffi::c_longlong; + fn set_count(&mut self, count: core::ffi::c_longlong) -> (); } -pub trait VtkBitArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { +pub trait VtkBitArray { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; fn initialize(&mut self) -> (); fn get_data_type(&mut self) -> core::ffi::c_int; fn get_data_type_size(&mut self) -> core::ffi::c_int; - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; fn set_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> (); fn insert_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> (); fn insert_next_tuple( &mut self, - j: core::ffi::c_uchar, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn get_tuple(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> (); - fn set_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_float) -> (); - fn set_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> (); - fn insert_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_float) -> (); - fn insert_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> (); - fn insert_next_tuple(&mut self, tuple: core::ffi::c_float) -> core::ffi::c_uchar; - fn insert_next_tuple(&mut self, tuple: core::ffi::c_double) -> core::ffi::c_uchar; - fn remove_tuple(&mut self, id: core::ffi::c_uchar) -> (); + ) -> core::ffi::c_longlong; + fn remove_tuple(&mut self, id: core::ffi::c_longlong) -> (); fn set_component( &mut self, - i: core::ffi::c_uchar, + i: core::ffi::c_longlong, j: core::ffi::c_int, c: core::ffi::c_double, ) -> (); fn squeeze(&mut self) -> (); - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> (); - fn insert_value(&mut self, id: core::ffi::c_uchar, i: core::ffi::c_int) -> (); - fn set_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_next_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_uchar; + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> (); + fn insert_value(&mut self, id: core::ffi::c_longlong, i: core::ffi::c_int) -> (); + fn insert_next_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_longlong; fn insert_component( &mut self, - i: core::ffi::c_uchar, + i: core::ffi::c_longlong, j: core::ffi::c_int, c: core::ffi::c_double, ) -> (); - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - fn write_void_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut (); - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); - fn set_void_array( - &mut self, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); fn new_iterator(&mut self) -> *mut core::ffi::c_void; - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> (); - fn lookup_value(&mut self, value: core::ffi::c_int) -> core::ffi::c_uchar; - fn lookup_value( - &mut self, - value: core::ffi::c_int, - ids: *mut core::ffi::c_void, - ) -> (); fn data_changed(&mut self) -> (); fn clear_lookup(&mut self) -> (); } -pub trait VtkBitArrayIterator: VtkArrayIterator + VtkObject + VtkObjectBase { +pub trait VtkBitArrayIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn initialize(&mut self, array: *mut core::ffi::c_void) -> (); fn get_array(&mut self) -> *mut core::ffi::c_void; - fn get_tuple(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_int; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int; - fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar; - fn get_number_of_values(&mut self) -> core::ffi::c_uchar; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong; + fn get_number_of_values(&mut self) -> core::ffi::c_longlong; fn get_number_of_components(&mut self) -> core::ffi::c_int; fn get_data_type(&mut self) -> core::ffi::c_int; fn get_data_type_size(&mut self) -> core::ffi::c_int; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> (); + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> (); } -pub trait VtkBoxMuellerRandomSequence: VtkGaussianRandomSequence + VtkRandomSequence + VtkObject + VtkObjectBase { +pub trait VtkBoxMuellerRandomSequence { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -560,13 +297,12 @@ pub trait VtkBoxMuellerRandomSequence: VtkGaussianRandomSequence + VtkRandomSequ pub trait VtkBreakPoint { fn break_(&mut self) -> (); } -pub trait VtkBuffer: VtkObject + VtkObjectBase { +pub trait VtkBuffer { fn get_buffer(&mut self) -> *mut core::ffi::c_void; - fn get_buffer(&mut self) -> *const ScalarTypeT; fn set_buffer( &mut self, array: *mut core::ffi::c_void, - size: core::ffi::c_uchar, + size: core::ffi::c_longlong, ) -> (); fn set_malloc_function(&mut self, mallocFunction: *mut core::ffi::c_void) -> (); fn set_realloc_function(&mut self, reallocFunction: *mut core::ffi::c_void) -> (); @@ -575,92 +311,19 @@ pub trait VtkBuffer: VtkObject + VtkObjectBase { noFreeFunction: bool, deleteFunction: *mut core::ffi::c_void, ) -> (); - fn get_size(&mut self) -> core::ffi::c_uchar; - fn allocate(&mut self, size: core::ffi::c_uchar) -> bool; - fn reallocate(&mut self, newsize: core::ffi::c_uchar) -> bool; + fn get_size(&mut self) -> core::ffi::c_longlong; + fn allocate(&mut self, size: core::ffi::c_longlong) -> bool; + fn reallocate(&mut self, newsize: core::ffi::c_longlong) -> bool; } -pub trait VtkByteSwap: VtkObject + VtkObjectBase { +pub trait VtkByteSwap { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn swap_le(&mut self, p: core::ffi::c_float) -> (); - fn swap_be(&mut self, p: core::ffi::c_float) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_float, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_float, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_double) -> (); - fn swap_be(&mut self, p: core::ffi::c_double) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_double, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_double, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_char) -> (); - fn swap_be(&mut self, p: core::ffi::c_char) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_char, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_char, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_short) -> (); - fn swap_be(&mut self, p: core::ffi::c_short) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_short, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_short, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_int) -> (); - fn swap_be(&mut self, p: core::ffi::c_int) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_int, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_int, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_long) -> (); - fn swap_be(&mut self, p: core::ffi::c_long) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_long, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_long, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_uchar) -> (); - fn swap_be(&mut self, p: core::ffi::c_uchar) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_uchar, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_uchar, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_char) -> (); - fn swap_be(&mut self, p: core::ffi::c_char) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_char, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_char, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_uchar) -> (); - fn swap_be(&mut self, p: core::ffi::c_uchar) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_uchar, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_uchar, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_ushort) -> (); - fn swap_be(&mut self, p: core::ffi::c_ushort) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_ushort, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_ushort, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_uint) -> (); - fn swap_be(&mut self, p: core::ffi::c_uint) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_uint, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_uint, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_ulong) -> (); - fn swap_be(&mut self, p: core::ffi::c_ulong) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_ulong, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_ulong, num: usize) -> (); - fn swap_le(&mut self, p: core::ffi::c_ulonglong) -> (); - fn swap_be(&mut self, p: core::ffi::c_ulonglong) -> (); - fn swap_le_range(&mut self, p: core::ffi::c_ulonglong, num: usize) -> (); - fn swap_be_range(&mut self, p: core::ffi::c_ulonglong, num: usize) -> (); - fn swap_2_le(&mut self, p: ()) -> (); - fn swap_4_le(&mut self, p: ()) -> (); - fn swap_8_le(&mut self, p: ()) -> (); - fn swap_2_le_range(&mut self, p: (), num: usize) -> (); - fn swap_4_le_range(&mut self, p: (), num: usize) -> (); - fn swap_8_le_range(&mut self, p: (), num: usize) -> (); - fn swap_2_be(&mut self, p: ()) -> (); - fn swap_4_be(&mut self, p: ()) -> (); - fn swap_8_be(&mut self, p: ()) -> (); - fn swap_2_be_range(&mut self, p: (), num: usize) -> (); - fn swap_4_be_range(&mut self, p: (), num: usize) -> (); - fn swap_8_be_range(&mut self, p: (), num: usize) -> (); - fn swap_void_range(&mut self, buffer: (), numWords: usize, wordSize: usize) -> (); -} -pub trait VtkCallbackCommand: VtkCommand + VtkObjectBase { +} +pub trait VtkCallbackCommand { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn execute( - &mut self, - caller: *mut core::ffi::c_void, - eid: core::ffi::c_ulong, - callData: (), - ) -> (); - fn set_client_data(&mut self, cd: ()) -> (); - fn get_client_data(&mut self) -> *mut (); fn set_callback(&mut self, f: *mut core::ffi::c_void) -> (); fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> (); fn set_abort_flag_on_execute(&mut self, f: core::ffi::c_int) -> (); @@ -668,57 +331,28 @@ pub trait VtkCallbackCommand: VtkCommand + VtkObjectBase { fn abort_flag_on_execute_on(&mut self) -> (); fn abort_flag_on_execute_off(&mut self) -> (); } -pub trait VtkCharArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { +pub trait VtkCharArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_char) -> (); - fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_char) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_char, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_char; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_char) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_char; - fn get_value_range(&mut self) -> *mut core::ffi::c_char; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_char; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_char; - fn set_array( - &mut self, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array( - &mut self, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); + fn set_typed_tuple(&mut self, i: core::ffi::c_longlong, tuple: &str) -> (); + fn insert_typed_tuple(&mut self, i: core::ffi::c_longlong, tuple: &str) -> (); + fn insert_next_typed_tuple(&mut self, tuple: &str) -> core::ffi::c_longlong; + fn get_value(&mut self, id: core::ffi::c_longlong) -> &str; + fn set_value(&mut self, id: core::ffi::c_longlong, value: &str) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: &str) -> (); + fn insert_next_value(&mut self, f: &str) -> core::ffi::c_longlong; fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_char; - fn get_data_type_value_max(&mut self) -> core::ffi::c_char; + fn get_data_type_value_min(&mut self) -> &str; + fn get_data_type_value_max(&mut self) -> &str; } -pub trait VtkCollection: VtkObject + VtkObjectBase { +pub trait VtkCollection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -726,19 +360,16 @@ pub trait VtkCollection: VtkObject + VtkObjectBase { fn insert_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn remove_item(&mut self, i: core::ffi::c_int) -> (); - fn remove_item(&mut self, p0: *mut core::ffi::c_void) -> (); fn remove_all_items(&mut self) -> (); fn is_item_present(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int; fn get_number_of_items(&mut self) -> core::ffi::c_int; fn init_traversal(&mut self) -> (); - fn init_traversal(&mut self, cookie: ()) -> (); fn get_next_item_as_object(&mut self) -> *mut core::ffi::c_void; fn get_item_as_object(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_next_item_as_object(&mut self, cookie: ()) -> *mut core::ffi::c_void; fn new_iterator(&mut self) -> *mut core::ffi::c_void; fn register(&mut self, o: *mut core::ffi::c_void) -> (); } -pub trait VtkCollectionIterator: VtkObject + VtkObjectBase { +pub trait VtkCollectionIterator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -750,35 +381,22 @@ pub trait VtkCollectionIterator: VtkObject + VtkObjectBase { fn is_done_with_traversal(&mut self) -> core::ffi::c_int; fn get_current_object(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkCommand: VtkObjectBase { - fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; - fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; +pub trait VtkCommand { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int; + fn is_a(&mut self, type_: &str) -> core::ffi::c_int; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_number_of_generations_from_base_type( &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; + type_: &str, + ) -> core::ffi::c_longlong; fn get_number_of_generations_from_base( &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; + type_: &str, + ) -> core::ffi::c_longlong; fn un_register(&mut self) -> (); - fn un_register(&mut self, p0: *mut core::ffi::c_void) -> (); - fn execute( - &mut self, - caller: *mut core::ffi::c_void, - eventId: core::ffi::c_ulong, - callData: (), - ) -> (); - fn get_string_from_event_id( - &mut self, - event: core::ffi::c_ulong, - ) -> *const core::ffi::c_char; - fn get_event_id_from_string( - &mut self, - event: core::ffi::c_char, - ) -> core::ffi::c_ulong; + fn get_string_from_event_id(&mut self, event: core::ffi::c_ulong) -> &str; + fn get_event_id_from_string(&mut self, event: &str) -> core::ffi::c_ulong; fn event_has_data(&mut self, event: core::ffi::c_ulong) -> bool; fn set_abort_flag(&mut self, f: core::ffi::c_int) -> (); fn get_abort_flag(&mut self) -> core::ffi::c_int; @@ -792,7 +410,7 @@ pub trait VtkCommand: VtkObjectBase { pub trait VtkCommonInformationKeyManager { fn register(&mut self, key: *mut core::ffi::c_void) -> (); } -pub trait VtkConditionVariable: VtkObject + VtkObjectBase { +pub trait VtkConditionVariable { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -800,14 +418,14 @@ pub trait VtkConditionVariable: VtkObject + VtkObjectBase { fn broadcast(&mut self) -> (); fn wait(&mut self, mutex: *mut core::ffi::c_void) -> core::ffi::c_int; } -pub trait VtkCriticalSection: VtkObject + VtkObjectBase { +pub trait VtkCriticalSection { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn lock(&mut self) -> (); fn unlock(&mut self) -> (); } -pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { +pub trait VtkDataArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn fast_down_cast( @@ -818,93 +436,49 @@ pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { fn get_element_component_size(&mut self) -> core::ffi::c_int; fn insert_tuple( &mut self, - dstTupleIdx: core::ffi::c_uchar, - srcTupleIdx: core::ffi::c_uchar, + dstTupleIdx: core::ffi::c_longlong, + srcTupleIdx: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> (); fn insert_next_tuple( &mut self, - srcTupleIdx: core::ffi::c_uchar, + srcTupleIdx: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn insert_tuples( &mut self, dstIds: *mut core::ffi::c_void, srcIds: *mut core::ffi::c_void, source: *mut core::ffi::c_void, ) -> (); - fn insert_tuples( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn interpolate_tuple( - &mut self, - dstTupleIdx: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_tuple( - &mut self, - dstTupleIdx: core::ffi::c_uchar, - srcTupleIdx1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - srcTupleIdx2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ) -> (); - fn get_tuple(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ) -> (); - fn get_tuple_1(&mut self, tupleIdx: core::ffi::c_uchar) -> core::ffi::c_double; - fn get_tuple_2(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_tuple_3(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_tuple_4(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_tuple_6(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_tuple_9(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_tuple_1(&mut self, tupleIdx: core::ffi::c_longlong) -> core::ffi::c_double; fn set_tuple( &mut self, - dstTupleIdx: core::ffi::c_uchar, - srcTupleIdx: core::ffi::c_uchar, + dstTupleIdx: core::ffi::c_longlong, + srcTupleIdx: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> (); - fn set_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ) -> (); - fn set_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ) -> (); fn set_tuple_1( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, value: core::ffi::c_double, ) -> (); fn set_tuple_2( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, val0: core::ffi::c_double, val1: core::ffi::c_double, ) -> (); fn set_tuple_3( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, val0: core::ffi::c_double, val1: core::ffi::c_double, val2: core::ffi::c_double, ) -> (); fn set_tuple_4( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, val0: core::ffi::c_double, val1: core::ffi::c_double, val2: core::ffi::c_double, @@ -912,7 +486,7 @@ pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { ) -> (); fn set_tuple_6( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, val0: core::ffi::c_double, val1: core::ffi::c_double, val2: core::ffi::c_double, @@ -922,7 +496,7 @@ pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { ) -> (); fn set_tuple_9( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, val0: core::ffi::c_double, val1: core::ffi::c_double, val2: core::ffi::c_double, @@ -933,37 +507,27 @@ pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { val7: core::ffi::c_double, val8: core::ffi::c_double, ) -> (); - fn insert_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ) -> (); - fn insert_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ) -> (); fn insert_tuple_1( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, value: core::ffi::c_double, ) -> (); fn insert_tuple_2( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, val0: core::ffi::c_double, val1: core::ffi::c_double, ) -> (); fn insert_tuple_3( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, val0: core::ffi::c_double, val1: core::ffi::c_double, val2: core::ffi::c_double, ) -> (); fn insert_tuple_4( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, val0: core::ffi::c_double, val1: core::ffi::c_double, val2: core::ffi::c_double, @@ -971,7 +535,7 @@ pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { ) -> (); fn insert_tuple_6( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, val0: core::ffi::c_double, val1: core::ffi::c_double, val2: core::ffi::c_double, @@ -981,7 +545,7 @@ pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { ) -> (); fn insert_tuple_9( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, val0: core::ffi::c_double, val1: core::ffi::c_double, val2: core::ffi::c_double, @@ -992,8 +556,6 @@ pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { val7: core::ffi::c_double, val8: core::ffi::c_double, ) -> (); - fn insert_next_tuple(&mut self, tuple: core::ffi::c_float) -> core::ffi::c_uchar; - fn insert_next_tuple(&mut self, tuple: core::ffi::c_double) -> core::ffi::c_uchar; fn insert_next_tuple_1(&mut self, value: core::ffi::c_double) -> (); fn insert_next_tuple_2( &mut self, @@ -1034,36 +596,35 @@ pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { val7: core::ffi::c_double, val8: core::ffi::c_double, ) -> (); - fn remove_tuple(&mut self, tupleIdx: core::ffi::c_uchar) -> (); + fn remove_tuple(&mut self, tupleIdx: core::ffi::c_longlong) -> (); fn remove_first_tuple(&mut self) -> (); fn remove_last_tuple(&mut self) -> (); fn get_component( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, compIdx: core::ffi::c_int, ) -> core::ffi::c_double; fn set_component( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, compIdx: core::ffi::c_int, value: core::ffi::c_double, ) -> (); fn insert_component( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, compIdx: core::ffi::c_int, value: core::ffi::c_double, ) -> (); fn get_data( &mut self, - tupleMin: core::ffi::c_uchar, - tupleMax: core::ffi::c_uchar, + tupleMin: core::ffi::c_longlong, + tupleMax: core::ffi::c_longlong, compMin: core::ffi::c_int, compMax: core::ffi::c_int, data: *mut core::ffi::c_void, ) -> (); fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); - fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); fn fill_component( &mut self, @@ -1077,37 +638,12 @@ pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { src: *mut core::ffi::c_void, srcComponent: core::ffi::c_int, ) -> (); - fn write_void_pointer( - &mut self, - valueIdx: core::ffi::c_uchar, - numValues: core::ffi::c_uchar, - ) -> *mut (); fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; fn create_default_lookup_table(&mut self) -> (); fn set_lookup_table(&mut self, lut: *mut core::ffi::c_void) -> (); fn get_lookup_table(&mut self) -> *mut core::ffi::c_void; - fn get_range(&mut self, range: core::ffi::c_double, comp: core::ffi::c_int) -> (); - fn get_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_double; - fn get_range(&mut self) -> *mut core::ffi::c_double; - fn get_range(&mut self, range: core::ffi::c_double) -> (); - fn get_finite_range( - &mut self, - range: core::ffi::c_double, - comp: core::ffi::c_int, - ) -> (); - fn get_finite_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_double; - fn get_finite_range(&mut self) -> *mut core::ffi::c_double; - fn get_finite_range(&mut self, range: core::ffi::c_double) -> (); - fn get_data_type_range(&mut self, range: core::ffi::c_double) -> (); fn get_data_type_min(&mut self) -> core::ffi::c_double; fn get_data_type_max(&mut self) -> core::ffi::c_double; - fn get_data_type_range( - &mut self, - type_: core::ffi::c_int, - range: core::ffi::c_double, - ) -> (); - fn get_data_type_min(&mut self, type_: core::ffi::c_int) -> core::ffi::c_double; - fn get_data_type_max(&mut self, type_: core::ffi::c_int) -> core::ffi::c_double; fn get_max_norm(&mut self) -> core::ffi::c_double; fn create_data_array( &mut self, @@ -1125,75 +661,54 @@ pub trait VtkDataArray: VtkAbstractArray + VtkObject + VtkObjectBase { ) -> core::ffi::c_int; fn get_array_type(&mut self) -> core::ffi::c_int; } -pub trait VtkDataArrayCollection: VtkCollection + VtkObject + VtkObjectBase { +pub trait VtkDataArrayCollection { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); fn get_next_item(&mut self) -> *mut core::ffi::c_void; fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_next_data_array(&mut self, cookie: ()) -> *mut core::ffi::c_void; fn get_number_of_items(&mut self) -> core::ffi::c_int; } -pub trait VtkDataArrayCollectionIterator: VtkCollectionIterator + VtkObject + VtkObjectBase { +pub trait VtkDataArrayCollectionIterator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_data_array(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkDataArraySelection: VtkObject + VtkObjectBase { +pub trait VtkDataArraySelection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn enable_array(&mut self, name: core::ffi::c_char) -> (); - fn disable_array(&mut self, name: core::ffi::c_char) -> (); - fn array_is_enabled(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; - fn array_exists(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn enable_array(&mut self, name: &str) -> (); + fn disable_array(&mut self, name: &str) -> (); + fn array_is_enabled(&mut self, name: &str) -> core::ffi::c_int; + fn array_exists(&mut self, name: &str) -> core::ffi::c_int; fn enable_all_arrays(&mut self) -> (); fn disable_all_arrays(&mut self) -> (); fn get_number_of_arrays(&mut self) -> core::ffi::c_int; fn get_number_of_arrays_enabled(&mut self) -> core::ffi::c_int; - fn get_array_name(&mut self, index: core::ffi::c_int) -> *const core::ffi::c_char; - fn get_array_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; - fn get_enabled_array_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn get_array_name(&mut self, index: core::ffi::c_int) -> &str; + fn get_array_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_enabled_array_index(&mut self, name: &str) -> core::ffi::c_int; fn get_array_setting(&mut self, index: core::ffi::c_int) -> core::ffi::c_int; - fn get_array_setting(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; - fn set_array_setting( - &mut self, - name: core::ffi::c_char, - setting: core::ffi::c_int, - ) -> (); + fn set_array_setting(&mut self, name: &str, setting: core::ffi::c_int) -> (); fn remove_all_arrays(&mut self) -> (); - fn add_array(&mut self, name: core::ffi::c_char, state: bool) -> core::ffi::c_int; + fn add_array(&mut self, name: &str, state: bool) -> core::ffi::c_int; fn remove_array_by_index(&mut self, index: core::ffi::c_int) -> (); - fn remove_array_by_name(&mut self, name: core::ffi::c_char) -> (); - fn set_arrays( - &mut self, - names: core::ffi::c_char, - numArrays: core::ffi::c_int, - ) -> (); - fn set_arrays_with_default( - &mut self, - names: core::ffi::c_char, - numArrays: core::ffi::c_int, - defaultStatus: core::ffi::c_int, - ) -> (); + fn remove_array_by_name(&mut self, name: &str) -> (); fn copy_selections(&mut self, selections: *mut core::ffi::c_void) -> (); fn union(&mut self, other: *mut core::ffi::c_void) -> (); - fn union(&mut self, other: *mut core::ffi::c_void, skipModified: bool) -> (); fn set_unknown_array_setting(&mut self, _arg: core::ffi::c_int) -> (); fn get_unknown_array_setting(&mut self) -> core::ffi::c_int; } -pub trait VtkDebugLeaks: VtkObject + VtkObjectBase { +pub trait VtkDebugLeaks { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn construct_class(&mut self, object: *mut core::ffi::c_void) -> (); - fn construct_class(&mut self, className: core::ffi::c_char) -> (); fn destruct_class(&mut self, object: *mut core::ffi::c_void) -> (); - fn destruct_class(&mut self, className: core::ffi::c_char) -> (); fn print_current_leaks(&mut self) -> core::ffi::c_int; fn get_exit_error(&mut self) -> core::ffi::c_int; fn set_exit_error(&mut self, p0: core::ffi::c_int) -> (); @@ -1204,102 +719,22 @@ pub trait VtkDebugLeaksObserver { fn constructing_object(&mut self, p0: *mut core::ffi::c_void) -> (); fn destructing_object(&mut self, p0: *mut core::ffi::c_void) -> (); } -pub trait VtkDenseArray: VtkTypedArray + VtkArray + VtkObject + VtkObjectBase { +pub trait VtkDenseArray { fn is_dense(&mut self) -> bool; - fn get_extents(&mut self) -> vtkArrayExtents; fn get_non_null_size(&mut self) -> core::ffi::c_ulonglong; - fn get_coordinates_n( - &mut self, - n: core::ffi::c_ulonglong, - coordinates: *mut core::ffi::c_void, - ) -> (); fn deep_copy(&mut self) -> *mut core::ffi::c_void; - fn get_value(&mut self, i: core::ffi::c_uchar) -> T; - fn get_value(&mut self, i: core::ffi::c_uchar, j: core::ffi::c_uchar) -> T; - fn get_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - k: core::ffi::c_uchar, - ) -> T; - fn get_value(&mut self, coordinates: vtkArrayCoordinates) -> T; - fn get_value_n(&mut self, n: core::ffi::c_ulonglong) -> T; - fn set_value(&mut self, i: core::ffi::c_uchar, value: T) -> (); - fn set_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - value: T, - ) -> (); - fn set_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - k: core::ffi::c_uchar, - value: T, - ) -> (); - fn set_value(&mut self, coordinates: vtkArrayCoordinates, value: T) -> (); - fn set_value_n(&mut self, n: core::ffi::c_ulonglong, value: T) -> (); - fn external_storage( - &mut self, - extents: vtkArrayExtents, - storage: *mut core::ffi::c_void, - ) -> (); - fn fill(&mut self, value: T) -> (); - fn get_storage(&mut self) -> *const T; - fn get_storage(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkDoubleArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { +pub trait VtkDoubleArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ) -> (); - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_double) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_double) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_double) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_double; - fn get_value_range(&mut self) -> *mut core::ffi::c_double; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn set_array( - &mut self, - array: core::ffi::c_double, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array( - &mut self, - array: core::ffi::c_double, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_double) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_double) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_double) -> core::ffi::c_longlong; fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, @@ -1307,98 +742,59 @@ pub trait VtkDoubleArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjec fn get_data_type_value_min(&mut self) -> core::ffi::c_double; fn get_data_type_value_max(&mut self) -> core::ffi::c_double; } -pub trait VtkDynamicLoader: VtkObject + VtkObjectBase { +pub trait VtkDynamicLoader { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn open_library(&mut self, p0: core::ffi::c_char) -> *mut core::ffi::c_void; - fn open_library( - &mut self, - p0: core::ffi::c_char, - p1: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn close_library(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int; - fn get_symbol_address( - &mut self, - p0: *mut core::ffi::c_void, - p1: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn lib_prefix(&mut self) -> *const core::ffi::c_char; - fn lib_extension(&mut self) -> *const core::ffi::c_char; - fn last_error(&mut self) -> *const core::ffi::c_char; + fn lib_prefix(&mut self) -> &str; + fn lib_extension(&mut self) -> &str; + fn last_error(&mut self) -> &str; } -pub trait VtkEventData: VtkObjectBase { - fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; - fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; +pub trait VtkEventData { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int; + fn is_a(&mut self, type_: &str) -> core::ffi::c_int; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_number_of_generations_from_base_type( &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; + type_: &str, + ) -> core::ffi::c_longlong; fn get_number_of_generations_from_base( &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; + type_: &str, + ) -> core::ffi::c_longlong; fn get_type(&mut self) -> core::ffi::c_int; fn set_type(&mut self, val: core::ffi::c_int) -> (); fn get_as_event_data_for_device(&mut self) -> *mut core::ffi::c_void; fn get_as_event_data_device_3_d(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkEventDataDevice3D: VtkEventDataForDevice + VtkEventData + VtkObjectBase { +pub trait VtkEventDataDevice3D { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn get_world_position(&mut self, v: core::ffi::c_double) -> (); - fn get_world_position(&mut self) -> *const core::ffi::c_double; - fn set_world_position(&mut self, p: core::ffi::c_double) -> (); - fn get_world_direction(&mut self, v: core::ffi::c_double) -> (); - fn get_world_direction(&mut self) -> *const core::ffi::c_double; - fn set_world_direction(&mut self, p: core::ffi::c_double) -> (); - fn get_world_orientation(&mut self, v: core::ffi::c_double) -> (); - fn get_world_orientation(&mut self) -> *const core::ffi::c_double; - fn set_world_orientation(&mut self, p: core::ffi::c_double) -> (); - fn get_track_pad_position(&mut self, v: core::ffi::c_double) -> (); - fn get_track_pad_position(&mut self) -> *const core::ffi::c_double; - fn set_track_pad_position(&mut self, p: core::ffi::c_double) -> (); fn set_track_pad_position( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, ) -> (); } -pub trait VtkEventDataForDevice: VtkEventData + VtkObjectBase { +pub trait VtkEventDataForDevice { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn get_device(&mut self) -> *mut core::ffi::c_void; - fn get_input(&mut self) -> *mut core::ffi::c_void; - fn get_action(&mut self) -> *mut core::ffi::c_void; - fn set_device(&mut self, v: *mut core::ffi::c_void) -> (); - fn set_input(&mut self, v: *mut core::ffi::c_void) -> (); - fn set_action(&mut self, v: *mut core::ffi::c_void) -> (); - fn device_matches(&mut self, val: *mut core::ffi::c_void) -> bool; -} -pub trait VtkEventForwarderCommand: VtkCommand + VtkObjectBase { +} +pub trait VtkEventForwarderCommand { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn execute( - &mut self, - caller: *mut core::ffi::c_void, - eid: core::ffi::c_ulong, - callData: (), - ) -> (); fn set_target(&mut self, obj: *mut core::ffi::c_void) -> (); - fn get_target(&mut self) -> *mut (); } -pub trait VtkFileOutputWindow: VtkOutputWindow + VtkObject + VtkObjectBase { +pub trait VtkFileOutputWindow { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn display_text(&mut self, p0: core::ffi::c_char) -> (); - fn set_file_name(&mut self, _arg: core::ffi::c_char) -> (); - fn get_file_name(&mut self) -> *mut core::ffi::c_char; + fn display_text(&mut self, p0: &str) -> (); + fn set_file_name(&mut self, _arg: &str) -> (); fn set_flush(&mut self, _arg: core::ffi::c_int) -> (); fn get_flush(&mut self) -> core::ffi::c_int; fn flush_on(&mut self) -> (); @@ -1408,57 +804,17 @@ pub trait VtkFileOutputWindow: VtkOutputWindow + VtkObject + VtkObjectBase { fn append_on(&mut self) -> (); fn append_off(&mut self) -> (); } -pub trait VtkFloatArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { +pub trait VtkFloatArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ) -> (); - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_float, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_float; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_float) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_float) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_float) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_float; - fn get_value_range(&mut self) -> *mut core::ffi::c_float; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_float; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_float; - fn set_array( - &mut self, - array: core::ffi::c_float, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array( - &mut self, - array: core::ffi::c_float, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_float; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_float) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_float) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_float) -> core::ffi::c_longlong; fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, @@ -1470,18 +826,17 @@ pub trait VtkFloatingPointExceptions { fn enable(&mut self) -> (); fn disable(&mut self) -> (); } -pub trait VtkGarbageCollector: VtkObject + VtkObjectBase { +pub trait VtkGarbageCollector { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn collect(&mut self) -> (); - fn collect(&mut self, root: *mut core::ffi::c_void) -> (); fn deferred_collection_push(&mut self) -> (); fn deferred_collection_pop(&mut self) -> (); fn set_global_debug_flag(&mut self, flag: bool) -> (); fn get_global_debug_flag(&mut self) -> bool; } -pub trait VtkGaussianRandomSequence: VtkRandomSequence + VtkObject + VtkObjectBase { +pub trait VtkGaussianRandomSequence { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_scaled_value( @@ -1495,285 +850,124 @@ pub trait VtkGaussianRandomSequence: VtkRandomSequence + VtkObject + VtkObjectBa standardDeviation: core::ffi::c_double, ) -> core::ffi::c_double; } -pub trait VtkGenericDataArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn get_value(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_value( - &mut self, - valueIdx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); +pub trait VtkGenericDataArray { fn get_typed_tuple( &mut self, - tupleIdx: core::ffi::c_uchar, + tupleIdx: core::ffi::c_longlong, tuple: *mut core::ffi::c_void, ) -> (); - fn set_typed_tuple(&mut self, tupleIdx: core::ffi::c_uchar, tuple: ValueTypeT) -> (); - fn get_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - compIdx: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn set_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - compIdx: core::ffi::c_int, - value: *mut core::ffi::c_void, - ) -> (); - fn get_void_pointer(&mut self, valueIdx: core::ffi::c_uchar) -> *mut (); - fn get_pointer(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_void_array( - &mut self, - p0: (), - p1: core::ffi::c_uchar, - p2: core::ffi::c_int, - ) -> (); - fn set_void_array( - &mut self, - p0: (), - p1: core::ffi::c_uchar, - p2: core::ffi::c_int, - p3: core::ffi::c_int, - ) -> (); + fn get_pointer(&mut self, valueIdx: core::ffi::c_longlong) -> *mut core::ffi::c_void; fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); - fn write_void_pointer( - &mut self, - valueIdx: core::ffi::c_uchar, - numValues: core::ffi::c_uchar, - ) -> *mut (); fn write_pointer( &mut self, - valueIdx: core::ffi::c_uchar, - numValues: core::ffi::c_uchar, + valueIdx: core::ffi::c_longlong, + numValues: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; - fn remove_tuple(&mut self, tupleIdx: core::ffi::c_uchar) -> (); - fn insert_next_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn insert_value( - &mut self, - valueIdx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_typed_tuple(&mut self, tupleIdx: core::ffi::c_uchar, t: ValueTypeT) -> (); - fn insert_next_typed_tuple(&mut self, t: ValueTypeT) -> core::ffi::c_uchar; - fn insert_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - compIdx: core::ffi::c_int, - val: *mut core::ffi::c_void, - ) -> (); - fn get_value_range( - &mut self, - range: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> (); + fn remove_tuple(&mut self, tupleIdx: core::ffi::c_longlong) -> (); fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_value_range(&mut self) -> *mut core::ffi::c_void; - fn get_value_range(&mut self, range: *mut core::ffi::c_void) -> (); - fn get_finite_value_range( - &mut self, - range: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> (); fn get_finite_value_range( &mut self, comp: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get_finite_value_range(&mut self) -> *mut core::ffi::c_void; - fn get_finite_value_range(&mut self, range: *mut core::ffi::c_void) -> (); - fn capacity(&mut self) -> core::ffi::c_uchar; - fn fill_typed_component( + fn capacity(&mut self) -> core::ffi::c_longlong; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn allocate( &mut self, - compIdx: core::ffi::c_int, - value: *mut core::ffi::c_void, - ) -> (); - fn fill_value(&mut self, value: *mut core::ffi::c_void) -> (); - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_data_type_size(&mut self) -> core::ffi::c_int; - fn allocate( - &mut self, - size: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + size: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; fn set_number_of_components(&mut self, num: core::ffi::c_int) -> (); - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); fn initialize(&mut self) -> (); fn squeeze(&mut self) -> (); - fn insert_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - source: core::ffi::c_float, - ) -> (); - fn insert_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - source: core::ffi::c_double, - ) -> (); - fn insert_next_tuple(&mut self, tuple: core::ffi::c_float) -> core::ffi::c_uchar; - fn insert_next_tuple(&mut self, tuple: core::ffi::c_double) -> core::ffi::c_uchar; - fn get_tuple(&mut self, tupleIdx: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ) -> (); - fn set_variant_value( - &mut self, - valueIdx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_variant_value( - &mut self, - valueIdx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn lookup_typed_value( - &mut self, - value: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - valueIds: *mut core::ffi::c_void, - ) -> (); - fn lookup_typed_value( - &mut self, - value: *mut core::ffi::c_void, - valueIds: *mut core::ffi::c_void, - ) -> (); fn clear_lookup(&mut self) -> (); fn data_changed(&mut self) -> (); fn new_iterator(&mut self) -> *mut core::ffi::c_void; } pub trait VtkGenericDataArrayLookupHelper { fn set_array(&mut self, array: *mut core::ffi::c_void) -> (); - fn lookup_value(&mut self, elem: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn lookup_value( - &mut self, - elem: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> (); fn clear_lookup(&mut self) -> (); } -pub trait VtkIdList: VtkObject + VtkObjectBase { +pub trait VtkIdList { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn initialize(&mut self) -> (); fn allocate( &mut self, - sz: core::ffi::c_uchar, + sz: core::ffi::c_longlong, strategy: core::ffi::c_int, ) -> core::ffi::c_int; - fn get_number_of_ids(&mut self) -> core::ffi::c_uchar; - fn get_id(&mut self, i: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn find_id_location(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn set_number_of_ids(&mut self, number: core::ffi::c_uchar) -> (); - fn set_id(&mut self, i: core::ffi::c_uchar, vtkid: core::ffi::c_uchar) -> (); - fn insert_id(&mut self, i: core::ffi::c_uchar, vtkid: core::ffi::c_uchar) -> (); - fn insert_next_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn insert_unique_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn sort(&mut self) -> (); - fn fill(&mut self, value: core::ffi::c_uchar) -> (); - fn get_pointer(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn write_pointer( + fn get_number_of_ids(&mut self) -> core::ffi::c_longlong; + fn get_id(&mut self, i: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn find_id_location(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn set_number_of_ids(&mut self, number: core::ffi::c_longlong) -> (); + fn set_id(&mut self, i: core::ffi::c_longlong, vtkid: core::ffi::c_longlong) -> (); + fn insert_id( + &mut self, + i: core::ffi::c_longlong, + vtkid: core::ffi::c_longlong, + ) -> (); + fn insert_next_id(&mut self, vtkid: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn insert_unique_id( &mut self, - i: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - fn set_array(&mut self, array: core::ffi::c_uchar, size: core::ffi::c_uchar) -> (); + vtkid: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn sort(&mut self) -> (); + fn fill(&mut self, value: core::ffi::c_longlong) -> (); fn reset(&mut self) -> (); fn squeeze(&mut self) -> (); fn deep_copy(&mut self, ids: *mut core::ffi::c_void) -> (); - fn delete_id(&mut self, vtkid: core::ffi::c_uchar) -> (); - fn is_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn delete_id(&mut self, vtkid: core::ffi::c_longlong) -> (); + fn is_id(&mut self, vtkid: core::ffi::c_longlong) -> core::ffi::c_longlong; fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> (); - fn resize(&mut self, sz: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> (); - fn begin(&mut self) -> *mut core::ffi::c_uchar; - fn end(&mut self) -> *mut core::ffi::c_uchar; - fn begin(&mut self) -> *const core::ffi::c_uchar; - fn end(&mut self) -> *const core::ffi::c_uchar; } -pub trait VtkIdListCollection: VtkCollection + VtkObject + VtkObjectBase { +pub trait VtkIdListCollection { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); fn get_next_item(&mut self) -> *mut core::ffi::c_void; fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_next_id_list(&mut self, cookie: ()) -> *mut core::ffi::c_void; fn get_number_of_items(&mut self) -> core::ffi::c_int; } -pub trait VtkIdTypeArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { +pub trait VtkIdTypeArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> (); - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar; - fn get_value_range(&mut self) -> *mut core::ffi::c_uchar; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn set_array( + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn set_value( &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, ) -> (); - fn set_array( + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value( &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, ) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_longlong) -> core::ffi::c_longlong; fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar; - fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar; + fn get_data_type_value_min(&mut self) -> core::ffi::c_longlong; + fn get_data_type_value_max(&mut self) -> core::ffi::c_longlong; } pub trait VtkIndent { fn delete(&mut self) -> (); fn new(&mut self) -> *mut core::ffi::c_void; - fn get_next_indent(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkInformation: VtkObject + VtkObjectBase { +pub trait VtkInformation { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn modified(&mut self) -> (); - fn modified(&mut self, key: *mut core::ffi::c_void) -> (); fn clear(&mut self) -> (); fn get_number_of_keys(&mut self) -> core::ffi::c_int; fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> (); @@ -1784,14837 +978,5936 @@ pub trait VtkInformation: VtkObject + VtkObjectBase { key: *mut core::ffi::c_void, deep: core::ffi::c_int, ) -> (); - fn copy_entry( + fn copy_entries( &mut self, from: *mut core::ffi::c_void, key: *mut core::ffi::c_void, deep: core::ffi::c_int, ) -> (); - fn copy_entry( + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn set(&mut self, key: *mut core::ffi::c_void) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append_unique( &mut self, - from: *mut core::ffi::c_void, key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + value: *mut core::ffi::c_void, ) -> (); - fn copy_entry( + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn set_request(&mut self, request: *mut core::ffi::c_void) -> (); + fn get_request(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkInformationDataObjectKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn copy_entry( +} +pub trait VtkInformationDoubleKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_double) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_double; + fn shallow_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn copy_entry( +} +pub trait VtkInformationDoubleVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> (); - fn copy_entry( + name: &str, + location: &str, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn copy_entry( +} +pub trait VtkInformationIdTypeKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_longlong) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_longlong; + fn shallow_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn copy_entry( +} +pub trait VtkInformationInformationKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn copy_entry( + fn deep_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn copy_entry( +} +pub trait VtkInformationInformationVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn copy_entry( + fn deep_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn copy_entry( +} +pub trait VtkInformationIntegerKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_int) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn copy_entry( +} +pub trait VtkInformationIntegerPointerKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn copy_entries( +} +pub trait VtkInformationIntegerVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: &str, + location: &str, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( &mut self, from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, + to: *mut core::ffi::c_void, ) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn set(&mut self, key: *mut core::ffi::c_void) -> (); - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_uchar) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_double; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set(&mut self, key: *mut core::ffi::c_void, value: vtkVariant) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> vtkVariant; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); - fn set( +} +pub trait VtkInformationIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_information(&mut self) -> *mut core::ffi::c_void; + fn set_information_weak(&mut self, p0: *mut core::ffi::c_void) -> (); + fn init_traversal(&mut self) -> (); + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; + fn get_current_key(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkInformationKey { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int; + fn is_a(&mut self, type_: &str) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( &mut self, - key: *mut core::ffi::c_void, - value: core::ffi::c_int, - length: core::ffi::c_int, + type_: &str, + ) -> core::ffi::c_longlong; + fn get_number_of_generations_from_base( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn register(&mut self, p0: *mut core::ffi::c_void) -> (); + fn un_register(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_name(&mut self) -> &str; + fn get_location(&mut self) -> &str; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, ) -> (); - fn set( + fn deep_copy( &mut self, - key: *mut core::ffi::c_void, - value1: core::ffi::c_int, - value2: core::ffi::c_int, - value3: core::ffi::c_int, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, ) -> (); - fn set( + fn has(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, info: *mut core::ffi::c_void) -> (); + fn report( &mut self, - key: *mut core::ffi::c_void, - value1: core::ffi::c_int, - value2: core::ffi::c_int, - value3: core::ffi::c_int, - value4: core::ffi::c_int, - value5: core::ffi::c_int, - value6: core::ffi::c_int, + info: *mut core::ffi::c_void, + collector: *mut core::ffi::c_void, ) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_int; - fn get( + fn print(&mut self, info: *mut core::ffi::c_void) -> (); + fn need_to_execute( &mut self, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_char) -> (); - fn set( + pipelineInfo: *mut core::ffi::c_void, + dobjInfo: *mut core::ffi::c_void, + ) -> bool; + fn store_meta_data( &mut self, - key: *mut core::ffi::c_void, - value: core::ffi::c_char, - idx: core::ffi::c_int, + request: *mut core::ffi::c_void, + pipelineInfo: *mut core::ffi::c_void, + dobjInfo: *mut core::ffi::c_void, ) -> (); - fn append(&mut self, key: *mut core::ffi::c_void, value: &str) -> (); - fn set( + fn copy_default_information( &mut self, - key: *mut core::ffi::c_void, - value: &str, - idx: core::ffi::c_int, - ) -> (); - fn get( - &mut self, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> *const core::ffi::c_char; - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: core::ffi::c_int, - length: core::ffi::c_int, - ) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_int; - fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_ulong) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_ulong; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: core::ffi::c_double, - length: core::ffi::c_int, - ) -> (); - fn set( - &mut self, - key: *mut core::ffi::c_void, - value1: core::ffi::c_double, - value2: core::ffi::c_double, - value3: core::ffi::c_double, - ) -> (); - fn set( - &mut self, - key: *mut core::ffi::c_void, - value1: core::ffi::c_double, - value2: core::ffi::c_double, - value3: core::ffi::c_double, - value4: core::ffi::c_double, - value5: core::ffi::c_double, - value6: core::ffi::c_double, - ) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_double; - fn get( - &mut self, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> core::ffi::c_double; - fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn append(&mut self, key: *mut core::ffi::c_void, value: vtkVariant) -> (); - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: vtkVariant, - length: core::ffi::c_int, - ) -> (); - fn set( - &mut self, - key: *mut core::ffi::c_void, - value1: vtkVariant, - value2: vtkVariant, - value3: vtkVariant, - ) -> (); - fn set( - &mut self, - key: *mut core::ffi::c_void, - value1: vtkVariant, - value2: vtkVariant, - value3: vtkVariant, - value4: vtkVariant, - value5: vtkVariant, - value6: vtkVariant, + request: *mut core::ffi::c_void, + fromInfo: *mut core::ffi::c_void, + toInfo: *mut core::ffi::c_void, ) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> *const vtkVariant; - fn get(&mut self, key: *mut core::ffi::c_void, idx: core::ffi::c_int) -> vtkVariant; - fn get(&mut self, key: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> (); - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; +} +pub trait VtkInformationKeyLookup { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn find(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; +} +pub trait VtkInformationKeyVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; fn append( &mut self, - key: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, value: *mut core::ffi::c_void, ) -> (); fn append_unique( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn set( - &mut self, - key: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, value: *mut core::ffi::c_void, - length: core::ffi::c_int, ) -> (); - fn remove( + fn remove_item( &mut self, - key: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, value: *mut core::ffi::c_void, ) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut &mut vtkInformationKey; fn get( &mut self, - key: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, idx: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get(&mut self, key: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> (); - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn append( + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, ) -> (); - fn append( +} +pub trait VtkInformationObjectBaseKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn append( + name: &str, + location: &str, + requiredClass: &str, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, ) -> (); - fn append( +} +pub trait VtkInformationObjectBaseVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); + name: &str, + location: &str, + requiredClass: &str, + ) -> *mut core::ffi::c_void; + fn clear(&mut self, info: *mut core::ffi::c_void) -> (); + fn resize(&mut self, info: *mut core::ffi::c_void, size: core::ffi::c_int) -> (); + fn size(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; fn append( &mut self, - key: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, value: *mut core::ffi::c_void, ) -> (); - fn append( + fn set( &mut self, - key: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, value: *mut core::ffi::c_void, + i: core::ffi::c_int, ) -> (); - fn append( + fn remove( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + val: *mut core::ffi::c_void, ) -> (); - fn append( + fn get( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn append( + info: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn shallow_copy( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + dest: *mut core::ffi::c_void, ) -> (); - fn append_unique( +} +pub trait VtkInformationRequestKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void) -> (); + fn shallow_copy( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, ) -> (); - fn append_unique( +} +pub trait VtkInformationStringKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: &str) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> &str; + fn shallow_copy( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, ) -> (); - fn append_unique( +} +pub trait VtkInformationStringVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn append_unique( + name: &str, + location: &str, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void, value: &str) -> (); + fn set( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + value: &str, + index: core::ffi::c_int, ) -> (); - fn append_unique( + fn get(&mut self, info: *mut core::ffi::c_void, idx: core::ffi::c_int) -> &str; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, ) -> (); - fn append_unique( +} +pub trait VtkInformationUnsignedLongKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_ulong) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_ulong; + fn shallow_copy( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, ) -> (); - fn append_unique( +} +pub trait VtkInformationVariantKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn shallow_copy( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, ) -> (); - fn append_unique( +} +pub trait VtkInformationVariantVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn append_unique( + name: &str, + location: &str, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, ) -> (); - fn append_unique( +} +pub trait VtkInformationVector { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_information_objects(&mut self) -> core::ffi::c_int; + fn set_number_of_information_objects(&mut self, n: core::ffi::c_int) -> (); + fn set_information_object( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + index: core::ffi::c_int, + info: *mut core::ffi::c_void, ) -> (); - fn append_unique( + fn get_information_object( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn set(&mut self, key: *mut core::ffi::c_void, p1: core::ffi::c_char) -> (); - fn set(&mut self, key: *mut core::ffi::c_void, p1: &str) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> *const core::ffi::c_char; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn append( - &mut self, - key: *mut core::ffi::c_void, - data: *mut core::ffi::c_void, - ) -> (); - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> (); - fn get( - &mut self, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, + index: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn remove( - &mut self, - key: *mut core::ffi::c_void, - objectToRemove: *mut core::ffi::c_void, - ) -> (); - fn remove( - &mut self, - key: *mut core::ffi::c_void, - indexToRemove: core::ffi::c_int, - ) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn remove(&mut self, key: *mut core::ffi::c_void) -> (); - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void) -> (); + fn remove(&mut self, info: *mut core::ffi::c_void) -> (); fn register(&mut self, o: *mut core::ffi::c_void) -> (); - fn set_request(&mut self, request: *mut core::ffi::c_void) -> (); - fn get_request(&mut self) -> *mut core::ffi::c_void; + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> (); } -pub trait VtkInformationDataObjectKey: VtkInformationKey + VtkObjectBase { +pub trait VtkIntArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_int) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_int) -> core::ffi::c_longlong; + fn fast_down_cast( &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, + source: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn shallow_copy( - &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, - ) -> (); + fn get_data_type_value_min(&mut self) -> core::ffi::c_int; + fn get_data_type_value_max(&mut self) -> core::ffi::c_int; +} +pub trait VtkLargeInteger { + fn cast_to_char(&mut self) -> &str; + fn cast_to_short(&mut self) -> core::ffi::c_short; + fn cast_to_int(&mut self) -> core::ffi::c_int; + fn cast_to_long(&mut self) -> core::ffi::c_long; + fn cast_to_unsigned_long(&mut self) -> core::ffi::c_ulong; + fn is_even(&mut self) -> core::ffi::c_int; + fn is_odd(&mut self) -> core::ffi::c_int; + fn get_length(&mut self) -> core::ffi::c_int; + fn get_bit(&mut self, p: core::ffi::c_uint) -> core::ffi::c_int; + fn is_zero(&mut self) -> core::ffi::c_int; + fn get_sign(&mut self) -> core::ffi::c_int; + fn truncate(&mut self, n: core::ffi::c_uint) -> (); + fn complement(&mut self) -> (); } -pub trait VtkInformationDoubleKey: VtkInformationKey + VtkObjectBase { +pub trait VtkLogger { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int; + fn is_a(&mut self, type_: &str) -> core::ffi::c_int; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( + fn get_number_of_generations_from_base_type( &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_double) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_double; - fn shallow_copy( + type_: &str, + ) -> core::ffi::c_longlong; + fn get_number_of_generations_from_base( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, - ) -> (); + type_: &str, + ) -> core::ffi::c_longlong; + fn init(&mut self) -> (); + fn end_log_to_file(&mut self, path: &str) -> (); + fn set_thread_name(&mut self, name: &str) -> (); + fn remove_callback(&mut self, id: &str) -> bool; + fn is_enabled(&mut self) -> bool; + fn end_scope(&mut self, id: &str) -> (); } -pub trait VtkInformationDoubleVectorKey: VtkInformationKey + VtkObjectBase { +pub trait VtkLongArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_long; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_long) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_long) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_long) -> core::ffi::c_longlong; + fn fast_down_cast( &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - length: core::ffi::c_int, + source: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; - fn append(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); - fn set( - &mut self, - info: *mut core::ffi::c_void, - value: core::ffi::c_double, - length: core::ffi::c_int, - ) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_double; - fn get( - &mut self, - info: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> core::ffi::c_double; - fn get(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); - fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; - fn shallow_copy( - &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, - ) -> (); + fn get_data_type_value_min(&mut self) -> core::ffi::c_long; + fn get_data_type_value_max(&mut self) -> core::ffi::c_long; } -pub trait VtkInformationIdTypeKey: VtkInformationKey + VtkObjectBase { +pub trait VtkLongLongArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn set_value( &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_uchar) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn shallow_copy( + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, + ) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, ) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_longlong; + fn get_data_type_value_max(&mut self) -> core::ffi::c_longlong; } -pub trait VtkInformationInformationKey: VtkInformationKey + VtkObjectBase { +pub trait VtkLookupTable { + fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( + fn is_opaque(&mut self) -> core::ffi::c_int; + fn allocate( &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn shallow_copy( + sz: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> core::ffi::c_int; + fn build(&mut self) -> (); + fn force_build(&mut self) -> (); + fn build_special_colors(&mut self) -> (); + fn set_ramp(&mut self, _arg: core::ffi::c_int) -> (); + fn set_ramp_to_linear(&mut self) -> (); + fn set_ramp_to_s_curve(&mut self) -> (); + fn set_ramp_to_sqrt(&mut self) -> (); + fn get_ramp(&mut self) -> core::ffi::c_int; + fn set_scale(&mut self, scale: core::ffi::c_int) -> (); + fn set_scale_to_linear(&mut self) -> (); + fn set_scale_to_log_10(&mut self) -> (); + fn get_scale(&mut self) -> core::ffi::c_int; + fn set_table_range( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + min: core::ffi::c_double, + max: core::ffi::c_double, ) -> (); - fn deep_copy( + fn set_hue_range( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ) -> (); -} -pub trait VtkInformationInformationVectorKey: VtkInformationKey + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn shallow_copy( + fn set_saturation_range( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ) -> (); - fn deep_copy( + fn set_value_range( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ) -> (); -} -pub trait VtkInformationIntegerKey: VtkInformationKey + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_int) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; - fn shallow_copy( + fn set_alpha_range( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ) -> (); -} -pub trait VtkInformationIntegerPointerKey: VtkInformationKey + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set( + fn set_nan_color( &mut self, - info: *mut core::ffi::c_void, - value: core::ffi::c_int, - length: core::ffi::c_int, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, ) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_int; - fn get(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); - fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; - fn shallow_copy( + fn set_below_range_color( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, ) -> (); -} -pub trait VtkInformationIntegerVectorKey: VtkInformationKey + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - length: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn append(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); - fn set( + fn set_use_below_range_color(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_below_range_color(&mut self) -> core::ffi::c_int; + fn use_below_range_color_on(&mut self) -> (); + fn use_below_range_color_off(&mut self) -> (); + fn set_above_range_color( &mut self, - info: *mut core::ffi::c_void, - value: core::ffi::c_int, - length: core::ffi::c_int, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, ) -> (); - fn set(&mut self, info: *mut core::ffi::c_void) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_int; - fn get( + fn set_use_above_range_color(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_above_range_color(&mut self) -> core::ffi::c_int; + fn use_above_range_color_on(&mut self) -> (); + fn use_above_range_color_off(&mut self) -> (); + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; + fn get_index(&mut self, v: core::ffi::c_double) -> core::ffi::c_longlong; + fn set_number_of_table_values(&mut self, number: core::ffi::c_longlong) -> (); + fn get_number_of_table_values(&mut self) -> core::ffi::c_longlong; + fn set_table_value( &mut self, - info: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); - fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; - fn shallow_copy( + indx: core::ffi::c_longlong, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ) -> (); + fn set_number_of_colors(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_number_of_colors_min_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_colors_max_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_colors(&mut self) -> core::ffi::c_longlong; + fn set_table(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_table(&mut self) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn using_log_scale(&mut self) -> core::ffi::c_int; +} +pub trait VtkMappedDataArray { + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); + fn get_tuples( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, ) -> (); + fn data_changed(&mut self) -> (); + fn modified(&mut self) -> (); } -pub trait VtkInformationIterator: VtkObject + VtkObjectBase { +pub trait VtkMath { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set_information(&mut self, p0: *mut core::ffi::c_void) -> (); - fn get_information(&mut self) -> *mut core::ffi::c_void; - fn set_information_weak(&mut self, p0: *mut core::ffi::c_void) -> (); - fn init_traversal(&mut self) -> (); - fn go_to_first_item(&mut self) -> (); - fn go_to_next_item(&mut self) -> (); - fn is_done_with_traversal(&mut self) -> core::ffi::c_int; - fn get_current_key(&mut self) -> *mut core::ffi::c_void; -} -pub trait VtkInformationKey: VtkObjectBase { - fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; - fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_number_of_generations_from_base_type( + fn pi(&mut self) -> core::ffi::c_double; + fn radians_from_degrees( &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; - fn get_number_of_generations_from_base( + degrees: core::ffi::c_float, + ) -> core::ffi::c_float; + fn degrees_from_radians( &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; - fn register(&mut self, p0: *mut core::ffi::c_void) -> (); - fn un_register(&mut self, p0: *mut core::ffi::c_void) -> (); - fn get_name(&mut self) -> *const core::ffi::c_char; - fn get_location(&mut self) -> *const core::ffi::c_char; - fn shallow_copy( + radians: core::ffi::c_float, + ) -> core::ffi::c_float; + fn round(&mut self, f: core::ffi::c_float) -> core::ffi::c_int; + fn floor(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn ceil(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn ceil_log_2(&mut self, x: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn is_power_of_two(&mut self, x: core::ffi::c_ulonglong) -> bool; + fn nearest_power_of_two(&mut self, x: core::ffi::c_int) -> core::ffi::c_int; + fn factorial(&mut self, N: core::ffi::c_int) -> core::ffi::c_longlong; + fn binomial( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, - ) -> (); - fn deep_copy( + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_longlong; + fn random_seed(&mut self, s: core::ffi::c_int) -> (); + fn get_seed(&mut self) -> core::ffi::c_int; + fn random(&mut self) -> core::ffi::c_double; + fn gaussian(&mut self) -> core::ffi::c_double; + fn gaussian_amplitude( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, - ) -> (); - fn has(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; - fn remove(&mut self, info: *mut core::ffi::c_void) -> (); - fn report( + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; + fn gaussian_weight( &mut self, - info: *mut core::ffi::c_void, - collector: *mut core::ffi::c_void, - ) -> (); - fn print(&mut self, info: *mut core::ffi::c_void) -> (); - fn need_to_execute( + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; + fn determinant_2_x_2( &mut self, - pipelineInfo: *mut core::ffi::c_void, - dobjInfo: *mut core::ffi::c_void, - ) -> bool; - fn store_meta_data( + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + d: core::ffi::c_double, + ) -> core::ffi::c_double; + fn determinant_3_x_3( &mut self, - request: *mut core::ffi::c_void, - pipelineInfo: *mut core::ffi::c_void, - dobjInfo: *mut core::ffi::c_void, - ) -> (); - fn copy_default_information( + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + b1: core::ffi::c_double, + b2: core::ffi::c_double, + b3: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double; + fn solve_linear_system_gepp_2_x_2( &mut self, - request: *mut core::ffi::c_void, - fromInfo: *mut core::ffi::c_void, - toInfo: *mut core::ffi::c_void, - ) -> (); + a00: core::ffi::c_double, + a01: core::ffi::c_double, + a10: core::ffi::c_double, + a11: core::ffi::c_double, + b0: core::ffi::c_double, + b1: core::ffi::c_double, + x0: &mut core::ffi::c_double, + x1: &mut core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_scalar_type_fitting_range( + &mut self, + range_min: core::ffi::c_double, + range_max: core::ffi::c_double, + scale: core::ffi::c_double, + shift: core::ffi::c_double, + ) -> core::ffi::c_int; + fn inf(&mut self) -> core::ffi::c_double; + fn neg_inf(&mut self) -> core::ffi::c_double; + fn nan(&mut self) -> core::ffi::c_double; + fn is_inf(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn is_nan(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn is_finite(&mut self, x: core::ffi::c_double) -> bool; } -pub trait VtkInformationKeyLookup: VtkObject + VtkObjectBase { +pub trait VtkMersenneTwister { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn find(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; -} -pub trait VtkInformationKeyVectorKey: VtkInformationKey + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn append( - &mut self, - info: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn append_unique( - &mut self, - info: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn set( - &mut self, - info: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - length: core::ffi::c_int, - ) -> (); - fn remove_item( - &mut self, - info: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> *mut &mut vtkInformationKey; - fn get( + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn initialize_new_sequence( &mut self, - info: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get(&mut self, info: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> (); - fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; - fn shallow_copy( + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> core::ffi::c_uint; + fn initialize_sequence( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + id: core::ffi::c_uint, + seed: core::ffi::c_uint, + p: core::ffi::c_int, ) -> (); + fn get_value(&mut self, id: core::ffi::c_uint) -> core::ffi::c_double; + fn next(&mut self, id: core::ffi::c_uint) -> (); } -pub trait VtkInformationObjectBaseKey: VtkInformationKey + VtkObjectBase { +pub trait VtkMinimalStandardRandomSequence { + fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn set_seed(&mut self, value: core::ffi::c_int) -> (); + fn set_seed_only(&mut self, value: core::ffi::c_int) -> (); + fn get_seed(&mut self) -> core::ffi::c_int; + fn get_value(&mut self) -> core::ffi::c_double; + fn next(&mut self) -> (); + fn get_range_value( &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - requiredClass: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn shallow_copy( + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_next_range_value( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, - ) -> (); + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double; } -pub trait VtkInformationObjectBaseVectorKey: VtkInformationKey + VtkObjectBase { +pub trait VtkMultiThreader { + fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - requiredClass: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn clear(&mut self, info: *mut core::ffi::c_void) -> (); - fn resize(&mut self, info: *mut core::ffi::c_void, size: core::ffi::c_int) -> (); - fn size(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; - fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; - fn append( - &mut self, - info: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> (); - fn set( + fn set_number_of_threads(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_threads_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_threads_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_threads(&mut self) -> core::ffi::c_int; + fn get_global_static_maximum_number_of_threads(&mut self) -> core::ffi::c_int; + fn set_global_maximum_number_of_threads(&mut self, val: core::ffi::c_int) -> (); + fn get_global_maximum_number_of_threads(&mut self) -> core::ffi::c_int; + fn set_global_default_number_of_threads(&mut self, val: core::ffi::c_int) -> (); + fn get_global_default_number_of_threads(&mut self) -> core::ffi::c_int; + fn single_method_execute(&mut self) -> (); + fn multiple_method_execute(&mut self) -> (); + fn terminate_thread(&mut self, threadId: core::ffi::c_int) -> (); + fn is_thread_active(&mut self, threadId: core::ffi::c_int) -> core::ffi::c_int; +} +pub trait VtkMutexLock { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkNew { + fn reset(&mut self) -> (); + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn get(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkOStrStreamWrapper { + fn rdbuf(&mut self) -> *mut core::ffi::c_void; + fn freeze(&mut self) -> (); +} +pub trait VtkObject { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int; + fn is_a(&mut self, type_: &str) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( &mut self, - info: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> (); - fn remove( + type_: &str, + ) -> core::ffi::c_longlong; + fn get_number_of_generations_from_base( &mut self, - info: *mut core::ffi::c_void, - val: *mut core::ffi::c_void, - ) -> (); - fn remove(&mut self, info: *mut core::ffi::c_void, idx: core::ffi::c_int) -> (); - fn set_range( + type_: &str, + ) -> core::ffi::c_longlong; + fn new(&mut self) -> *mut core::ffi::c_void; + fn debug_on(&mut self) -> (); + fn debug_off(&mut self) -> (); + fn get_debug(&mut self) -> bool; + fn set_debug(&mut self, debugFlag: bool) -> (); + fn break_on_error(&mut self) -> (); + fn modified(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_global_warning_display(&mut self, val: core::ffi::c_int) -> (); + fn global_warning_display_on(&mut self) -> (); + fn global_warning_display_off(&mut self) -> (); + fn get_global_warning_display(&mut self) -> core::ffi::c_int; + fn add_observer( &mut self, - info: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - from: core::ffi::c_int, - to: core::ffi::c_int, - n: core::ffi::c_int, - ) -> (); - fn get_range( + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + priority: core::ffi::c_float, + ) -> core::ffi::c_ulong; + fn get_command(&mut self, tag: core::ffi::c_ulong) -> *mut core::ffi::c_void; + fn remove_observer(&mut self, p0: *mut core::ffi::c_void) -> (); + fn remove_observers( &mut self, - info: *mut core::ffi::c_void, - dest: *mut core::ffi::c_void, - from: core::ffi::c_int, - to: core::ffi::c_int, - n: core::ffi::c_int, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, ) -> (); - fn get( - &mut self, - info: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn shallow_copy( + fn has_observer( &mut self, - source: *mut core::ffi::c_void, - dest: *mut core::ffi::c_void, - ) -> (); + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn remove_all_observers(&mut self) -> (); } -pub trait VtkInformationRequestKey: VtkInformationKey + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( +pub trait VtkObjectBase { + fn get_class_name(&mut self) -> &str; + fn is_type_of(&mut self, name: &str) -> core::ffi::c_int; + fn is_a(&mut self, name: &str) -> core::ffi::c_int; + fn get_number_of_generations_from_base_type( &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void) -> (); - fn shallow_copy( + name: &str, + ) -> core::ffi::c_longlong; + fn get_number_of_generations_from_base( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, - ) -> (); + name: &str, + ) -> core::ffi::c_longlong; + fn delete(&mut self) -> (); + fn fast_delete(&mut self) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize_object_base(&mut self) -> (); + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn un_register(&mut self, o: *mut core::ffi::c_void) -> (); + fn get_reference_count(&mut self) -> core::ffi::c_int; + fn set_reference_count(&mut self, p0: core::ffi::c_int) -> (); + fn set_memkind_directory(&mut self, directoryname: &str) -> (); + fn get_using_memkind(&mut self) -> bool; + fn get_is_in_memkind(&mut self) -> bool; } -pub trait VtkInformationStringKey: VtkInformationKey + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( +pub trait VtkObjectFactory { + fn create_instance( &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, + vtkclassname: &str, + isAbstract: bool, ) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_char) -> (); - fn set(&mut self, info: *mut core::ffi::c_void, str: &str) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> *const core::ffi::c_char; - fn shallow_copy( + fn create_all_instance( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + vtkclassname: &str, + retList: *mut core::ffi::c_void, ) -> (); -} -pub trait VtkInformationStringVectorKey: VtkInformationKey + VtkObjectBase { + fn re_hash(&mut self) -> (); + fn register_factory(&mut self, p0: *mut core::ffi::c_void) -> (); + fn un_register_factory(&mut self, p0: *mut core::ffi::c_void) -> (); + fn un_register_all_factories(&mut self) -> (); + fn get_registered_factories(&mut self) -> *mut core::ffi::c_void; + fn has_override_any(&mut self, className: &str) -> core::ffi::c_int; + fn get_override_information(&mut self, name: &str, p1: *mut core::ffi::c_void) -> (); + fn set_all_enable_flags(&mut self, flag: core::ffi::c_int, className: &str) -> (); fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - length: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn append(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_char) -> (); - fn set( - &mut self, - info: *mut core::ffi::c_void, - value: core::ffi::c_char, - index: core::ffi::c_int, - ) -> (); - fn append(&mut self, info: *mut core::ffi::c_void, value: &str) -> (); - fn set( - &mut self, - info: *mut core::ffi::c_void, - value: &str, - idx: core::ffi::c_int, - ) -> (); - fn get( - &mut self, - info: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> *const core::ffi::c_char; - fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; - fn shallow_copy( + fn get_vtk_source_version(&mut self) -> &str; + fn get_description(&mut self) -> &str; + fn get_number_of_overrides(&mut self) -> core::ffi::c_int; + fn get_class_override_name(&mut self, index: core::ffi::c_int) -> &str; + fn get_class_override_with_name(&mut self, index: core::ffi::c_int) -> &str; + fn get_enable_flag(&mut self, index: core::ffi::c_int) -> core::ffi::c_int; + fn get_override_description(&mut self, index: core::ffi::c_int) -> &str; + fn set_enable_flag( &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, + flag: core::ffi::c_int, + className: &str, + subclassName: &str, ) -> (); + fn has_override(&mut self, className: &str) -> core::ffi::c_int; + fn disable(&mut self, className: &str) -> (); } -pub trait VtkInformationUnsignedLongKey: VtkInformationKey + VtkObjectBase { +pub trait VtkObjectFactoryCollection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_ulong) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_ulong; - fn shallow_copy( - &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, - ) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, t: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkInformationVariantKey: VtkInformationKey + VtkObjectBase { +pub trait VtkOldStyleCallbackCommand { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn set(&mut self, info: *mut core::ffi::c_void, p1: vtkVariant) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> vtkVariant; - fn shallow_copy( - &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, - ) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_callback(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> (); } -pub trait VtkInformationVariantVectorKey: VtkInformationKey + VtkObjectBase { +pub trait VtkOutputWindow { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - length: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn append(&mut self, info: *mut core::ffi::c_void, value: vtkVariant) -> (); - fn set( - &mut self, - info: *mut core::ffi::c_void, - value: vtkVariant, - length: core::ffi::c_int, - ) -> (); - fn get(&mut self, info: *mut core::ffi::c_void) -> *const vtkVariant; - fn get(&mut self, info: *mut core::ffi::c_void, idx: core::ffi::c_int) -> vtkVariant; - fn get(&mut self, info: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> (); - fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; - fn shallow_copy( - &mut self, - from: *mut core::ffi::c_void, - to: *mut core::ffi::c_void, - ) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_instance(&mut self) -> *mut core::ffi::c_void; + fn set_instance(&mut self, instance: *mut core::ffi::c_void) -> (); + fn display_text(&mut self, p0: &str) -> (); + fn display_error_text(&mut self, p0: &str) -> (); + fn display_warning_text(&mut self, p0: &str) -> (); + fn display_generic_warning_text(&mut self, p0: &str) -> (); + fn display_debug_text(&mut self, p0: &str) -> (); + fn prompt_user_on(&mut self) -> (); + fn prompt_user_off(&mut self) -> (); + fn set_prompt_user(&mut self, _arg: bool) -> (); + fn set_use_std_error_for_all_messages(&mut self, p0: bool) -> (); + fn get_use_std_error_for_all_messages(&mut self) -> bool; + fn use_std_error_for_all_messages_on(&mut self) -> (); + fn use_std_error_for_all_messages_off(&mut self) -> (); + fn set_display_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_display_mode_min_value(&mut self) -> core::ffi::c_int; + fn get_display_mode_max_value(&mut self) -> core::ffi::c_int; + fn get_display_mode(&mut self) -> core::ffi::c_int; + fn set_display_mode_to_default(&mut self) -> (); + fn set_display_mode_to_never(&mut self) -> (); + fn set_display_mode_to_always(&mut self) -> (); + fn set_display_mode_to_always_std_err(&mut self) -> (); } -pub trait VtkInformationVector: VtkObject + VtkObjectBase { +pub trait VtkOverrideInformation { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_number_of_information_objects(&mut self) -> core::ffi::c_int; - fn set_number_of_information_objects(&mut self, n: core::ffi::c_int) -> (); - fn set_information_object( - &mut self, - index: core::ffi::c_int, - info: *mut core::ffi::c_void, - ) -> (); - fn get_information_object( - &mut self, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn append(&mut self, info: *mut core::ffi::c_void) -> (); - fn remove(&mut self, info: *mut core::ffi::c_void) -> (); - fn remove(&mut self, idx: core::ffi::c_int) -> (); - fn register(&mut self, o: *mut core::ffi::c_void) -> (); - fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> (); + fn get_class_override_name(&mut self) -> &str; + fn get_class_override_with_name(&mut self) -> &str; + fn get_description(&mut self) -> &str; + fn get_object_factory(&mut self) -> *mut core::ffi::c_void; + fn set_class_override_name(&mut self, _arg: &str) -> (); + fn set_class_override_with_name(&mut self, _arg: &str) -> (); + fn set_description(&mut self, _arg: &str) -> (); } -pub trait VtkIntArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { +pub trait VtkOverrideInformationCollection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPoints { + fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn set_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_void; fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_int) -> (); - fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_int) -> (); - fn insert_typed_tuple( + fn set_data_type(&mut self, dataType: core::ffi::c_int) -> (); + fn set_data_type_to_bit(&mut self) -> (); + fn set_data_type_to_char(&mut self) -> (); + fn set_data_type_to_unsigned_char(&mut self) -> (); + fn set_data_type_to_short(&mut self) -> (); + fn set_data_type_to_unsigned_short(&mut self) -> (); + fn set_data_type_to_int(&mut self) -> (); + fn set_data_type_to_unsigned_int(&mut self) -> (); + fn set_data_type_to_long(&mut self) -> (); + fn set_data_type_to_unsigned_long(&mut self) -> (); + fn set_data_type_to_float(&mut self) -> (); + fn set_data_type_to_double(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn set_point( &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_int, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, ) -> (); - fn insert_next_typed_tuple(&mut self, tuple: core::ffi::c_int) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_int) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_int) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_int; - fn get_value_range(&mut self) -> *mut core::ffi::c_int; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_int; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_int; - fn set_array( + fn insert_point( &mut self, - array: core::ffi::c_int, - size: core::ffi::c_uchar, - save: core::ffi::c_int, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, ) -> (); - fn set_array( + fn insert_points( &mut self, - array: core::ffi::c_int, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, ) -> (); - fn fast_down_cast( + fn insert_next_point( &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_int; - fn get_data_type_value_max(&mut self) -> core::ffi::c_int; + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> (); + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_points( + &mut self, + ptId: *mut core::ffi::c_void, + outPoints: *mut core::ffi::c_void, + ) -> (); + fn compute_bounds(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn modified(&mut self) -> (); } -pub trait VtkLargeInteger { - fn cast_to_char(&mut self) -> core::ffi::c_char; - fn cast_to_short(&mut self) -> core::ffi::c_short; - fn cast_to_int(&mut self) -> core::ffi::c_int; - fn cast_to_long(&mut self) -> core::ffi::c_long; - fn cast_to_unsigned_long(&mut self) -> core::ffi::c_ulong; - fn is_even(&mut self) -> core::ffi::c_int; - fn is_odd(&mut self) -> core::ffi::c_int; - fn get_length(&mut self) -> core::ffi::c_int; - fn get_bit(&mut self, p: core::ffi::c_uint) -> core::ffi::c_int; - fn is_zero(&mut self) -> core::ffi::c_int; - fn get_sign(&mut self) -> core::ffi::c_int; - fn truncate(&mut self, n: core::ffi::c_uint) -> (); - fn complement(&mut self) -> (); -} -pub trait VtkLogger: VtkObjectBase { - fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; - fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; +pub trait VtkPoints2D { + fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_number_of_generations_from_base_type( - &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; - fn get_number_of_generations_from_base( + fn allocate( &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; - fn init( + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn set_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn set_data_type(&mut self, dataType: core::ffi::c_int) -> (); + fn set_data_type_to_bit(&mut self) -> (); + fn set_data_type_to_char(&mut self) -> (); + fn set_data_type_to_unsigned_char(&mut self) -> (); + fn set_data_type_to_short(&mut self) -> (); + fn set_data_type_to_unsigned_short(&mut self) -> (); + fn set_data_type_to_int(&mut self) -> (); + fn set_data_type_to_unsigned_int(&mut self) -> (); + fn set_data_type_to_long(&mut self) -> (); + fn set_data_type_to_unsigned_long(&mut self) -> (); + fn set_data_type_to_float(&mut self) -> (); + fn set_data_type_to_double(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn set_point( &mut self, - argc: core::ffi::c_int, - argv: core::ffi::c_char, - verbosity_flag: core::ffi::c_char, - ) -> (); - fn init(&mut self) -> (); - fn set_stderr_verbosity(&mut self, level: *mut core::ffi::c_void) -> (); - fn set_internal_verbosity_level(&mut self, level: *mut core::ffi::c_void) -> (); - fn end_log_to_file(&mut self, path: core::ffi::c_char) -> (); - fn set_thread_name(&mut self, name: &str) -> (); - fn get_thread_name(&mut self) -> &str; - fn get_identifier(&mut self, obj: *mut core::ffi::c_void) -> &str; - fn add_callback( - &mut self, - id: core::ffi::c_char, - callback: (), - user_data: (), - verbosity: *mut core::ffi::c_void, - on_close: (), - on_flush: (), + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, ) -> (); - fn remove_callback(&mut self, id: core::ffi::c_char) -> bool; - fn is_enabled(&mut self) -> bool; - fn get_current_verbosity_cutoff(&mut self) -> *mut core::ffi::c_void; - fn convert_to_verbosity( + fn insert_point( &mut self, - value: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn convert_to_verbosity( + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> (); + fn insert_next_point( &mut self, - text: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn log( + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn remove_point(&mut self, id: core::ffi::c_longlong) -> (); + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> (); + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_points( &mut self, - verbosity: *mut core::ffi::c_void, - fname: core::ffi::c_char, - lineno: core::ffi::c_uint, - txt: core::ffi::c_char, + ptId: *mut core::ffi::c_void, + fp: *mut core::ffi::c_void, ) -> (); - fn start_scope( + fn compute_bounds(&mut self) -> (); +} +pub trait VtkPriorityQueue { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate(&mut self, sz: core::ffi::c_longlong, ext: core::ffi::c_longlong) -> (); + fn insert(&mut self, priority: core::ffi::c_double, id: core::ffi::c_longlong) -> (); + fn pop( + &mut self, + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn peek( + &mut self, + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn delete_id(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double; + fn get_priority(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double; + fn get_number_of_items(&mut self) -> core::ffi::c_longlong; + fn reset(&mut self) -> (); +} +pub trait VtkRandomPool { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_sequence(&mut self, seq: *mut core::ffi::c_void) -> (); + fn get_sequence(&mut self) -> *mut core::ffi::c_void; + fn set_size(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_size_min_value(&mut self) -> core::ffi::c_longlong; + fn get_size_max_value(&mut self) -> core::ffi::c_longlong; + fn get_size(&mut self) -> core::ffi::c_longlong; + fn set_number_of_components(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_number_of_components_min_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_components_max_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_components(&mut self) -> core::ffi::c_longlong; + fn get_total_size(&mut self) -> core::ffi::c_longlong; + fn get_value(&mut self, i: core::ffi::c_longlong) -> core::ffi::c_double; + fn populate_data_array( &mut self, - verbosity: *mut core::ffi::c_void, - id: core::ffi::c_char, - fname: core::ffi::c_char, - lineno: core::ffi::c_uint, + da: *mut core::ffi::c_void, + minRange: core::ffi::c_double, + maxRange: core::ffi::c_double, ) -> (); - fn end_scope(&mut self, id: core::ffi::c_char) -> (); + fn set_chunk_size(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_chunk_size_min_value(&mut self) -> core::ffi::c_longlong; + fn get_chunk_size_max_value(&mut self) -> core::ffi::c_longlong; + fn get_chunk_size(&mut self) -> core::ffi::c_longlong; } -pub trait VtkLongArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { +pub trait VtkRandomSequence { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn get_value(&mut self) -> core::ffi::c_double; + fn next(&mut self) -> (); + fn get_next_value(&mut self) -> core::ffi::c_double; +} +pub trait VtkReferenceCount { fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_long) -> (); - fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_long) -> (); - fn insert_typed_tuple( + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkSMPThreadLocal { + fn size(&mut self) -> usize; +} +pub trait VtkSMPThreadLocalObject { + fn local(&mut self) -> *mut core::ffi::c_void; + fn size(&mut self) -> usize; +} +pub trait VtkSMPTools { + fn get_backend(&mut self) -> &str; + fn set_backend(&mut self, backend: &str) -> bool; + fn initialize(&mut self, numThreads: core::ffi::c_int) -> (); + fn get_estimated_number_of_threads(&mut self) -> core::ffi::c_int; + fn set_nested_parallelism(&mut self, isNested: bool) -> (); + fn get_nested_parallelism(&mut self) -> bool; + fn is_parallel_scope(&mut self) -> bool; +} +pub trait VtkSOADataArrayTemplate { + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_typed_tuple( &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_long, + tupleIdx: core::ffi::c_longlong, + tuple: *mut core::ffi::c_void, ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_long, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_long; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_long) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_long) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_long) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_long; - fn get_value_range(&mut self) -> *mut core::ffi::c_long; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_long; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_long; fn set_array( &mut self, - array: core::ffi::c_long, - size: core::ffi::c_uchar, - save: core::ffi::c_int, + comp: core::ffi::c_int, + array: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + updateMaxId: bool, + save: bool, + deleteMethod: core::ffi::c_int, ) -> (); - fn set_array( + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_component_array_pointer( &mut self, - array: core::ffi::c_long, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_number_of_components(&mut self, numComps: core::ffi::c_int) -> (); +} +pub trait VtkScalarsToColors { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn is_opaque(&mut self) -> core::ffi::c_int; + fn build(&mut self) -> (); + fn set_range(&mut self, min: core::ffi::c_double, max: core::ffi::c_double) -> (); + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; + fn get_luminance(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn set_alpha(&mut self, alpha: core::ffi::c_double) -> (); + fn get_alpha(&mut self) -> core::ffi::c_double; + fn map_scalars( + &mut self, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_vector_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_vector_mode(&mut self) -> core::ffi::c_int; + fn set_vector_mode_to_magnitude(&mut self) -> (); + fn set_vector_mode_to_component(&mut self) -> (); + fn set_vector_mode_to_rgb_colors(&mut self) -> (); + fn set_vector_component(&mut self, _arg: core::ffi::c_int) -> (); + fn get_vector_component(&mut self) -> core::ffi::c_int; + fn set_vector_size(&mut self, _arg: core::ffi::c_int) -> (); + fn get_vector_size(&mut self) -> core::ffi::c_int; + fn deep_copy(&mut self, o: *mut core::ffi::c_void) -> (); + fn using_log_scale(&mut self) -> core::ffi::c_int; + fn get_number_of_available_colors(&mut self) -> core::ffi::c_longlong; + fn set_annotations( + &mut self, + values: *mut core::ffi::c_void, + annotations: *mut core::ffi::c_void, ) -> (); + fn get_annotated_values(&mut self) -> *mut core::ffi::c_void; + fn get_annotations(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_annotated_values(&mut self) -> core::ffi::c_longlong; + fn reset_annotations(&mut self) -> (); + fn set_indexed_lookup(&mut self, _arg: core::ffi::c_int) -> (); + fn get_indexed_lookup(&mut self) -> core::ffi::c_int; + fn indexed_lookup_on(&mut self) -> (); + fn indexed_lookup_off(&mut self) -> (); +} +pub trait VtkShortArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_short; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_short) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_short) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_short) -> core::ffi::c_longlong; fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_long; - fn get_data_type_value_max(&mut self) -> core::ffi::c_long; + fn get_data_type_value_min(&mut self) -> core::ffi::c_short; + fn get_data_type_value_max(&mut self) -> core::ffi::c_short; } -pub trait VtkLongLongArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { +pub trait VtkSignedCharArray { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple( + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_schar; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_schar) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_schar) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_schar) -> core::ffi::c_longlong; + fn fast_down_cast( &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> (); - fn set_typed_tuple( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_schar; + fn get_data_type_value_max(&mut self) -> core::ffi::c_schar; +} +pub trait VtkSimpleConditionVariable { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn signal(&mut self) -> (); + fn broadcast(&mut self) -> (); +} +pub trait VtkSimpleCriticalSection { + fn init(&mut self) -> (); + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkSimpleMutexLock { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkSmartPointer { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn get(&mut self) -> *mut core::ffi::c_void; + fn take_reference(&mut self, t: *mut core::ffi::c_void) -> (); +} +pub trait VtkSmartPointerBase { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn report(&mut self, collector: *mut core::ffi::c_void, desc: &str) -> (); +} +pub trait VtkSortDataArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn sort(&mut self, keys: *mut core::ffi::c_void) -> (); + fn sort_array_by_component( &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, + arr: *mut core::ffi::c_void, + k: core::ffi::c_int, ) -> (); - fn insert_typed_tuple( +} +pub trait VtkSparseArray { + fn is_dense(&mut self) -> bool; + fn get_non_null_size(&mut self) -> core::ffi::c_ulonglong; + fn deep_copy(&mut self) -> *mut core::ffi::c_void; + fn clear(&mut self) -> (); + fn reserve_storage(&mut self, value_count: core::ffi::c_ulonglong) -> (); + fn set_extents_from_contents(&mut self) -> (); + fn validate(&mut self) -> bool; +} +pub trait VtkStringArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_tuple( &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar; - fn get_value_range(&mut self) -> *mut core::ffi::c_uchar; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn set_array( + fn insert_tuple( &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, ) -> (); - fn set_array( + fn insert_tuples( &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, ) -> (); - fn fast_down_cast( + fn insert_next_tuple( &mut self, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar; - fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar; -} -pub trait VtkLookupTable: VtkScalarsToColors + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn is_opaque(&mut self) -> core::ffi::c_int; + ) -> core::ffi::c_longlong; + fn get_tuples( + &mut self, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); fn allocate( &mut self, - sz: core::ffi::c_int, - ext: core::ffi::c_int, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; - fn build(&mut self) -> (); - fn force_build(&mut self) -> (); - fn build_special_colors(&mut self) -> (); - fn set_ramp(&mut self, _arg: core::ffi::c_int) -> (); - fn set_ramp_to_linear(&mut self) -> (); - fn set_ramp_to_s_curve(&mut self) -> (); - fn set_ramp_to_sqrt(&mut self) -> (); - fn get_ramp(&mut self) -> core::ffi::c_int; - fn set_scale(&mut self, scale: core::ffi::c_int) -> (); - fn set_scale_to_linear(&mut self) -> (); - fn set_scale_to_log_10(&mut self) -> (); - fn get_scale(&mut self) -> core::ffi::c_int; - fn set_table_range(&mut self, r: core::ffi::c_double) -> (); - fn set_table_range( - &mut self, - min: core::ffi::c_double, - max: core::ffi::c_double, - ) -> (); - fn get_table_range(&mut self) -> *mut core::ffi::c_double; - fn get_table_range(&mut self, data: core::ffi::c_double) -> (); - fn set_hue_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> (); - fn set_hue_range(&mut self, _arg: core::ffi::c_double) -> (); - fn get_hue_range(&mut self) -> *mut core::ffi::c_double; - fn get_hue_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> (); - fn get_hue_range(&mut self, _arg: core::ffi::c_double) -> (); - fn set_saturation_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> (); - fn set_saturation_range(&mut self, _arg: core::ffi::c_double) -> (); - fn get_saturation_range(&mut self) -> *mut core::ffi::c_double; - fn get_saturation_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> (); - fn get_saturation_range(&mut self, _arg: core::ffi::c_double) -> (); - fn set_value_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> (); - fn set_value_range(&mut self, _arg: core::ffi::c_double) -> (); - fn get_value_range(&mut self) -> *mut core::ffi::c_double; - fn get_value_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> (); - fn get_value_range(&mut self, _arg: core::ffi::c_double) -> (); - fn set_alpha_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> (); - fn set_alpha_range(&mut self, _arg: core::ffi::c_double) -> (); - fn get_alpha_range(&mut self) -> *mut core::ffi::c_double; - fn get_alpha_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> (); - fn get_alpha_range(&mut self, _arg: core::ffi::c_double) -> (); - fn set_nan_color( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> (); - fn set_nan_color(&mut self, _arg: core::ffi::c_double) -> (); - fn get_nan_color(&mut self) -> *mut core::ffi::c_double; - fn get_nan_color( + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn get_number_of_values(&mut self) -> core::ffi::c_longlong; + fn get_number_of_element_components(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn write_pointer( &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> (); - fn get_nan_color(&mut self, _arg: core::ffi::c_double) -> (); - fn get_nan_color_as_unsigned_chars(&mut self) -> *mut core::ffi::c_uchar; - fn get_color_as_unsigned_chars( + id: core::ffi::c_longlong, + number: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + fn get_pointer(&mut self, id: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); + fn set_array( &mut self, - colorIn: core::ffi::c_double, - colorOut: core::ffi::c_uchar, + array: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, ) -> (); - fn set_below_range_color( + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data_size(&mut self) -> core::ffi::c_longlong; + fn data_changed(&mut self) -> (); + fn data_element_changed(&mut self, id: core::ffi::c_longlong) -> (); + fn clear_lookup(&mut self) -> (); +} +pub trait VtkStringOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn display_text(&mut self, p0: &str) -> (); +} +pub trait VtkTestDataArray { + fn get_typed_tuple( &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, + tupleIdx: core::ffi::c_longlong, + tuple: *mut core::ffi::c_void, ) -> (); - fn set_below_range_color(&mut self, _arg: core::ffi::c_double) -> (); - fn get_below_range_color(&mut self) -> *mut core::ffi::c_double; - fn get_below_range_color( +} +pub trait VtkTimePointUtility { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn date_to_time_point( &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> (); - fn get_below_range_color(&mut self, _arg: core::ffi::c_double) -> (); - fn set_use_below_range_color(&mut self, _arg: core::ffi::c_int) -> (); - fn get_use_below_range_color(&mut self) -> core::ffi::c_int; - fn use_below_range_color_on(&mut self) -> (); - fn use_below_range_color_off(&mut self) -> (); - fn set_above_range_color( + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + fn time_to_time_point( &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> (); - fn set_above_range_color(&mut self, _arg: core::ffi::c_double) -> (); - fn get_above_range_color(&mut self) -> *mut core::ffi::c_double; - fn get_above_range_color( + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + fn date_time_to_time_point( &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> (); - fn get_above_range_color(&mut self, _arg: core::ffi::c_double) -> (); - fn set_use_above_range_color(&mut self, _arg: core::ffi::c_int) -> (); - fn get_use_above_range_color(&mut self) -> core::ffi::c_int; - fn use_above_range_color_on(&mut self) -> (); - fn use_above_range_color_off(&mut self) -> (); - fn map_value(&mut self, v: core::ffi::c_double) -> *const core::ffi::c_uchar; - fn get_color(&mut self, v: core::ffi::c_double, rgb: core::ffi::c_double) -> (); - fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; - fn get_index(&mut self, v: core::ffi::c_double) -> core::ffi::c_uchar; - fn set_number_of_table_values(&mut self, number: core::ffi::c_uchar) -> (); - fn get_number_of_table_values(&mut self) -> core::ffi::c_uchar; - fn set_table_value( + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + sec: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + fn get_date( &mut self, - indx: core::ffi::c_uchar, - rgba: core::ffi::c_double, + time: core::ffi::c_ulonglong, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, ) -> (); - fn set_table_value( + fn get_time( &mut self, - indx: core::ffi::c_uchar, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - a: core::ffi::c_double, + time: core::ffi::c_ulonglong, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, ) -> (); - fn get_table_value(&mut self, indx: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_table_value( + fn get_date_time( &mut self, - indx: core::ffi::c_uchar, - rgba: core::ffi::c_double, + time: core::ffi::c_ulonglong, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, ) -> (); - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar; - fn get_range(&mut self) -> *mut core::ffi::c_double; - fn get_log_range( + fn get_year(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_month(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_day(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_hour(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_minute(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_second(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_millisecond(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn time_point_to_iso_8601( &mut self, - range: core::ffi::c_double, - log_range: core::ffi::c_double, - ) -> (); - fn apply_log_scale( + p0: core::ffi::c_ulonglong, + format: core::ffi::c_int, + ) -> &str; +} +pub trait VtkTimeStamp { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn modified(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkTypeFloat32Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( &mut self, - v: core::ffi::c_double, - range: core::ffi::c_double, - log_range: core::ffi::c_double, - ) -> core::ffi::c_double; - fn set_number_of_colors(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_number_of_colors_min_value(&mut self) -> core::ffi::c_uchar; - fn get_number_of_colors_max_value(&mut self) -> core::ffi::c_uchar; - fn get_number_of_colors(&mut self) -> core::ffi::c_uchar; - fn set_table(&mut self, p0: *mut core::ffi::c_void) -> (); - fn get_table(&mut self) -> *mut core::ffi::c_void; - fn map_scalars_through_table_2( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeFloat64Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( &mut self, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> (); - fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); - fn using_log_scale(&mut self) -> core::ffi::c_int; - fn get_indexed_color( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt16Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( &mut self, - idx: core::ffi::c_uchar, - rgba: core::ffi::c_double, - ) -> (); + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } -pub trait VtkMappedDataArray: VtkTypedDataArray + VtkGenericDataArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); - fn get_variant_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_variant_value( +pub trait VtkTypeInt32Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn get_tuples( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt64Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( &mut self, - ptIds: *mut core::ffi::c_void, - output: *mut core::ffi::c_void, - ) -> (); - fn get_tuples( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt8Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - output: *mut core::ffi::c_void, - ) -> (); - fn interpolate_tuple( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt16Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( &mut self, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ) -> (); - fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); - fn export_to_void_pointer(&mut self, ptr: ()) -> (); - fn data_changed(&mut self) -> (); - fn set_void_array( + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt32Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( &mut self, - p0: (), - p1: core::ffi::c_uchar, - p2: core::ffi::c_int, - ) -> (); - fn write_void_pointer( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt64Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( &mut self, - p0: core::ffi::c_uchar, - p1: core::ffi::c_uchar, - ) -> *mut (); - fn modified(&mut self) -> (); + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } -pub trait VtkMath: VtkObject + VtkObjectBase { +pub trait VtkTypeUInt8Array { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn pi(&mut self) -> core::ffi::c_double; - fn radians_from_degrees( + fn fast_down_cast( &mut self, - degrees: core::ffi::c_float, - ) -> core::ffi::c_float; - fn radians_from_degrees( - &mut self, - degrees: core::ffi::c_double, - ) -> core::ffi::c_double; - fn degrees_from_radians( - &mut self, - radians: core::ffi::c_float, - ) -> core::ffi::c_float; - fn degrees_from_radians( - &mut self, - radians: core::ffi::c_double, - ) -> core::ffi::c_double; - fn round(&mut self, f: core::ffi::c_float) -> core::ffi::c_int; - fn round(&mut self, f: core::ffi::c_double) -> core::ffi::c_int; - fn floor(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; - fn ceil(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; - fn ceil_log_2(&mut self, x: core::ffi::c_ulonglong) -> core::ffi::c_int; - fn is_power_of_two(&mut self, x: core::ffi::c_ulonglong) -> bool; - fn nearest_power_of_two(&mut self, x: core::ffi::c_int) -> core::ffi::c_int; - fn factorial(&mut self, N: core::ffi::c_int) -> core::ffi::c_uchar; - fn binomial( - &mut self, - m: core::ffi::c_int, - n: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn begin_combination( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypedArray {} +pub trait VtkTypedDataArray { + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( &mut self, - m: core::ffi::c_int, - n: core::ffi::c_int, - ) -> *mut core::ffi::c_int; - fn next_combination( + idx: core::ffi::c_longlong, + t: *mut core::ffi::c_void, + ) -> (); + fn allocate( &mut self, - m: core::ffi::c_int, - n: core::ffi::c_int, - combination: core::ffi::c_int, + size: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; - fn free_combination(&mut self, combination: core::ffi::c_int) -> (); - fn random_seed(&mut self, s: core::ffi::c_int) -> (); - fn get_seed(&mut self) -> core::ffi::c_int; - fn random(&mut self) -> core::ffi::c_double; - fn random( - &mut self, - min: core::ffi::c_double, - max: core::ffi::c_double, - ) -> core::ffi::c_double; - fn gaussian(&mut self) -> core::ffi::c_double; - fn gaussian( - &mut self, - mean: core::ffi::c_double, - std: core::ffi::c_double, - ) -> core::ffi::c_double; - fn assign(&mut self, a: core::ffi::c_double, b: core::ffi::c_double) -> (); - fn add( +} +pub trait VtkUnicodeString { + fn is_utf_8(&mut self, p0: &str) -> bool; + fn utf_8_str(&mut self) -> &str; + fn empty(&mut self) -> bool; + fn push_back(&mut self, p0: core::ffi::c_uint) -> (); + fn clear(&mut self) -> (); +} +pub trait VtkUnicodeStringArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, - ) -> (); - fn add( + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn set_tuple( &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, ) -> (); - fn subtract( + fn insert_tuple( &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, ) -> (); - fn subtract( + fn insert_tuples( &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, ) -> (); - fn multiply_scalar(&mut self, a: core::ffi::c_float, s: core::ffi::c_float) -> (); - fn multiply_scalar_2_d( + fn insert_next_tuple( &mut self, - a: core::ffi::c_float, - s: core::ffi::c_float, - ) -> (); - fn multiply_scalar(&mut self, a: core::ffi::c_double, s: core::ffi::c_double) -> (); - fn multiply_scalar_2_d( + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn data_changed(&mut self) -> (); + fn clear_lookup(&mut self) -> (); + fn insert_next_utf_8_value(&mut self, p0: &str) -> (); + fn set_utf_8_value(&mut self, i: core::ffi::c_longlong, p1: &str) -> (); + fn get_utf_8_value(&mut self, i: core::ffi::c_longlong) -> &str; +} +pub trait VtkUnsignedCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_uchar) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_uchar) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_longlong; + fn fast_down_cast( &mut self, - a: core::ffi::c_double, - s: core::ffi::c_double, - ) -> (); - fn dot( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar; + fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkUnsignedIntArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_uint; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_uint) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_uint) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_uint) -> core::ffi::c_longlong; + fn fast_down_cast( &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - ) -> core::ffi::c_float; - fn dot( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_uint; + fn get_data_type_value_max(&mut self) -> core::ffi::c_uint; +} +pub trait VtkUnsignedLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ulong; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_ulong) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_ulong) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_ulong) -> core::ffi::c_longlong; + fn fast_down_cast( &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - ) -> core::ffi::c_double; - fn outer( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_ulong; + fn get_data_type_value_max(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkUnsignedLongLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ulonglong; + fn set_value( &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, + id: core::ffi::c_longlong, + value: core::ffi::c_ulonglong, ) -> (); - fn outer( + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value( &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, + id: core::ffi::c_longlong, + f: core::ffi::c_ulonglong, ) -> (); - fn cross( + fn insert_next_value(&mut self, f: core::ffi::c_ulonglong) -> core::ffi::c_longlong; + fn fast_down_cast( &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, - ) -> (); - fn cross( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_ulonglong; + fn get_data_type_value_max(&mut self) -> core::ffi::c_ulonglong; +} +pub trait VtkUnsignedShortArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ushort; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_ushort) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_ushort) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_ushort) -> core::ffi::c_longlong; + fn fast_down_cast( &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ) -> (); - fn norm(&mut self, x: core::ffi::c_float, n: core::ffi::c_int) -> core::ffi::c_float; - fn norm( + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_ushort; + fn get_data_type_value_max(&mut self) -> core::ffi::c_ushort; +} +pub trait VtkVariant { + fn is_valid(&mut self) -> bool; + fn is_string(&mut self) -> bool; + fn is_unicode_string(&mut self) -> bool; + fn is_numeric(&mut self) -> bool; + fn is_float(&mut self) -> bool; + fn is_double(&mut self) -> bool; + fn is_char(&mut self) -> bool; + fn is_unsigned_char(&mut self) -> bool; + fn is_signed_char(&mut self) -> bool; + fn is_short(&mut self) -> bool; + fn is_unsigned_short(&mut self) -> bool; + fn is_int(&mut self) -> bool; + fn is_unsigned_int(&mut self) -> bool; + fn is_long(&mut self) -> bool; + fn is_unsigned_long(&mut self) -> bool; + fn is__int_64(&mut self) -> bool; + fn is_unsigned__int_64(&mut self) -> bool; + fn is_long_long(&mut self) -> bool; + fn is_unsigned_long_long(&mut self) -> bool; + fn is_vtk_object(&mut self) -> bool; + fn is_array(&mut self) -> bool; + fn get_type(&mut self) -> core::ffi::c_uint; + fn get_type_as_string(&mut self) -> &str; + fn to_vtk_object(&mut self) -> *mut core::ffi::c_void; + fn to_array(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkVariantArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( &mut self, - x: core::ffi::c_double, - n: core::ffi::c_int, - ) -> core::ffi::c_double; - fn norm(&mut self, v: core::ffi::c_float) -> core::ffi::c_float; - fn norm(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; - fn normalize(&mut self, v: core::ffi::c_float) -> core::ffi::c_float; - fn normalize(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; - fn perpendiculars( - &mut self, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - theta: core::ffi::c_double, - ) -> (); - fn perpendiculars( + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn set_tuple( &mut self, - v1: core::ffi::c_float, - v2: core::ffi::c_float, - v3: core::ffi::c_float, - theta: core::ffi::c_double, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, ) -> (); - fn project_vector( - &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - projection: core::ffi::c_float, - ) -> bool; - fn project_vector( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - projection: core::ffi::c_double, - ) -> bool; - fn project_vector_2_d( - &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - projection: core::ffi::c_float, - ) -> bool; - fn project_vector_2_d( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - projection: core::ffi::c_double, - ) -> bool; - fn distance_2_between_points( + fn insert_tuple( &mut self, - p1: core::ffi::c_float, - p2: core::ffi::c_float, - ) -> core::ffi::c_float; - fn distance_2_between_points( + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - ) -> core::ffi::c_double; - fn angle_between_vectors( + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( &mut self, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - ) -> core::ffi::c_double; - fn signed_angle_between_vectors( + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_pointer(&mut self, id: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn set_array( &mut self, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - vn: core::ffi::c_double, - ) -> core::ffi::c_double; - fn gaussian_amplitude( + arr: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_number_of_values(&mut self) -> core::ffi::c_longlong; + fn data_changed(&mut self) -> (); + fn data_element_changed(&mut self, id: core::ffi::c_longlong) -> (); + fn clear_lookup(&mut self) -> (); +} +pub trait VtkVersion { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_vtk_version(&mut self) -> &str; + fn get_vtk_version_full(&mut self) -> &str; + fn get_vtk_major_version(&mut self) -> core::ffi::c_int; + fn get_vtk_minor_version(&mut self) -> core::ffi::c_int; + fn get_vtk_build_version(&mut self) -> core::ffi::c_int; + fn get_vtk_source_version(&mut self) -> &str; +} +pub trait VtkVoidArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( &mut self, - variance: core::ffi::c_double, - distanceFromMean: core::ffi::c_double, - ) -> core::ffi::c_double; - fn gaussian_amplitude( - &mut self, - mean: core::ffi::c_double, - variance: core::ffi::c_double, - position: core::ffi::c_double, - ) -> core::ffi::c_double; - fn gaussian_weight( - &mut self, - variance: core::ffi::c_double, - distanceFromMean: core::ffi::c_double, - ) -> core::ffi::c_double; - fn gaussian_weight( - &mut self, - mean: core::ffi::c_double, - variance: core::ffi::c_double, - position: core::ffi::c_double, - ) -> core::ffi::c_double; - fn dot_2_d( - &mut self, - x: core::ffi::c_float, - y: core::ffi::c_float, - ) -> core::ffi::c_float; - fn dot_2_d( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> core::ffi::c_double; - fn outer_2_d( - &mut self, - x: core::ffi::c_float, - y: core::ffi::c_float, - A: core::ffi::c_float, - ) -> (); - fn outer_2_d( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - A: core::ffi::c_double, - ) -> (); - fn norm_2_d(&mut self, x: core::ffi::c_float) -> core::ffi::c_float; - fn norm_2_d(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn normalize_2_d(&mut self, v: core::ffi::c_float) -> core::ffi::c_float; - fn normalize_2_d(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; - fn determinant_2_x_2( - &mut self, - c1: core::ffi::c_float, - c2: core::ffi::c_float, - ) -> core::ffi::c_float; - fn determinant_2_x_2( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - d: core::ffi::c_double, - ) -> core::ffi::c_double; - fn determinant_2_x_2( - &mut self, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - ) -> core::ffi::c_double; - fn lu_factor_3_x_3(&mut self, A: core::ffi::c_float, index: core::ffi::c_int) -> (); - fn lu_factor_3_x_3(&mut self, A: core::ffi::c_double, index: core::ffi::c_int) -> (); - fn lu_solve_3_x_3( - &mut self, - A: core::ffi::c_float, - index: core::ffi::c_int, - x: core::ffi::c_float, - ) -> (); - fn lu_solve_3_x_3( - &mut self, - A: core::ffi::c_double, - index: core::ffi::c_int, - x: core::ffi::c_double, - ) -> (); - fn linear_solve_3_x_3( - &mut self, - A: core::ffi::c_float, - x: core::ffi::c_float, - y: core::ffi::c_float, - ) -> (); - fn linear_solve_3_x_3( - &mut self, - A: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> (); - fn multiply_3_x_3( - &mut self, - A: core::ffi::c_float, - v: core::ffi::c_float, - u: core::ffi::c_float, - ) -> (); - fn multiply_3_x_3( - &mut self, - A: core::ffi::c_double, - v: core::ffi::c_double, - u: core::ffi::c_double, - ) -> (); - fn multiply_3_x_3( - &mut self, - A: core::ffi::c_float, - B: core::ffi::c_float, - C: core::ffi::c_float, - ) -> (); - fn multiply_3_x_3( - &mut self, - A: core::ffi::c_double, - B: core::ffi::c_double, - C: core::ffi::c_double, - ) -> (); - fn multiply_matrix( - &mut self, - A: core::ffi::c_double, - B: core::ffi::c_double, - rowA: core::ffi::c_uint, - colA: core::ffi::c_uint, - rowB: core::ffi::c_uint, - colB: core::ffi::c_uint, - C: core::ffi::c_double, - ) -> (); - fn transpose_3_x_3(&mut self, A: core::ffi::c_float, AT: core::ffi::c_float) -> (); - fn transpose_3_x_3(&mut self, A: core::ffi::c_double, AT: core::ffi::c_double) -> (); - fn invert_3_x_3(&mut self, A: core::ffi::c_float, AI: core::ffi::c_float) -> (); - fn invert_3_x_3(&mut self, A: core::ffi::c_double, AI: core::ffi::c_double) -> (); - fn identity_3_x_3(&mut self, A: core::ffi::c_float) -> (); - fn identity_3_x_3(&mut self, A: core::ffi::c_double) -> (); - fn determinant_3_x_3(&mut self, A: core::ffi::c_float) -> core::ffi::c_double; - fn determinant_3_x_3(&mut self, A: core::ffi::c_double) -> core::ffi::c_double; - fn determinant_3_x_3( - &mut self, - c1: core::ffi::c_float, - c2: core::ffi::c_float, - c3: core::ffi::c_float, - ) -> core::ffi::c_float; - fn determinant_3_x_3( - &mut self, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - ) -> core::ffi::c_double; - fn determinant_3_x_3( - &mut self, - a1: core::ffi::c_double, - a2: core::ffi::c_double, - a3: core::ffi::c_double, - b1: core::ffi::c_double, - b2: core::ffi::c_double, - b3: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - ) -> core::ffi::c_double; - fn quaternion_to_matrix_3_x_3( - &mut self, - quat: core::ffi::c_float, - A: core::ffi::c_float, - ) -> (); - fn quaternion_to_matrix_3_x_3( - &mut self, - quat: core::ffi::c_double, - A: core::ffi::c_double, - ) -> (); - fn matrix_3_x_3_to_quaternion( - &mut self, - A: core::ffi::c_float, - quat: core::ffi::c_float, - ) -> (); - fn matrix_3_x_3_to_quaternion( - &mut self, - A: core::ffi::c_double, - quat: core::ffi::c_double, - ) -> (); - fn multiply_quaternion( - &mut self, - q1: core::ffi::c_float, - q2: core::ffi::c_float, - q: core::ffi::c_float, - ) -> (); - fn multiply_quaternion( - &mut self, - q1: core::ffi::c_double, - q2: core::ffi::c_double, - q: core::ffi::c_double, - ) -> (); - fn rotate_vector_by_normalized_quaternion( - &mut self, - v: core::ffi::c_float, - q: core::ffi::c_float, - r: core::ffi::c_float, - ) -> (); - fn rotate_vector_by_normalized_quaternion( - &mut self, - v: core::ffi::c_double, - q: core::ffi::c_double, - r: core::ffi::c_double, - ) -> (); - fn rotate_vector_by_wxyz( - &mut self, - v: core::ffi::c_float, - q: core::ffi::c_float, - r: core::ffi::c_float, - ) -> (); - fn rotate_vector_by_wxyz( - &mut self, - v: core::ffi::c_double, - q: core::ffi::c_double, - r: core::ffi::c_double, - ) -> (); - fn orthogonalize_3_x_3( - &mut self, - A: core::ffi::c_float, - B: core::ffi::c_float, - ) -> (); - fn orthogonalize_3_x_3( - &mut self, - A: core::ffi::c_double, - B: core::ffi::c_double, - ) -> (); - fn diagonalize_3_x_3( - &mut self, - A: core::ffi::c_float, - w: core::ffi::c_float, - V: core::ffi::c_float, - ) -> (); - fn diagonalize_3_x_3( - &mut self, - A: core::ffi::c_double, - w: core::ffi::c_double, - V: core::ffi::c_double, - ) -> (); - fn singular_value_decomposition_3_x_3( - &mut self, - A: core::ffi::c_float, - U: core::ffi::c_float, - w: core::ffi::c_float, - VT: core::ffi::c_float, - ) -> (); - fn singular_value_decomposition_3_x_3( - &mut self, - A: core::ffi::c_double, - U: core::ffi::c_double, - w: core::ffi::c_double, - VT: core::ffi::c_double, - ) -> (); - fn solve_linear_system_gepp_2_x_2( - &mut self, - a00: core::ffi::c_double, - a01: core::ffi::c_double, - a10: core::ffi::c_double, - a11: core::ffi::c_double, - b0: core::ffi::c_double, - b1: core::ffi::c_double, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - ) -> core::ffi::c_int; - fn solve_linear_system( - &mut self, - A: core::ffi::c_double, - x: core::ffi::c_double, - size: core::ffi::c_int, - ) -> core::ffi::c_int; - fn invert_matrix( - &mut self, - A: core::ffi::c_double, - AI: core::ffi::c_double, - size: core::ffi::c_int, - ) -> core::ffi::c_int; - fn invert_matrix( - &mut self, - A: core::ffi::c_double, - AI: core::ffi::c_double, - size: core::ffi::c_int, - tmp1Size: core::ffi::c_int, - tmp2Size: core::ffi::c_double, - ) -> core::ffi::c_int; - fn lu_factor_linear_system( - &mut self, - A: core::ffi::c_double, - index: core::ffi::c_int, - size: core::ffi::c_int, - ) -> core::ffi::c_int; - fn lu_factor_linear_system( - &mut self, - A: core::ffi::c_double, - index: core::ffi::c_int, - size: core::ffi::c_int, - tmpSize: core::ffi::c_double, - ) -> core::ffi::c_int; - fn lu_solve_linear_system( - &mut self, - A: core::ffi::c_double, - index: core::ffi::c_int, - x: core::ffi::c_double, - size: core::ffi::c_int, - ) -> (); - fn estimate_matrix_condition( - &mut self, - A: core::ffi::c_double, - size: core::ffi::c_int, - ) -> core::ffi::c_double; - fn jacobi( - &mut self, - a: core::ffi::c_float, - w: core::ffi::c_float, - v: core::ffi::c_float, - ) -> core::ffi::c_int; - fn jacobi( - &mut self, - a: core::ffi::c_double, - w: core::ffi::c_double, - v: core::ffi::c_double, - ) -> core::ffi::c_int; - fn jacobi_n( - &mut self, - a: core::ffi::c_float, - n: core::ffi::c_int, - w: core::ffi::c_float, - v: core::ffi::c_float, - ) -> core::ffi::c_int; - fn jacobi_n( - &mut self, - a: core::ffi::c_double, - n: core::ffi::c_int, - w: core::ffi::c_double, - v: core::ffi::c_double, - ) -> core::ffi::c_int; - fn solve_homogeneous_least_squares( - &mut self, - numberOfSamples: core::ffi::c_int, - xt: core::ffi::c_double, - xOrder: core::ffi::c_int, - mt: core::ffi::c_double, - ) -> core::ffi::c_int; - fn solve_least_squares( - &mut self, - numberOfSamples: core::ffi::c_int, - xt: core::ffi::c_double, - xOrder: core::ffi::c_int, - yt: core::ffi::c_double, - yOrder: core::ffi::c_int, - mt: core::ffi::c_double, - checkHomogeneous: core::ffi::c_int, - ) -> core::ffi::c_int; - fn rgb_to_hsv(&mut self, rgb: core::ffi::c_float, hsv: core::ffi::c_float) -> (); - fn rgb_to_hsv( - &mut self, - r: core::ffi::c_float, - g: core::ffi::c_float, - b: core::ffi::c_float, - h: core::ffi::c_float, - s: core::ffi::c_float, - v: core::ffi::c_float, - ) -> (); - fn rgb_to_hsv(&mut self, rgb: core::ffi::c_double, hsv: core::ffi::c_double) -> (); - fn rgb_to_hsv( - &mut self, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - h: core::ffi::c_double, - s: core::ffi::c_double, - v: core::ffi::c_double, - ) -> (); - fn hsv_to_rgb(&mut self, hsv: core::ffi::c_float, rgb: core::ffi::c_float) -> (); - fn hsv_to_rgb( - &mut self, - h: core::ffi::c_float, - s: core::ffi::c_float, - v: core::ffi::c_float, - r: core::ffi::c_float, - g: core::ffi::c_float, - b: core::ffi::c_float, - ) -> (); - fn hsv_to_rgb(&mut self, hsv: core::ffi::c_double, rgb: core::ffi::c_double) -> (); - fn hsv_to_rgb( - &mut self, - h: core::ffi::c_double, - s: core::ffi::c_double, - v: core::ffi::c_double, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - ) -> (); - fn lab_to_xyz(&mut self, lab: core::ffi::c_double, xyz: core::ffi::c_double) -> (); - fn lab_to_xyz( - &mut self, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> (); - fn xyz_to_lab(&mut self, xyz: core::ffi::c_double, lab: core::ffi::c_double) -> (); - fn xyz_to_lab( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - ) -> (); - fn xyz_to_rgb(&mut self, xyz: core::ffi::c_double, rgb: core::ffi::c_double) -> (); - fn xyz_to_rgb( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - ) -> (); - fn rgb_to_xyz(&mut self, rgb: core::ffi::c_double, xyz: core::ffi::c_double) -> (); - fn rgb_to_xyz( - &mut self, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> (); - fn rgb_to_lab(&mut self, rgb: core::ffi::c_double, lab: core::ffi::c_double) -> (); - fn rgb_to_lab( - &mut self, - red: core::ffi::c_double, - green: core::ffi::c_double, - blue: core::ffi::c_double, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - ) -> (); - fn lab_to_rgb(&mut self, lab: core::ffi::c_double, rgb: core::ffi::c_double) -> (); - fn lab_to_rgb( - &mut self, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - red: core::ffi::c_double, - green: core::ffi::c_double, - blue: core::ffi::c_double, - ) -> (); - fn uninitialize_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn are_bounds_initialized( - &mut self, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - fn clamp_value( - &mut self, - value: core::ffi::c_double, - range: core::ffi::c_double, - ) -> (); - fn clamp_value( - &mut self, - value: core::ffi::c_double, - range: core::ffi::c_double, - clamped_value: core::ffi::c_double, - ) -> (); - fn clamp_values( - &mut self, - values: core::ffi::c_double, - nb_values: core::ffi::c_int, - range: core::ffi::c_double, - ) -> (); - fn clamp_values( - &mut self, - values: core::ffi::c_double, - nb_values: core::ffi::c_int, - range: core::ffi::c_double, - clamped_values: core::ffi::c_double, - ) -> (); - fn clamp_and_normalize_value( - &mut self, - value: core::ffi::c_double, - range: core::ffi::c_double, - ) -> core::ffi::c_double; - fn get_scalar_type_fitting_range( - &mut self, - range_min: core::ffi::c_double, - range_max: core::ffi::c_double, - scale: core::ffi::c_double, - shift: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_adjusted_scalar_range( - &mut self, - array: *mut core::ffi::c_void, - comp: core::ffi::c_int, - range: core::ffi::c_double, - ) -> core::ffi::c_int; - fn extent_is_within_other_extent( - &mut self, - extent1: core::ffi::c_int, - extent2: core::ffi::c_int, - ) -> core::ffi::c_int; - fn bounds_is_within_other_bounds( - &mut self, - bounds1: core::ffi::c_double, - bounds2: core::ffi::c_double, - delta: core::ffi::c_double, - ) -> core::ffi::c_int; - fn point_is_within_bounds( - &mut self, - point: core::ffi::c_double, - bounds: core::ffi::c_double, - delta: core::ffi::c_double, - ) -> core::ffi::c_int; - fn plane_intersects_aabb( - &mut self, - bounds: core::ffi::c_double, - normal: core::ffi::c_double, - point: core::ffi::c_double, - ) -> core::ffi::c_int; - fn solve_3_point_circle( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - fn inf(&mut self) -> core::ffi::c_double; - fn neg_inf(&mut self) -> core::ffi::c_double; - fn nan(&mut self) -> core::ffi::c_double; - fn is_inf(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; - fn is_nan(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; - fn is_finite(&mut self, x: core::ffi::c_double) -> bool; - fn quadratic_root( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - min: core::ffi::c_double, - max: core::ffi::c_double, - u: core::ffi::c_double, - ) -> core::ffi::c_int; -} -pub trait VtkMersenneTwister: VtkRandomSequence + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn initialize(&mut self, seed: core::ffi::c_uint) -> (); - fn initialize_new_sequence( - &mut self, - seed: core::ffi::c_uint, - p: core::ffi::c_int, - ) -> core::ffi::c_uint; - fn initialize_sequence( - &mut self, - id: core::ffi::c_uint, - seed: core::ffi::c_uint, - p: core::ffi::c_int, - ) -> (); - fn get_value(&mut self, id: core::ffi::c_uint) -> core::ffi::c_double; - fn get_value(&mut self) -> core::ffi::c_double; - fn next(&mut self, id: core::ffi::c_uint) -> (); - fn next(&mut self) -> (); -} -pub trait VtkMinimalStandardRandomSequence: VtkRandomSequence + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn initialize(&mut self, seed: core::ffi::c_uint) -> (); - fn set_seed(&mut self, value: core::ffi::c_int) -> (); - fn set_seed_only(&mut self, value: core::ffi::c_int) -> (); - fn get_seed(&mut self) -> core::ffi::c_int; - fn get_value(&mut self) -> core::ffi::c_double; - fn next(&mut self) -> (); - fn get_range_value( - &mut self, - rangeMin: core::ffi::c_double, - rangeMax: core::ffi::c_double, - ) -> core::ffi::c_double; - fn get_next_range_value( - &mut self, - rangeMin: core::ffi::c_double, - rangeMax: core::ffi::c_double, - ) -> core::ffi::c_double; -} -pub trait VtkMultiThreader: VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set_number_of_threads(&mut self, _arg: core::ffi::c_int) -> (); - fn get_number_of_threads_min_value(&mut self) -> core::ffi::c_int; - fn get_number_of_threads_max_value(&mut self) -> core::ffi::c_int; - fn get_number_of_threads(&mut self) -> core::ffi::c_int; - fn get_global_static_maximum_number_of_threads(&mut self) -> core::ffi::c_int; - fn set_global_maximum_number_of_threads(&mut self, val: core::ffi::c_int) -> (); - fn get_global_maximum_number_of_threads(&mut self) -> core::ffi::c_int; - fn set_global_default_number_of_threads(&mut self, val: core::ffi::c_int) -> (); - fn get_global_default_number_of_threads(&mut self) -> core::ffi::c_int; - fn single_method_execute(&mut self) -> (); - fn multiple_method_execute(&mut self) -> (); - fn set_single_method(&mut self, p0: *mut core::ffi::c_void, data: ()) -> (); - fn set_multiple_method( - &mut self, - index: core::ffi::c_int, - p1: *mut core::ffi::c_void, - data: (), - ) -> (); - fn spawn_thread(&mut self, p0: *mut core::ffi::c_void, data: ()) -> core::ffi::c_int; - fn terminate_thread(&mut self, threadId: core::ffi::c_int) -> (); - fn is_thread_active(&mut self, threadId: core::ffi::c_int) -> core::ffi::c_int; - fn get_current_thread_id(&mut self) -> *mut core::ffi::c_void; - fn threads_equal( - &mut self, - t1: *mut core::ffi::c_void, - t2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; -} -pub trait VtkMutexLock: VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn lock(&mut self) -> (); - fn unlock(&mut self) -> (); -} -pub trait VtkNew { - fn reset(&mut self) -> (); - fn get_pointer(&mut self) -> *mut core::ffi::c_void; - fn get(&mut self) -> *mut core::ffi::c_void; -} -pub trait VtkOStrStreamWrapper { - fn str(&mut self) -> *mut core::ffi::c_char; - fn rdbuf(&mut self) -> *mut core::ffi::c_void; - fn freeze(&mut self) -> (); - fn freeze(&mut self, p0: core::ffi::c_int) -> (); -} -pub trait VtkObject: VtkObjectBase { - fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; - fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_number_of_generations_from_base_type( - &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; - fn get_number_of_generations_from_base( - &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; - fn new(&mut self) -> *mut core::ffi::c_void; - fn debug_on(&mut self) -> (); - fn debug_off(&mut self) -> (); - fn get_debug(&mut self) -> bool; - fn set_debug(&mut self, debugFlag: bool) -> (); - fn break_on_error(&mut self) -> (); - fn modified(&mut self) -> (); - fn get_m_time(&mut self) -> core::ffi::c_ulong; - fn set_global_warning_display(&mut self, val: core::ffi::c_int) -> (); - fn global_warning_display_on(&mut self) -> (); - fn global_warning_display_off(&mut self) -> (); - fn get_global_warning_display(&mut self) -> core::ffi::c_int; - fn add_observer( - &mut self, - event: core::ffi::c_ulong, - p1: *mut core::ffi::c_void, - priority: core::ffi::c_float, - ) -> core::ffi::c_ulong; - fn add_observer( - &mut self, - event: core::ffi::c_char, - p1: *mut core::ffi::c_void, - priority: core::ffi::c_float, - ) -> core::ffi::c_ulong; - fn get_command(&mut self, tag: core::ffi::c_ulong) -> *mut core::ffi::c_void; - fn remove_observer(&mut self, p0: *mut core::ffi::c_void) -> (); - fn remove_observers( - &mut self, - event: core::ffi::c_ulong, - p1: *mut core::ffi::c_void, - ) -> (); - fn remove_observers( - &mut self, - event: core::ffi::c_char, - p1: *mut core::ffi::c_void, - ) -> (); - fn has_observer( - &mut self, - event: core::ffi::c_ulong, - p1: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn has_observer( - &mut self, - event: core::ffi::c_char, - p1: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn remove_observer(&mut self, tag: core::ffi::c_ulong) -> (); - fn remove_observers(&mut self, event: core::ffi::c_ulong) -> (); - fn remove_observers(&mut self, event: core::ffi::c_char) -> (); - fn remove_all_observers(&mut self) -> (); - fn has_observer(&mut self, event: core::ffi::c_ulong) -> core::ffi::c_int; - fn has_observer(&mut self, event: core::ffi::c_char) -> core::ffi::c_int; - fn invoke_event( - &mut self, - event: core::ffi::c_ulong, - callData: (), - ) -> core::ffi::c_int; - fn invoke_event( - &mut self, - event: core::ffi::c_char, - callData: (), - ) -> core::ffi::c_int; - fn invoke_event(&mut self, event: core::ffi::c_ulong) -> core::ffi::c_int; - fn invoke_event(&mut self, event: core::ffi::c_char) -> core::ffi::c_int; -} -pub trait VtkObjectBase { - fn get_class_name(&mut self) -> *const core::ffi::c_char; - fn is_type_of(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; - fn is_a(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; - fn get_number_of_generations_from_base_type( - &mut self, - name: core::ffi::c_char, - ) -> core::ffi::c_uchar; - fn get_number_of_generations_from_base( - &mut self, - name: core::ffi::c_char, - ) -> core::ffi::c_uchar; - fn delete(&mut self) -> (); - fn fast_delete(&mut self) -> (); - fn new(&mut self) -> *mut core::ffi::c_void; - fn initialize_object_base(&mut self) -> (); - fn register(&mut self, o: *mut core::ffi::c_void) -> (); - fn un_register(&mut self, o: *mut core::ffi::c_void) -> (); - fn get_reference_count(&mut self) -> core::ffi::c_int; - fn set_reference_count(&mut self, p0: core::ffi::c_int) -> (); - fn set_memkind_directory(&mut self, directoryname: core::ffi::c_char) -> (); - fn get_using_memkind(&mut self) -> bool; - fn get_is_in_memkind(&mut self) -> bool; -} -pub trait VtkObjectFactory: VtkObject + VtkObjectBase { - fn create_instance( - &mut self, - vtkclassname: core::ffi::c_char, - isAbstract: bool, - ) -> *mut core::ffi::c_void; - fn create_all_instance( - &mut self, - vtkclassname: core::ffi::c_char, - retList: *mut core::ffi::c_void, - ) -> (); - fn re_hash(&mut self) -> (); - fn register_factory(&mut self, p0: *mut core::ffi::c_void) -> (); - fn un_register_factory(&mut self, p0: *mut core::ffi::c_void) -> (); - fn un_register_all_factories(&mut self) -> (); - fn get_registered_factories(&mut self) -> *mut core::ffi::c_void; - fn has_override_any(&mut self, className: core::ffi::c_char) -> core::ffi::c_int; - fn get_override_information( - &mut self, - name: core::ffi::c_char, - p1: *mut core::ffi::c_void, - ) -> (); - fn set_all_enable_flags( - &mut self, - flag: core::ffi::c_int, - className: core::ffi::c_char, - ) -> (); - fn set_all_enable_flags( - &mut self, - flag: core::ffi::c_int, - className: core::ffi::c_char, - subclassName: core::ffi::c_char, - ) -> (); - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_vtk_source_version(&mut self) -> *const core::ffi::c_char; - fn get_description(&mut self) -> *const core::ffi::c_char; - fn get_number_of_overrides(&mut self) -> core::ffi::c_int; - fn get_class_override_name( - &mut self, - index: core::ffi::c_int, - ) -> *const core::ffi::c_char; - fn get_class_override_with_name( - &mut self, - index: core::ffi::c_int, - ) -> *const core::ffi::c_char; - fn get_enable_flag(&mut self, index: core::ffi::c_int) -> core::ffi::c_int; - fn get_override_description( - &mut self, - index: core::ffi::c_int, - ) -> *const core::ffi::c_char; - fn set_enable_flag( - &mut self, - flag: core::ffi::c_int, - className: core::ffi::c_char, - subclassName: core::ffi::c_char, - ) -> (); - fn get_enable_flag( - &mut self, - className: core::ffi::c_char, - subclassName: core::ffi::c_char, - ) -> core::ffi::c_int; - fn has_override(&mut self, className: core::ffi::c_char) -> core::ffi::c_int; - fn has_override( - &mut self, - className: core::ffi::c_char, - subclassName: core::ffi::c_char, - ) -> core::ffi::c_int; - fn disable(&mut self, className: core::ffi::c_char) -> (); - fn get_library_path(&mut self) -> *mut core::ffi::c_char; -} -pub trait VtkObjectFactoryCollection: VtkCollection + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn add_item(&mut self, t: *mut core::ffi::c_void) -> (); - fn get_next_item(&mut self) -> *mut core::ffi::c_void; - fn get_next_object_factory(&mut self, cookie: ()) -> *mut core::ffi::c_void; -} -pub trait VtkOldStyleCallbackCommand: VtkCommand + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn execute( - &mut self, - invoker: *mut core::ffi::c_void, - eid: core::ffi::c_ulong, - calldata: (), - ) -> (); - fn set_client_data(&mut self, cd: ()) -> (); - fn set_callback(&mut self, f: *mut core::ffi::c_void) -> (); - fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> (); -} -pub trait VtkOutputWindow: VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn get_instance(&mut self) -> *mut core::ffi::c_void; - fn set_instance(&mut self, instance: *mut core::ffi::c_void) -> (); - fn display_text(&mut self, p0: core::ffi::c_char) -> (); - fn display_error_text(&mut self, p0: core::ffi::c_char) -> (); - fn display_warning_text(&mut self, p0: core::ffi::c_char) -> (); - fn display_generic_warning_text(&mut self, p0: core::ffi::c_char) -> (); - fn display_debug_text(&mut self, p0: core::ffi::c_char) -> (); - fn prompt_user_on(&mut self) -> (); - fn prompt_user_off(&mut self) -> (); - fn set_prompt_user(&mut self, _arg: bool) -> (); - fn set_use_std_error_for_all_messages(&mut self, p0: bool) -> (); - fn get_use_std_error_for_all_messages(&mut self) -> bool; - fn use_std_error_for_all_messages_on(&mut self) -> (); - fn use_std_error_for_all_messages_off(&mut self) -> (); - fn set_display_mode(&mut self, _arg: core::ffi::c_int) -> (); - fn get_display_mode_min_value(&mut self) -> core::ffi::c_int; - fn get_display_mode_max_value(&mut self) -> core::ffi::c_int; - fn get_display_mode(&mut self) -> core::ffi::c_int; - fn set_display_mode_to_default(&mut self) -> (); - fn set_display_mode_to_never(&mut self) -> (); - fn set_display_mode_to_always(&mut self) -> (); - fn set_display_mode_to_always_std_err(&mut self) -> (); -} -pub trait VtkOverrideInformation: VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_class_override_name(&mut self) -> *const core::ffi::c_char; - fn get_class_override_with_name(&mut self) -> *const core::ffi::c_char; - fn get_description(&mut self) -> *const core::ffi::c_char; - fn get_object_factory(&mut self) -> *mut core::ffi::c_void; - fn set_class_override_name(&mut self, _arg: core::ffi::c_char) -> (); - fn set_class_override_with_name(&mut self, _arg: core::ffi::c_char) -> (); - fn set_description(&mut self, _arg: core::ffi::c_char) -> (); -} -pub trait VtkOverrideInformationCollection: VtkCollection + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); - fn get_next_item(&mut self) -> *mut core::ffi::c_void; - fn get_next_override_information(&mut self, cookie: ()) -> *mut core::ffi::c_void; -} -pub trait VtkPoints: VtkObject + VtkObjectBase { - fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn allocate( - &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn initialize(&mut self) -> (); - fn set_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn get_data(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn set_data_type(&mut self, dataType: core::ffi::c_int) -> (); - fn set_data_type_to_bit(&mut self) -> (); - fn set_data_type_to_char(&mut self) -> (); - fn set_data_type_to_unsigned_char(&mut self) -> (); - fn set_data_type_to_short(&mut self) -> (); - fn set_data_type_to_unsigned_short(&mut self) -> (); - fn set_data_type_to_int(&mut self) -> (); - fn set_data_type_to_unsigned_int(&mut self) -> (); - fn set_data_type_to_long(&mut self) -> (); - fn set_data_type_to_unsigned_long(&mut self) -> (); - fn set_data_type_to_float(&mut self) -> (); - fn set_data_type_to_double(&mut self) -> (); - fn get_void_pointer(&mut self, id: core::ffi::c_int) -> *mut (); - fn squeeze(&mut self) -> (); - fn reset(&mut self) -> (); - fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> (); - fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> (); - fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; - fn get_point(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); - fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> (); - fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); - fn set_point( - &mut self, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> (); - fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> (); - fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); - fn insert_point( - &mut self, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> (); - fn insert_points( - &mut self, - dstIds: *mut core::ffi::c_void, - srcIds: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_points( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_next_point(&mut self, x: core::ffi::c_float) -> core::ffi::c_uchar; - fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn insert_next_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn set_number_of_points(&mut self, numPoints: core::ffi::c_uchar) -> (); - fn resize(&mut self, numPoints: core::ffi::c_uchar) -> core::ffi::c_int; - fn get_points( - &mut self, - ptId: *mut core::ffi::c_void, - outPoints: *mut core::ffi::c_void, - ) -> (); - fn compute_bounds(&mut self) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_m_time(&mut self) -> core::ffi::c_ulong; - fn modified(&mut self) -> (); -} -pub trait VtkPoints2D: VtkObject + VtkObjectBase { - fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn allocate( - &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn initialize(&mut self) -> (); - fn set_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn get_data(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn set_data_type(&mut self, dataType: core::ffi::c_int) -> (); - fn set_data_type_to_bit(&mut self) -> (); - fn set_data_type_to_char(&mut self) -> (); - fn set_data_type_to_unsigned_char(&mut self) -> (); - fn set_data_type_to_short(&mut self) -> (); - fn set_data_type_to_unsigned_short(&mut self) -> (); - fn set_data_type_to_int(&mut self) -> (); - fn set_data_type_to_unsigned_int(&mut self) -> (); - fn set_data_type_to_long(&mut self) -> (); - fn set_data_type_to_unsigned_long(&mut self) -> (); - fn set_data_type_to_float(&mut self) -> (); - fn set_data_type_to_double(&mut self) -> (); - fn get_void_pointer(&mut self, id: core::ffi::c_int) -> *mut (); - fn squeeze(&mut self) -> (); - fn reset(&mut self) -> (); - fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> (); - fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> (); - fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; - fn get_point(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); - fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> (); - fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); - fn set_point( - &mut self, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> (); - fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> (); - fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); - fn insert_point( - &mut self, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> (); - fn insert_next_point(&mut self, x: core::ffi::c_float) -> core::ffi::c_uchar; - fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn insert_next_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn remove_point(&mut self, id: core::ffi::c_uchar) -> (); - fn set_number_of_points(&mut self, numPoints: core::ffi::c_uchar) -> (); - fn resize(&mut self, numPoints: core::ffi::c_uchar) -> core::ffi::c_int; - fn get_points( - &mut self, - ptId: *mut core::ffi::c_void, - fp: *mut core::ffi::c_void, - ) -> (); - fn compute_bounds(&mut self) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); -} -pub trait VtkPriorityQueue: VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn allocate(&mut self, sz: core::ffi::c_uchar, ext: core::ffi::c_uchar) -> (); - fn insert(&mut self, priority: core::ffi::c_double, id: core::ffi::c_uchar) -> (); - fn pop( - &mut self, - location: core::ffi::c_uchar, - priority: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn pop(&mut self, location: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn peek( - &mut self, - location: core::ffi::c_uchar, - priority: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn peek(&mut self, location: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn delete_id(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double; - fn get_priority(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double; - fn get_number_of_items(&mut self) -> core::ffi::c_uchar; - fn reset(&mut self) -> (); -} -pub trait VtkRandomPool: VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set_sequence(&mut self, seq: *mut core::ffi::c_void) -> (); - fn get_sequence(&mut self) -> *mut core::ffi::c_void; - fn set_size(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_size_min_value(&mut self) -> core::ffi::c_uchar; - fn get_size_max_value(&mut self) -> core::ffi::c_uchar; - fn get_size(&mut self) -> core::ffi::c_uchar; - fn set_number_of_components(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_number_of_components_min_value(&mut self) -> core::ffi::c_uchar; - fn get_number_of_components_max_value(&mut self) -> core::ffi::c_uchar; - fn get_number_of_components(&mut self) -> core::ffi::c_uchar; - fn get_total_size(&mut self) -> core::ffi::c_uchar; - fn generate_pool(&mut self) -> *const core::ffi::c_double; - fn get_pool(&mut self) -> *const core::ffi::c_double; - fn get_value(&mut self, i: core::ffi::c_uchar) -> core::ffi::c_double; - fn get_value( - &mut self, - i: core::ffi::c_uchar, - compNum: core::ffi::c_int, - ) -> core::ffi::c_double; - fn populate_data_array( - &mut self, - da: *mut core::ffi::c_void, - minRange: core::ffi::c_double, - maxRange: core::ffi::c_double, - ) -> (); - fn populate_data_array( - &mut self, - da: *mut core::ffi::c_void, - compNumber: core::ffi::c_int, - minRange: core::ffi::c_double, - maxRange: core::ffi::c_double, - ) -> (); - fn set_chunk_size(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_chunk_size_min_value(&mut self) -> core::ffi::c_uchar; - fn get_chunk_size_max_value(&mut self) -> core::ffi::c_uchar; - fn get_chunk_size(&mut self) -> core::ffi::c_uchar; -} -pub trait VtkRandomSequence: VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn initialize(&mut self, seed: core::ffi::c_uint) -> (); - fn get_value(&mut self) -> core::ffi::c_double; - fn next(&mut self) -> (); - fn get_next_value(&mut self) -> core::ffi::c_double; -} -pub trait VtkReferenceCount: VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; -} -pub trait VtkSMPThreadLocal { - fn local(&mut self) -> *mut core::ffi::c_void; - fn size(&mut self) -> usize; -} -pub trait VtkSMPThreadLocalObject { - fn local(&mut self) -> *mut core::ffi::c_void; - fn size(&mut self) -> usize; - fn begin(&mut self) -> *mut core::ffi::c_void; - fn end(&mut self) -> *mut core::ffi::c_void; -} -pub trait VtkSMPTools { - fn get_backend(&mut self) -> *const core::ffi::c_char; - fn set_backend(&mut self, backend: core::ffi::c_char) -> bool; - fn initialize(&mut self, numThreads: core::ffi::c_int) -> (); - fn get_estimated_number_of_threads(&mut self) -> core::ffi::c_int; - fn set_nested_parallelism(&mut self, isNested: bool) -> (); - fn get_nested_parallelism(&mut self) -> bool; - fn is_parallel_scope(&mut self) -> bool; -} -pub trait VtkSOADataArrayTemplate: VtkGenericDataArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn get_value(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_value( - &mut self, - valueIdx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn get_typed_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - tuple: *mut core::ffi::c_void, - ) -> (); - fn set_typed_tuple(&mut self, tupleIdx: core::ffi::c_uchar, tuple: ValueTypeT) -> (); - fn get_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn set_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - comp: core::ffi::c_int, - value: *mut core::ffi::c_void, - ) -> (); - fn set_array( - &mut self, - comp: core::ffi::c_int, - array: *mut core::ffi::c_void, - size: core::ffi::c_uchar, - updateMaxId: bool, - save: bool, - deleteMethod: core::ffi::c_int, - ) -> (); - fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); - fn set_array_free_function( - &mut self, - comp: core::ffi::c_int, - callback: *mut core::ffi::c_void, - ) -> (); - fn get_component_array_pointer( - &mut self, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_void_pointer(&mut self, valueIdx: core::ffi::c_uchar) -> *mut (); - fn export_to_void_pointer(&mut self, ptr: ()) -> (); - fn set_number_of_components(&mut self, numComps: core::ffi::c_int) -> (); -} -pub trait VtkScalarsToColors: VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn is_opaque(&mut self) -> core::ffi::c_int; - fn is_opaque( - &mut self, - scalars: *mut core::ffi::c_void, - colorMode: core::ffi::c_int, - component: core::ffi::c_int, - ) -> core::ffi::c_int; - fn build(&mut self) -> (); - fn get_range(&mut self) -> *mut core::ffi::c_double; - fn set_range(&mut self, min: core::ffi::c_double, max: core::ffi::c_double) -> (); - fn set_range(&mut self, rng: core::ffi::c_double) -> (); - fn map_value(&mut self, v: core::ffi::c_double) -> *const core::ffi::c_uchar; - fn get_color(&mut self, v: core::ffi::c_double, rgb: core::ffi::c_double) -> (); - fn get_color(&mut self, v: core::ffi::c_double) -> *mut core::ffi::c_double; - fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; - fn get_luminance(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn set_alpha(&mut self, alpha: core::ffi::c_double) -> (); - fn get_alpha(&mut self) -> core::ffi::c_double; - fn map_scalars( - &mut self, - scalars: *mut core::ffi::c_void, - colorMode: core::ffi::c_int, - component: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn map_scalars( - &mut self, - scalars: *mut core::ffi::c_void, - colorMode: core::ffi::c_int, - component: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn set_vector_mode(&mut self, _arg: core::ffi::c_int) -> (); - fn get_vector_mode(&mut self) -> core::ffi::c_int; - fn set_vector_mode_to_magnitude(&mut self) -> (); - fn set_vector_mode_to_component(&mut self) -> (); - fn set_vector_mode_to_rgb_colors(&mut self) -> (); - fn set_vector_component(&mut self, _arg: core::ffi::c_int) -> (); - fn get_vector_component(&mut self) -> core::ffi::c_int; - fn set_vector_size(&mut self, _arg: core::ffi::c_int) -> (); - fn get_vector_size(&mut self) -> core::ffi::c_int; - fn map_vectors_through_table( - &mut self, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - vectorComponent: core::ffi::c_int, - vectorSize: core::ffi::c_int, - ) -> (); - fn map_vectors_through_table( - &mut self, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> (); - fn map_scalars_through_table( - &mut self, - scalars: *mut core::ffi::c_void, - output: core::ffi::c_uchar, - outputFormat: core::ffi::c_int, - ) -> (); - fn map_scalars_through_table( - &mut self, - scalars: *mut core::ffi::c_void, - output: core::ffi::c_uchar, - ) -> (); - fn map_scalars_through_table( - &mut self, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> (); - fn map_scalars_through_table_2( - &mut self, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> (); - fn deep_copy(&mut self, o: *mut core::ffi::c_void) -> (); - fn using_log_scale(&mut self) -> core::ffi::c_int; - fn get_number_of_available_colors(&mut self) -> core::ffi::c_uchar; - fn set_annotations( - &mut self, - values: *mut core::ffi::c_void, - annotations: *mut core::ffi::c_void, - ) -> (); - fn get_annotated_values(&mut self) -> *mut core::ffi::c_void; - fn get_annotations(&mut self) -> *mut core::ffi::c_void; - fn set_annotation( - &mut self, - value: *mut core::ffi::c_void, - annotation: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn set_annotation( - &mut self, - value: *mut core::ffi::c_void, - annotation: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn get_number_of_annotated_values(&mut self) -> core::ffi::c_uchar; - fn get_annotated_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_annotation(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_annotation_color(&mut self, val: vtkVariant, rgba: core::ffi::c_double) -> (); - fn get_annotated_value_index( - &mut self, - val: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn get_annotated_value_index_internal( - &mut self, - val: vtkVariant, - ) -> core::ffi::c_uchar; - fn get_indexed_color( - &mut self, - i: core::ffi::c_uchar, - rgba: core::ffi::c_double, - ) -> (); - fn remove_annotation(&mut self, value: *mut core::ffi::c_void) -> bool; - fn reset_annotations(&mut self) -> (); - fn set_indexed_lookup(&mut self, _arg: core::ffi::c_int) -> (); - fn get_indexed_lookup(&mut self) -> core::ffi::c_int; - fn indexed_lookup_on(&mut self) -> (); - fn indexed_lookup_off(&mut self) -> (); -} -pub trait VtkShortArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_short, - ) -> (); - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_short, - ) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_short, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_short, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_short; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_short) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_short) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_short) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_short; - fn get_value_range(&mut self) -> *mut core::ffi::c_short; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_short; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_short; - fn set_array( - &mut self, - array: core::ffi::c_short, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array( - &mut self, - array: core::ffi::c_short, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_short; - fn get_data_type_value_max(&mut self) -> core::ffi::c_short; -} -pub trait VtkSignedCharArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_char) -> (); - fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_char) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_char, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_char; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_char) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_char; - fn get_value_range(&mut self) -> *mut core::ffi::c_char; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_char; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_char; - fn set_array( - &mut self, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array( - &mut self, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_char; - fn get_data_type_value_max(&mut self) -> core::ffi::c_char; -} -pub trait VtkSimpleConditionVariable { - fn new(&mut self) -> *mut core::ffi::c_void; - fn delete(&mut self) -> (); - fn signal(&mut self) -> (); - fn broadcast(&mut self) -> (); - fn wait(&mut self, mutex: *mut core::ffi::c_void) -> core::ffi::c_int; -} -pub trait VtkSimpleCriticalSection { - fn init(&mut self) -> (); - fn lock(&mut self) -> (); - fn unlock(&mut self) -> (); -} -pub trait VtkSimpleMutexLock { - fn new(&mut self) -> *mut core::ffi::c_void; - fn delete(&mut self) -> (); - fn lock(&mut self) -> (); - fn unlock(&mut self) -> (); -} -pub trait VtkSmartPointer: VtkSmartPointerBase { - fn get_pointer(&mut self) -> *mut core::ffi::c_void; - fn get(&mut self) -> *mut core::ffi::c_void; - fn take_reference(&mut self, t: *mut core::ffi::c_void) -> (); -} -pub trait VtkSmartPointerBase { - fn get_pointer(&mut self) -> *mut core::ffi::c_void; - fn report( - &mut self, - collector: *mut core::ffi::c_void, - desc: core::ffi::c_char, - ) -> (); -} -pub trait VtkSortDataArray: VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn sort(&mut self, keys: *mut core::ffi::c_void) -> (); - fn sort(&mut self, keys: *mut core::ffi::c_void) -> (); - fn sort(&mut self, keys: *mut core::ffi::c_void, dir: core::ffi::c_int) -> (); - fn sort(&mut self, keys: *mut core::ffi::c_void, dir: core::ffi::c_int) -> (); - fn sort( - &mut self, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - ) -> (); - fn sort( - &mut self, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - ) -> (); - fn sort( - &mut self, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - dir: core::ffi::c_int, - ) -> (); - fn sort( - &mut self, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - dir: core::ffi::c_int, - ) -> (); - fn sort_array_by_component( - &mut self, - arr: *mut core::ffi::c_void, - k: core::ffi::c_int, - ) -> (); - fn sort_array_by_component( - &mut self, - arr: *mut core::ffi::c_void, - k: core::ffi::c_int, - dir: core::ffi::c_int, - ) -> (); - fn initialize_sort_indices( - &mut self, - numKeys: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - fn generate_sort_indices( - &mut self, - dataType: core::ffi::c_int, - dataIn: (), - numKeys: core::ffi::c_uchar, - numComp: core::ffi::c_int, - k: core::ffi::c_int, - idx: core::ffi::c_uchar, - ) -> (); - fn shuffle_array( - &mut self, - idx: core::ffi::c_uchar, - dataType: core::ffi::c_int, - numKeys: core::ffi::c_uchar, - numComp: core::ffi::c_int, - arr: *mut core::ffi::c_void, - dataIn: (), - dir: core::ffi::c_int, - ) -> (); - fn shuffle_id_list( - &mut self, - idx: core::ffi::c_uchar, - sze: core::ffi::c_uchar, - arrayIn: *mut core::ffi::c_void, - dataIn: core::ffi::c_uchar, - dir: core::ffi::c_int, - ) -> (); -} -pub trait VtkSparseArray: VtkTypedArray + VtkArray + VtkObject + VtkObjectBase { - fn is_dense(&mut self) -> bool; - fn get_extents(&mut self) -> vtkArrayExtents; - fn get_non_null_size(&mut self) -> core::ffi::c_ulonglong; - fn get_coordinates_n( - &mut self, - n: core::ffi::c_ulonglong, - coordinates: *mut core::ffi::c_void, - ) -> (); - fn deep_copy(&mut self) -> *mut core::ffi::c_void; - fn get_value(&mut self, i: core::ffi::c_uchar) -> T; - fn get_value(&mut self, i: core::ffi::c_uchar, j: core::ffi::c_uchar) -> T; - fn get_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - k: core::ffi::c_uchar, - ) -> T; - fn get_value(&mut self, coordinates: vtkArrayCoordinates) -> T; - fn get_value_n(&mut self, n: core::ffi::c_ulonglong) -> T; - fn set_value(&mut self, i: core::ffi::c_uchar, value: T) -> (); - fn set_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - value: T, - ) -> (); - fn set_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - k: core::ffi::c_uchar, - value: T, - ) -> (); - fn set_value(&mut self, coordinates: vtkArrayCoordinates, value: T) -> (); - fn set_value_n(&mut self, n: core::ffi::c_ulonglong, value: T) -> (); - fn set_null_value(&mut self, value: T) -> (); - fn get_null_value(&mut self) -> T; - fn clear(&mut self) -> (); - fn sort(&mut self, sort: vtkArraySort) -> (); - fn get_unique_coordinates( - &mut self, - dimension: core::ffi::c_uchar, - ) -> Vec; - fn get_coordinate_storage( - &mut self, - dimension: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_coordinate_storage( - &mut self, - dimension: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - fn get_value_storage(&mut self) -> *const T; - fn get_value_storage(&mut self) -> *mut core::ffi::c_void; - fn reserve_storage(&mut self, value_count: core::ffi::c_ulonglong) -> (); - fn set_extents_from_contents(&mut self) -> (); - fn set_extents(&mut self, extents: vtkArrayExtents) -> (); - fn add_value(&mut self, i: core::ffi::c_uchar, value: T) -> (); - fn add_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - value: T, - ) -> (); - fn add_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - k: core::ffi::c_uchar, - value: T, - ) -> (); - fn add_value(&mut self, coordinates: vtkArrayCoordinates, value: T) -> (); - fn validate(&mut self) -> bool; -} -pub trait VtkStringArray: VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn is_numeric(&mut self) -> core::ffi::c_int; - fn initialize(&mut self) -> (); - fn get_data_type_size(&mut self) -> core::ffi::c_int; - fn squeeze(&mut self) -> (); - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; - fn set_tuple( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_tuple( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_tuples( - &mut self, - dstIds: *mut core::ffi::c_void, - srcIds: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_tuples( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_next_tuple( - &mut self, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ) -> (); - fn get_tuples( - &mut self, - ptIds: *mut core::ffi::c_void, - output: *mut core::ffi::c_void, - ) -> (); - fn get_tuples( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - output: *mut core::ffi::c_void, - ) -> (); - fn allocate( - &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn get_value(&mut self, id: core::ffi::c_uchar) -> vtkStdString; - fn get_value(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_value(&mut self, id: core::ffi::c_uchar, value: *mut core::ffi::c_void) -> (); - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> (); - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); - fn get_number_of_values(&mut self) -> core::ffi::c_uchar; - fn get_number_of_element_components(&mut self) -> core::ffi::c_int; - fn get_element_component_size(&mut self) -> core::ffi::c_int; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: *mut core::ffi::c_void) -> (); - fn insert_value(&mut self, id: core::ffi::c_uchar, val: core::ffi::c_char) -> (); - fn set_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_next_value(&mut self, f: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); - fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); - fn set_array( - &mut self, - array: *mut core::ffi::c_void, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); - fn set_void_array( - &mut self, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); - fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; - fn new_iterator(&mut self) -> *mut core::ffi::c_void; - fn get_data_size(&mut self) -> core::ffi::c_uchar; - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> (); - fn lookup_value(&mut self, value: vtkStdString) -> core::ffi::c_uchar; - fn lookup_value(&mut self, value: vtkStdString, ids: *mut core::ffi::c_void) -> (); - fn lookup_value(&mut self, value: core::ffi::c_char) -> core::ffi::c_uchar; - fn lookup_value( - &mut self, - value: core::ffi::c_char, - ids: *mut core::ffi::c_void, - ) -> (); - fn data_changed(&mut self) -> (); - fn data_element_changed(&mut self, id: core::ffi::c_uchar) -> (); - fn clear_lookup(&mut self) -> (); -} -pub trait VtkStringOutputWindow: VtkOutputWindow + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn display_text(&mut self, p0: core::ffi::c_char) -> (); - fn get_output(&mut self) -> &str; -} -pub trait VtkTestDataArray: VtkGenericDataArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn get_value(&mut self, valueIdx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_value( - &mut self, - valueIdx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn get_typed_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - tuple: *mut core::ffi::c_void, - ) -> (); - fn set_typed_tuple( - &mut self, - tupleIdx: core::ffi::c_uchar, - tuple: ArrayT::ValueType, - ) -> (); - fn get_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - compIdx: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn set_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - compIdx: core::ffi::c_int, - value: *mut core::ffi::c_void, - ) -> (); -} -pub trait VtkTimePointUtility: VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn date_to_time_point( - &mut self, - year: core::ffi::c_int, - month: core::ffi::c_int, - day: core::ffi::c_int, - ) -> core::ffi::c_ulonglong; - fn time_to_time_point( - &mut self, - hour: core::ffi::c_int, - minute: core::ffi::c_int, - second: core::ffi::c_int, - millis: core::ffi::c_int, - ) -> core::ffi::c_ulonglong; - fn date_time_to_time_point( - &mut self, - year: core::ffi::c_int, - month: core::ffi::c_int, - day: core::ffi::c_int, - hour: core::ffi::c_int, - minute: core::ffi::c_int, - sec: core::ffi::c_int, - millis: core::ffi::c_int, - ) -> core::ffi::c_ulonglong; - fn get_date( - &mut self, - time: core::ffi::c_ulonglong, - year: core::ffi::c_int, - month: core::ffi::c_int, - day: core::ffi::c_int, - ) -> (); - fn get_time( - &mut self, - time: core::ffi::c_ulonglong, - hour: core::ffi::c_int, - minute: core::ffi::c_int, - second: core::ffi::c_int, - millis: core::ffi::c_int, - ) -> (); - fn get_date_time( - &mut self, - time: core::ffi::c_ulonglong, - year: core::ffi::c_int, - month: core::ffi::c_int, - day: core::ffi::c_int, - hour: core::ffi::c_int, - minute: core::ffi::c_int, - second: core::ffi::c_int, - millis: core::ffi::c_int, - ) -> (); - fn get_year(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; - fn get_month(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; - fn get_day(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; - fn get_hour(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; - fn get_minute(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; - fn get_second(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; - fn get_millisecond(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; - fn iso_8601_to_time_point( - &mut self, - str: core::ffi::c_char, - ok: bool, - ) -> core::ffi::c_ulonglong; - fn time_point_to_iso_8601( - &mut self, - p0: core::ffi::c_ulonglong, - format: core::ffi::c_int, - ) -> *const core::ffi::c_char; -} -pub trait VtkTimeStamp { - fn new(&mut self) -> *mut core::ffi::c_void; - fn delete(&mut self) -> (); - fn modified(&mut self) -> (); - fn get_m_time(&mut self) -> core::ffi::c_ulong; -} -pub trait VtkTypeFloat32Array: VtkFloatArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkTypeFloat64Array: VtkDoubleArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkTypeInt16Array: VtkShortArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkTypeInt32Array: VtkIntArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkTypeInt64Array: VtkLongLongArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkTypeInt8Array: VtkSignedCharArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkTypeUInt16Array: VtkUnsignedShortArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkTypeUInt32Array: VtkUnsignedIntArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkTypeUInt64Array: VtkUnsignedLongLongArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkTypeUInt8Array: VtkUnsignedCharArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkTypedArray: VtkArray + VtkObject + VtkObjectBase { - fn get_variant_value( - &mut self, - coordinates: vtkArrayCoordinates, - ) -> *mut core::ffi::c_void; - fn get_variant_value_n( - &mut self, - n: core::ffi::c_ulonglong, - ) -> *mut core::ffi::c_void; - fn set_variant_value( - &mut self, - coordinates: vtkArrayCoordinates, - value: vtkVariant, - ) -> (); - fn set_variant_value_n( - &mut self, - n: core::ffi::c_ulonglong, - value: vtkVariant, - ) -> (); - fn copy_value( - &mut self, - source: *mut core::ffi::c_void, - source_coordinates: vtkArrayCoordinates, - target_coordinates: vtkArrayCoordinates, - ) -> (); - fn copy_value( - &mut self, - source: *mut core::ffi::c_void, - source_index: core::ffi::c_ulonglong, - target_coordinates: vtkArrayCoordinates, - ) -> (); - fn copy_value( - &mut self, - source: *mut core::ffi::c_void, - source_coordinates: vtkArrayCoordinates, - target_index: core::ffi::c_ulonglong, - ) -> (); - fn get_value(&mut self, i: core::ffi::c_uchar) -> T; - fn get_value(&mut self, i: core::ffi::c_uchar, j: core::ffi::c_uchar) -> T; - fn get_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - k: core::ffi::c_uchar, - ) -> T; - fn get_value(&mut self, coordinates: vtkArrayCoordinates) -> T; - fn get_value_n(&mut self, n: core::ffi::c_ulonglong) -> T; - fn set_value(&mut self, i: core::ffi::c_uchar, value: T) -> (); - fn set_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - value: T, - ) -> (); - fn set_value( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - k: core::ffi::c_uchar, - value: T, - ) -> (); - fn set_value(&mut self, coordinates: vtkArrayCoordinates, value: T) -> (); - fn set_value_n(&mut self, n: core::ffi::c_ulonglong, value: T) -> (); -} -pub trait VtkTypedDataArray: VtkGenericDataArray + VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_data_type_size(&mut self) -> core::ffi::c_int; - fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, t: ValueTypeT) -> (); - fn insert_typed_tuple(&mut self, i: core::ffi::c_uchar, t: ValueTypeT) -> (); - fn insert_next_typed_tuple(&mut self, t: ValueTypeT) -> core::ffi::c_uchar; - fn get_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_value_reference(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn get_typed_tuple( - &mut self, - idx: core::ffi::c_uchar, - t: *mut core::ffi::c_void, - ) -> (); - fn insert_next_value(&mut self, v: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn insert_value(&mut self, idx: core::ffi::c_uchar, v: *mut core::ffi::c_void) -> (); - fn get_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn set_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - comp: core::ffi::c_int, - v: *mut core::ffi::c_void, - ) -> (); - fn allocate( - &mut self, - size: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> core::ffi::c_int; -} -pub trait VtkUnicodeString { - fn is_utf_8(&mut self, p0: core::ffi::c_char) -> bool; - fn is_utf_8(&mut self, p0: &str) -> bool; - fn from_utf_8(&mut self, p0: core::ffi::c_char) -> *mut core::ffi::c_void; - fn from_utf_8( - &mut self, - begin: core::ffi::c_char, - end: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn from_utf_8(&mut self, p0: &str) -> *mut core::ffi::c_void; - fn from_utf_16(&mut self, p0: core::ffi::c_ushort) -> *mut core::ffi::c_void; - fn begin(&mut self) -> *mut core::ffi::c_void; - fn end(&mut self) -> *mut core::ffi::c_void; - fn at(&mut self, offset: *mut core::ffi::c_void) -> core::ffi::c_uint; - fn utf_8_str(&mut self) -> *const core::ffi::c_char; - fn utf_8_str(&mut self, result: &str) -> (); - fn utf_16_str(&mut self) -> Vec; - fn utf_16_str(&mut self, result: Vec) -> (); - fn byte_count(&mut self) -> *mut core::ffi::c_void; - fn character_count(&mut self) -> *mut core::ffi::c_void; - fn empty(&mut self) -> bool; - fn push_back(&mut self, p0: core::ffi::c_uint) -> (); - fn append(&mut self, value: vtkUnicodeString) -> (); - fn append( - &mut self, - count: *mut core::ffi::c_void, - character: core::ffi::c_uint, - ) -> (); - fn append( - &mut self, - begin: *mut core::ffi::c_void, - end: *mut core::ffi::c_void, - ) -> (); - fn assign(&mut self, value: vtkUnicodeString) -> (); - fn assign( - &mut self, - count: *mut core::ffi::c_void, - character: core::ffi::c_uint, - ) -> (); - fn assign( - &mut self, - begin: *mut core::ffi::c_void, - end: *mut core::ffi::c_void, - ) -> (); - fn clear(&mut self) -> (); - fn fold_case(&mut self) -> *mut core::ffi::c_void; - fn compare(&mut self, p0: vtkUnicodeString) -> core::ffi::c_int; - fn substr( - &mut self, - offset: *mut core::ffi::c_void, - count: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn swap(&mut self, p0: *mut core::ffi::c_void) -> (); -} -pub trait VtkUnicodeStringArray: VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn allocate( - &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn initialize(&mut self) -> (); - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_data_type_size(&mut self) -> core::ffi::c_int; - fn get_element_component_size(&mut self) -> core::ffi::c_int; - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); - fn set_tuple( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_tuple( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_tuples( - &mut self, - dstIds: *mut core::ffi::c_void, - srcIds: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_tuples( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_next_tuple( - &mut self, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ) -> (); - fn squeeze(&mut self) -> (); - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; - fn set_void_array( - &mut self, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); - fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; - fn is_numeric(&mut self) -> core::ffi::c_int; - fn new_iterator(&mut self) -> *mut core::ffi::c_void; - fn get_variant_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> (); - fn set_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn data_changed(&mut self) -> (); - fn clear_lookup(&mut self) -> (); - fn insert_next_value(&mut self, p0: vtkUnicodeString) -> core::ffi::c_uchar; - fn insert_value(&mut self, idx: core::ffi::c_uchar, p1: vtkUnicodeString) -> (); - fn set_value(&mut self, i: core::ffi::c_uchar, p1: vtkUnicodeString) -> (); - fn get_value(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn insert_next_utf_8_value(&mut self, p0: core::ffi::c_char) -> (); - fn set_utf_8_value(&mut self, i: core::ffi::c_uchar, p1: core::ffi::c_char) -> (); - fn get_utf_8_value(&mut self, i: core::ffi::c_uchar) -> *const core::ffi::c_char; -} -pub trait VtkUnsignedCharArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> (); - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar; - fn get_value_range(&mut self) -> *mut core::ffi::c_uchar; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn set_array( - &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array( - &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar; - fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar; -} -pub trait VtkUnsignedIntArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_uint) -> (); - fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_uint) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uint, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_uint, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uint; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uint) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uint) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_uint) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uint; - fn get_value_range(&mut self) -> *mut core::ffi::c_uint; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uint; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uint; - fn set_array( - &mut self, - array: core::ffi::c_uint, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array( - &mut self, - array: core::ffi::c_uint, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_uint; - fn get_data_type_value_max(&mut self) -> core::ffi::c_uint; -} -pub trait VtkUnsignedLongArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulong, - ) -> (); - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulong, - ) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulong, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_ulong, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ulong; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_ulong) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ulong) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_ulong) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_ulong; - fn get_value_range(&mut self) -> *mut core::ffi::c_ulong; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ulong; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ulong; - fn set_array( - &mut self, - array: core::ffi::c_ulong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array( - &mut self, - array: core::ffi::c_ulong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_ulong; - fn get_data_type_value_max(&mut self) -> core::ffi::c_ulong; -} -pub trait VtkUnsignedLongLongArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulonglong, - ) -> (); - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulonglong, - ) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulonglong, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_ulonglong, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ulonglong; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_ulonglong) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ulonglong) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_ulonglong) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_ulonglong; - fn get_value_range(&mut self) -> *mut core::ffi::c_ulonglong; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ulonglong; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ulonglong; - fn set_array( - &mut self, - array: core::ffi::c_ulonglong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array( - &mut self, - array: core::ffi::c_ulonglong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_ulonglong; - fn get_data_type_value_max(&mut self) -> core::ffi::c_ulonglong; -} -pub trait VtkUnsignedShortArray: VtkDataArray + VtkAbstractArray + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ushort, - ) -> (); - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ushort, - ) -> (); - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ushort, - ) -> (); - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_ushort, - ) -> core::ffi::c_uchar; - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ushort; - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_ushort) -> (); - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool; - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ushort) -> (); - fn insert_next_value(&mut self, f: core::ffi::c_ushort) -> core::ffi::c_uchar; - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_ushort; - fn get_value_range(&mut self) -> *mut core::ffi::c_ushort; - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ushort; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ushort; - fn set_array( - &mut self, - array: core::ffi::c_ushort, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_array( - &mut self, - array: core::ffi::c_ushort, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn get_data_type_value_min(&mut self) -> core::ffi::c_ushort; - fn get_data_type_value_max(&mut self) -> core::ffi::c_ushort; -} -pub trait VtkVariant { - fn is_valid(&mut self) -> bool; - fn is_string(&mut self) -> bool; - fn is_unicode_string(&mut self) -> bool; - fn is_numeric(&mut self) -> bool; - fn is_float(&mut self) -> bool; - fn is_double(&mut self) -> bool; - fn is_char(&mut self) -> bool; - fn is_unsigned_char(&mut self) -> bool; - fn is_signed_char(&mut self) -> bool; - fn is_short(&mut self) -> bool; - fn is_unsigned_short(&mut self) -> bool; - fn is_int(&mut self) -> bool; - fn is_unsigned_int(&mut self) -> bool; - fn is_long(&mut self) -> bool; - fn is_unsigned_long(&mut self) -> bool; - fn is__int_64(&mut self) -> bool; - fn is_unsigned__int_64(&mut self) -> bool; - fn is_long_long(&mut self) -> bool; - fn is_unsigned_long_long(&mut self) -> bool; - fn is_vtk_object(&mut self) -> bool; - fn is_array(&mut self) -> bool; - fn get_type(&mut self) -> core::ffi::c_uint; - fn get_type_as_string(&mut self) -> *const core::ffi::c_char; - fn to_string( - &mut self, - formatting: core::ffi::c_int, - precision: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn to_unicode_string( - &mut self, - formatting: core::ffi::c_int, - precision: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn to_float(&mut self, valid: bool) -> core::ffi::c_float; - fn to_float(&mut self) -> core::ffi::c_float; - fn to_double(&mut self, valid: bool) -> core::ffi::c_double; - fn to_double(&mut self) -> core::ffi::c_double; - fn to_char(&mut self, valid: bool) -> core::ffi::c_char; - fn to_char(&mut self) -> core::ffi::c_char; - fn to_unsigned_char(&mut self, valid: bool) -> core::ffi::c_uchar; - fn to_unsigned_char(&mut self) -> core::ffi::c_uchar; - fn to_signed_char(&mut self, valid: bool) -> core::ffi::c_char; - fn to_signed_char(&mut self) -> core::ffi::c_char; - fn to_short(&mut self, valid: bool) -> core::ffi::c_short; - fn to_short(&mut self) -> core::ffi::c_short; - fn to_unsigned_short(&mut self, valid: bool) -> core::ffi::c_ushort; - fn to_unsigned_short(&mut self) -> core::ffi::c_ushort; - fn to_int(&mut self, valid: bool) -> core::ffi::c_int; - fn to_int(&mut self) -> core::ffi::c_int; - fn to_unsigned_int(&mut self, valid: bool) -> core::ffi::c_uint; - fn to_unsigned_int(&mut self) -> core::ffi::c_uint; - fn to_long(&mut self, valid: bool) -> core::ffi::c_long; - fn to_long(&mut self) -> core::ffi::c_long; - fn to_unsigned_long(&mut self, valid: bool) -> core::ffi::c_ulong; - fn to_unsigned_long(&mut self) -> core::ffi::c_ulong; - fn to_long_long(&mut self, valid: bool) -> core::ffi::c_uchar; - fn to_long_long(&mut self) -> core::ffi::c_uchar; - fn to_unsigned_long_long(&mut self, valid: bool) -> core::ffi::c_ulonglong; - fn to_unsigned_long_long(&mut self) -> core::ffi::c_ulonglong; - fn to_type_int_64(&mut self, valid: bool) -> core::ffi::c_uchar; - fn to_type_int_64(&mut self) -> core::ffi::c_uchar; - fn to_type_u_int_64(&mut self, valid: bool) -> core::ffi::c_ulonglong; - fn to_type_u_int_64(&mut self) -> core::ffi::c_ulonglong; - fn to_vtk_object(&mut self) -> *mut core::ffi::c_void; - fn to_array(&mut self) -> *mut core::ffi::c_void; - fn is_equal(&mut self, other: vtkVariant) -> bool; -} -pub trait VtkVariantArray: VtkAbstractArray + VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn allocate( - &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn initialize(&mut self) -> (); - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_data_type_size(&mut self) -> core::ffi::c_int; - fn get_element_component_size(&mut self) -> core::ffi::c_int; - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); - fn set_tuple( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_tuple( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_tuples( - &mut self, - dstIds: *mut core::ffi::c_void, - srcIds: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_tuples( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); - fn insert_next_tuple( - &mut self, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); - fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ) -> (); - fn squeeze(&mut self) -> (); - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; - fn set_void_array( - &mut self, - arr: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> (); - fn set_void_array( - &mut self, - arr: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteM: core::ffi::c_int, - ) -> (); - fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; - fn is_numeric(&mut self) -> core::ffi::c_int; - fn new_iterator(&mut self) -> *mut core::ffi::c_void; - fn get_value(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_value(&mut self, id: core::ffi::c_uchar, value: *mut core::ffi::c_void) -> (); - fn insert_value( - &mut self, - id: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn set_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_next_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn set_array( - &mut self, - arr: *mut core::ffi::c_void, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> (); - fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); - fn get_number_of_values(&mut self) -> core::ffi::c_uchar; - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> (); - fn data_changed(&mut self) -> (); - fn data_element_changed(&mut self, id: core::ffi::c_uchar) -> (); - fn clear_lookup(&mut self) -> (); -} -pub trait VtkVersion: VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_vtk_version(&mut self) -> *const core::ffi::c_char; - fn get_vtk_version_full(&mut self) -> *const core::ffi::c_char; - fn get_vtk_major_version(&mut self) -> core::ffi::c_int; - fn get_vtk_minor_version(&mut self) -> core::ffi::c_int; - fn get_vtk_build_version(&mut self) -> core::ffi::c_int; - fn get_vtk_source_version(&mut self) -> *const core::ffi::c_char; -} -pub trait VtkVoidArray: VtkObject + VtkObjectBase { - fn new(&mut self) -> *mut core::ffi::c_void; - fn extended_new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn allocate( - &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn initialize(&mut self) -> (); - fn get_data_type(&mut self) -> core::ffi::c_int; - fn get_data_type_size(&mut self) -> core::ffi::c_int; - fn set_number_of_pointers(&mut self, number: core::ffi::c_uchar) -> (); - fn get_number_of_pointers(&mut self) -> core::ffi::c_uchar; - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut (); - fn set_void_pointer(&mut self, id: core::ffi::c_uchar, ptr: ()) -> (); - fn insert_void_pointer(&mut self, i: core::ffi::c_uchar, ptr: ()) -> (); - fn insert_next_void_pointer(&mut self, tuple: ()) -> core::ffi::c_uchar; - fn reset(&mut self) -> (); - fn squeeze(&mut self) -> (); - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut &mut (); - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut &mut (); - fn deep_copy(&mut self, va: *mut core::ffi::c_void) -> (); -} -pub trait VtkWeakPointer: VtkWeakPointerBase { - fn get_pointer(&mut self) -> *mut core::ffi::c_void; - fn get(&mut self) -> *mut core::ffi::c_void; -} -pub trait VtkWeakPointerBase { - fn get_pointer(&mut self) -> *mut core::ffi::c_void; -} -pub trait VtkWeakReference: VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn set(&mut self, object: *mut core::ffi::c_void) -> (); - fn get(&mut self) -> *mut core::ffi::c_void; -} -pub trait VtkWindow: VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set_display_id(&mut self, p0: ()) -> (); - fn set_window_id(&mut self, p0: ()) -> (); - fn set_parent_id(&mut self, p0: ()) -> (); - fn get_generic_display_id(&mut self) -> *mut (); - fn get_generic_window_id(&mut self) -> *mut (); - fn get_generic_parent_id(&mut self) -> *mut (); - fn get_generic_context(&mut self) -> *mut (); - fn get_generic_drawable(&mut self) -> *mut (); - fn set_window_info(&mut self, p0: core::ffi::c_char) -> (); - fn set_parent_info(&mut self, p0: core::ffi::c_char) -> (); - fn get_position(&mut self) -> *mut core::ffi::c_int; - fn set_position(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); - fn set_position(&mut self, a: core::ffi::c_int) -> (); - fn get_size(&mut self) -> *mut core::ffi::c_int; - fn set_size(&mut self, width: core::ffi::c_int, height: core::ffi::c_int) -> (); - fn set_size(&mut self, a: core::ffi::c_int) -> (); - fn get_actual_size(&mut self) -> *mut core::ffi::c_int; - fn get_screen_size(&mut self) -> *mut core::ffi::c_int; - fn get_mapped(&mut self) -> core::ffi::c_int; - fn get_show_window(&mut self) -> bool; - fn set_show_window(&mut self, _arg: bool) -> (); - fn show_window_on(&mut self) -> (); - fn show_window_off(&mut self) -> (); - fn set_use_off_screen_buffers(&mut self, _arg: bool) -> (); - fn get_use_off_screen_buffers(&mut self) -> bool; - fn use_off_screen_buffers_on(&mut self) -> (); - fn use_off_screen_buffers_off(&mut self) -> (); - fn set_erase(&mut self, _arg: core::ffi::c_int) -> (); - fn get_erase(&mut self) -> core::ffi::c_int; - fn erase_on(&mut self) -> (); - fn erase_off(&mut self) -> (); - fn set_double_buffer(&mut self, _arg: core::ffi::c_int) -> (); - fn get_double_buffer(&mut self) -> core::ffi::c_int; - fn double_buffer_on(&mut self) -> (); - fn double_buffer_off(&mut self) -> (); - fn get_window_name(&mut self) -> *mut core::ffi::c_char; - fn set_window_name(&mut self, _arg: core::ffi::c_char) -> (); - fn set_icon(&mut self, p0: *mut core::ffi::c_void) -> (); - fn render(&mut self) -> (); - fn release_graphics_resources(&mut self, p0: *mut core::ffi::c_void) -> (); - fn get_pixel_data( - &mut self, - p0: core::ffi::c_int, - p1: core::ffi::c_int, - p2: core::ffi::c_int, - p3: core::ffi::c_int, - p4: core::ffi::c_int, - p5: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar; - fn get_pixel_data( - &mut self, - p0: core::ffi::c_int, - p1: core::ffi::c_int, - p2: core::ffi::c_int, - p3: core::ffi::c_int, - p4: core::ffi::c_int, - p5: *mut core::ffi::c_void, - p6: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_dpi(&mut self) -> core::ffi::c_int; - fn set_dpi(&mut self, _arg: core::ffi::c_int) -> (); - fn get_dpi_min_value(&mut self) -> core::ffi::c_int; - fn get_dpi_max_value(&mut self) -> core::ffi::c_int; - fn detect_dpi(&mut self) -> bool; - fn set_off_screen_rendering(&mut self, val: core::ffi::c_int) -> (); - fn off_screen_rendering_on(&mut self) -> (); - fn off_screen_rendering_off(&mut self) -> (); - fn get_off_screen_rendering(&mut self) -> core::ffi::c_int; - fn make_current(&mut self) -> (); - fn release_current(&mut self) -> (); - fn set_tile_scale(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> (); - fn set_tile_scale(&mut self, _arg: core::ffi::c_int) -> (); - fn get_tile_scale(&mut self) -> *mut core::ffi::c_int; - fn get_tile_scale(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> (); - fn get_tile_scale(&mut self, _arg: core::ffi::c_int) -> (); - fn set_tile_scale(&mut self, s: core::ffi::c_int) -> (); - fn set_tile_viewport( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> (); - fn set_tile_viewport(&mut self, _arg: core::ffi::c_double) -> (); - fn get_tile_viewport(&mut self) -> *mut core::ffi::c_double; - fn get_tile_viewport( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> (); - fn get_tile_viewport(&mut self, _arg: core::ffi::c_double) -> (); -} -pub trait VtkXMLFileOutputWindow: VtkFileOutputWindow + VtkOutputWindow + VtkObject + VtkObjectBase { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn new(&mut self) -> *mut core::ffi::c_void; - fn display_text(&mut self, p0: core::ffi::c_char) -> (); - fn display_tag(&mut self, p0: core::ffi::c_char) -> (); -} -impl VtkAnimationCue for vtkAnimationCue { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_animation_cue_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_animation_cue_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_animation_cue_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_animation_cue_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_animation_cue_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_animation_cue_new(self.0) } - } - fn set_time_mode(&mut self, mode: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_animation_cue_set_time_mode( - sself: *mut core::ffi::c_void, - mode: core::ffi::c_int, - ); - } - unsafe { vtk_animation_cue_set_time_mode(self.0, mode) } - } - fn get_time_mode(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_animation_cue_get_time_mode( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_animation_cue_get_time_mode(self.0) } - } - fn set_time_mode_to_relative(&mut self) -> () { - unsafe extern "C" { - fn vtk_animation_cue_set_time_mode_to_relative( - sself: *mut core::ffi::c_void, - ); - } - unsafe { vtk_animation_cue_set_time_mode_to_relative(self.0) } - } - fn set_time_mode_to_normalized(&mut self) -> () { - unsafe extern "C" { - fn vtk_animation_cue_set_time_mode_to_normalized( - sself: *mut core::ffi::c_void, - ); - } - unsafe { vtk_animation_cue_set_time_mode_to_normalized(self.0) } - } - fn set_start_time(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_animation_cue_set_start_time( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_animation_cue_set_start_time(self.0, _arg) } - } - fn get_start_time(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_animation_cue_get_start_time( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_animation_cue_get_start_time(self.0) } - } - fn set_end_time(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_animation_cue_set_end_time( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_animation_cue_set_end_time(self.0, _arg) } - } - fn get_end_time(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_animation_cue_get_end_time( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_animation_cue_get_end_time(self.0) } - } - fn tick( - &mut self, - currenttime: core::ffi::c_double, - deltatime: core::ffi::c_double, - clocktime: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_animation_cue_tick( - sself: *mut core::ffi::c_void, - currenttime: core::ffi::c_double, - deltatime: core::ffi::c_double, - clocktime: core::ffi::c_double, - ); - } - unsafe { vtk_animation_cue_tick(self.0, currenttime, deltatime, clocktime) } - } - fn initialize(&mut self) -> () { - unsafe extern "C" { - fn vtk_animation_cue_initialize(sself: *mut core::ffi::c_void); - } - unsafe { vtk_animation_cue_initialize(self.0) } - } - fn finalize(&mut self) -> () { - unsafe extern "C" { - fn vtk_animation_cue_finalize(sself: *mut core::ffi::c_void); - } - unsafe { vtk_animation_cue_finalize(self.0) } - } - fn get_animation_time(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_animation_cue_get_animation_time( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_animation_cue_get_animation_time(self.0) } - } - fn get_delta_time(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_animation_cue_get_delta_time( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_animation_cue_get_delta_time(self.0) } - } - fn get_clock_time(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_animation_cue_get_clock_time( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_animation_cue_get_clock_time(self.0) } - } -} -impl VtkArchiver for vtkArchiver { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_archiver_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtk_archiver_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_archiver_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_archiver_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_archiver_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_archiver_new_instance(self.0) } - } - fn get_archive_name(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_archiver_get_archive_name( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_archiver_get_archive_name(self.0) } - } - fn set_archive_name(&mut self, _arg: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_archiver_set_archive_name( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, - ); - } - unsafe { vtk_archiver_set_archive_name(self.0, _arg) } - } - fn open_archive(&mut self) -> () { - unsafe extern "C" { - fn vtk_archiver_open_archive(sself: *mut core::ffi::c_void); - } - unsafe { vtk_archiver_open_archive(self.0) } - } - fn close_archive(&mut self) -> () { - unsafe extern "C" { - fn vtk_archiver_close_archive(sself: *mut core::ffi::c_void); - } - unsafe { vtk_archiver_close_archive(self.0) } - } - fn insert_into_archive( - &mut self, - relativePath: &str, - data: core::ffi::c_char, - size: usize, - ) -> () { - let c_relativePath = std::ffi::CString::new(relativePath) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_archiver_insert_into_archive( - sself: *mut core::ffi::c_void, - relativePath: *const core::ffi::c_char, - data: core::ffi::c_char, - size: usize, - ); - } - unsafe { - vtk_archiver_insert_into_archive(self.0, c_relativePath.as_ptr(), data, size) - } - } - fn contains(&mut self, relativePath: &str) -> bool { - let c_relativePath = std::ffi::CString::new(relativePath) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_archiver_contains( - sself: *mut core::ffi::c_void, - relativePath: *const core::ffi::c_char, - ) -> bool; - } - unsafe { vtk_archiver_contains(self.0, c_relativePath.as_ptr()) } - } -} -impl VtkBitArray for vtkBitArray { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bit_array_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bit_array_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bit_array_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bit_array_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bit_array_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bit_array_new_instance(self.0) } - } - fn allocate( - &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bit_array_allocate( - sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_bit_array_allocate(self.0, sz, ext) } - } - fn initialize(&mut self) -> () { - unsafe extern "C" { - fn vtk_bit_array_initialize(sself: *mut core::ffi::c_void); - } - unsafe { vtk_bit_array_initialize(self.0) } - } - fn get_data_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bit_array_get_data_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_bit_array_get_data_type(self.0) } - } - fn get_data_type_size(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bit_array_get_data_type_size( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_bit_array_get_data_type_size(self.0) } - } - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_bit_array_set_number_of_tuples( - sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, - ); - } - unsafe { vtk_bit_array_set_number_of_tuples(self.0, number) } - } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { - unsafe extern "C" { - fn vtk_bit_array_set_number_of_values( - sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, - ) -> bool; - } - unsafe { vtk_bit_array_set_number_of_values(self.0, number) } - } - fn set_tuple( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_bit_array_set_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ); - } - unsafe { vtk_bit_array_set_tuple(self.0, i, j, source) } - } - fn insert_tuple( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_bit_array_insert_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ); - } - unsafe { vtk_bit_array_insert_tuple(self.0, i, j, source) } - } - fn insert_next_tuple( - &mut self, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bit_array_insert_next_tuple( - sself: *mut core::ffi::c_void, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_bit_array_insert_next_tuple(self.0, j, source) } - } - fn get_tuple(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_bit_array_get_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_bit_array_get_tuple(self.0, i) } - } - fn get_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_bit_array_get_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ); - } - unsafe { vtk_bit_array_get_tuple(self.0, i, tuple) } - } - fn set_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_bit_array_set_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ); - } - unsafe { vtk_bit_array_set_tuple(self.0, i, tuple) } - } - fn set_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_bit_array_set_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ); - } - unsafe { vtk_bit_array_set_tuple(self.0, i, tuple) } - } - fn insert_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_bit_array_insert_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ); - } - unsafe { vtk_bit_array_insert_tuple(self.0, i, tuple) } - } - fn insert_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_bit_array_insert_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ); - } - unsafe { vtk_bit_array_insert_tuple(self.0, i, tuple) } - } - fn insert_next_tuple(&mut self, tuple: core::ffi::c_float) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bit_array_insert_next_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_float, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_bit_array_insert_next_tuple(self.0, tuple) } - } - fn insert_next_tuple(&mut self, tuple: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bit_array_insert_next_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_bit_array_insert_next_tuple(self.0, tuple) } - } - fn remove_tuple(&mut self, id: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_bit_array_remove_tuple( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ); - } - unsafe { vtk_bit_array_remove_tuple(self.0, id) } - } - fn set_component( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_int, - c: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bit_array_set_component( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_int, - c: core::ffi::c_double, - ); - } - unsafe { vtk_bit_array_set_component(self.0, i, j, c) } - } - fn squeeze(&mut self) -> () { - unsafe extern "C" { - fn vtk_bit_array_squeeze(sself: *mut core::ffi::c_void); - } - unsafe { vtk_bit_array_squeeze(self.0) } - } - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bit_array_resize( - sself: *mut core::ffi::c_void, - numTuples: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_bit_array_resize(self.0, numTuples) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bit_array_get_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_bit_array_get_value(self.0, id) } - } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_bit_array_set_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_int, - ); - } - unsafe { vtk_bit_array_set_value(self.0, id, value) } - } - fn insert_value(&mut self, id: core::ffi::c_uchar, i: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_bit_array_insert_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - i: core::ffi::c_int, - ); - } - unsafe { vtk_bit_array_insert_value(self.0, id, i) } - } - fn set_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_bit_array_set_variant_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_bit_array_set_variant_value(self.0, idx, value) } - } - fn insert_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_bit_array_insert_variant_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_bit_array_insert_variant_value(self.0, idx, value) } - } - fn insert_next_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bit_array_insert_next_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_bit_array_insert_next_value(self.0, i) } - } - fn insert_component( - &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_int, - c: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bit_array_insert_component( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_int, - c: core::ffi::c_double, - ); - } - unsafe { vtk_bit_array_insert_component(self.0, i, j, c) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bit_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_bit_array_get_pointer(self.0, id) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bit_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_bit_array_write_pointer(self.0, id, number) } - } - fn write_void_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut () { - unsafe extern "C" { - fn vtk_bit_array_write_void_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut (); - } - unsafe { vtk_bit_array_write_void_pointer(self.0, id, number) } - } - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut () { - unsafe extern "C" { - fn vtk_bit_array_get_void_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut (); - } - unsafe { vtk_bit_array_get_void_pointer(self.0, id) } - } - fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_bit_array_deep_copy( - sself: *mut core::ffi::c_void, - da: *mut core::ffi::c_void, - ); - } - unsafe { vtk_bit_array_deep_copy(self.0, da) } - } - fn set_void_array( - &mut self, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_bit_array_set_void_array( - sself: *mut core::ffi::c_void, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_bit_array_set_void_array(self.0, array, size, save) } - } - fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_bit_array_set_array_free_function( - sself: *mut core::ffi::c_void, - callback: *mut core::ffi::c_void, - ); - } - unsafe { vtk_bit_array_set_array_free_function(self.0, callback) } - } - fn new_iterator(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bit_array_new_iterator( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bit_array_new_iterator(self.0) } - } - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bit_array_lookup_value( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_bit_array_lookup_value(self.0, value) } - } - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_bit_array_lookup_value( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ); - } - unsafe { vtk_bit_array_lookup_value(self.0, value, ids) } - } - fn lookup_value(&mut self, value: core::ffi::c_int) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bit_array_lookup_value( - sself: *mut core::ffi::c_void, - value: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_bit_array_lookup_value(self.0, value) } - } - fn lookup_value( - &mut self, - value: core::ffi::c_int, - ids: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_bit_array_lookup_value( - sself: *mut core::ffi::c_void, - value: core::ffi::c_int, - ids: *mut core::ffi::c_void, - ); - } - unsafe { vtk_bit_array_lookup_value(self.0, value, ids) } - } - fn data_changed(&mut self) -> () { - unsafe extern "C" { - fn vtk_bit_array_data_changed(sself: *mut core::ffi::c_void); - } - unsafe { vtk_bit_array_data_changed(self.0) } - } - fn clear_lookup(&mut self) -> () { - unsafe extern "C" { - fn vtk_bit_array_clear_lookup(sself: *mut core::ffi::c_void); - } - unsafe { vtk_bit_array_clear_lookup(self.0) } - } -} -impl VtkBitArrayIterator for vtkBitArrayIterator { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bit_array_iterator_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bit_array_iterator_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bit_array_iterator_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bit_array_iterator_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bit_array_iterator_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bit_array_iterator_new_instance(self.0) } - } - fn initialize(&mut self, array: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_bit_array_iterator_initialize( - sself: *mut core::ffi::c_void, - array: *mut core::ffi::c_void, - ); - } - unsafe { vtk_bit_array_iterator_initialize(self.0, array) } - } - fn get_array(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bit_array_iterator_get_array( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bit_array_iterator_get_array(self.0) } - } - fn get_tuple(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_bit_array_iterator_get_tuple( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_bit_array_iterator_get_tuple(self.0, id) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bit_array_iterator_get_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_bit_array_iterator_get_value(self.0, id) } - } - fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bit_array_iterator_get_number_of_tuples( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_bit_array_iterator_get_number_of_tuples(self.0) } - } - fn get_number_of_values(&mut self) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bit_array_iterator_get_number_of_values( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_bit_array_iterator_get_number_of_values(self.0) } - } - fn get_number_of_components(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bit_array_iterator_get_number_of_components( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_bit_array_iterator_get_number_of_components(self.0) } - } - fn get_data_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bit_array_iterator_get_data_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_bit_array_iterator_get_data_type(self.0) } - } - fn get_data_type_size(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bit_array_iterator_get_data_type_size( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_bit_array_iterator_get_data_type_size(self.0) } - } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_bit_array_iterator_set_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_int, - ); - } - unsafe { vtk_bit_array_iterator_set_value(self.0, id, value) } - } -} -impl VtkBoxMuellerRandomSequence for vtkBoxMuellerRandomSequence { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_box_mueller_random_sequence_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_box_mueller_random_sequence_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_box_mueller_random_sequence_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_box_mueller_random_sequence_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_box_mueller_random_sequence_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_box_mueller_random_sequence_new_instance(self.0) } - } - fn initialize(&mut self, seed: core::ffi::c_uint) -> () { - unsafe extern "C" { - fn vtk_box_mueller_random_sequence_initialize( - sself: *mut core::ffi::c_void, - seed: core::ffi::c_uint, - ); - } - unsafe { vtk_box_mueller_random_sequence_initialize(self.0, seed) } - } - fn get_value(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_box_mueller_random_sequence_get_value( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_box_mueller_random_sequence_get_value(self.0) } - } - fn next(&mut self) -> () { - unsafe extern "C" { - fn vtk_box_mueller_random_sequence_next(sself: *mut core::ffi::c_void); - } - unsafe { vtk_box_mueller_random_sequence_next(self.0) } - } - fn get_uniform_sequence(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_box_mueller_random_sequence_get_uniform_sequence( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_box_mueller_random_sequence_get_uniform_sequence(self.0) } - } - fn set_uniform_sequence(&mut self, uniformSequence: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_box_mueller_random_sequence_set_uniform_sequence( - sself: *mut core::ffi::c_void, - uniformSequence: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_box_mueller_random_sequence_set_uniform_sequence(self.0, uniformSequence) - } - } -} -impl VtkByteSwap for vtkByteSwap { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_byte_swap_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_byte_swap_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_byte_swap_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_byte_swap_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_byte_swap_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_byte_swap_new_instance(self.0) } - } - fn swap_le(&mut self, p: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_float, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_float, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_float, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_float, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_float, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_float, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_double, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_double, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_double, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_double, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_double, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_double, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_char, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_char, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_char, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_char, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_char, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_char, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_short) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_short, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_short) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_short, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_short, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_short, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_short, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_short, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le(sself: *mut core::ffi::c_void, p: core::ffi::c_int); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be(sself: *mut core::ffi::c_void, p: core::ffi::c_int); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_int, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_int, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_int, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_int, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_long) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_long, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_long) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_long, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_long, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_long, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_long, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_long, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uchar, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uchar, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_uchar, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uchar, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_uchar, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uchar, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_char, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_char, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_char, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_char, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_char, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_char, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uchar, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uchar, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_uchar, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uchar, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_uchar, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uchar, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_ushort) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ushort, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_ushort) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ushort, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_ushort, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ushort, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_ushort, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ushort, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_uint) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uint, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_uint) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uint, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_uint, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uint, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_uint, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_uint, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_ulong) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ulong, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_ulong) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ulong, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_ulong, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ulong, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_ulong, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ulong, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_le(&mut self, p: core::ffi::c_ulonglong) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ulonglong, - ); - } - unsafe { vtk_byte_swap_swap_le(self.0, p) } - } - fn swap_be(&mut self, p: core::ffi::c_ulonglong) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ulonglong, - ); - } - unsafe { vtk_byte_swap_swap_be(self.0, p) } - } - fn swap_le_range(&mut self, p: core::ffi::c_ulonglong, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_le_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ulonglong, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_le_range(self.0, p, num) } - } - fn swap_be_range(&mut self, p: core::ffi::c_ulonglong, num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_be_range( - sself: *mut core::ffi::c_void, - p: core::ffi::c_ulonglong, - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_be_range(self.0, p, num) } - } - fn swap_2_le(&mut self, p: ()) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_2_le(sself: *mut core::ffi::c_void, p: ()); - } - unsafe { vtk_byte_swap_swap_2_le(self.0, p) } - } - fn swap_4_le(&mut self, p: ()) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_4_le(sself: *mut core::ffi::c_void, p: ()); - } - unsafe { vtk_byte_swap_swap_4_le(self.0, p) } - } - fn swap_8_le(&mut self, p: ()) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_8_le(sself: *mut core::ffi::c_void, p: ()); - } - unsafe { vtk_byte_swap_swap_8_le(self.0, p) } - } - fn swap_2_le_range(&mut self, p: (), num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_2_le_range( - sself: *mut core::ffi::c_void, - p: (), - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_2_le_range(self.0, p, num) } - } - fn swap_4_le_range(&mut self, p: (), num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_4_le_range( - sself: *mut core::ffi::c_void, - p: (), - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_4_le_range(self.0, p, num) } - } - fn swap_8_le_range(&mut self, p: (), num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_8_le_range( - sself: *mut core::ffi::c_void, - p: (), - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_8_le_range(self.0, p, num) } - } - fn swap_2_be(&mut self, p: ()) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_2_be(sself: *mut core::ffi::c_void, p: ()); - } - unsafe { vtk_byte_swap_swap_2_be(self.0, p) } - } - fn swap_4_be(&mut self, p: ()) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_4_be(sself: *mut core::ffi::c_void, p: ()); - } - unsafe { vtk_byte_swap_swap_4_be(self.0, p) } - } - fn swap_8_be(&mut self, p: ()) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_8_be(sself: *mut core::ffi::c_void, p: ()); - } - unsafe { vtk_byte_swap_swap_8_be(self.0, p) } - } - fn swap_2_be_range(&mut self, p: (), num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_2_be_range( - sself: *mut core::ffi::c_void, - p: (), - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_2_be_range(self.0, p, num) } - } - fn swap_4_be_range(&mut self, p: (), num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_4_be_range( - sself: *mut core::ffi::c_void, - p: (), - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_4_be_range(self.0, p, num) } - } - fn swap_8_be_range(&mut self, p: (), num: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_8_be_range( - sself: *mut core::ffi::c_void, - p: (), - num: usize, - ); - } - unsafe { vtk_byte_swap_swap_8_be_range(self.0, p, num) } - } - fn swap_void_range(&mut self, buffer: (), numWords: usize, wordSize: usize) -> () { - unsafe extern "C" { - fn vtk_byte_swap_swap_void_range( - sself: *mut core::ffi::c_void, - buffer: (), - numWords: usize, - wordSize: usize, - ); - } - unsafe { vtk_byte_swap_swap_void_range(self.0, buffer, numWords, wordSize) } - } -} -impl VtkCallbackCommand for vtkCallbackCommand { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_callback_command_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_callback_command_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_callback_command_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_callback_command_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_callback_command_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_callback_command_new(self.0) } - } - fn execute( - &mut self, - caller: *mut core::ffi::c_void, - eid: core::ffi::c_ulong, - callData: (), - ) -> () { - unsafe extern "C" { - fn vtk_callback_command_execute( - sself: *mut core::ffi::c_void, - caller: *mut core::ffi::c_void, - eid: core::ffi::c_ulong, - callData: (), - ); - } - unsafe { vtk_callback_command_execute(self.0, caller, eid, callData) } - } - fn set_client_data(&mut self, cd: ()) -> () { - unsafe extern "C" { - fn vtk_callback_command_set_client_data( - sself: *mut core::ffi::c_void, - cd: (), - ); - } - unsafe { vtk_callback_command_set_client_data(self.0, cd) } - } - fn get_client_data(&mut self) -> *mut () { - unsafe extern "C" { - fn vtk_callback_command_get_client_data( - sself: *mut core::ffi::c_void, - ) -> *mut (); - } - unsafe { vtk_callback_command_get_client_data(self.0) } - } - fn set_callback(&mut self, f: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_callback_command_set_callback( - sself: *mut core::ffi::c_void, - f: *mut core::ffi::c_void, - ); - } - unsafe { vtk_callback_command_set_callback(self.0, f) } - } - fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_callback_command_set_client_data_delete_callback( - sself: *mut core::ffi::c_void, - f: *mut core::ffi::c_void, - ); - } - unsafe { vtk_callback_command_set_client_data_delete_callback(self.0, f) } - } - fn set_abort_flag_on_execute(&mut self, f: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_callback_command_set_abort_flag_on_execute( - sself: *mut core::ffi::c_void, - f: core::ffi::c_int, - ); - } - unsafe { vtk_callback_command_set_abort_flag_on_execute(self.0, f) } - } - fn get_abort_flag_on_execute(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_callback_command_get_abort_flag_on_execute( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_callback_command_get_abort_flag_on_execute(self.0) } - } - fn abort_flag_on_execute_on(&mut self) -> () { - unsafe extern "C" { - fn vtk_callback_command_abort_flag_on_execute_on( - sself: *mut core::ffi::c_void, - ); - } - unsafe { vtk_callback_command_abort_flag_on_execute_on(self.0) } - } - fn abort_flag_on_execute_off(&mut self) -> () { - unsafe extern "C" { - fn vtk_callback_command_abort_flag_on_execute_off( - sself: *mut core::ffi::c_void, - ); - } - unsafe { vtk_callback_command_abort_flag_on_execute_off(self.0) } - } -} -impl VtkCharArray for vtkCharArray { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_char_array_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_char_array_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_char_array_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_char_array_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_char_array_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_char_array_new(self.0) } - } - fn extended_new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_char_array_extended_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_char_array_extended_new(self.0) } - } - fn get_data_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_char_array_get_data_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_char_array_get_data_type(self.0) } - } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ) -> () { - unsafe extern "C" { - fn vtk_char_array_get_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ); - } - unsafe { vtk_char_array_get_typed_tuple(self.0, i, tuple) } - } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ) -> () { - unsafe extern "C" { - fn vtk_char_array_set_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ); - } - unsafe { vtk_char_array_set_typed_tuple(self.0, i, tuple) } - } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ) -> () { - unsafe extern "C" { - fn vtk_char_array_insert_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ); - } - unsafe { vtk_char_array_insert_typed_tuple(self.0, i, tuple) } - } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_char, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_char_array_insert_next_typed_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_char, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_char_array_insert_next_typed_tuple(self.0, tuple) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_char { - unsafe extern "C" { - fn vtk_char_array_get_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_char; - } - unsafe { vtk_char_array_get_value(self.0, id) } - } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_char_array_set_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_char, - ); - } - unsafe { vtk_char_array_set_value(self.0, id, value) } - } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { - unsafe extern "C" { - fn vtk_char_array_set_number_of_values( - sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, - ) -> bool; - } - unsafe { vtk_char_array_set_number_of_values(self.0, number) } - } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_char_array_insert_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - f: core::ffi::c_char, - ); - } - unsafe { vtk_char_array_insert_value(self.0, id, f) } - } - fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_char_array_insert_next_value( - sself: *mut core::ffi::c_void, - f: core::ffi::c_char, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_char_array_insert_next_value(self.0, f) } - } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_char_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_char_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_char_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_char_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_char_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_char_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_char_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_char_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_char_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_char_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_char_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { vtk_char_array_set_array(self.0, array, size, save, deleteMethod) } - } - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_char_array_fast_down_cast( - sself: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_char_array_fast_down_cast(self.0, source) } - } - fn get_data_type_value_min(&mut self) -> core::ffi::c_char { - unsafe extern "C" { - fn vtk_char_array_get_data_type_value_min( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_char; - } - unsafe { vtk_char_array_get_data_type_value_min(self.0) } - } - fn get_data_type_value_max(&mut self) -> core::ffi::c_char { - unsafe extern "C" { - fn vtk_char_array_get_data_type_value_max( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_char; - } - unsafe { vtk_char_array_get_data_type_value_max(self.0) } - } -} -impl VtkCollection for vtkCollection { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_new(self.0) } - } - fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_collection_add_item( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_collection_add_item(self.0, p0) } - } - fn insert_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_collection_insert_item( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_collection_insert_item(self.0, i, p1) } - } - fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_collection_replace_item( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_collection_replace_item(self.0, i, p1) } - } - fn remove_item(&mut self, i: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_collection_remove_item( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ); - } - unsafe { vtk_collection_remove_item(self.0, i) } - } - fn remove_item(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_collection_remove_item( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_collection_remove_item(self.0, p0) } - } - fn remove_all_items(&mut self) -> () { - unsafe extern "C" { - fn vtk_collection_remove_all_items(sself: *mut core::ffi::c_void); - } - unsafe { vtk_collection_remove_all_items(self.0) } - } - fn is_item_present(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_collection_is_item_present( - sself: *mut core::ffi::c_void, - a: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_collection_is_item_present(self.0, a) } - } - fn get_number_of_items(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_collection_get_number_of_items( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_collection_get_number_of_items(self.0) } - } - fn init_traversal(&mut self) -> () { - unsafe extern "C" { - fn vtk_collection_init_traversal(sself: *mut core::ffi::c_void); - } - unsafe { vtk_collection_init_traversal(self.0) } - } - fn init_traversal(&mut self, cookie: ()) -> () { - unsafe extern "C" { - fn vtk_collection_init_traversal(sself: *mut core::ffi::c_void, cookie: ()); - } - unsafe { vtk_collection_init_traversal(self.0, cookie) } - } - fn get_next_item_as_object(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_get_next_item_as_object( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_get_next_item_as_object(self.0) } - } - fn get_item_as_object(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_get_item_as_object( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_get_item_as_object(self.0, i) } - } - fn get_next_item_as_object(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_get_next_item_as_object( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_get_next_item_as_object(self.0, cookie) } - } - fn new_iterator(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_new_iterator( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_new_iterator(self.0) } - } - fn register(&mut self, o: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_collection_register( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ); - } - unsafe { vtk_collection_register(self.0, o) } - } -} -impl VtkCollectionIterator for vtkCollectionIterator { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_iterator_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_iterator_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_iterator_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_iterator_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_iterator_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_iterator_new(self.0) } - } - fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_collection_iterator_set_collection( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_collection_iterator_set_collection(self.0, p0) } - } - fn get_collection(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_iterator_get_collection( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_iterator_get_collection(self.0) } - } - fn init_traversal(&mut self) -> () { - unsafe extern "C" { - fn vtk_collection_iterator_init_traversal(sself: *mut core::ffi::c_void); - } - unsafe { vtk_collection_iterator_init_traversal(self.0) } - } - fn go_to_first_item(&mut self) -> () { - unsafe extern "C" { - fn vtk_collection_iterator_go_to_first_item(sself: *mut core::ffi::c_void); - } - unsafe { vtk_collection_iterator_go_to_first_item(self.0) } - } - fn go_to_next_item(&mut self) -> () { - unsafe extern "C" { - fn vtk_collection_iterator_go_to_next_item(sself: *mut core::ffi::c_void); - } - unsafe { vtk_collection_iterator_go_to_next_item(self.0) } - } - fn is_done_with_traversal(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_collection_iterator_is_done_with_traversal( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_collection_iterator_is_done_with_traversal(self.0) } - } - fn get_current_object(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_collection_iterator_get_current_object( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_collection_iterator_get_current_object(self.0) } - } -} -impl VtkCriticalSection for vtkCriticalSection { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_critical_section_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_critical_section_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_critical_section_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_critical_section_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_critical_section_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_critical_section_new_instance(self.0) } - } - fn lock(&mut self) -> () { - unsafe extern "C" { - fn vtk_critical_section_lock(sself: *mut core::ffi::c_void); - } - unsafe { vtk_critical_section_lock(self.0) } - } - fn unlock(&mut self) -> () { - unsafe extern "C" { - fn vtk_critical_section_unlock(sself: *mut core::ffi::c_void); - } - unsafe { vtk_critical_section_unlock(self.0) } - } -} -impl VtkDataArrayCollection for vtkDataArrayCollection { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_collection_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_collection_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_collection_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_collection_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_collection_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_collection_new_instance(self.0) } - } - fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_data_array_collection_add_item( - sself: *mut core::ffi::c_void, - ds: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_array_collection_add_item(self.0, ds) } - } - fn get_next_item(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_collection_get_next_item( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_collection_get_next_item(self.0) } - } - fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_collection_get_item( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_collection_get_item(self.0, i) } - } - fn get_next_data_array(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_collection_get_next_data_array( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_collection_get_next_data_array(self.0, cookie) } - } - fn get_number_of_items(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_collection_get_number_of_items( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_collection_get_number_of_items(self.0) } - } -} -impl VtkDataArrayCollectionIterator for vtkDataArrayCollectionIterator { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_collection_iterator_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_collection_iterator_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_collection_iterator_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_collection_iterator_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_collection_iterator_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_collection_iterator_new(self.0) } - } - fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_data_array_collection_iterator_set_collection( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_array_collection_iterator_set_collection(self.0, p0) } - } - fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_data_array_collection_iterator_set_collection( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_array_collection_iterator_set_collection(self.0, p0) } - } - fn get_data_array(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_collection_iterator_get_data_array( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_collection_iterator_get_data_array(self.0) } - } -} -impl VtkDataArraySelection for vtkDataArraySelection { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_selection_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_selection_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_selection_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_selection_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_array_selection_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_array_selection_new(self.0) } - } - fn enable_array(&mut self, name: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_enable_array( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ); - } - unsafe { vtk_data_array_selection_enable_array(self.0, name) } - } - fn disable_array(&mut self, name: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_disable_array( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ); - } - unsafe { vtk_data_array_selection_disable_array(self.0, name) } - } - fn array_is_enabled(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_selection_array_is_enabled( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_selection_array_is_enabled(self.0, name) } - } - fn array_exists(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_selection_array_exists( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_selection_array_exists(self.0, name) } - } - fn enable_all_arrays(&mut self) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_enable_all_arrays(sself: *mut core::ffi::c_void); - } - unsafe { vtk_data_array_selection_enable_all_arrays(self.0) } - } - fn disable_all_arrays(&mut self) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_disable_all_arrays( - sself: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_array_selection_disable_all_arrays(self.0) } - } - fn get_number_of_arrays(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_selection_get_number_of_arrays( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_selection_get_number_of_arrays(self.0) } - } - fn get_number_of_arrays_enabled(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_selection_get_number_of_arrays_enabled( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_selection_get_number_of_arrays_enabled(self.0) } - } - fn get_array_name(&mut self, index: core::ffi::c_int) -> *const core::ffi::c_char { - unsafe extern "C" { - fn vtk_data_array_selection_get_array_name( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *const core::ffi::c_char; - } - unsafe { vtk_data_array_selection_get_array_name(self.0, index) } - } - fn get_array_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_selection_get_array_index( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_selection_get_array_index(self.0, name) } - } - fn get_enabled_array_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_selection_get_enabled_array_index( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_selection_get_enabled_array_index(self.0, name) } - } - fn get_array_setting(&mut self, index: core::ffi::c_int) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_selection_get_array_setting( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_selection_get_array_setting(self.0, index) } - } - fn get_array_setting(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_selection_get_array_setting( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_selection_get_array_setting(self.0, name) } - } - fn set_array_setting( - &mut self, - name: core::ffi::c_char, - setting: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_set_array_setting( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - setting: core::ffi::c_int, - ); - } - unsafe { vtk_data_array_selection_set_array_setting(self.0, name, setting) } - } - fn remove_all_arrays(&mut self) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_remove_all_arrays(sself: *mut core::ffi::c_void); - } - unsafe { vtk_data_array_selection_remove_all_arrays(self.0) } - } - fn add_array(&mut self, name: core::ffi::c_char, state: bool) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_selection_add_array( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - state: bool, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_selection_add_array(self.0, name, state) } - } - fn remove_array_by_index(&mut self, index: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_remove_array_by_index( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ); - } - unsafe { vtk_data_array_selection_remove_array_by_index(self.0, index) } - } - fn remove_array_by_name(&mut self, name: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_remove_array_by_name( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ); - } - unsafe { vtk_data_array_selection_remove_array_by_name(self.0, name) } - } - fn set_arrays( - &mut self, - names: core::ffi::c_char, - numArrays: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_set_arrays( - sself: *mut core::ffi::c_void, - names: core::ffi::c_char, - numArrays: core::ffi::c_int, - ); - } - unsafe { vtk_data_array_selection_set_arrays(self.0, names, numArrays) } - } - fn set_arrays_with_default( - &mut self, - names: core::ffi::c_char, - numArrays: core::ffi::c_int, - defaultStatus: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_set_arrays_with_default( - sself: *mut core::ffi::c_void, - names: core::ffi::c_char, - numArrays: core::ffi::c_int, - defaultStatus: core::ffi::c_int, - ); - } - unsafe { - vtk_data_array_selection_set_arrays_with_default( - self.0, - names, - numArrays, - defaultStatus, - ) - } - } - fn copy_selections(&mut self, selections: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_copy_selections( - sself: *mut core::ffi::c_void, - selections: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_array_selection_copy_selections(self.0, selections) } - } - fn union(&mut self, other: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_union( - sself: *mut core::ffi::c_void, - other: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_array_selection_union(self.0, other) } - } - fn union(&mut self, other: *mut core::ffi::c_void, skipModified: bool) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_union( - sself: *mut core::ffi::c_void, - other: *mut core::ffi::c_void, - skipModified: bool, - ); - } - unsafe { vtk_data_array_selection_union(self.0, other, skipModified) } - } - fn set_unknown_array_setting(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_data_array_selection_set_unknown_array_setting( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_data_array_selection_set_unknown_array_setting(self.0, _arg) } - } - fn get_unknown_array_setting(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_array_selection_get_unknown_array_setting( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_array_selection_get_unknown_array_setting(self.0) } - } -} -impl VtkDebugLeaks for vtkDebugLeaks { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_debug_leaks_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_debug_leaks_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_debug_leaks_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_debug_leaks_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_debug_leaks_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_debug_leaks_new_instance(self.0) } - } - fn construct_class(&mut self, object: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_debug_leaks_construct_class( - sself: *mut core::ffi::c_void, - object: *mut core::ffi::c_void, - ); - } - unsafe { vtk_debug_leaks_construct_class(self.0, object) } - } - fn construct_class(&mut self, className: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_debug_leaks_construct_class( - sself: *mut core::ffi::c_void, - className: core::ffi::c_char, - ); - } - unsafe { vtk_debug_leaks_construct_class(self.0, className) } - } - fn destruct_class(&mut self, object: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_debug_leaks_destruct_class( - sself: *mut core::ffi::c_void, - object: *mut core::ffi::c_void, - ); - } - unsafe { vtk_debug_leaks_destruct_class(self.0, object) } - } - fn destruct_class(&mut self, className: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_debug_leaks_destruct_class( - sself: *mut core::ffi::c_void, - className: core::ffi::c_char, - ); - } - unsafe { vtk_debug_leaks_destruct_class(self.0, className) } - } - fn print_current_leaks(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_debug_leaks_print_current_leaks( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_debug_leaks_print_current_leaks(self.0) } - } - fn get_exit_error(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_debug_leaks_get_exit_error( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_debug_leaks_get_exit_error(self.0) } - } - fn set_exit_error(&mut self, p0: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_debug_leaks_set_exit_error( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ); - } - unsafe { vtk_debug_leaks_set_exit_error(self.0, p0) } - } - fn set_debug_leaks_observer(&mut self, observer: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_debug_leaks_set_debug_leaks_observer( - sself: *mut core::ffi::c_void, - observer: *mut core::ffi::c_void, - ); - } - unsafe { vtk_debug_leaks_set_debug_leaks_observer(self.0, observer) } - } - fn get_debug_leaks_observer(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_debug_leaks_get_debug_leaks_observer( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_debug_leaks_get_debug_leaks_observer(self.0) } - } -} -impl VtkDoubleArray for vtkDoubleArray { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_double_array_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_double_array_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_double_array_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_double_array_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_double_array_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_double_array_new(self.0) } - } - fn extended_new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_double_array_extended_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_double_array_extended_new(self.0) } - } - fn get_data_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_double_array_get_data_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_double_array_get_data_type(self.0) } - } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_double_array_get_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ); - } - unsafe { vtk_double_array_get_typed_tuple(self.0, i, tuple) } - } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_double_array_set_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ); - } - unsafe { vtk_double_array_set_typed_tuple(self.0, i, tuple) } - } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_double_array_insert_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_double, - ); - } - unsafe { vtk_double_array_insert_typed_tuple(self.0, i, tuple) } - } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_double_array_insert_next_typed_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_double_array_insert_next_typed_tuple(self.0, tuple) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_double_array_get_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_double; - } - unsafe { vtk_double_array_get_value(self.0, id) } - } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_double_array_set_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_double, - ); - } - unsafe { vtk_double_array_set_value(self.0, id, value) } - } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { - unsafe extern "C" { - fn vtk_double_array_set_number_of_values( - sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, - ) -> bool; - } - unsafe { vtk_double_array_set_number_of_values(self.0, number) } - } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_double_array_insert_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - f: core::ffi::c_double, - ); - } - unsafe { vtk_double_array_insert_value(self.0, id, f) } - } - fn insert_next_value(&mut self, f: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_double_array_insert_next_value( - sself: *mut core::ffi::c_void, - f: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_double_array_insert_next_value(self.0, f) } - } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_double_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_double_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_double_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_double_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_double_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_double_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_double_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_double_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_double, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_double_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_double, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_double_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_double, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_double_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_double, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { vtk_double_array_set_array(self.0, array, size, save, deleteMethod) } - } - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_double_array_fast_down_cast( - sself: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_double_array_fast_down_cast(self.0, source) } - } - fn get_data_type_value_min(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_double_array_get_data_type_value_min( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_double_array_get_data_type_value_min(self.0) } - } - fn get_data_type_value_max(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_double_array_get_data_type_value_max( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_double_array_get_data_type_value_max(self.0) } - } -} -impl VtkDynamicLoader for vtkDynamicLoader { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_dynamic_loader_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_dynamic_loader_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_dynamic_loader_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_dynamic_loader_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_dynamic_loader_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_dynamic_loader_new_instance(self.0) } - } - fn open_library(&mut self, p0: core::ffi::c_char) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_dynamic_loader_open_library( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_dynamic_loader_open_library(self.0, p0) } - } - fn open_library( - &mut self, - p0: core::ffi::c_char, - p1: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_dynamic_loader_open_library( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, - p1: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_dynamic_loader_open_library(self.0, p0, p1) } - } - fn close_library(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_dynamic_loader_close_library( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_dynamic_loader_close_library(self.0, p0) } - } - fn get_symbol_address( - &mut self, - p0: *mut core::ffi::c_void, - p1: core::ffi::c_char, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_dynamic_loader_get_symbol_address( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_dynamic_loader_get_symbol_address(self.0, p0, p1) } - } - fn lib_prefix(&mut self) -> *const core::ffi::c_char { - unsafe extern "C" { - fn vtk_dynamic_loader_lib_prefix( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - unsafe { vtk_dynamic_loader_lib_prefix(self.0) } - } - fn lib_extension(&mut self) -> *const core::ffi::c_char { - unsafe extern "C" { - fn vtk_dynamic_loader_lib_extension( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - unsafe { vtk_dynamic_loader_lib_extension(self.0) } - } - fn last_error(&mut self) -> *const core::ffi::c_char { - unsafe extern "C" { - fn vtk_dynamic_loader_last_error( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - unsafe { vtk_dynamic_loader_last_error(self.0) } - } -} -impl VtkEventDataDevice3D for vtkEventDataDevice3D { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_data_device_3_d_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_data_device_3_d_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_data_device_3_d_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_data_device_3_d_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_data_device_3_d_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_data_device_3_d_new(self.0) } - } - fn get_world_position(&mut self, v: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_event_data_device_3_d_get_world_position( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ); - } - unsafe { vtk_event_data_device_3_d_get_world_position(self.0, v) } - } - fn get_world_position(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_event_data_device_3_d_get_world_position( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_event_data_device_3_d_get_world_position(self.0) } - } - fn set_world_position(&mut self, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_event_data_device_3_d_set_world_position( - sself: *mut core::ffi::c_void, - p: core::ffi::c_double, - ); - } - unsafe { vtk_event_data_device_3_d_set_world_position(self.0, p) } - } - fn get_world_direction(&mut self, v: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_event_data_device_3_d_get_world_direction( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ); - } - unsafe { vtk_event_data_device_3_d_get_world_direction(self.0, v) } - } - fn get_world_direction(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_event_data_device_3_d_get_world_direction( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_event_data_device_3_d_get_world_direction(self.0) } - } - fn set_world_direction(&mut self, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_event_data_device_3_d_set_world_direction( - sself: *mut core::ffi::c_void, - p: core::ffi::c_double, - ); - } - unsafe { vtk_event_data_device_3_d_set_world_direction(self.0, p) } - } - fn get_world_orientation(&mut self, v: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_event_data_device_3_d_get_world_orientation( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ); - } - unsafe { vtk_event_data_device_3_d_get_world_orientation(self.0, v) } - } - fn get_world_orientation(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_event_data_device_3_d_get_world_orientation( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_event_data_device_3_d_get_world_orientation(self.0) } - } - fn set_world_orientation(&mut self, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_event_data_device_3_d_set_world_orientation( - sself: *mut core::ffi::c_void, - p: core::ffi::c_double, - ); - } - unsafe { vtk_event_data_device_3_d_set_world_orientation(self.0, p) } - } - fn get_track_pad_position(&mut self, v: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_event_data_device_3_d_get_track_pad_position( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ); - } - unsafe { vtk_event_data_device_3_d_get_track_pad_position(self.0, v) } - } - fn get_track_pad_position(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_event_data_device_3_d_get_track_pad_position( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_event_data_device_3_d_get_track_pad_position(self.0) } - } - fn set_track_pad_position(&mut self, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_event_data_device_3_d_set_track_pad_position( - sself: *mut core::ffi::c_void, - p: core::ffi::c_double, - ); - } - unsafe { vtk_event_data_device_3_d_set_track_pad_position(self.0, p) } - } - fn set_track_pad_position( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_event_data_device_3_d_set_track_pad_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - ); - } - unsafe { vtk_event_data_device_3_d_set_track_pad_position(self.0, x, y) } - } -} -impl VtkEventDataForDevice for vtkEventDataForDevice { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_data_for_device_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_data_for_device_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_data_for_device_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_data_for_device_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_data_for_device_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_data_for_device_new(self.0) } - } - fn get_device(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_data_for_device_get_device( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_data_for_device_get_device(self.0) } - } - fn get_input(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_data_for_device_get_input( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_data_for_device_get_input(self.0) } - } - fn get_action(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_data_for_device_get_action( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_data_for_device_get_action(self.0) } - } - fn set_device(&mut self, v: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_event_data_for_device_set_device( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - ); - } - unsafe { vtk_event_data_for_device_set_device(self.0, v) } - } - fn set_input(&mut self, v: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_event_data_for_device_set_input( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - ); - } - unsafe { vtk_event_data_for_device_set_input(self.0, v) } - } - fn set_action(&mut self, v: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_event_data_for_device_set_action( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - ); - } - unsafe { vtk_event_data_for_device_set_action(self.0, v) } - } - fn device_matches(&mut self, val: *mut core::ffi::c_void) -> bool { - unsafe extern "C" { - fn vtk_event_data_for_device_device_matches( - sself: *mut core::ffi::c_void, - val: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_event_data_for_device_device_matches(self.0, val) } - } -} -impl VtkEventForwarderCommand for vtkEventForwarderCommand { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_forwarder_command_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_forwarder_command_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_forwarder_command_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_forwarder_command_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_event_forwarder_command_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_event_forwarder_command_new(self.0) } - } - fn execute( - &mut self, - caller: *mut core::ffi::c_void, - eid: core::ffi::c_ulong, - callData: (), - ) -> () { - unsafe extern "C" { - fn vtk_event_forwarder_command_execute( - sself: *mut core::ffi::c_void, - caller: *mut core::ffi::c_void, - eid: core::ffi::c_ulong, - callData: (), - ); - } - unsafe { vtk_event_forwarder_command_execute(self.0, caller, eid, callData) } - } - fn set_target(&mut self, obj: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_event_forwarder_command_set_target( - sself: *mut core::ffi::c_void, - obj: *mut core::ffi::c_void, - ); - } - unsafe { vtk_event_forwarder_command_set_target(self.0, obj) } - } - fn get_target(&mut self) -> *mut () { - unsafe extern "C" { - fn vtk_event_forwarder_command_get_target( - sself: *mut core::ffi::c_void, - ) -> *mut (); - } - unsafe { vtk_event_forwarder_command_get_target(self.0) } - } -} -impl VtkFileOutputWindow for vtkFileOutputWindow { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_file_output_window_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_file_output_window_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_file_output_window_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_file_output_window_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_file_output_window_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_file_output_window_new(self.0) } - } - fn display_text(&mut self, p0: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_file_output_window_display_text( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, - ); - } - unsafe { vtk_file_output_window_display_text(self.0, p0) } - } - fn set_file_name(&mut self, _arg: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_file_output_window_set_file_name( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, - ); - } - unsafe { vtk_file_output_window_set_file_name(self.0, _arg) } - } - fn get_file_name(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_file_output_window_get_file_name( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_file_output_window_get_file_name(self.0) } - } - fn set_flush(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_file_output_window_set_flush( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_file_output_window_set_flush(self.0, _arg) } - } - fn get_flush(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_file_output_window_get_flush( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_file_output_window_get_flush(self.0) } - } - fn flush_on(&mut self) -> () { - unsafe extern "C" { - fn vtk_file_output_window_flush_on(sself: *mut core::ffi::c_void); - } - unsafe { vtk_file_output_window_flush_on(self.0) } - } - fn flush_off(&mut self) -> () { - unsafe extern "C" { - fn vtk_file_output_window_flush_off(sself: *mut core::ffi::c_void); - } - unsafe { vtk_file_output_window_flush_off(self.0) } - } - fn set_append(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_file_output_window_set_append( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_file_output_window_set_append(self.0, _arg) } - } - fn get_append(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_file_output_window_get_append( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_file_output_window_get_append(self.0) } - } - fn append_on(&mut self) -> () { - unsafe extern "C" { - fn vtk_file_output_window_append_on(sself: *mut core::ffi::c_void); - } - unsafe { vtk_file_output_window_append_on(self.0) } - } - fn append_off(&mut self) -> () { - unsafe extern "C" { - fn vtk_file_output_window_append_off(sself: *mut core::ffi::c_void); - } - unsafe { vtk_file_output_window_append_off(self.0) } - } -} -impl VtkFloatArray for vtkFloatArray { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_float_array_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_float_array_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_float_array_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_float_array_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_float_array_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_float_array_new(self.0) } - } - fn extended_new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_float_array_extended_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_float_array_extended_new(self.0) } - } - fn get_data_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_float_array_get_data_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_float_array_get_data_type(self.0) } - } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_float_array_get_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ); - } - unsafe { vtk_float_array_get_typed_tuple(self.0, i, tuple) } - } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_float_array_set_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ); - } - unsafe { vtk_float_array_set_typed_tuple(self.0, i, tuple) } - } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_float_array_insert_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_float, - ); - } - unsafe { vtk_float_array_insert_typed_tuple(self.0, i, tuple) } - } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_float, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_float_array_insert_next_typed_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_float, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_float_array_insert_next_typed_tuple(self.0, tuple) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_float { - unsafe extern "C" { - fn vtk_float_array_get_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_float; - } - unsafe { vtk_float_array_get_value(self.0, id) } - } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_float_array_set_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_float, - ); - } - unsafe { vtk_float_array_set_value(self.0, id, value) } - } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { - unsafe extern "C" { - fn vtk_float_array_set_number_of_values( - sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, - ) -> bool; - } - unsafe { vtk_float_array_set_number_of_values(self.0, number) } - } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_float_array_insert_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - f: core::ffi::c_float, - ); - } - unsafe { vtk_float_array_insert_value(self.0, id, f) } - } - fn insert_next_value(&mut self, f: core::ffi::c_float) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_float_array_insert_next_value( - sself: *mut core::ffi::c_void, - f: core::ffi::c_float, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_float_array_insert_next_value(self.0, f) } - } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_float { - unsafe extern "C" { - fn vtk_float_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_float; - } - unsafe { vtk_float_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_float { - unsafe extern "C" { - fn vtk_float_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_float; - } - unsafe { vtk_float_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_float { - unsafe extern "C" { - fn vtk_float_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_float; - } - unsafe { vtk_float_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_float { - unsafe extern "C" { - fn vtk_float_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_float; - } - unsafe { vtk_float_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_float, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_float_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_float, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_float_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_float, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_float_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_float, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { vtk_float_array_set_array(self.0, array, size, save, deleteMethod) } - } - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_float_array_fast_down_cast( - sself: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_float_array_fast_down_cast(self.0, source) } - } - fn get_data_type_value_min(&mut self) -> core::ffi::c_float { - unsafe extern "C" { - fn vtk_float_array_get_data_type_value_min( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_float; - } - unsafe { vtk_float_array_get_data_type_value_min(self.0) } - } - fn get_data_type_value_max(&mut self) -> core::ffi::c_float { - unsafe extern "C" { - fn vtk_float_array_get_data_type_value_max( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_float; - } - unsafe { vtk_float_array_get_data_type_value_max(self.0) } - } -} -impl VtkGarbageCollector for vtkGarbageCollector { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_garbage_collector_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_garbage_collector_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_garbage_collector_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_garbage_collector_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_garbage_collector_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_garbage_collector_new(self.0) } - } - fn collect(&mut self) -> () { - unsafe extern "C" { - fn vtk_garbage_collector_collect(sself: *mut core::ffi::c_void); - } - unsafe { vtk_garbage_collector_collect(self.0) } - } - fn collect(&mut self, root: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_garbage_collector_collect( - sself: *mut core::ffi::c_void, - root: *mut core::ffi::c_void, - ); - } - unsafe { vtk_garbage_collector_collect(self.0, root) } - } - fn deferred_collection_push(&mut self) -> () { - unsafe extern "C" { - fn vtk_garbage_collector_deferred_collection_push( - sself: *mut core::ffi::c_void, - ); - } - unsafe { vtk_garbage_collector_deferred_collection_push(self.0) } - } - fn deferred_collection_pop(&mut self) -> () { - unsafe extern "C" { - fn vtk_garbage_collector_deferred_collection_pop( - sself: *mut core::ffi::c_void, - ); - } - unsafe { vtk_garbage_collector_deferred_collection_pop(self.0) } - } - fn set_global_debug_flag(&mut self, flag: bool) -> () { - unsafe extern "C" { - fn vtk_garbage_collector_set_global_debug_flag( - sself: *mut core::ffi::c_void, - flag: bool, - ); - } - unsafe { vtk_garbage_collector_set_global_debug_flag(self.0, flag) } - } - fn get_global_debug_flag(&mut self) -> bool { - unsafe extern "C" { - fn vtk_garbage_collector_get_global_debug_flag( - sself: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_garbage_collector_get_global_debug_flag(self.0) } - } -} -impl VtkIdList for vtkIdList { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_list_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_list_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_list_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_list_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_list_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_list_new_instance(self.0) } - } - fn initialize(&mut self) -> () { - unsafe extern "C" { - fn vtk_id_list_initialize(sself: *mut core::ffi::c_void); - } - unsafe { vtk_id_list_initialize(self.0) } - } - fn allocate( - &mut self, - sz: core::ffi::c_uchar, - strategy: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_id_list_allocate( - sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - strategy: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_id_list_allocate(self.0, sz, strategy) } - } - fn get_number_of_ids(&mut self) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_get_number_of_ids( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_list_get_number_of_ids(self.0) } - } - fn get_id(&mut self, i: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_get_id( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_list_get_id(self.0, i) } - } - fn find_id_location(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_find_id_location( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_list_find_id_location(self.0, id) } - } - fn set_number_of_ids(&mut self, number: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_id_list_set_number_of_ids( - sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_list_set_number_of_ids(self.0, number) } - } - fn set_id(&mut self, i: core::ffi::c_uchar, vtkid: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_id_list_set_id( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - vtkid: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_list_set_id(self.0, i, vtkid) } - } - fn insert_id(&mut self, i: core::ffi::c_uchar, vtkid: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_id_list_insert_id( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - vtkid: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_list_insert_id(self.0, i, vtkid) } - } - fn insert_next_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_insert_next_id( - sself: *mut core::ffi::c_void, - vtkid: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_list_insert_next_id(self.0, vtkid) } - } - fn insert_unique_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_insert_unique_id( - sself: *mut core::ffi::c_void, - vtkid: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_list_insert_unique_id(self.0, vtkid) } - } - fn sort(&mut self) -> () { - unsafe extern "C" { - fn vtk_id_list_sort(sself: *mut core::ffi::c_void); - } - unsafe { vtk_id_list_sort(self.0) } - } - fn fill(&mut self, value: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_id_list_fill( - sself: *mut core::ffi::c_void, - value: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_list_fill(self.0, value) } - } - fn get_pointer(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_get_pointer( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_id_list_get_pointer(self.0, i) } - } - fn write_pointer( - &mut self, - i: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_write_pointer( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_id_list_write_pointer(self.0, i, number) } - } - fn set_array(&mut self, array: core::ffi::c_uchar, size: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_id_list_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_list_set_array(self.0, array, size) } - } - fn reset(&mut self) -> () { - unsafe extern "C" { - fn vtk_id_list_reset(sself: *mut core::ffi::c_void); - } - unsafe { vtk_id_list_reset(self.0) } - } - fn squeeze(&mut self) -> () { - unsafe extern "C" { - fn vtk_id_list_squeeze(sself: *mut core::ffi::c_void); - } - unsafe { vtk_id_list_squeeze(self.0) } - } - fn deep_copy(&mut self, ids: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_id_list_deep_copy( - sself: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ); - } - unsafe { vtk_id_list_deep_copy(self.0, ids) } - } - fn delete_id(&mut self, vtkid: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_id_list_delete_id( - sself: *mut core::ffi::c_void, - vtkid: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_list_delete_id(self.0, vtkid) } - } - fn is_id(&mut self, vtkid: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_is_id( - sself: *mut core::ffi::c_void, - vtkid: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_list_is_id(self.0, vtkid) } - } - fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_id_list_intersect_with( - sself: *mut core::ffi::c_void, - otherIds: *mut core::ffi::c_void, - ); - } - unsafe { vtk_id_list_intersect_with(self.0, otherIds) } - } - fn resize(&mut self, sz: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_resize( - sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_id_list_resize(self.0, sz) } - } - fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_id_list_intersect_with( - sself: *mut core::ffi::c_void, - otherIds: *mut core::ffi::c_void, - ); - } - unsafe { vtk_id_list_intersect_with(self.0, otherIds) } - } - fn begin(&mut self) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_begin( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_id_list_begin(self.0) } - } - fn end(&mut self) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_end(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_id_list_end(self.0) } - } - fn begin(&mut self) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_begin( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_id_list_begin(self.0) } - } - fn end(&mut self) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_list_end( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_id_list_end(self.0) } - } -} -impl VtkIdListCollection for vtkIdListCollection { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_list_collection_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_list_collection_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_list_collection_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_list_collection_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_list_collection_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_list_collection_new_instance(self.0) } - } - fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_id_list_collection_add_item( - sself: *mut core::ffi::c_void, - ds: *mut core::ffi::c_void, - ); - } - unsafe { vtk_id_list_collection_add_item(self.0, ds) } - } - fn get_next_item(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_list_collection_get_next_item( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_list_collection_get_next_item(self.0) } - } - fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_list_collection_get_item( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_list_collection_get_item(self.0, i) } - } - fn get_next_id_list(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_list_collection_get_next_id_list( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_list_collection_get_next_id_list(self.0, cookie) } - } - fn get_number_of_items(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_id_list_collection_get_number_of_items( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_id_list_collection_get_number_of_items(self.0) } - } -} -impl VtkIdTypeArray for vtkIdTypeArray { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_type_array_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_type_array_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_type_array_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_type_array_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_type_array_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_type_array_new(self.0) } - } - fn extended_new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_type_array_extended_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_type_array_extended_new(self.0) } - } - fn get_data_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_id_type_array_get_data_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_id_type_array_get_data_type(self.0) } - } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_id_type_array_get_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_type_array_get_typed_tuple(self.0, i, tuple) } - } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_id_type_array_set_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_type_array_set_typed_tuple(self.0, i, tuple) } - } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_id_type_array_insert_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_type_array_insert_typed_tuple(self.0, i, tuple) } - } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_type_array_insert_next_typed_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_type_array_insert_next_typed_tuple(self.0, tuple) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_type_array_get_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_type_array_get_value(self.0, id) } - } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_id_type_array_set_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_type_array_set_value(self.0, id, value) } - } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { - unsafe extern "C" { - fn vtk_id_type_array_set_number_of_values( - sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, - ) -> bool; - } - unsafe { vtk_id_type_array_set_number_of_values(self.0, number) } - } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_id_type_array_insert_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - f: core::ffi::c_uchar, - ); - } - unsafe { vtk_id_type_array_insert_value(self.0, id, f) } - } - fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_type_array_insert_next_value( - sself: *mut core::ffi::c_void, - f: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_type_array_insert_next_value(self.0, f) } - } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_type_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_id_type_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_type_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_id_type_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_type_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_id_type_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_type_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_id_type_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_id_type_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_id_type_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_id_type_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { vtk_id_type_array_set_array(self.0, array, size, save, deleteMethod) } - } - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_id_type_array_fast_down_cast( - sself: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_id_type_array_fast_down_cast(self.0, source) } - } - fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_type_array_get_data_type_value_min( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_type_array_get_data_type_value_min(self.0) } - } - fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_id_type_array_get_data_type_value_max( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_id_type_array_get_data_type_value_max(self.0) } - } -} -impl VtkInformation for vtkInformation { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_information_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_information_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_information_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_information_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_information_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_information_new_instance(self.0) } - } - fn modified(&mut self) -> () { - unsafe extern "C" { - fn vtk_information_modified(sself: *mut core::ffi::c_void); - } - unsafe { vtk_information_modified(self.0) } - } - fn modified(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_modified( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_modified(self.0, key) } - } - fn clear(&mut self) -> () { - unsafe extern "C" { - fn vtk_information_clear(sself: *mut core::ffi::c_void); - } - unsafe { vtk_information_clear(self.0) } - } - fn get_number_of_keys(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_get_number_of_keys( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_get_number_of_keys(self.0) } - } - fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_information_copy( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy(self.0, from, deep) } - } - fn append(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_information_append( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_append(self.0, from, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entry( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entry( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entry(self.0, from, key, deep) } - } - fn copy_entries( - &mut self, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_copy_entries( - sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - deep: core::ffi::c_int, - ); - } - unsafe { vtk_information_copy_entries(self.0, from, key, deep) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn set(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_set(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_int, - ); - } - unsafe { vtk_information_set(self.0, key, value) } - } - fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_get(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_uchar, - ); - } - unsafe { vtk_information_set(self.0, key, value) } - } - fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_information_get(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_double, - ); - } - unsafe { vtk_information_set(self.0, key, value) } - } - fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_information_get(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn set(&mut self, key: *mut core::ffi::c_void, value: vtkVariant) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: vtkVariant, - ); - } - unsafe { vtk_information_set(self.0, key, value) } - } - fn get(&mut self, key: *mut core::ffi::c_void) -> vtkVariant { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> vtkVariant; - } - unsafe { vtk_information_get(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_information_append( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_int, - ); - } - unsafe { vtk_information_append(self.0, key, value) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: core::ffi::c_int, - length: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_int, - length: core::ffi::c_int, - ); - } - unsafe { vtk_information_set(self.0, key, value, length) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value1: core::ffi::c_int, - value2: core::ffi::c_int, - value3: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value1: core::ffi::c_int, - value2: core::ffi::c_int, - value3: core::ffi::c_int, - ); - } - unsafe { vtk_information_set(self.0, key, value1, value2, value3) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value1: core::ffi::c_int, - value2: core::ffi::c_int, - value3: core::ffi::c_int, - value4: core::ffi::c_int, - value5: core::ffi::c_int, - value6: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value1: core::ffi::c_int, - value2: core::ffi::c_int, - value3: core::ffi::c_int, - value4: core::ffi::c_int, - value5: core::ffi::c_int, - value6: core::ffi::c_int, - ); - } - unsafe { - vtk_information_set( - self.0, - key, - value1, - value2, - value3, - value4, - value5, - value6, - ) - } - } - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_information_get(self.0, key) } - } - fn get( - &mut self, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_get(self.0, key, idx) } - } - fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_int, - ); - } - unsafe { vtk_information_get(self.0, key, value) } - } - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_length( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_length(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_information_append( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_char, - ); - } - unsafe { vtk_information_append(self.0, key, value) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: core::ffi::c_char, - idx: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_char, - idx: core::ffi::c_int, - ); - } - unsafe { vtk_information_set(self.0, key, value, idx) } - } - fn append(&mut self, key: *mut core::ffi::c_void, value: &str) -> () { - let c_value = std::ffi::CString::new(value).expect("CString::new failed"); - unsafe extern "C" { - fn vtk_information_append( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *const core::ffi::c_char, - ); - } - unsafe { vtk_information_append(self.0, key, c_value.as_ptr()) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: &str, - idx: core::ffi::c_int, - ) -> () { - let c_value = std::ffi::CString::new(value).expect("CString::new failed"); - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *const core::ffi::c_char, - idx: core::ffi::c_int, - ); - } - unsafe { vtk_information_set(self.0, key, c_value.as_ptr(), idx) } - } - fn get( - &mut self, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> *const core::ffi::c_char { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> *const core::ffi::c_char; - } - unsafe { vtk_information_get(self.0, key, idx) } - } - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_length( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_length(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: core::ffi::c_int, - length: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_int, - length: core::ffi::c_int, - ); - } - unsafe { vtk_information_set(self.0, key, value, length) } - } - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_information_get(self.0, key) } - } - fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_int, - ); - } - unsafe { vtk_information_get(self.0, key, value) } - } - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_length( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_length(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn set(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_ulong) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_ulong, - ); - } - unsafe { vtk_information_set(self.0, key, value) } - } - fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_ulong { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_ulong; - } - unsafe { vtk_information_get(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn append(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_information_append( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_double, - ); - } - unsafe { vtk_information_append(self.0, key, value) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: core::ffi::c_double, - length: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_double, - length: core::ffi::c_int, - ); - } - unsafe { vtk_information_set(self.0, key, value, length) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value1: core::ffi::c_double, - value2: core::ffi::c_double, - value3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value1: core::ffi::c_double, - value2: core::ffi::c_double, - value3: core::ffi::c_double, - ); - } - unsafe { vtk_information_set(self.0, key, value1, value2, value3) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value1: core::ffi::c_double, - value2: core::ffi::c_double, - value3: core::ffi::c_double, - value4: core::ffi::c_double, - value5: core::ffi::c_double, - value6: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value1: core::ffi::c_double, - value2: core::ffi::c_double, - value3: core::ffi::c_double, - value4: core::ffi::c_double, - value5: core::ffi::c_double, - value6: core::ffi::c_double, - ); - } - unsafe { - vtk_information_set( - self.0, - key, - value1, - value2, - value3, - value4, - value5, - value6, - ) - } - } - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_information_get(self.0, key) } - } - fn get( - &mut self, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> core::ffi::c_double; - } - unsafe { vtk_information_get(self.0, key, idx) } - } - fn get(&mut self, key: *mut core::ffi::c_void, value: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: core::ffi::c_double, - ); - } - unsafe { vtk_information_get(self.0, key, value) } - } - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_length( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_length(self.0, key) } - } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); - } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } - } - fn append(&mut self, key: *mut core::ffi::c_void, value: vtkVariant) -> () { - unsafe extern "C" { - fn vtk_information_append( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: vtkVariant, - ); - } - unsafe { vtk_information_append(self.0, key, value) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: vtkVariant, - length: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: vtkVariant, - length: core::ffi::c_int, - ); - } - unsafe { vtk_information_set(self.0, key, value, length) } - } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value1: vtkVariant, - value2: vtkVariant, - value3: vtkVariant, - ) -> () { - unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value1: vtkVariant, - value2: vtkVariant, - value3: vtkVariant, - ); - } - unsafe { vtk_information_set(self.0, key, value1, value2, value3) } - } - fn set( + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn set_number_of_pointers(&mut self, number: core::ffi::c_longlong) -> (); + fn get_number_of_pointers(&mut self) -> core::ffi::c_longlong; + fn reset(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn deep_copy(&mut self, va: *mut core::ffi::c_void) -> (); +} +pub trait VtkWeakPointer { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn get(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkWeakPointerBase { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkWeakReference { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set(&mut self, object: *mut core::ffi::c_void) -> (); + fn get(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_window_info(&mut self, p0: &str) -> (); + fn set_parent_info(&mut self, p0: &str) -> (); + fn set_position(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); + fn set_size(&mut self, width: core::ffi::c_int, height: core::ffi::c_int) -> (); + fn get_mapped(&mut self) -> core::ffi::c_int; + fn get_show_window(&mut self) -> bool; + fn set_show_window(&mut self, _arg: bool) -> (); + fn show_window_on(&mut self) -> (); + fn show_window_off(&mut self) -> (); + fn set_use_off_screen_buffers(&mut self, _arg: bool) -> (); + fn get_use_off_screen_buffers(&mut self) -> bool; + fn use_off_screen_buffers_on(&mut self) -> (); + fn use_off_screen_buffers_off(&mut self) -> (); + fn set_erase(&mut self, _arg: core::ffi::c_int) -> (); + fn get_erase(&mut self) -> core::ffi::c_int; + fn erase_on(&mut self) -> (); + fn erase_off(&mut self) -> (); + fn set_double_buffer(&mut self, _arg: core::ffi::c_int) -> (); + fn get_double_buffer(&mut self) -> core::ffi::c_int; + fn double_buffer_on(&mut self) -> (); + fn double_buffer_off(&mut self) -> (); + fn set_window_name(&mut self, _arg: &str) -> (); + fn set_icon(&mut self, p0: *mut core::ffi::c_void) -> (); + fn render(&mut self) -> (); + fn release_graphics_resources(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_dpi(&mut self) -> core::ffi::c_int; + fn set_dpi(&mut self, _arg: core::ffi::c_int) -> (); + fn get_dpi_min_value(&mut self) -> core::ffi::c_int; + fn get_dpi_max_value(&mut self) -> core::ffi::c_int; + fn detect_dpi(&mut self) -> bool; + fn set_off_screen_rendering(&mut self, val: core::ffi::c_int) -> (); + fn off_screen_rendering_on(&mut self) -> (); + fn off_screen_rendering_off(&mut self) -> (); + fn get_off_screen_rendering(&mut self) -> core::ffi::c_int; + fn make_current(&mut self) -> (); + fn release_current(&mut self) -> (); + fn set_tile_scale(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> (); + fn set_tile_viewport( &mut self, - key: *mut core::ffi::c_void, - value1: vtkVariant, - value2: vtkVariant, - value3: vtkVariant, - value4: vtkVariant, - value5: vtkVariant, - value6: vtkVariant, - ) -> () { + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); +} +pub trait VtkXMLFileOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn display_text(&mut self, p0: &str) -> (); + fn display_tag(&mut self, p0: &str) -> (); +} +impl VtkAnimationCue for vtkAnimationCue { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_set( + fn vtk_animation_cue_safe_down_cast( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value1: vtkVariant, - value2: vtkVariant, - value3: vtkVariant, - value4: vtkVariant, - value5: vtkVariant, - value6: vtkVariant, - ); - } - unsafe { - vtk_information_set( - self.0, - key, - value1, - value2, - value3, - value4, - value5, - value6, - ) + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } + unsafe { vtk_animation_cue_safe_down_cast(self.0, o) } } - fn get(&mut self, key: *mut core::ffi::c_void) -> *const vtkVariant { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get( + fn vtk_animation_cue_new_instance( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *const vtkVariant; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get(self.0, key) } + unsafe { vtk_animation_cue_new_instance(self.0) } } - fn get(&mut self, key: *mut core::ffi::c_void, idx: core::ffi::c_int) -> vtkVariant { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get( + fn vtk_animation_cue_new( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> vtkVariant; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get(self.0, key, idx) } + unsafe { vtk_animation_cue_new(self.0) } } - fn get(&mut self, key: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> () { + fn set_time_mode(&mut self, mode: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_information_get( + fn vtk_animation_cue_set_time_mode( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + mode: core::ffi::c_int, ); } - unsafe { vtk_information_get(self.0, key, value) } + unsafe { vtk_animation_cue_set_time_mode(self.0, mode) } } - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + fn get_time_mode(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_length( + fn vtk_animation_cue_get_time_mode( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ) -> core::ffi::c_int; } - unsafe { vtk_information_length(self.0, key) } + unsafe { vtk_animation_cue_get_time_mode(self.0) } } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + fn set_time_mode_to_relative(&mut self) -> () { unsafe extern "C" { - fn vtk_information_remove( + fn vtk_animation_cue_set_time_mode_to_relative( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ); } - unsafe { vtk_information_remove(self.0, key) } + unsafe { vtk_animation_cue_set_time_mode_to_relative(self.0) } } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + fn set_time_mode_to_normalized(&mut self) -> () { unsafe extern "C" { - fn vtk_information_has( + fn vtk_animation_cue_set_time_mode_to_normalized( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + ); } - unsafe { vtk_information_has(self.0, key) } + unsafe { vtk_animation_cue_set_time_mode_to_normalized(self.0) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn set_start_time(&mut self, _arg: core::ffi::c_double) -> () { unsafe extern "C" { - fn vtk_information_append( + fn vtk_animation_cue_set_start_time( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + _arg: core::ffi::c_double, ); } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_animation_cue_set_start_time(self.0, _arg) } } - fn append_unique( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn get_start_time(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_animation_cue_get_start_time( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + ) -> core::ffi::c_double; } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_animation_cue_get_start_time(self.0) } } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - length: core::ffi::c_int, - ) -> () { + fn set_end_time(&mut self, _arg: core::ffi::c_double) -> () { unsafe extern "C" { - fn vtk_information_set( + fn vtk_animation_cue_set_end_time( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - length: core::ffi::c_int, + _arg: core::ffi::c_double, ); } - unsafe { vtk_information_set(self.0, key, value, length) } + unsafe { vtk_animation_cue_set_end_time(self.0, _arg) } } - fn remove( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn get_end_time(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_information_remove( + fn vtk_animation_cue_get_end_time( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + ) -> core::ffi::c_double; } - unsafe { vtk_information_remove(self.0, key, value) } + unsafe { vtk_animation_cue_get_end_time(self.0) } } - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut &mut vtkInformationKey { + fn tick( + &mut self, + currenttime: core::ffi::c_double, + deltatime: core::ffi::c_double, + clocktime: core::ffi::c_double, + ) -> () { unsafe extern "C" { - fn vtk_information_get( + fn vtk_animation_cue_tick( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut &mut vtkInformationKey; + currenttime: core::ffi::c_double, + deltatime: core::ffi::c_double, + clocktime: core::ffi::c_double, + ); } - unsafe { vtk_information_get(self.0, key) } + unsafe { vtk_animation_cue_tick(self.0, currenttime, deltatime, clocktime) } } - fn get( - &mut self, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> *mut core::ffi::c_void { + fn initialize(&mut self) -> () { unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> *mut core::ffi::c_void; + fn vtk_animation_cue_initialize(sself: *mut core::ffi::c_void); } - unsafe { vtk_information_get(self.0, key, idx) } + unsafe { vtk_animation_cue_initialize(self.0) } } - fn get(&mut self, key: *mut core::ffi::c_void, value: *mut core::ffi::c_void) -> () { + fn finalize(&mut self) -> () { unsafe extern "C" { - fn vtk_information_get( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + fn vtk_animation_cue_finalize(sself: *mut core::ffi::c_void); } - unsafe { vtk_information_get(self.0, key, value) } + unsafe { vtk_animation_cue_finalize(self.0) } } - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + fn get_animation_time(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_information_length( + fn vtk_animation_cue_get_animation_time( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + ) -> core::ffi::c_double; } - unsafe { vtk_information_length(self.0, key) } + unsafe { vtk_animation_cue_get_animation_time(self.0) } } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + fn get_delta_time(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_information_remove( + fn vtk_animation_cue_get_delta_time( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); + ) -> core::ffi::c_double; } - unsafe { vtk_information_remove(self.0, key) } + unsafe { vtk_animation_cue_get_delta_time(self.0) } } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + fn get_clock_time(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_information_has( + fn vtk_animation_cue_get_clock_time( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + ) -> core::ffi::c_double; } - unsafe { vtk_information_has(self.0, key) } + unsafe { vtk_animation_cue_get_clock_time(self.0) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { +} +impl VtkArchiver for vtkArchiver { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_append( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + fn vtk_archiver_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_archiver_new(self.0) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_append( + fn vtk_archiver_safe_down_cast( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_archiver_safe_down_cast(self.0, o) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_append( + fn vtk_archiver_new_instance( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_archiver_new_instance(self.0) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn set_archive_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { - fn vtk_information_append( + fn vtk_archiver_set_archive_name( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, ); } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_archiver_set_archive_name(self.0, c__arg.as_ptr()) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn open_archive(&mut self) -> () { unsafe extern "C" { - fn vtk_information_append( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + fn vtk_archiver_open_archive(sself: *mut core::ffi::c_void); } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_archiver_open_archive(self.0) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn close_archive(&mut self) -> () { unsafe extern "C" { - fn vtk_information_append( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + fn vtk_archiver_close_archive(sself: *mut core::ffi::c_void); } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_archiver_close_archive(self.0) } } - fn append( + fn insert_into_archive( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + relativePath: &str, + data: &str, + size: usize, ) -> () { + let c_relativePath = std::ffi::CString::new(relativePath) + .expect("CString::new failed"); + let c_data = std::ffi::CString::new(data).expect("CString::new failed"); unsafe extern "C" { - fn vtk_information_append( + fn vtk_archiver_insert_into_archive( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + relativePath: *const core::ffi::c_char, + data: *const core::ffi::c_char, + size: usize, ); } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { + vtk_archiver_insert_into_archive( + self.0, + c_relativePath.as_ptr(), + c_data.as_ptr(), + size, + ) + } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn contains(&mut self, relativePath: &str) -> bool { + let c_relativePath = std::ffi::CString::new(relativePath) + .expect("CString::new failed"); unsafe extern "C" { - fn vtk_information_append( + fn vtk_archiver_contains( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + relativePath: *const core::ffi::c_char, + ) -> bool; } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_archiver_contains(self.0, c_relativePath.as_ptr()) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { +} +impl VtkBitArray for vtkBitArray { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_append( + fn vtk_bit_array_new( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_bit_array_new(self.0) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_append( + fn vtk_bit_array_safe_down_cast( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_bit_array_safe_down_cast(self.0, o) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_append( + fn vtk_bit_array_new_instance( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_append(self.0, key, value) } + unsafe { vtk_bit_array_new_instance(self.0) } } - fn append_unique( + fn allocate( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_bit_array_allocate( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_allocate(self.0, sz, ext) } } - fn append_unique( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn initialize(&mut self) -> () { unsafe extern "C" { - fn vtk_information_append_unique( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + fn vtk_bit_array_initialize(sself: *mut core::ffi::c_void); } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_initialize(self.0) } } - fn append_unique( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_bit_array_get_data_type( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_get_data_type(self.0) } } - fn append_unique( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn get_data_type_size(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_bit_array_get_data_type_size( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_get_data_type_size(self.0) } } - fn append_unique( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> () { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_bit_array_set_number_of_tuples( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + number: core::ffi::c_longlong, ); } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_set_number_of_tuples(self.0, number) } } - fn append_unique( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_bit_array_set_number_of_values( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + number: core::ffi::c_longlong, + ) -> bool; } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_set_number_of_values(self.0, number) } } - fn append_unique( + fn set_tuple( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_bit_array_set_tuple( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, ); } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_set_tuple(self.0, i, j, source) } } - fn append_unique( + fn insert_tuple( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_bit_array_insert_tuple( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, ); } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_insert_tuple(self.0, i, j, source) } } - fn append_unique( + fn insert_next_tuple( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_bit_array_insert_next_tuple( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ); + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_insert_next_tuple(self.0, j, source) } } - fn append_unique( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> () { + fn remove_tuple(&mut self, id: core::ffi::c_longlong) -> () { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_bit_array_remove_tuple( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + id: core::ffi::c_longlong, ); } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_remove_tuple(self.0, id) } } - fn append_unique( + fn set_component( &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_int, + c: core::ffi::c_double, ) -> () { unsafe extern "C" { - fn vtk_information_append_unique( + fn vtk_bit_array_set_component( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_int, + c: core::ffi::c_double, ); } - unsafe { vtk_information_append_unique(self.0, key, value) } + unsafe { vtk_bit_array_set_component(self.0, i, j, c) } } - fn set(&mut self, key: *mut core::ffi::c_void, p1: core::ffi::c_char) -> () { + fn squeeze(&mut self) -> () { unsafe extern "C" { - fn vtk_information_set( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - p1: core::ffi::c_char, - ); + fn vtk_bit_array_squeeze(sself: *mut core::ffi::c_void); } - unsafe { vtk_information_set(self.0, key, p1) } + unsafe { vtk_bit_array_squeeze(self.0) } } - fn set(&mut self, key: *mut core::ffi::c_void, p1: &str) -> () { - let c_p1 = std::ffi::CString::new(p1).expect("CString::new failed"); + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_set( + fn vtk_bit_array_resize( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - p1: *const core::ffi::c_char, - ); + numTuples: core::ffi::c_longlong, + ) -> core::ffi::c_int; } - unsafe { vtk_information_set(self.0, key, c_p1.as_ptr()) } + unsafe { vtk_bit_array_resize(self.0, numTuples) } } - fn get(&mut self, key: *mut core::ffi::c_void) -> *const core::ffi::c_char { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_get( + fn vtk_bit_array_get_value( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; + id: core::ffi::c_longlong, + ) -> core::ffi::c_int; } - unsafe { vtk_information_get(self.0, key) } + unsafe { vtk_bit_array_get_value(self.0, id) } } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_information_remove( + fn vtk_bit_array_set_value( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_int, ); } - unsafe { vtk_information_remove(self.0, key) } - } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_information_has( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_information_has(self.0, key) } + unsafe { vtk_bit_array_set_value(self.0, id, value) } } - fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> () { + fn insert_value(&mut self, id: core::ffi::c_longlong, i: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_information_set( + fn vtk_bit_array_insert_value( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + i: core::ffi::c_int, ); } - unsafe { vtk_information_set(self.0, key, p1) } + unsafe { vtk_bit_array_insert_value(self.0, id, i) } } - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn insert_next_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_information_get( + fn vtk_bit_array_insert_next_value( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + i: core::ffi::c_int, + ) -> core::ffi::c_longlong; } - unsafe { vtk_information_get(self.0, key) } + unsafe { vtk_bit_array_insert_next_value(self.0, i) } } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + fn insert_component( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_int, + c: core::ffi::c_double, + ) -> () { unsafe extern "C" { - fn vtk_information_remove( + fn vtk_bit_array_insert_component( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_int, + c: core::ffi::c_double, ); } - unsafe { vtk_information_remove(self.0, key) } + unsafe { vtk_bit_array_insert_component(self.0, i, j, c) } } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_information_has( + fn vtk_bit_array_deep_copy( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + da: *mut core::ffi::c_void, + ); } - unsafe { vtk_information_has(self.0, key) } + unsafe { vtk_bit_array_deep_copy(self.0, da) } } - fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> () { + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_information_set( + fn vtk_bit_array_set_array_free_function( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, + callback: *mut core::ffi::c_void, ); } - unsafe { vtk_information_set(self.0, key, p1) } + unsafe { vtk_bit_array_set_array_free_function(self.0, callback) } } - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn new_iterator(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get( + fn vtk_bit_array_new_iterator( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get(self.0, key) } + unsafe { vtk_bit_array_new_iterator(self.0) } } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + fn data_changed(&mut self) -> () { unsafe extern "C" { - fn vtk_information_remove( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); + fn vtk_bit_array_data_changed(sself: *mut core::ffi::c_void); } - unsafe { vtk_information_remove(self.0, key) } + unsafe { vtk_bit_array_data_changed(self.0) } } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + fn clear_lookup(&mut self) -> () { unsafe extern "C" { - fn vtk_information_has( + fn vtk_bit_array_clear_lookup(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bit_array_clear_lookup(self.0) } + } +} +impl VtkBitArrayIterator for vtkBitArrayIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_iterator_new( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_has(self.0, key) } + unsafe { vtk_bit_array_iterator_new(self.0) } } - fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_set( + fn vtk_bit_array_iterator_safe_down_cast( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_set(self.0, key, p1) } + unsafe { vtk_bit_array_iterator_safe_down_cast(self.0, o) } } - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get( + fn vtk_bit_array_iterator_new_instance( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get(self.0, key) } + unsafe { vtk_bit_array_iterator_new_instance(self.0) } } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + fn initialize(&mut self, array: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_information_remove( + fn vtk_bit_array_iterator_initialize( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, ); } - unsafe { vtk_information_remove(self.0, key) } + unsafe { vtk_bit_array_iterator_initialize(self.0, array) } } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + fn get_array(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_has( + fn vtk_bit_array_iterator_get_array( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_has(self.0, key) } + unsafe { vtk_bit_array_iterator_get_array(self.0) } } - fn append( - &mut self, - key: *mut core::ffi::c_void, - data: *mut core::ffi::c_void, - ) -> () { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_append( + fn vtk_bit_array_iterator_get_value( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - data: *mut core::ffi::c_void, - ); + id: core::ffi::c_longlong, + ) -> core::ffi::c_int; } - unsafe { vtk_information_append(self.0, key, data) } + unsafe { vtk_bit_array_iterator_get_value(self.0, id) } } - fn set( - &mut self, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> () { + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_information_set( + fn vtk_bit_array_iterator_get_number_of_tuples( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ); + ) -> core::ffi::c_longlong; } - unsafe { vtk_information_set(self.0, key, value, idx) } + unsafe { vtk_bit_array_iterator_get_number_of_tuples(self.0) } } - fn get( - &mut self, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> *mut core::ffi::c_void { + fn get_number_of_values(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_information_get( + fn vtk_bit_array_iterator_get_number_of_values( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ) -> *mut core::ffi::c_void; + ) -> core::ffi::c_longlong; } - unsafe { vtk_information_get(self.0, key, idx) } + unsafe { vtk_bit_array_iterator_get_number_of_values(self.0) } } - fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + fn get_number_of_components(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_length( + fn vtk_bit_array_iterator_get_number_of_components( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ) -> core::ffi::c_int; } - unsafe { vtk_information_length(self.0, key) } + unsafe { vtk_bit_array_iterator_get_number_of_components(self.0) } } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_remove( + fn vtk_bit_array_iterator_get_data_type( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_information_remove(self.0, key) } + unsafe { vtk_bit_array_iterator_get_data_type(self.0) } } - fn remove( - &mut self, - key: *mut core::ffi::c_void, - objectToRemove: *mut core::ffi::c_void, - ) -> () { + fn get_data_type_size(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_remove( + fn vtk_bit_array_iterator_get_data_type_size( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - objectToRemove: *mut core::ffi::c_void, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_information_remove(self.0, key, objectToRemove) } + unsafe { vtk_bit_array_iterator_get_data_type_size(self.0) } } - fn remove( - &mut self, - key: *mut core::ffi::c_void, - indexToRemove: core::ffi::c_int, - ) -> () { + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_information_remove( + fn vtk_bit_array_iterator_set_value( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - indexToRemove: core::ffi::c_int, + id: core::ffi::c_longlong, + value: core::ffi::c_int, ); } - unsafe { vtk_information_remove(self.0, key, indexToRemove) } + unsafe { vtk_bit_array_iterator_set_value(self.0, id, value) } } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { +} +impl VtkBoxMuellerRandomSequence for vtkBoxMuellerRandomSequence { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_has( + fn vtk_box_mueller_random_sequence_new( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_has(self.0, key) } + unsafe { vtk_box_mueller_random_sequence_new(self.0) } } - fn set(&mut self, key: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_set( + fn vtk_box_mueller_random_sequence_safe_down_cast( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_set(self.0, key, p1) } + unsafe { vtk_box_mueller_random_sequence_safe_down_cast(self.0, o) } } - fn get(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get( + fn vtk_box_mueller_random_sequence_new_instance( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get(self.0, key) } + unsafe { vtk_box_mueller_random_sequence_new_instance(self.0) } } - fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + fn initialize(&mut self, seed: core::ffi::c_uint) -> () { unsafe extern "C" { - fn vtk_information_remove( + fn vtk_box_mueller_random_sequence_initialize( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, + seed: core::ffi::c_uint, ); } - unsafe { vtk_information_remove(self.0, key) } + unsafe { vtk_box_mueller_random_sequence_initialize(self.0, seed) } } - fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + fn get_value(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_information_has( + fn vtk_box_mueller_random_sequence_get_value( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + ) -> core::ffi::c_double; } - unsafe { vtk_information_has(self.0, key) } + unsafe { vtk_box_mueller_random_sequence_get_value(self.0) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn next(&mut self) -> () { unsafe extern "C" { - fn vtk_information_get_key( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + fn vtk_box_mueller_random_sequence_next(sself: *mut core::ffi::c_void); } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_box_mueller_random_sequence_next(self.0) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn get_uniform_sequence(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_box_mueller_random_sequence_get_uniform_sequence( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_box_mueller_random_sequence_get_uniform_sequence(self.0) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn set_uniform_sequence(&mut self, uniformSequence: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_box_mueller_random_sequence_set_uniform_sequence( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + uniformSequence: *mut core::ffi::c_void, + ); } - unsafe { vtk_information_get_key(self.0, key) } - } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_information_get_key( - sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + unsafe { + vtk_box_mueller_random_sequence_set_uniform_sequence(self.0, uniformSequence) } - unsafe { vtk_information_get_key(self.0, key) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { +} +impl VtkByteSwap for vtkByteSwap { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_byte_swap_new( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_byte_swap_new(self.0) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_byte_swap_safe_down_cast( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_byte_swap_safe_down_cast(self.0, o) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_byte_swap_new_instance( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_byte_swap_new_instance(self.0) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { +} +impl VtkCallbackCommand for vtkCallbackCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_callback_command_safe_down_cast( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_callback_command_safe_down_cast(self.0, o) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_callback_command_new_instance( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_callback_command_new_instance(self.0) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_callback_command_new( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_callback_command_new(self.0) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn set_callback(&mut self, f: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_callback_command_set_callback( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + f: *mut core::ffi::c_void, + ); } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_callback_command_set_callback(self.0, f) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_callback_command_set_client_data_delete_callback( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + f: *mut core::ffi::c_void, + ); } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_callback_command_set_client_data_delete_callback(self.0, f) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn set_abort_flag_on_execute(&mut self, f: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_callback_command_set_abort_flag_on_execute( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + f: core::ffi::c_int, + ); } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_callback_command_set_abort_flag_on_execute(self.0, f) } } - fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn get_abort_flag_on_execute(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_get_key( + fn vtk_callback_command_get_abort_flag_on_execute( sself: *mut core::ffi::c_void, - key: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + ) -> core::ffi::c_int; } - unsafe { vtk_information_get_key(self.0, key) } + unsafe { vtk_callback_command_get_abort_flag_on_execute(self.0) } } - fn register(&mut self, o: *mut core::ffi::c_void) -> () { + fn abort_flag_on_execute_on(&mut self) -> () { unsafe extern "C" { - fn vtk_information_register( + fn vtk_callback_command_abort_flag_on_execute_on( sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, ); } - unsafe { vtk_information_register(self.0, o) } + unsafe { vtk_callback_command_abort_flag_on_execute_on(self.0) } } - fn set_request(&mut self, request: *mut core::ffi::c_void) -> () { + fn abort_flag_on_execute_off(&mut self) -> () { unsafe extern "C" { - fn vtk_information_set_request( + fn vtk_callback_command_abort_flag_on_execute_off( sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, ); } - unsafe { vtk_information_set_request(self.0, request) } + unsafe { vtk_callback_command_abort_flag_on_execute_off(self.0) } } - fn get_request(&mut self) -> *mut core::ffi::c_void { +} +impl VtkCharArray for vtkCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_get_request( + fn vtk_char_array_safe_down_cast( sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_get_request(self.0) } + unsafe { vtk_char_array_safe_down_cast(self.0, o) } } -} -impl VtkInformationIterator for vtkInformationIterator { - fn new(&mut self) -> *mut core::ffi::c_void { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_iterator_new( + fn vtk_char_array_new_instance( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_iterator_new(self.0) } + unsafe { vtk_char_array_new_instance(self.0) } } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_iterator_safe_down_cast( + fn vtk_char_array_new( sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_iterator_safe_down_cast(self.0, o) } + unsafe { vtk_char_array_new(self.0) } } - fn new_instance(&mut self) -> *mut core::ffi::c_void { + fn extended_new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_iterator_new_instance( + fn vtk_char_array_extended_new( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_iterator_new_instance(self.0) } + unsafe { vtk_char_array_extended_new(self.0) } } - fn set_information(&mut self, p0: *mut core::ffi::c_void) -> () { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_iterator_set_information( + fn vtk_char_array_get_data_type( sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_information_iterator_set_information(self.0, p0) } + unsafe { vtk_char_array_get_data_type(self.0) } } - fn get_information(&mut self) -> *mut core::ffi::c_void { + fn set_typed_tuple(&mut self, i: core::ffi::c_longlong, tuple: &str) -> () { + let c_tuple = std::ffi::CString::new(tuple).expect("CString::new failed"); unsafe extern "C" { - fn vtk_information_iterator_get_information( + fn vtk_char_array_set_typed_tuple( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + i: core::ffi::c_longlong, + tuple: *const core::ffi::c_char, + ); } - unsafe { vtk_information_iterator_get_information(self.0) } + unsafe { vtk_char_array_set_typed_tuple(self.0, i, c_tuple.as_ptr()) } } - fn set_information_weak(&mut self, p0: *mut core::ffi::c_void) -> () { + fn insert_typed_tuple(&mut self, i: core::ffi::c_longlong, tuple: &str) -> () { + let c_tuple = std::ffi::CString::new(tuple).expect("CString::new failed"); unsafe extern "C" { - fn vtk_information_iterator_set_information_weak( + fn vtk_char_array_insert_typed_tuple( sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + tuple: *const core::ffi::c_char, ); } - unsafe { vtk_information_iterator_set_information_weak(self.0, p0) } + unsafe { vtk_char_array_insert_typed_tuple(self.0, i, c_tuple.as_ptr()) } } - fn init_traversal(&mut self) -> () { + fn insert_next_typed_tuple(&mut self, tuple: &str) -> core::ffi::c_longlong { + let c_tuple = std::ffi::CString::new(tuple).expect("CString::new failed"); unsafe extern "C" { - fn vtk_information_iterator_init_traversal(sself: *mut core::ffi::c_void); + fn vtk_char_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: *const core::ffi::c_char, + ) -> core::ffi::c_longlong; } - unsafe { vtk_information_iterator_init_traversal(self.0) } + unsafe { vtk_char_array_insert_next_typed_tuple(self.0, c_tuple.as_ptr()) } } - fn go_to_first_item(&mut self) -> () { + fn get_value(&mut self, id: core::ffi::c_longlong) -> &str { unsafe extern "C" { - fn vtk_information_iterator_go_to_first_item(sself: *mut core::ffi::c_void); + fn vtk_char_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> *const core::ffi::c_char; } - unsafe { vtk_information_iterator_go_to_first_item(self.0) } + let ptr = unsafe { vtk_char_array_get_value(self.0, id) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn go_to_next_item(&mut self) -> () { + fn set_value(&mut self, id: core::ffi::c_longlong, value: &str) -> () { + let c_value = std::ffi::CString::new(value).expect("CString::new failed"); unsafe extern "C" { - fn vtk_information_iterator_go_to_next_item(sself: *mut core::ffi::c_void); + fn vtk_char_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: *const core::ffi::c_char, + ); } - unsafe { vtk_information_iterator_go_to_next_item(self.0) } + unsafe { vtk_char_array_set_value(self.0, id, c_value.as_ptr()) } } - fn is_done_with_traversal(&mut self) -> core::ffi::c_int { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { - fn vtk_information_iterator_is_done_with_traversal( + fn vtk_char_array_set_number_of_values( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + number: core::ffi::c_longlong, + ) -> bool; } - unsafe { vtk_information_iterator_is_done_with_traversal(self.0) } + unsafe { vtk_char_array_set_number_of_values(self.0, number) } } - fn get_current_key(&mut self) -> *mut core::ffi::c_void { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: &str) -> () { + let c_f = std::ffi::CString::new(f).expect("CString::new failed"); unsafe extern "C" { - fn vtk_information_iterator_get_current_key( + fn vtk_char_array_insert_value( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + id: core::ffi::c_longlong, + f: *const core::ffi::c_char, + ); } - unsafe { vtk_information_iterator_get_current_key(self.0) } + unsafe { vtk_char_array_insert_value(self.0, id, c_f.as_ptr()) } } -} -impl VtkInformationKeyLookup for vtkInformationKeyLookup { - fn new(&mut self) -> *mut core::ffi::c_void { + fn insert_next_value(&mut self, f: &str) -> core::ffi::c_longlong { + let c_f = std::ffi::CString::new(f).expect("CString::new failed"); unsafe extern "C" { - fn vtk_information_key_lookup_new( + fn vtk_char_array_insert_next_value( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + f: *const core::ffi::c_char, + ) -> core::ffi::c_longlong; } - unsafe { vtk_information_key_lookup_new(self.0) } + unsafe { vtk_char_array_insert_next_value(self.0, c_f.as_ptr()) } } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_key_lookup_safe_down_cast( + fn vtk_char_array_fast_down_cast( sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_key_lookup_safe_down_cast(self.0, o) } + unsafe { vtk_char_array_fast_down_cast(self.0, source) } } - fn new_instance(&mut self) -> *mut core::ffi::c_void { + fn get_data_type_value_min(&mut self) -> &str { unsafe extern "C" { - fn vtk_information_key_lookup_new_instance( + fn vtk_char_array_get_data_type_value_min( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + ) -> *const core::ffi::c_char; } - unsafe { vtk_information_key_lookup_new_instance(self.0) } + let ptr = unsafe { vtk_char_array_get_data_type_value_min(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn find(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void { - let c_name = std::ffi::CString::new(name).expect("CString::new failed"); - let c_location = std::ffi::CString::new(location).expect("CString::new failed"); + fn get_data_type_value_max(&mut self) -> &str { unsafe extern "C" { - fn vtk_information_key_lookup_find( + fn vtk_char_array_get_data_type_value_max( sself: *mut core::ffi::c_void, - name: *const core::ffi::c_char, - location: *const core::ffi::c_char, - ) -> *mut core::ffi::c_void; + ) -> *const core::ffi::c_char; } - unsafe { - vtk_information_key_lookup_find(self.0, c_name.as_ptr(), c_location.as_ptr()) + let ptr = unsafe { vtk_char_array_get_data_type_value_max(self.0) }; + if ptr.is_null() { + return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } } -impl VtkInformationVector for vtkInformationVector { - fn new(&mut self) -> *mut core::ffi::c_void { +impl VtkCollection for vtkCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_vector_new( + fn vtk_collection_safe_down_cast( sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_vector_new(self.0) } + unsafe { vtk_collection_safe_down_cast(self.0, o) } } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_vector_safe_down_cast( + fn vtk_collection_new_instance( sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_vector_safe_down_cast(self.0, o) } + unsafe { vtk_collection_new_instance(self.0) } } - fn new_instance(&mut self) -> *mut core::ffi::c_void { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_vector_new_instance( + fn vtk_collection_new( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_vector_new_instance(self.0) } + unsafe { vtk_collection_new(self.0) } } - fn get_number_of_information_objects(&mut self) -> core::ffi::c_int { + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_information_vector_get_number_of_information_objects( + fn vtk_collection_add_item( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + p0: *mut core::ffi::c_void, + ); } - unsafe { vtk_information_vector_get_number_of_information_objects(self.0) } + unsafe { vtk_collection_add_item(self.0, p0) } } - fn set_number_of_information_objects(&mut self, n: core::ffi::c_int) -> () { + fn insert_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_information_vector_set_number_of_information_objects( + fn vtk_collection_insert_item( sself: *mut core::ffi::c_void, - n: core::ffi::c_int, + i: core::ffi::c_int, + p1: *mut core::ffi::c_void, ); } - unsafe { vtk_information_vector_set_number_of_information_objects(self.0, n) } + unsafe { vtk_collection_insert_item(self.0, i, p1) } } - fn set_information_object( - &mut self, - index: core::ffi::c_int, - info: *mut core::ffi::c_void, - ) -> () { + fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_replace_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_replace_item(self.0, i, p1) } + } + fn remove_item(&mut self, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_collection_remove_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ); + } + unsafe { vtk_collection_remove_item(self.0, i) } + } + fn remove_all_items(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_remove_all_items(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_remove_all_items(self.0) } + } + fn is_item_present(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_vector_set_information_object( + fn vtk_collection_is_item_present( sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - info: *mut core::ffi::c_void, - ); + a: *mut core::ffi::c_void, + ) -> core::ffi::c_int; } - unsafe { vtk_information_vector_set_information_object(self.0, index, info) } + unsafe { vtk_collection_is_item_present(self.0, a) } } - fn get_information_object( - &mut self, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void { + fn get_number_of_items(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_information_vector_get_information_object( + fn vtk_collection_get_number_of_items( sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; + ) -> core::ffi::c_int; } - unsafe { vtk_information_vector_get_information_object(self.0, index) } + unsafe { vtk_collection_get_number_of_items(self.0) } } - fn append(&mut self, info: *mut core::ffi::c_void) -> () { + fn init_traversal(&mut self) -> () { unsafe extern "C" { - fn vtk_information_vector_append( - sself: *mut core::ffi::c_void, - info: *mut core::ffi::c_void, - ); + fn vtk_collection_init_traversal(sself: *mut core::ffi::c_void); } - unsafe { vtk_information_vector_append(self.0, info) } + unsafe { vtk_collection_init_traversal(self.0) } } - fn remove(&mut self, info: *mut core::ffi::c_void) -> () { + fn get_next_item_as_object(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_vector_remove( + fn vtk_collection_get_next_item_as_object( sself: *mut core::ffi::c_void, - info: *mut core::ffi::c_void, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_vector_remove(self.0, info) } + unsafe { vtk_collection_get_next_item_as_object(self.0) } } - fn remove(&mut self, idx: core::ffi::c_int) -> () { + fn get_item_as_object(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_vector_remove( + fn vtk_collection_get_item_as_object( sself: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ); + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_vector_remove(self.0, idx) } + unsafe { vtk_collection_get_item_as_object(self.0, i) } } - fn register(&mut self, o: *mut core::ffi::c_void) -> () { + fn new_iterator(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_information_vector_register( + fn vtk_collection_new_iterator( sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_information_vector_register(self.0, o) } + unsafe { vtk_collection_new_iterator(self.0) } } - fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { + fn register(&mut self, o: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_information_vector_copy( + fn vtk_collection_register( sself: *mut core::ffi::c_void, - from: *mut core::ffi::c_void, - deep: core::ffi::c_int, + o: *mut core::ffi::c_void, ); } - unsafe { vtk_information_vector_copy(self.0, from, deep) } + unsafe { vtk_collection_register(self.0, o) } } } -impl VtkIntArray for vtkIntArray { +impl VtkCollectionIterator for vtkCollectionIterator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_safe_down_cast( + fn vtk_collection_iterator_safe_down_cast( sself: *mut core::ffi::c_void, o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_safe_down_cast(self.0, o) } + unsafe { vtk_collection_iterator_safe_down_cast(self.0, o) } } fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_new_instance( + fn vtk_collection_iterator_new_instance( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_new_instance(self.0) } + unsafe { vtk_collection_iterator_new_instance(self.0) } } fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_new( + fn vtk_collection_iterator_new( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_new(self.0) } + unsafe { vtk_collection_iterator_new(self.0) } } - fn extended_new(&mut self) -> *mut core::ffi::c_void { + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_int_array_extended_new( + fn vtk_collection_iterator_set_collection( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_iterator_set_collection(self.0, p0) } + } + fn get_collection(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_get_collection( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_extended_new(self.0) } + unsafe { vtk_collection_iterator_get_collection(self.0) } } - fn get_data_type(&mut self) -> core::ffi::c_int { + fn init_traversal(&mut self) -> () { unsafe extern "C" { - fn vtk_int_array_get_data_type( + fn vtk_collection_iterator_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_iterator_init_traversal(self.0) } + } + fn go_to_first_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_iterator_go_to_first_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_iterator_go_to_first_item(self.0) } + } + fn go_to_next_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_iterator_go_to_next_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_iterator_go_to_next_item(self.0) } + } + fn is_done_with_traversal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_collection_iterator_is_done_with_traversal( sself: *mut core::ffi::c_void, ) -> core::ffi::c_int; } - unsafe { vtk_int_array_get_data_type(self.0) } + unsafe { vtk_collection_iterator_is_done_with_traversal(self.0) } } - fn get_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_int) -> () { + fn get_current_object(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_get_typed_tuple( + fn vtk_collection_iterator_get_current_object( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_int, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_get_typed_tuple(self.0, i, tuple) } + unsafe { vtk_collection_iterator_get_current_object(self.0) } } - fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_int) -> () { +} +impl VtkCriticalSection for vtkCriticalSection { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_set_typed_tuple( + fn vtk_critical_section_new( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_int, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_set_typed_tuple(self.0, i, tuple) } + unsafe { vtk_critical_section_new(self.0) } } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_int, - ) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_insert_typed_tuple( + fn vtk_critical_section_safe_down_cast( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_int, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_insert_typed_tuple(self.0, i, tuple) } + unsafe { vtk_critical_section_safe_down_cast(self.0, o) } } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_int, - ) -> core::ffi::c_uchar { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_insert_next_typed_tuple( + fn vtk_critical_section_new_instance( sself: *mut core::ffi::c_void, - tuple: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_insert_next_typed_tuple(self.0, tuple) } + unsafe { vtk_critical_section_new_instance(self.0) } } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_int { + fn lock(&mut self) -> () { unsafe extern "C" { - fn vtk_int_array_get_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_int; + fn vtk_critical_section_lock(sself: *mut core::ffi::c_void); } - unsafe { vtk_int_array_get_value(self.0, id) } + unsafe { vtk_critical_section_lock(self.0) } } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_int) -> () { + fn unlock(&mut self) -> () { unsafe extern "C" { - fn vtk_int_array_set_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_int, - ); + fn vtk_critical_section_unlock(sself: *mut core::ffi::c_void); } - unsafe { vtk_int_array_set_value(self.0, id, value) } + unsafe { vtk_critical_section_unlock(self.0) } } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { +} +impl VtkDataArrayCollection for vtkDataArrayCollection { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_set_number_of_values( + fn vtk_data_array_collection_new( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, - ) -> bool; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_set_number_of_values(self.0, number) } + unsafe { vtk_data_array_collection_new(self.0) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_int) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_insert_value( + fn vtk_data_array_collection_safe_down_cast( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - f: core::ffi::c_int, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_insert_value(self.0, id, f) } + unsafe { vtk_data_array_collection_safe_down_cast(self.0, o) } } - fn insert_next_value(&mut self, f: core::ffi::c_int) -> core::ffi::c_uchar { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_insert_next_value( + fn vtk_data_array_collection_new_instance( sself: *mut core::ffi::c_void, - f: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_insert_next_value(self.0, f) } + unsafe { vtk_data_array_collection_new_instance(self.0) } } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_int { + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_int_array_get_value_range( + fn vtk_data_array_collection_add_item( sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_int; + ds: *mut core::ffi::c_void, + ); } - unsafe { vtk_int_array_get_value_range(self.0, comp) } + unsafe { vtk_data_array_collection_add_item(self.0, ds) } } - fn get_value_range(&mut self) -> *mut core::ffi::c_int { + fn get_next_item(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_get_value_range( + fn vtk_data_array_collection_get_next_item( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_get_value_range(self.0) } + unsafe { vtk_data_array_collection_get_next_item(self.0) } } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_int { + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_write_pointer( + fn vtk_data_array_collection_get_item( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_int; + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_write_pointer(self.0, id, number) } + unsafe { vtk_data_array_collection_get_item(self.0, i) } } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_int { + fn get_number_of_items(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_int_array_get_pointer( + fn vtk_data_array_collection_get_number_of_items( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_int; + ) -> core::ffi::c_int; } - unsafe { vtk_int_array_get_pointer(self.0, id) } + unsafe { vtk_data_array_collection_get_number_of_items(self.0) } } - fn set_array( - &mut self, - array: core::ffi::c_int, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { +} +impl VtkDataArrayCollectionIterator for vtkDataArrayCollectionIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_set_array( + fn vtk_data_array_collection_iterator_safe_down_cast( sself: *mut core::ffi::c_void, - array: core::ffi::c_int, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_set_array(self.0, array, size, save) } + unsafe { vtk_data_array_collection_iterator_safe_down_cast(self.0, o) } } - fn set_array( - &mut self, - array: core::ffi::c_int, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_set_array( + fn vtk_data_array_collection_iterator_new_instance( sself: *mut core::ffi::c_void, - array: core::ffi::c_int, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_set_array(self.0, array, size, save, deleteMethod) } + unsafe { vtk_data_array_collection_iterator_new_instance(self.0) } } - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_fast_down_cast( + fn vtk_data_array_collection_iterator_new( sself: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_fast_down_cast(self.0, source) } + unsafe { vtk_data_array_collection_iterator_new(self.0) } } - fn get_data_type_value_min(&mut self) -> core::ffi::c_int { + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_int_array_get_data_type_value_min( + fn vtk_data_array_collection_iterator_set_collection( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + p0: *mut core::ffi::c_void, + ); } - unsafe { vtk_int_array_get_data_type_value_min(self.0) } + unsafe { vtk_data_array_collection_iterator_set_collection(self.0, p0) } } - fn get_data_type_value_max(&mut self) -> core::ffi::c_int { + fn get_data_array(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_int_array_get_data_type_value_max( + fn vtk_data_array_collection_iterator_get_data_array( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_int_array_get_data_type_value_max(self.0) } + unsafe { vtk_data_array_collection_iterator_get_data_array(self.0) } } } -impl VtkLongArray for vtkLongArray { +impl VtkDataArraySelection for vtkDataArraySelection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_array_safe_down_cast( + fn vtk_data_array_selection_safe_down_cast( sself: *mut core::ffi::c_void, o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_array_safe_down_cast(self.0, o) } + unsafe { vtk_data_array_selection_safe_down_cast(self.0, o) } } fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_array_new_instance( + fn vtk_data_array_selection_new_instance( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_array_new_instance(self.0) } + unsafe { vtk_data_array_selection_new_instance(self.0) } } fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_array_new( + fn vtk_data_array_selection_new( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_array_new(self.0) } + unsafe { vtk_data_array_selection_new(self.0) } } - fn extended_new(&mut self) -> *mut core::ffi::c_void { + fn enable_array(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { - fn vtk_long_array_extended_new( + fn vtk_data_array_selection_enable_array( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + name: *const core::ffi::c_char, + ); } - unsafe { vtk_long_array_extended_new(self.0) } + unsafe { vtk_data_array_selection_enable_array(self.0, c_name.as_ptr()) } } - fn get_data_type(&mut self) -> core::ffi::c_int { + fn disable_array(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { - fn vtk_long_array_get_data_type( + fn vtk_data_array_selection_disable_array( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + name: *const core::ffi::c_char, + ); } - unsafe { vtk_long_array_get_data_type(self.0) } + unsafe { vtk_data_array_selection_disable_array(self.0, c_name.as_ptr()) } } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_long, - ) -> () { + fn array_is_enabled(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { - fn vtk_long_array_get_typed_tuple( + fn vtk_data_array_selection_array_is_enabled( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_long, - ); + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; } - unsafe { vtk_long_array_get_typed_tuple(self.0, i, tuple) } + unsafe { vtk_data_array_selection_array_is_enabled(self.0, c_name.as_ptr()) } } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_long, - ) -> () { + fn array_exists(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { - fn vtk_long_array_set_typed_tuple( + fn vtk_data_array_selection_array_exists( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_long, - ); + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; } - unsafe { vtk_long_array_set_typed_tuple(self.0, i, tuple) } + unsafe { vtk_data_array_selection_array_exists(self.0, c_name.as_ptr()) } } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_long, - ) -> () { + fn enable_all_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_enable_all_arrays(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_array_selection_enable_all_arrays(self.0) } + } + fn disable_all_arrays(&mut self) -> () { unsafe extern "C" { - fn vtk_long_array_insert_typed_tuple( + fn vtk_data_array_selection_disable_all_arrays( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_long, ); } - unsafe { vtk_long_array_insert_typed_tuple(self.0, i, tuple) } + unsafe { vtk_data_array_selection_disable_all_arrays(self.0) } } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_long, - ) -> core::ffi::c_uchar { + fn get_number_of_arrays(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_long_array_insert_next_typed_tuple( + fn vtk_data_array_selection_get_number_of_arrays( sself: *mut core::ffi::c_void, - tuple: core::ffi::c_long, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_int; } - unsafe { vtk_long_array_insert_next_typed_tuple(self.0, tuple) } + unsafe { vtk_data_array_selection_get_number_of_arrays(self.0) } } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_long { + fn get_number_of_arrays_enabled(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_long_array_get_value( + fn vtk_data_array_selection_get_number_of_arrays_enabled( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_long; + ) -> core::ffi::c_int; } - unsafe { vtk_long_array_get_value(self.0, id) } + unsafe { vtk_data_array_selection_get_number_of_arrays_enabled(self.0) } } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_long) -> () { + fn get_array_name(&mut self, index: core::ffi::c_int) -> &str { unsafe extern "C" { - fn vtk_long_array_set_value( + fn vtk_data_array_selection_get_array_name( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_long, - ); + index: core::ffi::c_int, + ) -> *const core::ffi::c_char; } - unsafe { vtk_long_array_set_value(self.0, id, value) } + let ptr = unsafe { vtk_data_array_selection_get_array_name(self.0, index) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + fn get_array_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { - fn vtk_long_array_set_number_of_values( + fn vtk_data_array_selection_get_array_index( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, - ) -> bool; + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; } - unsafe { vtk_long_array_set_number_of_values(self.0, number) } + unsafe { vtk_data_array_selection_get_array_index(self.0, c_name.as_ptr()) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_long) -> () { + fn get_enabled_array_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { - fn vtk_long_array_insert_value( + fn vtk_data_array_selection_get_enabled_array_index( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - f: core::ffi::c_long, - ); + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_array_selection_get_enabled_array_index(self.0, c_name.as_ptr()) } - unsafe { vtk_long_array_insert_value(self.0, id, f) } } - fn insert_next_value(&mut self, f: core::ffi::c_long) -> core::ffi::c_uchar { + fn get_array_setting(&mut self, index: core::ffi::c_int) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_long_array_insert_next_value( + fn vtk_data_array_selection_get_array_setting( sself: *mut core::ffi::c_void, - f: core::ffi::c_long, - ) -> core::ffi::c_uchar; + index: core::ffi::c_int, + ) -> core::ffi::c_int; } - unsafe { vtk_long_array_insert_next_value(self.0, f) } + unsafe { vtk_data_array_selection_get_array_setting(self.0, index) } } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_long { + fn set_array_setting(&mut self, name: &str, setting: core::ffi::c_int) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { - fn vtk_long_array_get_value_range( + fn vtk_data_array_selection_set_array_setting( sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_long; + name: *const core::ffi::c_char, + setting: core::ffi::c_int, + ); + } + unsafe { + vtk_data_array_selection_set_array_setting(self.0, c_name.as_ptr(), setting) } - unsafe { vtk_long_array_get_value_range(self.0, comp) } } - fn get_value_range(&mut self) -> *mut core::ffi::c_long { + fn remove_all_arrays(&mut self) -> () { unsafe extern "C" { - fn vtk_long_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_long; + fn vtk_data_array_selection_remove_all_arrays(sself: *mut core::ffi::c_void); } - unsafe { vtk_long_array_get_value_range(self.0) } + unsafe { vtk_data_array_selection_remove_all_arrays(self.0) } } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_long { + fn add_array(&mut self, name: &str, state: bool) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { - fn vtk_long_array_write_pointer( + fn vtk_data_array_selection_add_array( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_long; + name: *const core::ffi::c_char, + state: bool, + ) -> core::ffi::c_int; } - unsafe { vtk_long_array_write_pointer(self.0, id, number) } + unsafe { vtk_data_array_selection_add_array(self.0, c_name.as_ptr(), state) } } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_long { + fn remove_array_by_index(&mut self, index: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_long_array_get_pointer( + fn vtk_data_array_selection_remove_array_by_index( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_long; + index: core::ffi::c_int, + ); } - unsafe { vtk_long_array_get_pointer(self.0, id) } + unsafe { vtk_data_array_selection_remove_array_by_index(self.0, index) } } - fn set_array( - &mut self, - array: core::ffi::c_long, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { + fn remove_array_by_name(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { - fn vtk_long_array_set_array( + fn vtk_data_array_selection_remove_array_by_name( sself: *mut core::ffi::c_void, - array: core::ffi::c_long, - size: core::ffi::c_uchar, - save: core::ffi::c_int, + name: *const core::ffi::c_char, ); } - unsafe { vtk_long_array_set_array(self.0, array, size, save) } + unsafe { vtk_data_array_selection_remove_array_by_name(self.0, c_name.as_ptr()) } } - fn set_array( - &mut self, - array: core::ffi::c_long, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { + fn copy_selections(&mut self, selections: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_long_array_set_array( + fn vtk_data_array_selection_copy_selections( sself: *mut core::ffi::c_void, - array: core::ffi::c_long, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, + selections: *mut core::ffi::c_void, ); } - unsafe { vtk_long_array_set_array(self.0, array, size, save, deleteMethod) } + unsafe { vtk_data_array_selection_copy_selections(self.0, selections) } } - fn fast_down_cast( - &mut self, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { + fn union(&mut self, other: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_long_array_fast_down_cast( + fn vtk_data_array_selection_union( sself: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + other: *mut core::ffi::c_void, + ); } - unsafe { vtk_long_array_fast_down_cast(self.0, source) } + unsafe { vtk_data_array_selection_union(self.0, other) } } - fn get_data_type_value_min(&mut self) -> core::ffi::c_long { + fn set_unknown_array_setting(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_long_array_get_data_type_value_min( + fn vtk_data_array_selection_set_unknown_array_setting( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_long; + _arg: core::ffi::c_int, + ); } - unsafe { vtk_long_array_get_data_type_value_min(self.0) } + unsafe { vtk_data_array_selection_set_unknown_array_setting(self.0, _arg) } } - fn get_data_type_value_max(&mut self) -> core::ffi::c_long { + fn get_unknown_array_setting(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_long_array_get_data_type_value_max( + fn vtk_data_array_selection_get_unknown_array_setting( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_long; + ) -> core::ffi::c_int; } - unsafe { vtk_long_array_get_data_type_value_max(self.0) } + unsafe { vtk_data_array_selection_get_unknown_array_setting(self.0) } } } -impl VtkLongLongArray for vtkLongLongArray { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { +impl VtkDebugLeaks for vtkDebugLeaks { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_long_array_safe_down_cast( + fn vtk_debug_leaks_new( sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_long_array_safe_down_cast(self.0, o) } + unsafe { vtk_debug_leaks_new(self.0) } } - fn new_instance(&mut self) -> *mut core::ffi::c_void { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_long_array_new_instance( + fn vtk_debug_leaks_safe_down_cast( sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_long_array_new_instance(self.0) } + unsafe { vtk_debug_leaks_safe_down_cast(self.0, o) } } - fn new(&mut self) -> *mut core::ffi::c_void { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_long_array_new( + fn vtk_debug_leaks_new_instance( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_long_array_new(self.0) } + unsafe { vtk_debug_leaks_new_instance(self.0) } } - fn extended_new(&mut self) -> *mut core::ffi::c_void { + fn construct_class(&mut self, object: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_long_long_array_extended_new( + fn vtk_debug_leaks_construct_class( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + object: *mut core::ffi::c_void, + ); } - unsafe { vtk_long_long_array_extended_new(self.0) } + unsafe { vtk_debug_leaks_construct_class(self.0, object) } } - fn get_data_type(&mut self) -> core::ffi::c_int { + fn destruct_class(&mut self, object: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_long_long_array_get_data_type( + fn vtk_debug_leaks_destruct_class( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + object: *mut core::ffi::c_void, + ); } - unsafe { vtk_long_long_array_get_data_type(self.0) } + unsafe { vtk_debug_leaks_destruct_class(self.0, object) } } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> () { + fn print_current_leaks(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_long_long_array_get_typed_tuple( + fn vtk_debug_leaks_print_current_leaks( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_long_long_array_get_typed_tuple(self.0, i, tuple) } + unsafe { vtk_debug_leaks_print_current_leaks(self.0) } } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> () { + fn get_exit_error(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_long_long_array_set_typed_tuple( + fn vtk_debug_leaks_get_exit_error( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_long_long_array_set_typed_tuple(self.0, i, tuple) } + unsafe { vtk_debug_leaks_get_exit_error(self.0) } } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> () { + fn set_exit_error(&mut self, p0: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_long_long_array_insert_typed_tuple( + fn vtk_debug_leaks_set_exit_error( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, + p0: core::ffi::c_int, ); } - unsafe { vtk_long_long_array_insert_typed_tuple(self.0, i, tuple) } + unsafe { vtk_debug_leaks_set_exit_error(self.0, p0) } } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + fn set_debug_leaks_observer(&mut self, observer: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_long_long_array_insert_next_typed_tuple( + fn vtk_debug_leaks_set_debug_leaks_observer( sself: *mut core::ffi::c_void, - tuple: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + observer: *mut core::ffi::c_void, + ); } - unsafe { vtk_long_long_array_insert_next_typed_tuple(self.0, tuple) } + unsafe { vtk_debug_leaks_set_debug_leaks_observer(self.0, observer) } } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn get_debug_leaks_observer(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_long_array_get_value( + fn vtk_debug_leaks_get_debug_leaks_observer( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_long_array_get_value(self.0, id) } + unsafe { vtk_debug_leaks_get_debug_leaks_observer(self.0) } } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> () { +} +impl VtkDoubleArray for vtkDoubleArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_long_array_set_value( + fn vtk_double_array_safe_down_cast( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_uchar, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_long_array_set_value(self.0, id, value) } + unsafe { vtk_double_array_safe_down_cast(self.0, o) } } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_long_array_set_number_of_values( + fn vtk_double_array_new_instance( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, - ) -> bool; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_long_array_set_number_of_values(self.0, number) } + unsafe { vtk_double_array_new_instance(self.0) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> () { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_long_array_insert_value( + fn vtk_double_array_new( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - f: core::ffi::c_uchar, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_long_array_insert_value(self.0, id, f) } + unsafe { vtk_double_array_new(self.0) } } - fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn extended_new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_long_array_insert_next_value( + fn vtk_double_array_extended_new( sself: *mut core::ffi::c_void, - f: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_long_array_insert_next_value(self.0, f) } + unsafe { vtk_double_array_extended_new(self.0) } } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_long_long_array_get_value_range( + fn vtk_double_array_get_data_type( sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar; + ) -> core::ffi::c_int; } - unsafe { vtk_long_long_array_get_value_range(self.0, comp) } + unsafe { vtk_double_array_get_data_type(self.0) } } - fn get_value_range(&mut self) -> *mut core::ffi::c_uchar { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_long_long_array_get_value_range( + fn vtk_double_array_get_value( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_uchar; + id: core::ffi::c_longlong, + ) -> core::ffi::c_double; } - unsafe { vtk_long_long_array_get_value_range(self.0) } + unsafe { vtk_double_array_get_value(self.0, id) } } - fn write_pointer( + fn set_value( &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar { + id: core::ffi::c_longlong, + value: core::ffi::c_double, + ) -> () { unsafe extern "C" { - fn vtk_long_long_array_write_pointer( + fn vtk_double_array_set_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; + id: core::ffi::c_longlong, + value: core::ffi::c_double, + ); } - unsafe { vtk_long_long_array_write_pointer(self.0, id, number) } + unsafe { vtk_double_array_set_value(self.0, id, value) } } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { - fn vtk_long_long_array_get_pointer( + fn vtk_double_array_set_number_of_values( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; + number: core::ffi::c_longlong, + ) -> bool; } - unsafe { vtk_long_long_array_get_pointer(self.0, id) } + unsafe { vtk_double_array_set_number_of_values(self.0, number) } } - fn set_array( - &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_double) -> () { unsafe extern "C" { - fn vtk_long_long_array_set_array( + fn vtk_double_array_insert_value( sself: *mut core::ffi::c_void, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, + id: core::ffi::c_longlong, + f: core::ffi::c_double, ); } - unsafe { vtk_long_long_array_set_array(self.0, array, size, save) } + unsafe { vtk_double_array_insert_value(self.0, id, f) } } - fn set_array( - &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { + fn insert_next_value(&mut self, f: core::ffi::c_double) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_long_long_array_set_array( + fn vtk_double_array_insert_next_value( sself: *mut core::ffi::c_void, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); + f: core::ffi::c_double, + ) -> core::ffi::c_longlong; } - unsafe { vtk_long_long_array_set_array(self.0, array, size, save, deleteMethod) } + unsafe { vtk_double_array_insert_next_value(self.0, f) } } fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_long_long_array_fast_down_cast( + fn vtk_double_array_fast_down_cast( sself: *mut core::ffi::c_void, source: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_long_long_array_fast_down_cast(self.0, source) } + unsafe { vtk_double_array_fast_down_cast(self.0, source) } } - fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar { + fn get_data_type_value_min(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_long_long_array_get_data_type_value_min( + fn vtk_double_array_get_data_type_value_min( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_double; } - unsafe { vtk_long_long_array_get_data_type_value_min(self.0) } + unsafe { vtk_double_array_get_data_type_value_min(self.0) } } - fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar { + fn get_data_type_value_max(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_long_long_array_get_data_type_value_max( + fn vtk_double_array_get_data_type_value_max( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_double; } - unsafe { vtk_long_long_array_get_data_type_value_max(self.0) } + unsafe { vtk_double_array_get_data_type_value_max(self.0) } } } -impl VtkLookupTable for vtkLookupTable { +impl VtkDynamicLoader for vtkDynamicLoader { fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_new( + fn vtk_dynamic_loader_new( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_new(self.0) } + unsafe { vtk_dynamic_loader_new(self.0) } } fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_safe_down_cast( + fn vtk_dynamic_loader_safe_down_cast( sself: *mut core::ffi::c_void, o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_safe_down_cast(self.0, o) } + unsafe { vtk_dynamic_loader_safe_down_cast(self.0, o) } } fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_new_instance( + fn vtk_dynamic_loader_new_instance( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_new_instance(self.0) } - } - fn is_opaque(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_lookup_table_is_opaque( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_lookup_table_is_opaque(self.0) } + unsafe { vtk_dynamic_loader_new_instance(self.0) } } - fn allocate( - &mut self, - sz: core::ffi::c_int, - ext: core::ffi::c_int, - ) -> core::ffi::c_int { + fn lib_prefix(&mut self) -> &str { unsafe extern "C" { - fn vtk_lookup_table_allocate( + fn vtk_dynamic_loader_lib_prefix( sself: *mut core::ffi::c_void, - sz: core::ffi::c_int, - ext: core::ffi::c_int, - ) -> core::ffi::c_int; + ) -> *const core::ffi::c_char; } - unsafe { vtk_lookup_table_allocate(self.0, sz, ext) } - } - fn build(&mut self) -> () { - unsafe extern "C" { - fn vtk_lookup_table_build(sself: *mut core::ffi::c_void); + let ptr = unsafe { vtk_dynamic_loader_lib_prefix(self.0) }; + if ptr.is_null() { + return ""; } - unsafe { vtk_lookup_table_build(self.0) } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn force_build(&mut self) -> () { + fn lib_extension(&mut self) -> &str { unsafe extern "C" { - fn vtk_lookup_table_force_build(sself: *mut core::ffi::c_void); + fn vtk_dynamic_loader_lib_extension( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; } - unsafe { vtk_lookup_table_force_build(self.0) } - } - fn build_special_colors(&mut self) -> () { - unsafe extern "C" { - fn vtk_lookup_table_build_special_colors(sself: *mut core::ffi::c_void); + let ptr = unsafe { vtk_dynamic_loader_lib_extension(self.0) }; + if ptr.is_null() { + return ""; } - unsafe { vtk_lookup_table_build_special_colors(self.0) } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn set_ramp(&mut self, _arg: core::ffi::c_int) -> () { + fn last_error(&mut self) -> &str { unsafe extern "C" { - fn vtk_lookup_table_set_ramp( + fn vtk_dynamic_loader_last_error( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); + ) -> *const core::ffi::c_char; } - unsafe { vtk_lookup_table_set_ramp(self.0, _arg) } - } - fn set_ramp_to_linear(&mut self) -> () { - unsafe extern "C" { - fn vtk_lookup_table_set_ramp_to_linear(sself: *mut core::ffi::c_void); + let ptr = unsafe { vtk_dynamic_loader_last_error(self.0) }; + if ptr.is_null() { + return ""; } - unsafe { vtk_lookup_table_set_ramp_to_linear(self.0) } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn set_ramp_to_s_curve(&mut self) -> () { +} +impl VtkEventDataDevice3D for vtkEventDataDevice3D { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_ramp_to_s_curve(sself: *mut core::ffi::c_void); + fn vtk_event_data_device_3_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_ramp_to_s_curve(self.0) } + unsafe { vtk_event_data_device_3_d_safe_down_cast(self.0, o) } } - fn set_ramp_to_sqrt(&mut self) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_ramp_to_sqrt(sself: *mut core::ffi::c_void); + fn vtk_event_data_device_3_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_ramp_to_sqrt(self.0) } + unsafe { vtk_event_data_device_3_d_new_instance(self.0) } } - fn get_ramp(&mut self) -> core::ffi::c_int { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_ramp( + fn vtk_event_data_device_3_d_new( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_ramp(self.0) } + unsafe { vtk_event_data_device_3_d_new(self.0) } } - fn set_scale(&mut self, scale: core::ffi::c_int) -> () { + fn set_track_pad_position( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> () { unsafe extern "C" { - fn vtk_lookup_table_set_scale( + fn vtk_event_data_device_3_d_set_track_pad_position( sself: *mut core::ffi::c_void, - scale: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, ); } - unsafe { vtk_lookup_table_set_scale(self.0, scale) } + unsafe { vtk_event_data_device_3_d_set_track_pad_position(self.0, x, y) } } - fn set_scale_to_linear(&mut self) -> () { +} +impl VtkEventDataForDevice for vtkEventDataForDevice { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_scale_to_linear(sself: *mut core::ffi::c_void); + fn vtk_event_data_for_device_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_scale_to_linear(self.0) } + unsafe { vtk_event_data_for_device_safe_down_cast(self.0, o) } } - fn set_scale_to_log_10(&mut self) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_scale_to_log_10(sself: *mut core::ffi::c_void); + fn vtk_event_data_for_device_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_scale_to_log_10(self.0) } + unsafe { vtk_event_data_for_device_new_instance(self.0) } } - fn get_scale(&mut self) -> core::ffi::c_int { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_scale( + fn vtk_event_data_for_device_new( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_scale(self.0) } + unsafe { vtk_event_data_for_device_new(self.0) } } - fn set_table_range(&mut self, r: core::ffi::c_double) -> () { +} +impl VtkEventForwarderCommand for vtkEventForwarderCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_table_range( + fn vtk_event_forwarder_command_safe_down_cast( sself: *mut core::ffi::c_void, - r: core::ffi::c_double, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_table_range(self.0, r) } + unsafe { vtk_event_forwarder_command_safe_down_cast(self.0, o) } } - fn set_table_range( - &mut self, - min: core::ffi::c_double, - max: core::ffi::c_double, - ) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_table_range( + fn vtk_event_forwarder_command_new_instance( sself: *mut core::ffi::c_void, - min: core::ffi::c_double, - max: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_table_range(self.0, min, max) } + unsafe { vtk_event_forwarder_command_new_instance(self.0) } } - fn get_table_range(&mut self) -> *mut core::ffi::c_double { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_table_range( + fn vtk_event_forwarder_command_new( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_table_range(self.0) } + unsafe { vtk_event_forwarder_command_new(self.0) } } - fn get_table_range(&mut self, data: core::ffi::c_double) -> () { + fn set_target(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_table_range( + fn vtk_event_forwarder_command_set_target( sself: *mut core::ffi::c_void, - data: core::ffi::c_double, + obj: *mut core::ffi::c_void, ); } - unsafe { vtk_lookup_table_get_table_range(self.0, data) } + unsafe { vtk_event_forwarder_command_set_target(self.0, obj) } } - fn set_hue_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> () { +} +impl VtkFileOutputWindow for vtkFileOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_hue_range( + fn vtk_file_output_window_safe_down_cast( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_hue_range(self.0, _arg1, _arg2) } + unsafe { vtk_file_output_window_safe_down_cast(self.0, o) } } - fn set_hue_range(&mut self, _arg: core::ffi::c_double) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_hue_range( + fn vtk_file_output_window_new_instance( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_hue_range(self.0, _arg) } + unsafe { vtk_file_output_window_new_instance(self.0) } } - fn get_hue_range(&mut self) -> *mut core::ffi::c_double { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_hue_range( + fn vtk_file_output_window_new( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_hue_range(self.0) } + unsafe { vtk_file_output_window_new(self.0) } } - fn get_hue_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> () { + fn display_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); unsafe extern "C" { - fn vtk_lookup_table_get_hue_range( + fn vtk_file_output_window_display_text( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, + p0: *const core::ffi::c_char, ); } - unsafe { vtk_lookup_table_get_hue_range(self.0, _arg1, _arg2) } + unsafe { vtk_file_output_window_display_text(self.0, c_p0.as_ptr()) } } - fn get_hue_range(&mut self, _arg: core::ffi::c_double) -> () { + fn set_file_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { - fn vtk_lookup_table_get_hue_range( + fn vtk_file_output_window_set_file_name( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, + _arg: *const core::ffi::c_char, ); } - unsafe { vtk_lookup_table_get_hue_range(self.0, _arg) } + unsafe { vtk_file_output_window_set_file_name(self.0, c__arg.as_ptr()) } } - fn set_saturation_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> () { + fn set_flush(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_lookup_table_set_saturation_range( + fn vtk_file_output_window_set_flush( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, + _arg: core::ffi::c_int, ); } - unsafe { vtk_lookup_table_set_saturation_range(self.0, _arg1, _arg2) } + unsafe { vtk_file_output_window_set_flush(self.0, _arg) } } - fn set_saturation_range(&mut self, _arg: core::ffi::c_double) -> () { + fn get_flush(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_lookup_table_set_saturation_range( + fn vtk_file_output_window_get_flush( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_lookup_table_set_saturation_range(self.0, _arg) } + unsafe { vtk_file_output_window_get_flush(self.0) } } - fn get_saturation_range(&mut self) -> *mut core::ffi::c_double { + fn flush_on(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_saturation_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + fn vtk_file_output_window_flush_on(sself: *mut core::ffi::c_void); } - unsafe { vtk_lookup_table_get_saturation_range(self.0) } + unsafe { vtk_file_output_window_flush_on(self.0) } } - fn get_saturation_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> () { + fn flush_off(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_saturation_range( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ); + fn vtk_file_output_window_flush_off(sself: *mut core::ffi::c_void); } - unsafe { vtk_lookup_table_get_saturation_range(self.0, _arg1, _arg2) } + unsafe { vtk_file_output_window_flush_off(self.0) } } - fn get_saturation_range(&mut self, _arg: core::ffi::c_double) -> () { + fn set_append(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_saturation_range( + fn vtk_file_output_window_set_append( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, + _arg: core::ffi::c_int, ); } - unsafe { vtk_lookup_table_get_saturation_range(self.0, _arg) } + unsafe { vtk_file_output_window_set_append(self.0, _arg) } } - fn set_value_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> () { + fn get_append(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_lookup_table_set_value_range( + fn vtk_file_output_window_get_append( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_lookup_table_set_value_range(self.0, _arg1, _arg2) } + unsafe { vtk_file_output_window_get_append(self.0) } } - fn set_value_range(&mut self, _arg: core::ffi::c_double) -> () { + fn append_on(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_set_value_range( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); + fn vtk_file_output_window_append_on(sself: *mut core::ffi::c_void); } - unsafe { vtk_lookup_table_set_value_range(self.0, _arg) } + unsafe { vtk_file_output_window_append_on(self.0) } } - fn get_value_range(&mut self) -> *mut core::ffi::c_double { + fn append_off(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + fn vtk_file_output_window_append_off(sself: *mut core::ffi::c_void); } - unsafe { vtk_lookup_table_get_value_range(self.0) } + unsafe { vtk_file_output_window_append_off(self.0) } } - fn get_value_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> () { +} +impl VtkFloatArray for vtkFloatArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_value_range( + fn vtk_float_array_safe_down_cast( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_value_range(self.0, _arg1, _arg2) } + unsafe { vtk_float_array_safe_down_cast(self.0, o) } } - fn get_value_range(&mut self, _arg: core::ffi::c_double) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_value_range( + fn vtk_float_array_new_instance( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_value_range(self.0, _arg) } + unsafe { vtk_float_array_new_instance(self.0) } } - fn set_alpha_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> () { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_alpha_range( + fn vtk_float_array_new( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_alpha_range(self.0, _arg1, _arg2) } + unsafe { vtk_float_array_new(self.0) } } - fn set_alpha_range(&mut self, _arg: core::ffi::c_double) -> () { + fn extended_new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_alpha_range( + fn vtk_float_array_extended_new( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_alpha_range(self.0, _arg) } + unsafe { vtk_float_array_extended_new(self.0) } } - fn get_alpha_range(&mut self) -> *mut core::ffi::c_double { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_lookup_table_get_alpha_range( + fn vtk_float_array_get_data_type( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + ) -> core::ffi::c_int; } - unsafe { vtk_lookup_table_get_alpha_range(self.0) } + unsafe { vtk_float_array_get_data_type(self.0) } } - fn get_alpha_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> () { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_float { unsafe extern "C" { - fn vtk_lookup_table_get_alpha_range( + fn vtk_float_array_get_value( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ); + id: core::ffi::c_longlong, + ) -> core::ffi::c_float; } - unsafe { vtk_lookup_table_get_alpha_range(self.0, _arg1, _arg2) } + unsafe { vtk_float_array_get_value(self.0, id) } } - fn get_alpha_range(&mut self, _arg: core::ffi::c_double) -> () { + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_float) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_alpha_range( + fn vtk_float_array_set_value( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, + id: core::ffi::c_longlong, + value: core::ffi::c_float, ); } - unsafe { vtk_lookup_table_get_alpha_range(self.0, _arg) } + unsafe { vtk_float_array_set_value(self.0, id, value) } } - fn set_nan_color( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> () { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { - fn vtk_lookup_table_set_nan_color( + fn vtk_float_array_set_number_of_values( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ); + number: core::ffi::c_longlong, + ) -> bool; } - unsafe { vtk_lookup_table_set_nan_color(self.0, _arg1, _arg2, _arg3, _arg4) } + unsafe { vtk_float_array_set_number_of_values(self.0, number) } } - fn set_nan_color(&mut self, _arg: core::ffi::c_double) -> () { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_float) -> () { unsafe extern "C" { - fn vtk_lookup_table_set_nan_color( + fn vtk_float_array_insert_value( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, + id: core::ffi::c_longlong, + f: core::ffi::c_float, ); } - unsafe { vtk_lookup_table_set_nan_color(self.0, _arg) } + unsafe { vtk_float_array_insert_value(self.0, id, f) } } - fn get_nan_color(&mut self) -> *mut core::ffi::c_double { + fn insert_next_value(&mut self, f: core::ffi::c_float) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_lookup_table_get_nan_color( + fn vtk_float_array_insert_next_value( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + f: core::ffi::c_float, + ) -> core::ffi::c_longlong; } - unsafe { vtk_lookup_table_get_nan_color(self.0) } + unsafe { vtk_float_array_insert_next_value(self.0, f) } } - fn get_nan_color( + fn fast_down_cast( &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> () { + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_nan_color( + fn vtk_float_array_fast_down_cast( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ); + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_nan_color(self.0, _arg1, _arg2, _arg3, _arg4) } + unsafe { vtk_float_array_fast_down_cast(self.0, source) } } - fn get_nan_color(&mut self, _arg: core::ffi::c_double) -> () { + fn get_data_type_value_min(&mut self) -> core::ffi::c_float { unsafe extern "C" { - fn vtk_lookup_table_get_nan_color( + fn vtk_float_array_get_data_type_value_min( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); + ) -> core::ffi::c_float; } - unsafe { vtk_lookup_table_get_nan_color(self.0, _arg) } + unsafe { vtk_float_array_get_data_type_value_min(self.0) } } - fn get_nan_color_as_unsigned_chars(&mut self) -> *mut core::ffi::c_uchar { + fn get_data_type_value_max(&mut self) -> core::ffi::c_float { unsafe extern "C" { - fn vtk_lookup_table_get_nan_color_as_unsigned_chars( + fn vtk_float_array_get_data_type_value_max( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_uchar; + ) -> core::ffi::c_float; } - unsafe { vtk_lookup_table_get_nan_color_as_unsigned_chars(self.0) } + unsafe { vtk_float_array_get_data_type_value_max(self.0) } } - fn get_color_as_unsigned_chars( - &mut self, - colorIn: core::ffi::c_double, - colorOut: core::ffi::c_uchar, - ) -> () { +} +impl VtkGarbageCollector for vtkGarbageCollector { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_color_as_unsigned_chars( + fn vtk_garbage_collector_safe_down_cast( sself: *mut core::ffi::c_void, - colorIn: core::ffi::c_double, - colorOut: core::ffi::c_uchar, - ); - } - unsafe { - vtk_lookup_table_get_color_as_unsigned_chars(self.0, colorIn, colorOut) + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } + unsafe { vtk_garbage_collector_safe_down_cast(self.0, o) } } - fn set_below_range_color( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_below_range_color( + fn vtk_garbage_collector_new_instance( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { - vtk_lookup_table_set_below_range_color(self.0, _arg1, _arg2, _arg3, _arg4) + unsafe { vtk_garbage_collector_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_garbage_collector_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } + unsafe { vtk_garbage_collector_new(self.0) } } - fn set_below_range_color(&mut self, _arg: core::ffi::c_double) -> () { + fn collect(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_set_below_range_color( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); + fn vtk_garbage_collector_collect(sself: *mut core::ffi::c_void); } - unsafe { vtk_lookup_table_set_below_range_color(self.0, _arg) } + unsafe { vtk_garbage_collector_collect(self.0) } } - fn get_below_range_color(&mut self) -> *mut core::ffi::c_double { + fn deferred_collection_push(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_below_range_color( + fn vtk_garbage_collector_deferred_collection_push( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + ); } - unsafe { vtk_lookup_table_get_below_range_color(self.0) } + unsafe { vtk_garbage_collector_deferred_collection_push(self.0) } } - fn get_below_range_color( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> () { + fn deferred_collection_pop(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_below_range_color( + fn vtk_garbage_collector_deferred_collection_pop( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, ); } - unsafe { - vtk_lookup_table_get_below_range_color(self.0, _arg1, _arg2, _arg3, _arg4) - } + unsafe { vtk_garbage_collector_deferred_collection_pop(self.0) } } - fn get_below_range_color(&mut self, _arg: core::ffi::c_double) -> () { + fn set_global_debug_flag(&mut self, flag: bool) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_below_range_color( + fn vtk_garbage_collector_set_global_debug_flag( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, + flag: bool, ); } - unsafe { vtk_lookup_table_get_below_range_color(self.0, _arg) } + unsafe { vtk_garbage_collector_set_global_debug_flag(self.0, flag) } } - fn set_use_below_range_color(&mut self, _arg: core::ffi::c_int) -> () { + fn get_global_debug_flag(&mut self) -> bool { unsafe extern "C" { - fn vtk_lookup_table_set_use_below_range_color( + fn vtk_garbage_collector_get_global_debug_flag( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); + ) -> bool; } - unsafe { vtk_lookup_table_set_use_below_range_color(self.0, _arg) } + unsafe { vtk_garbage_collector_get_global_debug_flag(self.0) } } - fn get_use_below_range_color(&mut self) -> core::ffi::c_int { +} +impl VtkIdList for vtkIdList { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_use_below_range_color( + fn vtk_id_list_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_safe_down_cast( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_use_below_range_color(self.0) } + unsafe { vtk_id_list_safe_down_cast(self.0, o) } } - fn use_below_range_color_on(&mut self) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_use_below_range_color_on(sself: *mut core::ffi::c_void); + fn vtk_id_list_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_use_below_range_color_on(self.0) } + unsafe { vtk_id_list_new_instance(self.0) } } - fn use_below_range_color_off(&mut self) -> () { + fn initialize(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_use_below_range_color_off(sself: *mut core::ffi::c_void); + fn vtk_id_list_initialize(sself: *mut core::ffi::c_void); } - unsafe { vtk_lookup_table_use_below_range_color_off(self.0) } + unsafe { vtk_id_list_initialize(self.0) } } - fn set_above_range_color( + fn allocate( &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> () { + sz: core::ffi::c_longlong, + strategy: core::ffi::c_int, + ) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_lookup_table_set_above_range_color( + fn vtk_id_list_allocate( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ); - } - unsafe { - vtk_lookup_table_set_above_range_color(self.0, _arg1, _arg2, _arg3, _arg4) + sz: core::ffi::c_longlong, + strategy: core::ffi::c_int, + ) -> core::ffi::c_int; } + unsafe { vtk_id_list_allocate(self.0, sz, strategy) } } - fn set_above_range_color(&mut self, _arg: core::ffi::c_double) -> () { + fn get_number_of_ids(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_lookup_table_set_above_range_color( + fn vtk_id_list_get_number_of_ids( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); + ) -> core::ffi::c_longlong; } - unsafe { vtk_lookup_table_set_above_range_color(self.0, _arg) } + unsafe { vtk_id_list_get_number_of_ids(self.0) } } - fn get_above_range_color(&mut self) -> *mut core::ffi::c_double { + fn get_id(&mut self, i: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_lookup_table_get_above_range_color( + fn vtk_id_list_get_id( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + i: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } - unsafe { vtk_lookup_table_get_above_range_color(self.0) } + unsafe { vtk_id_list_get_id(self.0, i) } } - fn get_above_range_color( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ) -> () { + fn find_id_location(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_lookup_table_get_above_range_color( + fn vtk_id_list_find_id_location( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - _arg4: core::ffi::c_double, - ); - } - unsafe { - vtk_lookup_table_get_above_range_color(self.0, _arg1, _arg2, _arg3, _arg4) + id: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } + unsafe { vtk_id_list_find_id_location(self.0, id) } } - fn get_above_range_color(&mut self, _arg: core::ffi::c_double) -> () { + fn set_number_of_ids(&mut self, number: core::ffi::c_longlong) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_above_range_color( + fn vtk_id_list_set_number_of_ids( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, + number: core::ffi::c_longlong, ); } - unsafe { vtk_lookup_table_get_above_range_color(self.0, _arg) } + unsafe { vtk_id_list_set_number_of_ids(self.0, number) } } - fn set_use_above_range_color(&mut self, _arg: core::ffi::c_int) -> () { + fn set_id(&mut self, i: core::ffi::c_longlong, vtkid: core::ffi::c_longlong) -> () { unsafe extern "C" { - fn vtk_lookup_table_set_use_above_range_color( + fn vtk_id_list_set_id( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, + i: core::ffi::c_longlong, + vtkid: core::ffi::c_longlong, ); } - unsafe { vtk_lookup_table_set_use_above_range_color(self.0, _arg) } + unsafe { vtk_id_list_set_id(self.0, i, vtkid) } } - fn get_use_above_range_color(&mut self) -> core::ffi::c_int { + fn insert_id( + &mut self, + i: core::ffi::c_longlong, + vtkid: core::ffi::c_longlong, + ) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_use_above_range_color( + fn vtk_id_list_insert_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + i: core::ffi::c_longlong, + vtkid: core::ffi::c_longlong, + ); } - unsafe { vtk_lookup_table_get_use_above_range_color(self.0) } + unsafe { vtk_id_list_insert_id(self.0, i, vtkid) } } - fn use_above_range_color_on(&mut self) -> () { + fn insert_next_id(&mut self, vtkid: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_lookup_table_use_above_range_color_on(sself: *mut core::ffi::c_void); + fn vtk_id_list_insert_next_id( + sself: *mut core::ffi::c_void, + vtkid: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } - unsafe { vtk_lookup_table_use_above_range_color_on(self.0) } + unsafe { vtk_id_list_insert_next_id(self.0, vtkid) } } - fn use_above_range_color_off(&mut self) -> () { + fn insert_unique_id( + &mut self, + vtkid: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_lookup_table_use_above_range_color_off(sself: *mut core::ffi::c_void); + fn vtk_id_list_insert_unique_id( + sself: *mut core::ffi::c_void, + vtkid: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } - unsafe { vtk_lookup_table_use_above_range_color_off(self.0) } + unsafe { vtk_id_list_insert_unique_id(self.0, vtkid) } } - fn map_value(&mut self, v: core::ffi::c_double) -> *const core::ffi::c_uchar { + fn sort(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_map_value( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ) -> *const core::ffi::c_uchar; + fn vtk_id_list_sort(sself: *mut core::ffi::c_void); } - unsafe { vtk_lookup_table_map_value(self.0, v) } + unsafe { vtk_id_list_sort(self.0) } } - fn get_color(&mut self, v: core::ffi::c_double, rgb: core::ffi::c_double) -> () { + fn fill(&mut self, value: core::ffi::c_longlong) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_color( + fn vtk_id_list_fill( sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - rgb: core::ffi::c_double, + value: core::ffi::c_longlong, ); } - unsafe { vtk_lookup_table_get_color(self.0, v, rgb) } + unsafe { vtk_id_list_fill(self.0, value) } } - fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + fn reset(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_opacity( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ) -> core::ffi::c_double; + fn vtk_id_list_reset(sself: *mut core::ffi::c_void); } - unsafe { vtk_lookup_table_get_opacity(self.0, v) } + unsafe { vtk_id_list_reset(self.0) } } - fn get_index(&mut self, v: core::ffi::c_double) -> core::ffi::c_uchar { + fn squeeze(&mut self) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_index( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ) -> core::ffi::c_uchar; + fn vtk_id_list_squeeze(sself: *mut core::ffi::c_void); } - unsafe { vtk_lookup_table_get_index(self.0, v) } + unsafe { vtk_id_list_squeeze(self.0) } } - fn set_number_of_table_values(&mut self, number: core::ffi::c_uchar) -> () { + fn deep_copy(&mut self, ids: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_lookup_table_set_number_of_table_values( + fn vtk_id_list_deep_copy( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + ids: *mut core::ffi::c_void, ); } - unsafe { vtk_lookup_table_set_number_of_table_values(self.0, number) } + unsafe { vtk_id_list_deep_copy(self.0, ids) } } - fn get_number_of_table_values(&mut self) -> core::ffi::c_uchar { + fn delete_id(&mut self, vtkid: core::ffi::c_longlong) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_number_of_table_values( + fn vtk_id_list_delete_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + vtkid: core::ffi::c_longlong, + ); } - unsafe { vtk_lookup_table_get_number_of_table_values(self.0) } + unsafe { vtk_id_list_delete_id(self.0, vtkid) } } - fn set_table_value( - &mut self, - indx: core::ffi::c_uchar, - rgba: core::ffi::c_double, - ) -> () { + fn is_id(&mut self, vtkid: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_lookup_table_set_table_value( + fn vtk_id_list_is_id( sself: *mut core::ffi::c_void, - indx: core::ffi::c_uchar, - rgba: core::ffi::c_double, - ); + vtkid: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } - unsafe { vtk_lookup_table_set_table_value(self.0, indx, rgba) } + unsafe { vtk_id_list_is_id(self.0, vtkid) } } - fn set_table_value( - &mut self, - indx: core::ffi::c_uchar, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - a: core::ffi::c_double, - ) -> () { + fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_lookup_table_set_table_value( + fn vtk_id_list_intersect_with( sself: *mut core::ffi::c_void, - indx: core::ffi::c_uchar, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - a: core::ffi::c_double, + otherIds: *mut core::ffi::c_void, ); } - unsafe { vtk_lookup_table_set_table_value(self.0, indx, r, g, b, a) } + unsafe { vtk_id_list_intersect_with(self.0, otherIds) } } - fn get_table_value(&mut self, indx: core::ffi::c_uchar) -> *mut core::ffi::c_double { +} +impl VtkIdListCollection for vtkIdListCollection { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_table_value( + fn vtk_id_list_collection_new( sself: *mut core::ffi::c_void, - indx: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_table_value(self.0, indx) } + unsafe { vtk_id_list_collection_new(self.0) } } - fn get_table_value( - &mut self, - indx: core::ffi::c_uchar, - rgba: core::ffi::c_double, - ) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_table_value( + fn vtk_id_list_collection_safe_down_cast( sself: *mut core::ffi::c_void, - indx: core::ffi::c_uchar, - rgba: core::ffi::c_double, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_table_value(self.0, indx, rgba) } + unsafe { vtk_id_list_collection_safe_down_cast(self.0, o) } } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_pointer( + fn vtk_id_list_collection_new_instance( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_pointer(self.0, id) } + unsafe { vtk_id_list_collection_new_instance(self.0) } } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar { + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_lookup_table_write_pointer( + fn vtk_id_list_collection_add_item( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar; + ds: *mut core::ffi::c_void, + ); } - unsafe { vtk_lookup_table_write_pointer(self.0, id, number) } + unsafe { vtk_id_list_collection_add_item(self.0, ds) } } - fn get_range(&mut self) -> *mut core::ffi::c_double { + fn get_next_item(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_range( + fn vtk_id_list_collection_get_next_item( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_range(self.0) } + unsafe { vtk_id_list_collection_get_next_item(self.0) } } - fn get_log_range( - &mut self, - range: core::ffi::c_double, - log_range: core::ffi::c_double, - ) -> () { + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_log_range( + fn vtk_id_list_collection_get_item( sself: *mut core::ffi::c_void, - range: core::ffi::c_double, - log_range: core::ffi::c_double, - ); + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_log_range(self.0, range, log_range) } + unsafe { vtk_id_list_collection_get_item(self.0, i) } } - fn apply_log_scale( - &mut self, - v: core::ffi::c_double, - range: core::ffi::c_double, - log_range: core::ffi::c_double, - ) -> core::ffi::c_double { + fn get_number_of_items(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_lookup_table_apply_log_scale( + fn vtk_id_list_collection_get_number_of_items( sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - range: core::ffi::c_double, - log_range: core::ffi::c_double, - ) -> core::ffi::c_double; + ) -> core::ffi::c_int; } - unsafe { vtk_lookup_table_apply_log_scale(self.0, v, range, log_range) } + unsafe { vtk_id_list_collection_get_number_of_items(self.0) } } - fn set_number_of_colors(&mut self, _arg: core::ffi::c_uchar) -> () { +} +impl VtkIdTypeArray for vtkIdTypeArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_set_number_of_colors( + fn vtk_id_type_array_safe_down_cast( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_set_number_of_colors(self.0, _arg) } + unsafe { vtk_id_type_array_safe_down_cast(self.0, o) } } - fn get_number_of_colors_min_value(&mut self) -> core::ffi::c_uchar { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_number_of_colors_min_value( + fn vtk_id_type_array_new_instance( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_number_of_colors_min_value(self.0) } + unsafe { vtk_id_type_array_new_instance(self.0) } } - fn get_number_of_colors_max_value(&mut self) -> core::ffi::c_uchar { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_number_of_colors_max_value( + fn vtk_id_type_array_new( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_number_of_colors_max_value(self.0) } + unsafe { vtk_id_type_array_new(self.0) } } - fn get_number_of_colors(&mut self) -> core::ffi::c_uchar { + fn extended_new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lookup_table_get_number_of_colors( + fn vtk_id_type_array_extended_new( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_lookup_table_get_number_of_colors(self.0) } + unsafe { vtk_id_type_array_extended_new(self.0) } } - fn set_table(&mut self, p0: *mut core::ffi::c_void) -> () { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_lookup_table_set_table( + fn vtk_id_type_array_get_data_type( sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_lookup_table_set_table(self.0, p0) } + unsafe { vtk_id_type_array_get_data_type(self.0) } } - fn get_table(&mut self) -> *mut core::ffi::c_void { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_lookup_table_get_table( + fn vtk_id_type_array_get_value( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + id: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } - unsafe { vtk_lookup_table_get_table(self.0) } + unsafe { vtk_id_type_array_get_value(self.0, id) } } - fn map_scalars_through_table_2( + fn set_value( &mut self, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, ) -> () { unsafe extern "C" { - fn vtk_lookup_table_map_scalars_through_table_2( - sself: *mut core::ffi::c_void, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ); - } - unsafe { - vtk_lookup_table_map_scalars_through_table_2( - self.0, - input, - output, - inputDataType, - numberOfValues, - inputIncrement, - outputFormat, - ) - } - } - fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_lookup_table_deep_copy( + fn vtk_id_type_array_set_value( sself: *mut core::ffi::c_void, - obj: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, ); } - unsafe { vtk_lookup_table_deep_copy(self.0, obj) } + unsafe { vtk_id_type_array_set_value(self.0, id, value) } } - fn using_log_scale(&mut self) -> core::ffi::c_int { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { - fn vtk_lookup_table_using_log_scale( + fn vtk_id_type_array_set_number_of_values( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; + number: core::ffi::c_longlong, + ) -> bool; } - unsafe { vtk_lookup_table_using_log_scale(self.0) } + unsafe { vtk_id_type_array_set_number_of_values(self.0, number) } } - fn get_indexed_color( + fn insert_value( &mut self, - idx: core::ffi::c_uchar, - rgba: core::ffi::c_double, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, ) -> () { unsafe extern "C" { - fn vtk_lookup_table_get_indexed_color( + fn vtk_id_type_array_insert_value( sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - rgba: core::ffi::c_double, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, ); } - unsafe { vtk_lookup_table_get_indexed_color(self.0, idx, rgba) } + unsafe { vtk_id_type_array_insert_value(self.0, id, f) } } -} -impl VtkMath for vtkMath { - fn new(&mut self) -> *mut core::ffi::c_void { + fn insert_next_value(&mut self, f: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn vtk_id_type_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_new(self.0) } + unsafe { vtk_id_type_array_insert_next_value(self.0, f) } } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_safe_down_cast( + fn vtk_id_type_array_fast_down_cast( sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_safe_down_cast(self.0, o) } + unsafe { vtk_id_type_array_fast_down_cast(self.0, source) } } - fn new_instance(&mut self) -> *mut core::ffi::c_void { + fn get_data_type_value_min(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_new_instance( + fn vtk_id_type_array_get_data_type_value_min( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_new_instance(self.0) } + unsafe { vtk_id_type_array_get_data_type_value_min(self.0) } } - fn pi(&mut self) -> core::ffi::c_double { + fn get_data_type_value_max(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_pi(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + fn vtk_id_type_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_pi(self.0) } + unsafe { vtk_id_type_array_get_data_type_value_max(self.0) } } - fn radians_from_degrees( - &mut self, - degrees: core::ffi::c_float, - ) -> core::ffi::c_float { +} +impl VtkInformation for vtkInformation { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_radians_from_degrees( + fn vtk_information_new( sself: *mut core::ffi::c_void, - degrees: core::ffi::c_float, - ) -> core::ffi::c_float; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_radians_from_degrees(self.0, degrees) } + unsafe { vtk_information_new(self.0) } } - fn radians_from_degrees( - &mut self, - degrees: core::ffi::c_double, - ) -> core::ffi::c_double { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_radians_from_degrees( + fn vtk_information_safe_down_cast( sself: *mut core::ffi::c_void, - degrees: core::ffi::c_double, - ) -> core::ffi::c_double; + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_radians_from_degrees(self.0, degrees) } + unsafe { vtk_information_safe_down_cast(self.0, o) } } - fn degrees_from_radians( - &mut self, - radians: core::ffi::c_float, - ) -> core::ffi::c_float { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_degrees_from_radians( + fn vtk_information_new_instance( sself: *mut core::ffi::c_void, - radians: core::ffi::c_float, - ) -> core::ffi::c_float; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_degrees_from_radians(self.0, radians) } + unsafe { vtk_information_new_instance(self.0) } } - fn degrees_from_radians( - &mut self, - radians: core::ffi::c_double, - ) -> core::ffi::c_double { + fn modified(&mut self) -> () { unsafe extern "C" { - fn vtk_math_degrees_from_radians( - sself: *mut core::ffi::c_void, - radians: core::ffi::c_double, - ) -> core::ffi::c_double; + fn vtk_information_modified(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_degrees_from_radians(self.0, radians) } + unsafe { vtk_information_modified(self.0) } } - fn round(&mut self, f: core::ffi::c_float) -> core::ffi::c_int { + fn clear(&mut self) -> () { unsafe extern "C" { - fn vtk_math_round( - sself: *mut core::ffi::c_void, - f: core::ffi::c_float, - ) -> core::ffi::c_int; + fn vtk_information_clear(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_round(self.0, f) } + unsafe { vtk_information_clear(self.0) } } - fn round(&mut self, f: core::ffi::c_double) -> core::ffi::c_int { + fn get_number_of_keys(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_round( + fn vtk_information_get_number_of_keys( sself: *mut core::ffi::c_void, - f: core::ffi::c_double, ) -> core::ffi::c_int; } - unsafe { vtk_math_round(self.0, f) } + unsafe { vtk_information_get_number_of_keys(self.0) } } - fn floor(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_floor( + fn vtk_information_copy( sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_int; + from: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); } - unsafe { vtk_math_floor(self.0, x) } + unsafe { vtk_information_copy(self.0, from, deep) } } - fn ceil(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + fn append(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_ceil( + fn vtk_information_append( sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_int; + from: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); } - unsafe { vtk_math_ceil(self.0, x) } + unsafe { vtk_information_append(self.0, from, deep) } } - fn ceil_log_2(&mut self, x: core::ffi::c_ulonglong) -> core::ffi::c_int { + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { unsafe extern "C" { - fn vtk_math_ceil_log_2( + fn vtk_information_copy_entry( sself: *mut core::ffi::c_void, - x: core::ffi::c_ulonglong, - ) -> core::ffi::c_int; + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); } - unsafe { vtk_math_ceil_log_2(self.0, x) } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } } - fn is_power_of_two(&mut self, x: core::ffi::c_ulonglong) -> bool { + fn copy_entries( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { unsafe extern "C" { - fn vtk_math_is_power_of_two( + fn vtk_information_copy_entries( sself: *mut core::ffi::c_void, - x: core::ffi::c_ulonglong, - ) -> bool; + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); } - unsafe { vtk_math_is_power_of_two(self.0, x) } + unsafe { vtk_information_copy_entries(self.0, from, key, deep) } } - fn nearest_power_of_two(&mut self, x: core::ffi::c_int) -> core::ffi::c_int { + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_nearest_power_of_two( + fn vtk_information_has( sself: *mut core::ffi::c_void, - x: core::ffi::c_int, + key: *mut core::ffi::c_void, ) -> core::ffi::c_int; } - unsafe { vtk_math_nearest_power_of_two(self.0, x) } + unsafe { vtk_information_has(self.0, key) } } - fn factorial(&mut self, N: core::ffi::c_int) -> core::ffi::c_uchar { + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_math_factorial( + fn vtk_information_remove( sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - ) -> core::ffi::c_uchar; + key: *mut core::ffi::c_void, + ); } - unsafe { vtk_math_factorial(self.0, N) } + unsafe { vtk_information_remove(self.0, key) } } - fn binomial( - &mut self, - m: core::ffi::c_int, - n: core::ffi::c_int, - ) -> core::ffi::c_uchar { + fn set(&mut self, key: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_math_binomial( + fn vtk_information_set( sself: *mut core::ffi::c_void, - m: core::ffi::c_int, - n: core::ffi::c_int, - ) -> core::ffi::c_uchar; + key: *mut core::ffi::c_void, + ); } - unsafe { vtk_math_binomial(self.0, m, n) } + unsafe { vtk_information_set(self.0, key) } } - fn begin_combination( - &mut self, - m: core::ffi::c_int, - n: core::ffi::c_int, - ) -> *mut core::ffi::c_int { + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_begin_combination( + fn vtk_information_get( sself: *mut core::ffi::c_void, - m: core::ffi::c_int, - n: core::ffi::c_int, - ) -> *mut core::ffi::c_int; + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; } - unsafe { vtk_math_begin_combination(self.0, m, n) } + unsafe { vtk_information_get(self.0, key) } } - fn next_combination( - &mut self, - m: core::ffi::c_int, - n: core::ffi::c_int, - combination: core::ffi::c_int, - ) -> core::ffi::c_int { + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_next_combination( + fn vtk_information_length( sself: *mut core::ffi::c_void, - m: core::ffi::c_int, - n: core::ffi::c_int, - combination: core::ffi::c_int, + key: *mut core::ffi::c_void, ) -> core::ffi::c_int; } - unsafe { vtk_math_next_combination(self.0, m, n, combination) } + unsafe { vtk_information_length(self.0, key) } } - fn free_combination(&mut self, combination: core::ffi::c_int) -> () { + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { unsafe extern "C" { - fn vtk_math_free_combination( + fn vtk_information_append_unique( sself: *mut core::ffi::c_void, - combination: core::ffi::c_int, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, ); } - unsafe { vtk_math_free_combination(self.0, combination) } + unsafe { vtk_information_append_unique(self.0, key, value) } } - fn random_seed(&mut self, s: core::ffi::c_int) -> () { + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_random_seed(sself: *mut core::ffi::c_void, s: core::ffi::c_int); + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_random_seed(self.0, s) } + unsafe { vtk_information_get_key(self.0, key) } } - fn get_seed(&mut self) -> core::ffi::c_int { + fn register(&mut self, o: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_math_get_seed(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + fn vtk_information_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); } - unsafe { vtk_math_get_seed(self.0) } + unsafe { vtk_information_register(self.0, o) } } - fn random(&mut self) -> core::ffi::c_double { + fn set_request(&mut self, request: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_math_random(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + fn vtk_information_set_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + ); } - unsafe { vtk_math_random(self.0) } + unsafe { vtk_information_set_request(self.0, request) } } - fn random( - &mut self, - min: core::ffi::c_double, - max: core::ffi::c_double, - ) -> core::ffi::c_double { + fn get_request(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_random( + fn vtk_information_get_request( sself: *mut core::ffi::c_void, - min: core::ffi::c_double, - max: core::ffi::c_double, - ) -> core::ffi::c_double; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_random(self.0, min, max) } + unsafe { vtk_information_get_request(self.0) } } - fn gaussian(&mut self) -> core::ffi::c_double { +} +impl VtkInformationIterator for vtkInformationIterator { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_gaussian(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + fn vtk_information_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_gaussian(self.0) } + unsafe { vtk_information_iterator_new(self.0) } } - fn gaussian( - &mut self, - mean: core::ffi::c_double, - std: core::ffi::c_double, - ) -> core::ffi::c_double { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_gaussian( + fn vtk_information_iterator_safe_down_cast( sself: *mut core::ffi::c_void, - mean: core::ffi::c_double, - std: core::ffi::c_double, - ) -> core::ffi::c_double; + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_gaussian(self.0, mean, std) } + unsafe { vtk_information_iterator_safe_down_cast(self.0, o) } } - fn assign(&mut self, a: core::ffi::c_double, b: core::ffi::c_double) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_assign( + fn vtk_information_iterator_new_instance( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_assign(self.0, a, b) } + unsafe { vtk_information_iterator_new_instance(self.0) } } - fn add( - &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, - ) -> () { + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_math_add( + fn vtk_information_iterator_set_information( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, + p0: *mut core::ffi::c_void, ); } - unsafe { vtk_math_add(self.0, a, b, c) } + unsafe { vtk_information_iterator_set_information(self.0, p0) } } - fn add( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ) -> () { + fn get_information(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_add( + fn vtk_information_iterator_get_information( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_add(self.0, a, b, c) } + unsafe { vtk_information_iterator_get_information(self.0) } } - fn subtract( - &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, - ) -> () { + fn set_information_weak(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_math_subtract( + fn vtk_information_iterator_set_information_weak( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, + p0: *mut core::ffi::c_void, ); } - unsafe { vtk_math_subtract(self.0, a, b, c) } + unsafe { vtk_information_iterator_set_information_weak(self.0, p0) } } - fn subtract( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ) -> () { + fn init_traversal(&mut self) -> () { unsafe extern "C" { - fn vtk_math_subtract( - sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ); + fn vtk_information_iterator_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_iterator_init_traversal(self.0) } + } + fn go_to_first_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_iterator_go_to_first_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_iterator_go_to_first_item(self.0) } + } + fn go_to_next_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_iterator_go_to_next_item(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_subtract(self.0, a, b, c) } + unsafe { vtk_information_iterator_go_to_next_item(self.0) } } - fn multiply_scalar(&mut self, a: core::ffi::c_float, s: core::ffi::c_float) -> () { + fn is_done_with_traversal(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_multiply_scalar( + fn vtk_information_iterator_is_done_with_traversal( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - s: core::ffi::c_float, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_math_multiply_scalar(self.0, a, s) } + unsafe { vtk_information_iterator_is_done_with_traversal(self.0) } } - fn multiply_scalar_2_d( - &mut self, - a: core::ffi::c_float, - s: core::ffi::c_float, - ) -> () { + fn get_current_key(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_multiply_scalar_2_d( + fn vtk_information_iterator_get_current_key( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - s: core::ffi::c_float, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_multiply_scalar_2_d(self.0, a, s) } + unsafe { vtk_information_iterator_get_current_key(self.0) } } - fn multiply_scalar(&mut self, a: core::ffi::c_double, s: core::ffi::c_double) -> () { +} +impl VtkInformationKeyLookup for vtkInformationKeyLookup { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_multiply_scalar( + fn vtk_information_key_lookup_new( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - s: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_multiply_scalar(self.0, a, s) } + unsafe { vtk_information_key_lookup_new(self.0) } } - fn multiply_scalar_2_d( - &mut self, - a: core::ffi::c_double, - s: core::ffi::c_double, - ) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_multiply_scalar_2_d( + fn vtk_information_key_lookup_safe_down_cast( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - s: core::ffi::c_double, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_multiply_scalar_2_d(self.0, a, s) } + unsafe { vtk_information_key_lookup_safe_down_cast(self.0, o) } } - fn dot( - &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - ) -> core::ffi::c_float { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_dot( + fn vtk_information_key_lookup_new_instance( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - b: core::ffi::c_float, - ) -> core::ffi::c_float; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_dot(self.0, a, b) } + unsafe { vtk_information_key_lookup_new_instance(self.0) } } - fn dot( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - ) -> core::ffi::c_double { + fn find(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_location = std::ffi::CString::new(location).expect("CString::new failed"); unsafe extern "C" { - fn vtk_math_dot( + fn vtk_information_key_lookup_find( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - ) -> core::ffi::c_double; + name: *const core::ffi::c_char, + location: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_information_key_lookup_find(self.0, c_name.as_ptr(), c_location.as_ptr()) } - unsafe { vtk_math_dot(self.0, a, b) } } - fn outer( - &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, - ) -> () { +} +impl VtkInformationVector for vtkInformationVector { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_outer( + fn vtk_information_vector_new( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_outer(self.0, a, b, c) } + unsafe { vtk_information_vector_new(self.0) } } - fn outer( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_outer( + fn vtk_information_vector_safe_down_cast( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_outer(self.0, a, b, c) } + unsafe { vtk_information_vector_safe_down_cast(self.0, o) } } - fn cross( - &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, - ) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_cross( + fn vtk_information_vector_new_instance( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - b: core::ffi::c_float, - c: core::ffi::c_float, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_cross(self.0, a, b, c) } + unsafe { vtk_information_vector_new_instance(self.0) } } - fn cross( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ) -> () { + fn get_number_of_information_objects(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_cross( + fn vtk_information_vector_get_number_of_information_objects( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_math_cross(self.0, a, b, c) } + unsafe { vtk_information_vector_get_number_of_information_objects(self.0) } } - fn norm( - &mut self, - x: core::ffi::c_float, - n: core::ffi::c_int, - ) -> core::ffi::c_float { + fn set_number_of_information_objects(&mut self, n: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_norm( + fn vtk_information_vector_set_number_of_information_objects( sself: *mut core::ffi::c_void, - x: core::ffi::c_float, n: core::ffi::c_int, - ) -> core::ffi::c_float; + ); } - unsafe { vtk_math_norm(self.0, x, n) } + unsafe { vtk_information_vector_set_number_of_information_objects(self.0, n) } } - fn norm( + fn set_information_object( &mut self, - x: core::ffi::c_double, - n: core::ffi::c_int, - ) -> core::ffi::c_double { + index: core::ffi::c_int, + info: *mut core::ffi::c_void, + ) -> () { unsafe extern "C" { - fn vtk_math_norm( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_int, - ) -> core::ffi::c_double; + fn vtk_information_vector_set_information_object( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + info: *mut core::ffi::c_void, + ); } - unsafe { vtk_math_norm(self.0, x, n) } + unsafe { vtk_information_vector_set_information_object(self.0, index, info) } } - fn norm(&mut self, v: core::ffi::c_float) -> core::ffi::c_float { + fn get_information_object( + &mut self, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_norm( + fn vtk_information_vector_get_information_object( sself: *mut core::ffi::c_void, - v: core::ffi::c_float, - ) -> core::ffi::c_float; + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_norm(self.0, v) } + unsafe { vtk_information_vector_get_information_object(self.0, index) } } - fn norm(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + fn append(&mut self, info: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_math_norm( + fn vtk_information_vector_append( sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ) -> core::ffi::c_double; + info: *mut core::ffi::c_void, + ); } - unsafe { vtk_math_norm(self.0, v) } + unsafe { vtk_information_vector_append(self.0, info) } } - fn normalize(&mut self, v: core::ffi::c_float) -> core::ffi::c_float { + fn remove(&mut self, info: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_math_normalize( + fn vtk_information_vector_remove( sself: *mut core::ffi::c_void, - v: core::ffi::c_float, - ) -> core::ffi::c_float; + info: *mut core::ffi::c_void, + ); } - unsafe { vtk_math_normalize(self.0, v) } + unsafe { vtk_information_vector_remove(self.0, info) } } - fn normalize(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + fn register(&mut self, o: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_math_normalize( + fn vtk_information_vector_register( sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ) -> core::ffi::c_double; + o: *mut core::ffi::c_void, + ); } - unsafe { vtk_math_normalize(self.0, v) } + unsafe { vtk_information_vector_register(self.0, o) } } - fn perpendiculars( - &mut self, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - theta: core::ffi::c_double, - ) -> () { + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_perpendiculars( + fn vtk_information_vector_copy( sself: *mut core::ffi::c_void, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - theta: core::ffi::c_double, + from: *mut core::ffi::c_void, + deep: core::ffi::c_int, ); } - unsafe { vtk_math_perpendiculars(self.0, v1, v2, v3, theta) } + unsafe { vtk_information_vector_copy(self.0, from, deep) } } - fn perpendiculars( - &mut self, - v1: core::ffi::c_float, - v2: core::ffi::c_float, - v3: core::ffi::c_float, - theta: core::ffi::c_double, - ) -> () { +} +impl VtkIntArray for vtkIntArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_perpendiculars( + fn vtk_int_array_safe_down_cast( sself: *mut core::ffi::c_void, - v1: core::ffi::c_float, - v2: core::ffi::c_float, - v3: core::ffi::c_float, - theta: core::ffi::c_double, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_perpendiculars(self.0, v1, v2, v3, theta) } + unsafe { vtk_int_array_safe_down_cast(self.0, o) } } - fn project_vector( - &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - projection: core::ffi::c_float, - ) -> bool { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_project_vector( + fn vtk_int_array_new_instance( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - b: core::ffi::c_float, - projection: core::ffi::c_float, - ) -> bool; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_project_vector(self.0, a, b, projection) } + unsafe { vtk_int_array_new_instance(self.0) } } - fn project_vector( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - projection: core::ffi::c_double, - ) -> bool { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_project_vector( + fn vtk_int_array_new( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - projection: core::ffi::c_double, - ) -> bool; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_project_vector(self.0, a, b, projection) } + unsafe { vtk_int_array_new(self.0) } } - fn project_vector_2_d( - &mut self, - a: core::ffi::c_float, - b: core::ffi::c_float, - projection: core::ffi::c_float, - ) -> bool { + fn extended_new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_project_vector_2_d( + fn vtk_int_array_extended_new( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - b: core::ffi::c_float, - projection: core::ffi::c_float, - ) -> bool; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_project_vector_2_d(self.0, a, b, projection) } + unsafe { vtk_int_array_extended_new(self.0) } } - fn project_vector_2_d( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - projection: core::ffi::c_double, - ) -> bool { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_project_vector_2_d( + fn vtk_int_array_get_data_type( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - projection: core::ffi::c_double, - ) -> bool; + ) -> core::ffi::c_int; } - unsafe { vtk_math_project_vector_2_d(self.0, a, b, projection) } + unsafe { vtk_int_array_get_data_type(self.0) } } - fn distance_2_between_points( - &mut self, - p1: core::ffi::c_float, - p2: core::ffi::c_float, - ) -> core::ffi::c_float { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_distance_2_between_points( + fn vtk_int_array_get_value( sself: *mut core::ffi::c_void, - p1: core::ffi::c_float, - p2: core::ffi::c_float, - ) -> core::ffi::c_float; + id: core::ffi::c_longlong, + ) -> core::ffi::c_int; } - unsafe { vtk_math_distance_2_between_points(self.0, p1, p2) } + unsafe { vtk_int_array_get_value(self.0, id) } } - fn distance_2_between_points( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - ) -> core::ffi::c_double { + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_distance_2_between_points( + fn vtk_int_array_set_value( sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - ) -> core::ffi::c_double; + id: core::ffi::c_longlong, + value: core::ffi::c_int, + ); } - unsafe { vtk_math_distance_2_between_points(self.0, p1, p2) } + unsafe { vtk_int_array_set_value(self.0, id, value) } } - fn angle_between_vectors( - &mut self, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - ) -> core::ffi::c_double { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { - fn vtk_math_angle_between_vectors( + fn vtk_int_array_set_number_of_values( sself: *mut core::ffi::c_void, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - ) -> core::ffi::c_double; + number: core::ffi::c_longlong, + ) -> bool; } - unsafe { vtk_math_angle_between_vectors(self.0, v1, v2) } + unsafe { vtk_int_array_set_number_of_values(self.0, number) } } - fn signed_angle_between_vectors( - &mut self, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - vn: core::ffi::c_double, - ) -> core::ffi::c_double { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_signed_angle_between_vectors( + fn vtk_int_array_insert_value( sself: *mut core::ffi::c_void, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - vn: core::ffi::c_double, - ) -> core::ffi::c_double; + id: core::ffi::c_longlong, + f: core::ffi::c_int, + ); } - unsafe { vtk_math_signed_angle_between_vectors(self.0, v1, v2, vn) } + unsafe { vtk_int_array_insert_value(self.0, id, f) } } - fn gaussian_amplitude( - &mut self, - variance: core::ffi::c_double, - distanceFromMean: core::ffi::c_double, - ) -> core::ffi::c_double { + fn insert_next_value(&mut self, f: core::ffi::c_int) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_gaussian_amplitude( + fn vtk_int_array_insert_next_value( sself: *mut core::ffi::c_void, - variance: core::ffi::c_double, - distanceFromMean: core::ffi::c_double, - ) -> core::ffi::c_double; + f: core::ffi::c_int, + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_gaussian_amplitude(self.0, variance, distanceFromMean) } + unsafe { vtk_int_array_insert_next_value(self.0, f) } } - fn gaussian_amplitude( + fn fast_down_cast( &mut self, - mean: core::ffi::c_double, - variance: core::ffi::c_double, - position: core::ffi::c_double, - ) -> core::ffi::c_double { + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_gaussian_amplitude( + fn vtk_int_array_fast_down_cast( sself: *mut core::ffi::c_void, - mean: core::ffi::c_double, - variance: core::ffi::c_double, - position: core::ffi::c_double, - ) -> core::ffi::c_double; + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_gaussian_amplitude(self.0, mean, variance, position) } + unsafe { vtk_int_array_fast_down_cast(self.0, source) } } - fn gaussian_weight( - &mut self, - variance: core::ffi::c_double, - distanceFromMean: core::ffi::c_double, - ) -> core::ffi::c_double { + fn get_data_type_value_min(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_gaussian_weight( + fn vtk_int_array_get_data_type_value_min( sself: *mut core::ffi::c_void, - variance: core::ffi::c_double, - distanceFromMean: core::ffi::c_double, - ) -> core::ffi::c_double; + ) -> core::ffi::c_int; } - unsafe { vtk_math_gaussian_weight(self.0, variance, distanceFromMean) } + unsafe { vtk_int_array_get_data_type_value_min(self.0) } } - fn gaussian_weight( - &mut self, - mean: core::ffi::c_double, - variance: core::ffi::c_double, - position: core::ffi::c_double, - ) -> core::ffi::c_double { + fn get_data_type_value_max(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_gaussian_weight( + fn vtk_int_array_get_data_type_value_max( sself: *mut core::ffi::c_void, - mean: core::ffi::c_double, - variance: core::ffi::c_double, - position: core::ffi::c_double, - ) -> core::ffi::c_double; + ) -> core::ffi::c_int; } - unsafe { vtk_math_gaussian_weight(self.0, mean, variance, position) } + unsafe { vtk_int_array_get_data_type_value_max(self.0) } } - fn dot_2_d( - &mut self, - x: core::ffi::c_float, - y: core::ffi::c_float, - ) -> core::ffi::c_float { +} +impl VtkLongArray for vtkLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_dot_2_d( + fn vtk_long_array_safe_down_cast( sself: *mut core::ffi::c_void, - x: core::ffi::c_float, - y: core::ffi::c_float, - ) -> core::ffi::c_float; + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_dot_2_d(self.0, x, y) } + unsafe { vtk_long_array_safe_down_cast(self.0, o) } } - fn dot_2_d( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> core::ffi::c_double { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_dot_2_d( + fn vtk_long_array_new_instance( sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> core::ffi::c_double; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_dot_2_d(self.0, x, y) } + unsafe { vtk_long_array_new_instance(self.0) } } - fn outer_2_d( - &mut self, - x: core::ffi::c_float, - y: core::ffi::c_float, - A: core::ffi::c_float, - ) -> () { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_outer_2_d( + fn vtk_long_array_new( sself: *mut core::ffi::c_void, - x: core::ffi::c_float, - y: core::ffi::c_float, - A: core::ffi::c_float, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_outer_2_d(self.0, x, y, A) } + unsafe { vtk_long_array_new(self.0) } } - fn outer_2_d( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - A: core::ffi::c_double, - ) -> () { + fn extended_new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_outer_2_d( + fn vtk_long_array_extended_new( sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - A: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_outer_2_d(self.0, x, y, A) } + unsafe { vtk_long_array_extended_new(self.0) } } - fn norm_2_d(&mut self, x: core::ffi::c_float) -> core::ffi::c_float { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_norm_2_d( + fn vtk_long_array_get_data_type( sself: *mut core::ffi::c_void, - x: core::ffi::c_float, - ) -> core::ffi::c_float; + ) -> core::ffi::c_int; } - unsafe { vtk_math_norm_2_d(self.0, x) } + unsafe { vtk_long_array_get_data_type(self.0) } } - fn norm_2_d(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_long { unsafe extern "C" { - fn vtk_math_norm_2_d( + fn vtk_long_array_get_value( sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; + id: core::ffi::c_longlong, + ) -> core::ffi::c_long; } - unsafe { vtk_math_norm_2_d(self.0, x) } + unsafe { vtk_long_array_get_value(self.0, id) } } - fn normalize_2_d(&mut self, v: core::ffi::c_float) -> core::ffi::c_float { + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_long) -> () { unsafe extern "C" { - fn vtk_math_normalize_2_d( + fn vtk_long_array_set_value( sself: *mut core::ffi::c_void, - v: core::ffi::c_float, - ) -> core::ffi::c_float; + id: core::ffi::c_longlong, + value: core::ffi::c_long, + ); } - unsafe { vtk_math_normalize_2_d(self.0, v) } + unsafe { vtk_long_array_set_value(self.0, id, value) } } - fn normalize_2_d(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { - fn vtk_math_normalize_2_d( + fn vtk_long_array_set_number_of_values( sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ) -> core::ffi::c_double; + number: core::ffi::c_longlong, + ) -> bool; } - unsafe { vtk_math_normalize_2_d(self.0, v) } + unsafe { vtk_long_array_set_number_of_values(self.0, number) } } - fn determinant_2_x_2( - &mut self, - c1: core::ffi::c_float, - c2: core::ffi::c_float, - ) -> core::ffi::c_float { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_long) -> () { unsafe extern "C" { - fn vtk_math_determinant_2_x_2( + fn vtk_long_array_insert_value( sself: *mut core::ffi::c_void, - c1: core::ffi::c_float, - c2: core::ffi::c_float, - ) -> core::ffi::c_float; + id: core::ffi::c_longlong, + f: core::ffi::c_long, + ); } - unsafe { vtk_math_determinant_2_x_2(self.0, c1, c2) } + unsafe { vtk_long_array_insert_value(self.0, id, f) } } - fn determinant_2_x_2( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - d: core::ffi::c_double, - ) -> core::ffi::c_double { + fn insert_next_value(&mut self, f: core::ffi::c_long) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_determinant_2_x_2( + fn vtk_long_array_insert_next_value( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - d: core::ffi::c_double, - ) -> core::ffi::c_double; + f: core::ffi::c_long, + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_determinant_2_x_2(self.0, a, b, c, d) } + unsafe { vtk_long_array_insert_next_value(self.0, f) } } - fn determinant_2_x_2( + fn fast_down_cast( &mut self, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - ) -> core::ffi::c_double { + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_determinant_2_x_2( + fn vtk_long_array_fast_down_cast( sself: *mut core::ffi::c_void, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - ) -> core::ffi::c_double; + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_determinant_2_x_2(self.0, c1, c2) } + unsafe { vtk_long_array_fast_down_cast(self.0, source) } } - fn lu_factor_3_x_3(&mut self, A: core::ffi::c_float, index: core::ffi::c_int) -> () { + fn get_data_type_value_min(&mut self) -> core::ffi::c_long { unsafe extern "C" { - fn vtk_math_lu_factor_3_x_3( + fn vtk_long_array_get_data_type_value_min( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - index: core::ffi::c_int, - ); + ) -> core::ffi::c_long; } - unsafe { vtk_math_lu_factor_3_x_3(self.0, A, index) } + unsafe { vtk_long_array_get_data_type_value_min(self.0) } } - fn lu_factor_3_x_3( - &mut self, - A: core::ffi::c_double, - index: core::ffi::c_int, - ) -> () { + fn get_data_type_value_max(&mut self) -> core::ffi::c_long { unsafe extern "C" { - fn vtk_math_lu_factor_3_x_3( + fn vtk_long_array_get_data_type_value_max( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - index: core::ffi::c_int, - ); + ) -> core::ffi::c_long; } - unsafe { vtk_math_lu_factor_3_x_3(self.0, A, index) } + unsafe { vtk_long_array_get_data_type_value_max(self.0) } } - fn lu_solve_3_x_3( - &mut self, - A: core::ffi::c_float, - index: core::ffi::c_int, - x: core::ffi::c_float, - ) -> () { +} +impl VtkLongLongArray for vtkLongLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_lu_solve_3_x_3( + fn vtk_long_long_array_safe_down_cast( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - index: core::ffi::c_int, - x: core::ffi::c_float, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_lu_solve_3_x_3(self.0, A, index, x) } + unsafe { vtk_long_long_array_safe_down_cast(self.0, o) } } - fn lu_solve_3_x_3( - &mut self, - A: core::ffi::c_double, - index: core::ffi::c_int, - x: core::ffi::c_double, - ) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_lu_solve_3_x_3( + fn vtk_long_long_array_new_instance( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - index: core::ffi::c_int, - x: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_lu_solve_3_x_3(self.0, A, index, x) } + unsafe { vtk_long_long_array_new_instance(self.0) } } - fn linear_solve_3_x_3( - &mut self, - A: core::ffi::c_float, - x: core::ffi::c_float, - y: core::ffi::c_float, - ) -> () { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_linear_solve_3_x_3( + fn vtk_long_long_array_new( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - x: core::ffi::c_float, - y: core::ffi::c_float, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_linear_solve_3_x_3(self.0, A, x, y) } + unsafe { vtk_long_long_array_new(self.0) } } - fn linear_solve_3_x_3( - &mut self, - A: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> () { + fn extended_new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_linear_solve_3_x_3( + fn vtk_long_long_array_extended_new( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_linear_solve_3_x_3(self.0, A, x, y) } + unsafe { vtk_long_long_array_extended_new(self.0) } } - fn multiply_3_x_3( - &mut self, - A: core::ffi::c_float, - v: core::ffi::c_float, - u: core::ffi::c_float, - ) -> () { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_multiply_3_x_3( + fn vtk_long_long_array_get_data_type( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - v: core::ffi::c_float, - u: core::ffi::c_float, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_math_multiply_3_x_3(self.0, A, v, u) } + unsafe { vtk_long_long_array_get_data_type(self.0) } } - fn multiply_3_x_3( - &mut self, - A: core::ffi::c_double, - v: core::ffi::c_double, - u: core::ffi::c_double, - ) -> () { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_multiply_3_x_3( + fn vtk_long_long_array_get_value( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - v: core::ffi::c_double, - u: core::ffi::c_double, - ); + id: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_multiply_3_x_3(self.0, A, v, u) } + unsafe { vtk_long_long_array_get_value(self.0, id) } } - fn multiply_3_x_3( + fn set_value( &mut self, - A: core::ffi::c_float, - B: core::ffi::c_float, - C: core::ffi::c_float, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, ) -> () { unsafe extern "C" { - fn vtk_math_multiply_3_x_3( + fn vtk_long_long_array_set_value( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - B: core::ffi::c_float, - C: core::ffi::c_float, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, ); } - unsafe { vtk_math_multiply_3_x_3(self.0, A, B, C) } + unsafe { vtk_long_long_array_set_value(self.0, id, value) } } - fn multiply_3_x_3( - &mut self, - A: core::ffi::c_double, - B: core::ffi::c_double, - C: core::ffi::c_double, - ) -> () { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { - fn vtk_math_multiply_3_x_3( + fn vtk_long_long_array_set_number_of_values( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - B: core::ffi::c_double, - C: core::ffi::c_double, - ); + number: core::ffi::c_longlong, + ) -> bool; } - unsafe { vtk_math_multiply_3_x_3(self.0, A, B, C) } + unsafe { vtk_long_long_array_set_number_of_values(self.0, number) } } - fn multiply_matrix( + fn insert_value( &mut self, - A: core::ffi::c_double, - B: core::ffi::c_double, - rowA: core::ffi::c_uint, - colA: core::ffi::c_uint, - rowB: core::ffi::c_uint, - colB: core::ffi::c_uint, - C: core::ffi::c_double, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, ) -> () { unsafe extern "C" { - fn vtk_math_multiply_matrix( + fn vtk_long_long_array_insert_value( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - B: core::ffi::c_double, - rowA: core::ffi::c_uint, - colA: core::ffi::c_uint, - rowB: core::ffi::c_uint, - colB: core::ffi::c_uint, - C: core::ffi::c_double, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, ); } - unsafe { vtk_math_multiply_matrix(self.0, A, B, rowA, colA, rowB, colB, C) } + unsafe { vtk_long_long_array_insert_value(self.0, id, f) } } - fn transpose_3_x_3(&mut self, A: core::ffi::c_float, AT: core::ffi::c_float) -> () { + fn insert_next_value(&mut self, f: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_transpose_3_x_3( + fn vtk_long_long_array_insert_next_value( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - AT: core::ffi::c_float, - ); + f: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_transpose_3_x_3(self.0, A, AT) } + unsafe { vtk_long_long_array_insert_next_value(self.0, f) } } - fn transpose_3_x_3( + fn fast_down_cast( &mut self, - A: core::ffi::c_double, - AT: core::ffi::c_double, - ) -> () { + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_transpose_3_x_3( + fn vtk_long_long_array_fast_down_cast( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - AT: core::ffi::c_double, - ); + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_transpose_3_x_3(self.0, A, AT) } + unsafe { vtk_long_long_array_fast_down_cast(self.0, source) } } - fn invert_3_x_3(&mut self, A: core::ffi::c_float, AI: core::ffi::c_float) -> () { + fn get_data_type_value_min(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_invert_3_x_3( + fn vtk_long_long_array_get_data_type_value_min( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - AI: core::ffi::c_float, - ); + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_invert_3_x_3(self.0, A, AI) } + unsafe { vtk_long_long_array_get_data_type_value_min(self.0) } } - fn invert_3_x_3(&mut self, A: core::ffi::c_double, AI: core::ffi::c_double) -> () { + fn get_data_type_value_max(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_invert_3_x_3( + fn vtk_long_long_array_get_data_type_value_max( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - AI: core::ffi::c_double, - ); + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_invert_3_x_3(self.0, A, AI) } + unsafe { vtk_long_long_array_get_data_type_value_max(self.0) } } - fn identity_3_x_3(&mut self, A: core::ffi::c_float) -> () { +} +impl VtkLookupTable for vtkLookupTable { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_identity_3_x_3( + fn vtk_lookup_table_new( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_identity_3_x_3(self.0, A) } + unsafe { vtk_lookup_table_new(self.0) } } - fn identity_3_x_3(&mut self, A: core::ffi::c_double) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_identity_3_x_3( + fn vtk_lookup_table_safe_down_cast( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_identity_3_x_3(self.0, A) } + unsafe { vtk_lookup_table_safe_down_cast(self.0, o) } } - fn determinant_3_x_3(&mut self, A: core::ffi::c_float) -> core::ffi::c_double { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_determinant_3_x_3( + fn vtk_lookup_table_new_instance( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - ) -> core::ffi::c_double; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_determinant_3_x_3(self.0, A) } + unsafe { vtk_lookup_table_new_instance(self.0) } } - fn determinant_3_x_3(&mut self, A: core::ffi::c_double) -> core::ffi::c_double { + fn is_opaque(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_determinant_3_x_3( + fn vtk_lookup_table_is_opaque( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - ) -> core::ffi::c_double; + ) -> core::ffi::c_int; } - unsafe { vtk_math_determinant_3_x_3(self.0, A) } + unsafe { vtk_lookup_table_is_opaque(self.0) } } - fn determinant_3_x_3( + fn allocate( &mut self, - c1: core::ffi::c_float, - c2: core::ffi::c_float, - c3: core::ffi::c_float, - ) -> core::ffi::c_float { + sz: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_determinant_3_x_3( + fn vtk_lookup_table_allocate( sself: *mut core::ffi::c_void, - c1: core::ffi::c_float, - c2: core::ffi::c_float, - c3: core::ffi::c_float, - ) -> core::ffi::c_float; + sz: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> core::ffi::c_int; } - unsafe { vtk_math_determinant_3_x_3(self.0, c1, c2, c3) } + unsafe { vtk_lookup_table_allocate(self.0, sz, ext) } } - fn determinant_3_x_3( - &mut self, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - ) -> core::ffi::c_double { + fn build(&mut self) -> () { unsafe extern "C" { - fn vtk_math_determinant_3_x_3( - sself: *mut core::ffi::c_void, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - ) -> core::ffi::c_double; + fn vtk_lookup_table_build(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_determinant_3_x_3(self.0, c1, c2, c3) } + unsafe { vtk_lookup_table_build(self.0) } } - fn determinant_3_x_3( - &mut self, - a1: core::ffi::c_double, - a2: core::ffi::c_double, - a3: core::ffi::c_double, - b1: core::ffi::c_double, - b2: core::ffi::c_double, - b3: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - ) -> core::ffi::c_double { + fn force_build(&mut self) -> () { unsafe extern "C" { - fn vtk_math_determinant_3_x_3( - sself: *mut core::ffi::c_void, - a1: core::ffi::c_double, - a2: core::ffi::c_double, - a3: core::ffi::c_double, - b1: core::ffi::c_double, - b2: core::ffi::c_double, - b3: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - ) -> core::ffi::c_double; + fn vtk_lookup_table_force_build(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_determinant_3_x_3(self.0, a1, a2, a3, b1, b2, b3, c1, c2, c3) } + unsafe { vtk_lookup_table_force_build(self.0) } } - fn quaternion_to_matrix_3_x_3( - &mut self, - quat: core::ffi::c_float, - A: core::ffi::c_float, - ) -> () { + fn build_special_colors(&mut self) -> () { unsafe extern "C" { - fn vtk_math_quaternion_to_matrix_3_x_3( - sself: *mut core::ffi::c_void, - quat: core::ffi::c_float, - A: core::ffi::c_float, - ); + fn vtk_lookup_table_build_special_colors(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_quaternion_to_matrix_3_x_3(self.0, quat, A) } + unsafe { vtk_lookup_table_build_special_colors(self.0) } } - fn quaternion_to_matrix_3_x_3( - &mut self, - quat: core::ffi::c_double, - A: core::ffi::c_double, - ) -> () { + fn set_ramp(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_quaternion_to_matrix_3_x_3( + fn vtk_lookup_table_set_ramp( sself: *mut core::ffi::c_void, - quat: core::ffi::c_double, - A: core::ffi::c_double, + _arg: core::ffi::c_int, ); } - unsafe { vtk_math_quaternion_to_matrix_3_x_3(self.0, quat, A) } + unsafe { vtk_lookup_table_set_ramp(self.0, _arg) } } - fn matrix_3_x_3_to_quaternion( - &mut self, - A: core::ffi::c_float, - quat: core::ffi::c_float, - ) -> () { + fn set_ramp_to_linear(&mut self) -> () { unsafe extern "C" { - fn vtk_math_matrix_3_x_3_to_quaternion( - sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - quat: core::ffi::c_float, - ); + fn vtk_lookup_table_set_ramp_to_linear(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_matrix_3_x_3_to_quaternion(self.0, A, quat) } + unsafe { vtk_lookup_table_set_ramp_to_linear(self.0) } } - fn matrix_3_x_3_to_quaternion( - &mut self, - A: core::ffi::c_double, - quat: core::ffi::c_double, - ) -> () { + fn set_ramp_to_s_curve(&mut self) -> () { unsafe extern "C" { - fn vtk_math_matrix_3_x_3_to_quaternion( - sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - quat: core::ffi::c_double, - ); + fn vtk_lookup_table_set_ramp_to_s_curve(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_matrix_3_x_3_to_quaternion(self.0, A, quat) } + unsafe { vtk_lookup_table_set_ramp_to_s_curve(self.0) } } - fn multiply_quaternion( - &mut self, - q1: core::ffi::c_float, - q2: core::ffi::c_float, - q: core::ffi::c_float, - ) -> () { + fn set_ramp_to_sqrt(&mut self) -> () { unsafe extern "C" { - fn vtk_math_multiply_quaternion( - sself: *mut core::ffi::c_void, - q1: core::ffi::c_float, - q2: core::ffi::c_float, - q: core::ffi::c_float, - ); + fn vtk_lookup_table_set_ramp_to_sqrt(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_multiply_quaternion(self.0, q1, q2, q) } + unsafe { vtk_lookup_table_set_ramp_to_sqrt(self.0) } } - fn multiply_quaternion( - &mut self, - q1: core::ffi::c_double, - q2: core::ffi::c_double, - q: core::ffi::c_double, - ) -> () { + fn get_ramp(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_multiply_quaternion( + fn vtk_lookup_table_get_ramp( sself: *mut core::ffi::c_void, - q1: core::ffi::c_double, - q2: core::ffi::c_double, - q: core::ffi::c_double, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_math_multiply_quaternion(self.0, q1, q2, q) } + unsafe { vtk_lookup_table_get_ramp(self.0) } } - fn rotate_vector_by_normalized_quaternion( - &mut self, - v: core::ffi::c_float, - q: core::ffi::c_float, - r: core::ffi::c_float, - ) -> () { + fn set_scale(&mut self, scale: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_rotate_vector_by_normalized_quaternion( + fn vtk_lookup_table_set_scale( sself: *mut core::ffi::c_void, - v: core::ffi::c_float, - q: core::ffi::c_float, - r: core::ffi::c_float, + scale: core::ffi::c_int, ); } - unsafe { vtk_math_rotate_vector_by_normalized_quaternion(self.0, v, q, r) } + unsafe { vtk_lookup_table_set_scale(self.0, scale) } } - fn rotate_vector_by_normalized_quaternion( - &mut self, - v: core::ffi::c_double, - q: core::ffi::c_double, - r: core::ffi::c_double, - ) -> () { + fn set_scale_to_linear(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_scale_to_linear(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_scale_to_linear(self.0) } + } + fn set_scale_to_log_10(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_scale_to_log_10(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_scale_to_log_10(self.0) } + } + fn get_scale(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_rotate_vector_by_normalized_quaternion( + fn vtk_lookup_table_get_scale( sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - q: core::ffi::c_double, - r: core::ffi::c_double, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_math_rotate_vector_by_normalized_quaternion(self.0, v, q, r) } + unsafe { vtk_lookup_table_get_scale(self.0) } } - fn rotate_vector_by_wxyz( + fn set_table_range( &mut self, - v: core::ffi::c_float, - q: core::ffi::c_float, - r: core::ffi::c_float, + min: core::ffi::c_double, + max: core::ffi::c_double, ) -> () { unsafe extern "C" { - fn vtk_math_rotate_vector_by_wxyz( + fn vtk_lookup_table_set_table_range( sself: *mut core::ffi::c_void, - v: core::ffi::c_float, - q: core::ffi::c_float, - r: core::ffi::c_float, + min: core::ffi::c_double, + max: core::ffi::c_double, ); } - unsafe { vtk_math_rotate_vector_by_wxyz(self.0, v, q, r) } + unsafe { vtk_lookup_table_set_table_range(self.0, min, max) } } - fn rotate_vector_by_wxyz( + fn set_hue_range( &mut self, - v: core::ffi::c_double, - q: core::ffi::c_double, - r: core::ffi::c_double, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ) -> () { unsafe extern "C" { - fn vtk_math_rotate_vector_by_wxyz( + fn vtk_lookup_table_set_hue_range( sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - q: core::ffi::c_double, - r: core::ffi::c_double, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ); } - unsafe { vtk_math_rotate_vector_by_wxyz(self.0, v, q, r) } + unsafe { vtk_lookup_table_set_hue_range(self.0, _arg1, _arg2) } } - fn orthogonalize_3_x_3( + fn set_saturation_range( &mut self, - A: core::ffi::c_float, - B: core::ffi::c_float, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ) -> () { unsafe extern "C" { - fn vtk_math_orthogonalize_3_x_3( + fn vtk_lookup_table_set_saturation_range( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - B: core::ffi::c_float, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ); } - unsafe { vtk_math_orthogonalize_3_x_3(self.0, A, B) } + unsafe { vtk_lookup_table_set_saturation_range(self.0, _arg1, _arg2) } } - fn orthogonalize_3_x_3( + fn set_value_range( &mut self, - A: core::ffi::c_double, - B: core::ffi::c_double, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ) -> () { unsafe extern "C" { - fn vtk_math_orthogonalize_3_x_3( + fn vtk_lookup_table_set_value_range( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - B: core::ffi::c_double, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ); } - unsafe { vtk_math_orthogonalize_3_x_3(self.0, A, B) } + unsafe { vtk_lookup_table_set_value_range(self.0, _arg1, _arg2) } } - fn diagonalize_3_x_3( + fn set_alpha_range( &mut self, - A: core::ffi::c_float, - w: core::ffi::c_float, - V: core::ffi::c_float, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ) -> () { unsafe extern "C" { - fn vtk_math_diagonalize_3_x_3( + fn vtk_lookup_table_set_alpha_range( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - w: core::ffi::c_float, - V: core::ffi::c_float, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, ); } - unsafe { vtk_math_diagonalize_3_x_3(self.0, A, w, V) } + unsafe { vtk_lookup_table_set_alpha_range(self.0, _arg1, _arg2) } } - fn diagonalize_3_x_3( + fn set_nan_color( &mut self, - A: core::ffi::c_double, - w: core::ffi::c_double, - V: core::ffi::c_double, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, ) -> () { unsafe extern "C" { - fn vtk_math_diagonalize_3_x_3( + fn vtk_lookup_table_set_nan_color( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - w: core::ffi::c_double, - V: core::ffi::c_double, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, ); } - unsafe { vtk_math_diagonalize_3_x_3(self.0, A, w, V) } + unsafe { vtk_lookup_table_set_nan_color(self.0, _arg1, _arg2, _arg3, _arg4) } } - fn singular_value_decomposition_3_x_3( + fn set_below_range_color( &mut self, - A: core::ffi::c_float, - U: core::ffi::c_float, - w: core::ffi::c_float, - VT: core::ffi::c_float, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, ) -> () { unsafe extern "C" { - fn vtk_math_singular_value_decomposition_3_x_3( + fn vtk_lookup_table_set_below_range_color( sself: *mut core::ffi::c_void, - A: core::ffi::c_float, - U: core::ffi::c_float, - w: core::ffi::c_float, - VT: core::ffi::c_float, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, ); } - unsafe { vtk_math_singular_value_decomposition_3_x_3(self.0, A, U, w, VT) } + unsafe { + vtk_lookup_table_set_below_range_color(self.0, _arg1, _arg2, _arg3, _arg4) + } } - fn singular_value_decomposition_3_x_3( - &mut self, - A: core::ffi::c_double, - U: core::ffi::c_double, - w: core::ffi::c_double, - VT: core::ffi::c_double, - ) -> () { + fn set_use_below_range_color(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_singular_value_decomposition_3_x_3( + fn vtk_lookup_table_set_use_below_range_color( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - U: core::ffi::c_double, - w: core::ffi::c_double, - VT: core::ffi::c_double, + _arg: core::ffi::c_int, ); } - unsafe { vtk_math_singular_value_decomposition_3_x_3(self.0, A, U, w, VT) } + unsafe { vtk_lookup_table_set_use_below_range_color(self.0, _arg) } } - fn solve_linear_system_gepp_2_x_2( - &mut self, - a00: core::ffi::c_double, - a01: core::ffi::c_double, - a10: core::ffi::c_double, - a11: core::ffi::c_double, - b0: core::ffi::c_double, - b1: core::ffi::c_double, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - ) -> core::ffi::c_int { + fn get_use_below_range_color(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_solve_linear_system_gepp_2_x_2( + fn vtk_lookup_table_get_use_below_range_color( sself: *mut core::ffi::c_void, - a00: core::ffi::c_double, - a01: core::ffi::c_double, - a10: core::ffi::c_double, - a11: core::ffi::c_double, - b0: core::ffi::c_double, - b1: core::ffi::c_double, - x0: core::ffi::c_double, - x1: core::ffi::c_double, ) -> core::ffi::c_int; } - unsafe { - vtk_math_solve_linear_system_gepp_2_x_2( - self.0, - a00, - a01, - a10, - a11, - b0, - b1, - x0, - x1, - ) + unsafe { vtk_lookup_table_get_use_below_range_color(self.0) } + } + fn use_below_range_color_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_use_below_range_color_on(sself: *mut core::ffi::c_void); } + unsafe { vtk_lookup_table_use_below_range_color_on(self.0) } } - fn solve_linear_system( - &mut self, - A: core::ffi::c_double, - x: core::ffi::c_double, - size: core::ffi::c_int, - ) -> core::ffi::c_int { + fn use_below_range_color_off(&mut self) -> () { unsafe extern "C" { - fn vtk_math_solve_linear_system( - sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - x: core::ffi::c_double, - size: core::ffi::c_int, - ) -> core::ffi::c_int; + fn vtk_lookup_table_use_below_range_color_off(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_solve_linear_system(self.0, A, x, size) } + unsafe { vtk_lookup_table_use_below_range_color_off(self.0) } } - fn invert_matrix( + fn set_above_range_color( &mut self, - A: core::ffi::c_double, - AI: core::ffi::c_double, - size: core::ffi::c_int, - ) -> core::ffi::c_int { + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> () { unsafe extern "C" { - fn vtk_math_invert_matrix( + fn vtk_lookup_table_set_above_range_color( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - AI: core::ffi::c_double, - size: core::ffi::c_int, - ) -> core::ffi::c_int; + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ); + } + unsafe { + vtk_lookup_table_set_above_range_color(self.0, _arg1, _arg2, _arg3, _arg4) } - unsafe { vtk_math_invert_matrix(self.0, A, AI, size) } } - fn invert_matrix( - &mut self, - A: core::ffi::c_double, - AI: core::ffi::c_double, - size: core::ffi::c_int, - tmp1Size: core::ffi::c_int, - tmp2Size: core::ffi::c_double, - ) -> core::ffi::c_int { + fn set_use_above_range_color(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_invert_matrix( + fn vtk_lookup_table_set_use_above_range_color( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - AI: core::ffi::c_double, - size: core::ffi::c_int, - tmp1Size: core::ffi::c_int, - tmp2Size: core::ffi::c_double, - ) -> core::ffi::c_int; + _arg: core::ffi::c_int, + ); } - unsafe { vtk_math_invert_matrix(self.0, A, AI, size, tmp1Size, tmp2Size) } + unsafe { vtk_lookup_table_set_use_above_range_color(self.0, _arg) } } - fn lu_factor_linear_system( - &mut self, - A: core::ffi::c_double, - index: core::ffi::c_int, - size: core::ffi::c_int, - ) -> core::ffi::c_int { + fn get_use_above_range_color(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_lu_factor_linear_system( + fn vtk_lookup_table_get_use_above_range_color( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - index: core::ffi::c_int, - size: core::ffi::c_int, ) -> core::ffi::c_int; } - unsafe { vtk_math_lu_factor_linear_system(self.0, A, index, size) } + unsafe { vtk_lookup_table_get_use_above_range_color(self.0) } } - fn lu_factor_linear_system( - &mut self, - A: core::ffi::c_double, - index: core::ffi::c_int, - size: core::ffi::c_int, - tmpSize: core::ffi::c_double, - ) -> core::ffi::c_int { + fn use_above_range_color_on(&mut self) -> () { unsafe extern "C" { - fn vtk_math_lu_factor_linear_system( - sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - index: core::ffi::c_int, - size: core::ffi::c_int, - tmpSize: core::ffi::c_double, - ) -> core::ffi::c_int; + fn vtk_lookup_table_use_above_range_color_on(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_lu_factor_linear_system(self.0, A, index, size, tmpSize) } + unsafe { vtk_lookup_table_use_above_range_color_on(self.0) } } - fn lu_solve_linear_system( - &mut self, - A: core::ffi::c_double, - index: core::ffi::c_int, - x: core::ffi::c_double, - size: core::ffi::c_int, - ) -> () { + fn use_above_range_color_off(&mut self) -> () { unsafe extern "C" { - fn vtk_math_lu_solve_linear_system( - sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - index: core::ffi::c_int, - x: core::ffi::c_double, - size: core::ffi::c_int, - ); + fn vtk_lookup_table_use_above_range_color_off(sself: *mut core::ffi::c_void); } - unsafe { vtk_math_lu_solve_linear_system(self.0, A, index, x, size) } + unsafe { vtk_lookup_table_use_above_range_color_off(self.0) } } - fn estimate_matrix_condition( - &mut self, - A: core::ffi::c_double, - size: core::ffi::c_int, - ) -> core::ffi::c_double { + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_math_estimate_matrix_condition( + fn vtk_lookup_table_get_opacity( sself: *mut core::ffi::c_void, - A: core::ffi::c_double, - size: core::ffi::c_int, + v: core::ffi::c_double, ) -> core::ffi::c_double; } - unsafe { vtk_math_estimate_matrix_condition(self.0, A, size) } + unsafe { vtk_lookup_table_get_opacity(self.0, v) } } - fn jacobi( - &mut self, - a: core::ffi::c_float, - w: core::ffi::c_float, - v: core::ffi::c_float, - ) -> core::ffi::c_int { + fn get_index(&mut self, v: core::ffi::c_double) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_jacobi( + fn vtk_lookup_table_get_index( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - w: core::ffi::c_float, - v: core::ffi::c_float, - ) -> core::ffi::c_int; + v: core::ffi::c_double, + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_jacobi(self.0, a, w, v) } + unsafe { vtk_lookup_table_get_index(self.0, v) } } - fn jacobi( - &mut self, - a: core::ffi::c_double, - w: core::ffi::c_double, - v: core::ffi::c_double, - ) -> core::ffi::c_int { + fn set_number_of_table_values(&mut self, number: core::ffi::c_longlong) -> () { unsafe extern "C" { - fn vtk_math_jacobi( + fn vtk_lookup_table_set_number_of_table_values( sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - w: core::ffi::c_double, - v: core::ffi::c_double, - ) -> core::ffi::c_int; + number: core::ffi::c_longlong, + ); } - unsafe { vtk_math_jacobi(self.0, a, w, v) } + unsafe { vtk_lookup_table_set_number_of_table_values(self.0, number) } } - fn jacobi_n( - &mut self, - a: core::ffi::c_float, - n: core::ffi::c_int, - w: core::ffi::c_float, - v: core::ffi::c_float, - ) -> core::ffi::c_int { + fn get_number_of_table_values(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_jacobi_n( + fn vtk_lookup_table_get_number_of_table_values( sself: *mut core::ffi::c_void, - a: core::ffi::c_float, - n: core::ffi::c_int, - w: core::ffi::c_float, - v: core::ffi::c_float, - ) -> core::ffi::c_int; + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_jacobi_n(self.0, a, n, w, v) } + unsafe { vtk_lookup_table_get_number_of_table_values(self.0) } } - fn jacobi_n( + fn set_table_value( &mut self, + indx: core::ffi::c_longlong, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, a: core::ffi::c_double, - n: core::ffi::c_int, - w: core::ffi::c_double, - v: core::ffi::c_double, - ) -> core::ffi::c_int { + ) -> () { unsafe extern "C" { - fn vtk_math_jacobi_n( + fn vtk_lookup_table_set_table_value( sself: *mut core::ffi::c_void, + indx: core::ffi::c_longlong, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, a: core::ffi::c_double, - n: core::ffi::c_int, - w: core::ffi::c_double, - v: core::ffi::c_double, - ) -> core::ffi::c_int; + ); } - unsafe { vtk_math_jacobi_n(self.0, a, n, w, v) } + unsafe { vtk_lookup_table_set_table_value(self.0, indx, r, g, b, a) } } - fn solve_homogeneous_least_squares( - &mut self, - numberOfSamples: core::ffi::c_int, - xt: core::ffi::c_double, - xOrder: core::ffi::c_int, - mt: core::ffi::c_double, - ) -> core::ffi::c_int { + fn set_number_of_colors(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { - fn vtk_math_solve_homogeneous_least_squares( + fn vtk_lookup_table_set_number_of_colors( sself: *mut core::ffi::c_void, - numberOfSamples: core::ffi::c_int, - xt: core::ffi::c_double, - xOrder: core::ffi::c_int, - mt: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_math_solve_homogeneous_least_squares( - self.0, - numberOfSamples, - xt, - xOrder, - mt, - ) + _arg: core::ffi::c_longlong, + ); } + unsafe { vtk_lookup_table_set_number_of_colors(self.0, _arg) } } - fn solve_least_squares( - &mut self, - numberOfSamples: core::ffi::c_int, - xt: core::ffi::c_double, - xOrder: core::ffi::c_int, - yt: core::ffi::c_double, - yOrder: core::ffi::c_int, - mt: core::ffi::c_double, - checkHomogeneous: core::ffi::c_int, - ) -> core::ffi::c_int { + fn get_number_of_colors_min_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_solve_least_squares( + fn vtk_lookup_table_get_number_of_colors_min_value( sself: *mut core::ffi::c_void, - numberOfSamples: core::ffi::c_int, - xt: core::ffi::c_double, - xOrder: core::ffi::c_int, - yt: core::ffi::c_double, - yOrder: core::ffi::c_int, - mt: core::ffi::c_double, - checkHomogeneous: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_math_solve_least_squares( - self.0, - numberOfSamples, - xt, - xOrder, - yt, - yOrder, - mt, - checkHomogeneous, - ) + ) -> core::ffi::c_longlong; } + unsafe { vtk_lookup_table_get_number_of_colors_min_value(self.0) } } - fn rgb_to_hsv(&mut self, rgb: core::ffi::c_float, hsv: core::ffi::c_float) -> () { + fn get_number_of_colors_max_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_rgb_to_hsv( + fn vtk_lookup_table_get_number_of_colors_max_value( sself: *mut core::ffi::c_void, - rgb: core::ffi::c_float, - hsv: core::ffi::c_float, - ); + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_rgb_to_hsv(self.0, rgb, hsv) } + unsafe { vtk_lookup_table_get_number_of_colors_max_value(self.0) } } - fn rgb_to_hsv( - &mut self, - r: core::ffi::c_float, - g: core::ffi::c_float, - b: core::ffi::c_float, - h: core::ffi::c_float, - s: core::ffi::c_float, - v: core::ffi::c_float, - ) -> () { + fn get_number_of_colors(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_rgb_to_hsv( + fn vtk_lookup_table_get_number_of_colors( sself: *mut core::ffi::c_void, - r: core::ffi::c_float, - g: core::ffi::c_float, - b: core::ffi::c_float, - h: core::ffi::c_float, - s: core::ffi::c_float, - v: core::ffi::c_float, - ); + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_rgb_to_hsv(self.0, r, g, b, h, s, v) } + unsafe { vtk_lookup_table_get_number_of_colors(self.0) } } - fn rgb_to_hsv(&mut self, rgb: core::ffi::c_double, hsv: core::ffi::c_double) -> () { + fn set_table(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_math_rgb_to_hsv( + fn vtk_lookup_table_set_table( sself: *mut core::ffi::c_void, - rgb: core::ffi::c_double, - hsv: core::ffi::c_double, + p0: *mut core::ffi::c_void, ); } - unsafe { vtk_math_rgb_to_hsv(self.0, rgb, hsv) } + unsafe { vtk_lookup_table_set_table(self.0, p0) } } - fn rgb_to_hsv( - &mut self, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - h: core::ffi::c_double, - s: core::ffi::c_double, - v: core::ffi::c_double, - ) -> () { + fn get_table(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_rgb_to_hsv( + fn vtk_lookup_table_get_table( sself: *mut core::ffi::c_void, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - h: core::ffi::c_double, - s: core::ffi::c_double, - v: core::ffi::c_double, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lookup_table_get_table(self.0) } + } + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_lookup_table_deep_copy( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, ); } - unsafe { vtk_math_rgb_to_hsv(self.0, r, g, b, h, s, v) } + unsafe { vtk_lookup_table_deep_copy(self.0, obj) } } - fn hsv_to_rgb(&mut self, hsv: core::ffi::c_float, rgb: core::ffi::c_float) -> () { + fn using_log_scale(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_hsv_to_rgb( + fn vtk_lookup_table_using_log_scale( sself: *mut core::ffi::c_void, - hsv: core::ffi::c_float, - rgb: core::ffi::c_float, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_math_hsv_to_rgb(self.0, hsv, rgb) } + unsafe { vtk_lookup_table_using_log_scale(self.0) } } - fn hsv_to_rgb( - &mut self, - h: core::ffi::c_float, - s: core::ffi::c_float, - v: core::ffi::c_float, - r: core::ffi::c_float, - g: core::ffi::c_float, - b: core::ffi::c_float, - ) -> () { +} +impl VtkMath for vtkMath { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_hsv_to_rgb( - sself: *mut core::ffi::c_void, - h: core::ffi::c_float, - s: core::ffi::c_float, - v: core::ffi::c_float, - r: core::ffi::c_float, - g: core::ffi::c_float, - b: core::ffi::c_float, - ); + fn vtk_math_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; } - unsafe { vtk_math_hsv_to_rgb(self.0, h, s, v, r, g, b) } + unsafe { vtk_math_new(self.0) } } - fn hsv_to_rgb(&mut self, hsv: core::ffi::c_double, rgb: core::ffi::c_double) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_hsv_to_rgb( + fn vtk_math_safe_down_cast( sself: *mut core::ffi::c_void, - hsv: core::ffi::c_double, - rgb: core::ffi::c_double, - ); + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_math_hsv_to_rgb(self.0, hsv, rgb) } + unsafe { vtk_math_safe_down_cast(self.0, o) } } - fn hsv_to_rgb( - &mut self, - h: core::ffi::c_double, - s: core::ffi::c_double, - v: core::ffi::c_double, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - ) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_math_hsv_to_rgb( + fn vtk_math_new_instance( sself: *mut core::ffi::c_void, - h: core::ffi::c_double, - s: core::ffi::c_double, - v: core::ffi::c_double, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_math_new_instance(self.0) } + } + fn pi(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_pi(sself: *mut core::ffi::c_void) -> core::ffi::c_double; } - unsafe { vtk_math_hsv_to_rgb(self.0, h, s, v, r, g, b) } + unsafe { vtk_math_pi(self.0) } } - fn lab_to_xyz(&mut self, lab: core::ffi::c_double, xyz: core::ffi::c_double) -> () { + fn radians_from_degrees( + &mut self, + degrees: core::ffi::c_float, + ) -> core::ffi::c_float { unsafe extern "C" { - fn vtk_math_lab_to_xyz( + fn vtk_math_radians_from_degrees( sself: *mut core::ffi::c_void, - lab: core::ffi::c_double, - xyz: core::ffi::c_double, - ); + degrees: core::ffi::c_float, + ) -> core::ffi::c_float; } - unsafe { vtk_math_lab_to_xyz(self.0, lab, xyz) } + unsafe { vtk_math_radians_from_degrees(self.0, degrees) } } - fn lab_to_xyz( + fn degrees_from_radians( &mut self, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> () { + radians: core::ffi::c_float, + ) -> core::ffi::c_float { unsafe extern "C" { - fn vtk_math_lab_to_xyz( + fn vtk_math_degrees_from_radians( sself: *mut core::ffi::c_void, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ); + radians: core::ffi::c_float, + ) -> core::ffi::c_float; } - unsafe { vtk_math_lab_to_xyz(self.0, L, a, b, x, y, z) } + unsafe { vtk_math_degrees_from_radians(self.0, radians) } } - fn xyz_to_lab(&mut self, xyz: core::ffi::c_double, lab: core::ffi::c_double) -> () { + fn round(&mut self, f: core::ffi::c_float) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_xyz_to_lab( + fn vtk_math_round( sself: *mut core::ffi::c_void, - xyz: core::ffi::c_double, - lab: core::ffi::c_double, - ); + f: core::ffi::c_float, + ) -> core::ffi::c_int; } - unsafe { vtk_math_xyz_to_lab(self.0, xyz, lab) } + unsafe { vtk_math_round(self.0, f) } } - fn xyz_to_lab( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - ) -> () { + fn floor(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_xyz_to_lab( + fn vtk_math_floor( sself: *mut core::ffi::c_void, x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_math_xyz_to_lab(self.0, x, y, z, L, a, b) } + unsafe { vtk_math_floor(self.0, x) } } - fn xyz_to_rgb(&mut self, xyz: core::ffi::c_double, rgb: core::ffi::c_double) -> () { + fn ceil(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_xyz_to_rgb( + fn vtk_math_ceil( sself: *mut core::ffi::c_void, - xyz: core::ffi::c_double, - rgb: core::ffi::c_double, - ); + x: core::ffi::c_double, + ) -> core::ffi::c_int; } - unsafe { vtk_math_xyz_to_rgb(self.0, xyz, rgb) } + unsafe { vtk_math_ceil(self.0, x) } } - fn xyz_to_rgb( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - ) -> () { + fn ceil_log_2(&mut self, x: core::ffi::c_ulonglong) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_xyz_to_rgb( + fn vtk_math_ceil_log_2( sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - ); + x: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; } - unsafe { vtk_math_xyz_to_rgb(self.0, x, y, z, r, g, b) } + unsafe { vtk_math_ceil_log_2(self.0, x) } } - fn rgb_to_xyz(&mut self, rgb: core::ffi::c_double, xyz: core::ffi::c_double) -> () { + fn is_power_of_two(&mut self, x: core::ffi::c_ulonglong) -> bool { unsafe extern "C" { - fn vtk_math_rgb_to_xyz( + fn vtk_math_is_power_of_two( sself: *mut core::ffi::c_void, - rgb: core::ffi::c_double, - xyz: core::ffi::c_double, - ); + x: core::ffi::c_ulonglong, + ) -> bool; } - unsafe { vtk_math_rgb_to_xyz(self.0, rgb, xyz) } + unsafe { vtk_math_is_power_of_two(self.0, x) } } - fn rgb_to_xyz( - &mut self, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> () { + fn nearest_power_of_two(&mut self, x: core::ffi::c_int) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_rgb_to_xyz( + fn vtk_math_nearest_power_of_two( sself: *mut core::ffi::c_void, - r: core::ffi::c_double, - g: core::ffi::c_double, - b: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ); + x: core::ffi::c_int, + ) -> core::ffi::c_int; } - unsafe { vtk_math_rgb_to_xyz(self.0, r, g, b, x, y, z) } + unsafe { vtk_math_nearest_power_of_two(self.0, x) } } - fn rgb_to_lab(&mut self, rgb: core::ffi::c_double, lab: core::ffi::c_double) -> () { + fn factorial(&mut self, N: core::ffi::c_int) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_rgb_to_lab( + fn vtk_math_factorial( sself: *mut core::ffi::c_void, - rgb: core::ffi::c_double, - lab: core::ffi::c_double, - ); + N: core::ffi::c_int, + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_rgb_to_lab(self.0, rgb, lab) } + unsafe { vtk_math_factorial(self.0, N) } } - fn rgb_to_lab( + fn binomial( &mut self, - red: core::ffi::c_double, - green: core::ffi::c_double, - blue: core::ffi::c_double, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - ) -> () { + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_math_rgb_to_lab( + fn vtk_math_binomial( sself: *mut core::ffi::c_void, - red: core::ffi::c_double, - green: core::ffi::c_double, - blue: core::ffi::c_double, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - ); + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_longlong; } - unsafe { vtk_math_rgb_to_lab(self.0, red, green, blue, L, a, b) } + unsafe { vtk_math_binomial(self.0, m, n) } } - fn lab_to_rgb(&mut self, lab: core::ffi::c_double, rgb: core::ffi::c_double) -> () { + fn random_seed(&mut self, s: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_math_lab_to_rgb( - sself: *mut core::ffi::c_void, - lab: core::ffi::c_double, - rgb: core::ffi::c_double, - ); + fn vtk_math_random_seed(sself: *mut core::ffi::c_void, s: core::ffi::c_int); } - unsafe { vtk_math_lab_to_rgb(self.0, lab, rgb) } + unsafe { vtk_math_random_seed(self.0, s) } } - fn lab_to_rgb( - &mut self, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - red: core::ffi::c_double, - green: core::ffi::c_double, - blue: core::ffi::c_double, - ) -> () { + fn get_seed(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_lab_to_rgb( - sself: *mut core::ffi::c_void, - L: core::ffi::c_double, - a: core::ffi::c_double, - b: core::ffi::c_double, - red: core::ffi::c_double, - green: core::ffi::c_double, - blue: core::ffi::c_double, - ); + fn vtk_math_get_seed(sself: *mut core::ffi::c_void) -> core::ffi::c_int; } - unsafe { vtk_math_lab_to_rgb(self.0, L, a, b, red, green, blue) } + unsafe { vtk_math_get_seed(self.0) } } - fn uninitialize_bounds(&mut self, bounds: core::ffi::c_double) -> () { + fn random(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_math_uninitialize_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); + fn vtk_math_random(sself: *mut core::ffi::c_void) -> core::ffi::c_double; } - unsafe { vtk_math_uninitialize_bounds(self.0, bounds) } + unsafe { vtk_math_random(self.0) } } - fn are_bounds_initialized( - &mut self, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int { + fn gaussian(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_math_are_bounds_initialized( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; + fn vtk_math_gaussian(sself: *mut core::ffi::c_void) -> core::ffi::c_double; } - unsafe { vtk_math_are_bounds_initialized(self.0, bounds) } + unsafe { vtk_math_gaussian(self.0) } } - fn clamp_value( + fn gaussian_amplitude( &mut self, - value: core::ffi::c_double, - range: core::ffi::c_double, - ) -> () { + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_math_clamp_value( + fn vtk_math_gaussian_amplitude( sself: *mut core::ffi::c_void, - value: core::ffi::c_double, - range: core::ffi::c_double, - ); + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; } - unsafe { vtk_math_clamp_value(self.0, value, range) } + unsafe { vtk_math_gaussian_amplitude(self.0, variance, distanceFromMean) } } - fn clamp_value( + fn gaussian_weight( &mut self, - value: core::ffi::c_double, - range: core::ffi::c_double, - clamped_value: core::ffi::c_double, - ) -> () { + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_math_clamp_value( + fn vtk_math_gaussian_weight( sself: *mut core::ffi::c_void, - value: core::ffi::c_double, - range: core::ffi::c_double, - clamped_value: core::ffi::c_double, - ); + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; } - unsafe { vtk_math_clamp_value(self.0, value, range, clamped_value) } + unsafe { vtk_math_gaussian_weight(self.0, variance, distanceFromMean) } } - fn clamp_values( + fn determinant_2_x_2( &mut self, - values: core::ffi::c_double, - nb_values: core::ffi::c_int, - range: core::ffi::c_double, - ) -> () { + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + d: core::ffi::c_double, + ) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_math_clamp_values( + fn vtk_math_determinant_2_x_2( sself: *mut core::ffi::c_void, - values: core::ffi::c_double, - nb_values: core::ffi::c_int, - range: core::ffi::c_double, - ); + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + d: core::ffi::c_double, + ) -> core::ffi::c_double; } - unsafe { vtk_math_clamp_values(self.0, values, nb_values, range) } + unsafe { vtk_math_determinant_2_x_2(self.0, a, b, c, d) } } - fn clamp_values( + fn determinant_3_x_3( &mut self, - values: core::ffi::c_double, - nb_values: core::ffi::c_int, - range: core::ffi::c_double, - clamped_values: core::ffi::c_double, - ) -> () { + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + b1: core::ffi::c_double, + b2: core::ffi::c_double, + b3: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_math_clamp_values( + fn vtk_math_determinant_3_x_3( sself: *mut core::ffi::c_void, - values: core::ffi::c_double, - nb_values: core::ffi::c_int, - range: core::ffi::c_double, - clamped_values: core::ffi::c_double, - ); - } - unsafe { - vtk_math_clamp_values(self.0, values, nb_values, range, clamped_values) + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + b1: core::ffi::c_double, + b2: core::ffi::c_double, + b3: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double; } + unsafe { vtk_math_determinant_3_x_3(self.0, a1, a2, a3, b1, b2, b3, c1, c2, c3) } } - fn clamp_and_normalize_value( + fn solve_linear_system_gepp_2_x_2( &mut self, - value: core::ffi::c_double, - range: core::ffi::c_double, - ) -> core::ffi::c_double { + a00: core::ffi::c_double, + a01: core::ffi::c_double, + a10: core::ffi::c_double, + a11: core::ffi::c_double, + b0: core::ffi::c_double, + b1: core::ffi::c_double, + x0: &mut core::ffi::c_double, + x1: &mut core::ffi::c_double, + ) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_math_clamp_and_normalize_value( + fn vtk_math_solve_linear_system_gepp_2_x_2( sself: *mut core::ffi::c_void, - value: core::ffi::c_double, - range: core::ffi::c_double, - ) -> core::ffi::c_double; + a00: core::ffi::c_double, + a01: core::ffi::c_double, + a10: core::ffi::c_double, + a11: core::ffi::c_double, + b0: core::ffi::c_double, + b1: core::ffi::c_double, + x0: &mut core::ffi::c_double, + x1: &mut core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_math_solve_linear_system_gepp_2_x_2( + self.0, + a00, + a01, + a10, + a11, + b0, + b1, + x0, + x1, + ) } - unsafe { vtk_math_clamp_and_normalize_value(self.0, value, range) } } fn get_scalar_type_fitting_range( &mut self, @@ -16642,104 +6935,6 @@ impl VtkMath for vtkMath { ) } } - fn get_adjusted_scalar_range( - &mut self, - array: *mut core::ffi::c_void, - comp: core::ffi::c_int, - range: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_math_get_adjusted_scalar_range( - sself: *mut core::ffi::c_void, - array: *mut core::ffi::c_void, - comp: core::ffi::c_int, - range: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_math_get_adjusted_scalar_range(self.0, array, comp, range) } - } - fn extent_is_within_other_extent( - &mut self, - extent1: core::ffi::c_int, - extent2: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_math_extent_is_within_other_extent( - sself: *mut core::ffi::c_void, - extent1: core::ffi::c_int, - extent2: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_math_extent_is_within_other_extent(self.0, extent1, extent2) } - } - fn bounds_is_within_other_bounds( - &mut self, - bounds1: core::ffi::c_double, - bounds2: core::ffi::c_double, - delta: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_math_bounds_is_within_other_bounds( - sself: *mut core::ffi::c_void, - bounds1: core::ffi::c_double, - bounds2: core::ffi::c_double, - delta: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_math_bounds_is_within_other_bounds(self.0, bounds1, bounds2, delta) - } - } - fn point_is_within_bounds( - &mut self, - point: core::ffi::c_double, - bounds: core::ffi::c_double, - delta: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_math_point_is_within_bounds( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - bounds: core::ffi::c_double, - delta: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_math_point_is_within_bounds(self.0, point, bounds, delta) } - } - fn plane_intersects_aabb( - &mut self, - bounds: core::ffi::c_double, - normal: core::ffi::c_double, - point: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_math_plane_intersects_aabb( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - normal: core::ffi::c_double, - point: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_math_plane_intersects_aabb(self.0, bounds, normal, point) } - } - fn solve_3_point_circle( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_math_solve_3_point_circle( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_math_solve_3_point_circle(self.0, p1, p2, p3, center) } - } fn inf(&mut self) -> core::ffi::c_double { unsafe extern "C" { fn vtk_math_inf(sself: *mut core::ffi::c_void) -> core::ffi::c_double; @@ -16785,28 +6980,6 @@ impl VtkMath for vtkMath { } unsafe { vtk_math_is_finite(self.0, x) } } - fn quadratic_root( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - min: core::ffi::c_double, - max: core::ffi::c_double, - u: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_math_quadratic_root( - sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - min: core::ffi::c_double, - max: core::ffi::c_double, - u: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_math_quadratic_root(self.0, a, b, c, min, max, u) } - } } impl VtkMersenneTwister for vtkMersenneTwister { fn new(&mut self) -> *mut core::ffi::c_void { @@ -16882,14 +7055,6 @@ impl VtkMersenneTwister for vtkMersenneTwister { } unsafe { vtk_mersenne_twister_get_value(self.0, id) } } - fn get_value(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_mersenne_twister_get_value( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_mersenne_twister_get_value(self.0) } - } fn next(&mut self, id: core::ffi::c_uint) -> () { unsafe extern "C" { fn vtk_mersenne_twister_next( @@ -16899,12 +7064,6 @@ impl VtkMersenneTwister for vtkMersenneTwister { } unsafe { vtk_mersenne_twister_next(self.0, id) } } - fn next(&mut self) -> () { - unsafe extern "C" { - fn vtk_mersenne_twister_next(sself: *mut core::ffi::c_void); - } - unsafe { vtk_mersenne_twister_next(self.0) } - } } impl VtkMinimalStandardRandomSequence for vtkMinimalStandardRandomSequence { fn new(&mut self) -> *mut core::ffi::c_void { @@ -17135,46 +7294,6 @@ impl VtkMultiThreader for vtkMultiThreader { } unsafe { vtk_multi_threader_multiple_method_execute(self.0) } } - fn set_single_method(&mut self, p0: *mut core::ffi::c_void, data: ()) -> () { - unsafe extern "C" { - fn vtk_multi_threader_set_single_method( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - data: (), - ); - } - unsafe { vtk_multi_threader_set_single_method(self.0, p0, data) } - } - fn set_multiple_method( - &mut self, - index: core::ffi::c_int, - p1: *mut core::ffi::c_void, - data: (), - ) -> () { - unsafe extern "C" { - fn vtk_multi_threader_set_multiple_method( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - p1: *mut core::ffi::c_void, - data: (), - ); - } - unsafe { vtk_multi_threader_set_multiple_method(self.0, index, p1, data) } - } - fn spawn_thread( - &mut self, - p0: *mut core::ffi::c_void, - data: (), - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_multi_threader_spawn_thread( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - data: (), - ) -> core::ffi::c_int; - } - unsafe { vtk_multi_threader_spawn_thread(self.0, p0, data) } - } fn terminate_thread(&mut self, threadId: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_multi_threader_terminate_thread( @@ -17193,47 +7312,27 @@ impl VtkMultiThreader for vtkMultiThreader { } unsafe { vtk_multi_threader_is_thread_active(self.0, threadId) } } - fn get_current_thread_id(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_multi_threader_get_current_thread_id( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_multi_threader_get_current_thread_id(self.0) } - } - fn threads_equal( - &mut self, - t1: *mut core::ffi::c_void, - t2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_multi_threader_threads_equal( - sself: *mut core::ffi::c_void, - t1: *mut core::ffi::c_void, - t2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_multi_threader_threads_equal(self.0, t1, t2) } - } } impl VtkObject for vtkObject { - fn is_type_of(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); unsafe extern "C" { fn vtk_object_is_type_of( sself: *mut core::ffi::c_void, - type_: core::ffi::c_char, + type_: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_object_is_type_of(self.0, type_) } + unsafe { vtk_object_is_type_of(self.0, c_type.as_ptr()) } } - fn is_a(&mut self, type_: core::ffi::c_char) -> core::ffi::c_int { + fn is_a(&mut self, type_: &str) -> core::ffi::c_int { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); unsafe extern "C" { fn vtk_object_is_a( sself: *mut core::ffi::c_void, - type_: core::ffi::c_char, + type_: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_object_is_a(self.0, type_) } + unsafe { vtk_object_is_a(self.0, c_type.as_ptr()) } } fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -17254,27 +7353,33 @@ impl VtkObject for vtkObject { } fn get_number_of_generations_from_base_type( &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar { + type_: &str, + ) -> core::ffi::c_longlong { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); unsafe extern "C" { fn vtk_object_get_number_of_generations_from_base_type( sself: *mut core::ffi::c_void, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; + type_: *const core::ffi::c_char, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_object_get_number_of_generations_from_base_type(self.0, c_type.as_ptr()) } - unsafe { vtk_object_get_number_of_generations_from_base_type(self.0, type_) } } fn get_number_of_generations_from_base( &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar { + type_: &str, + ) -> core::ffi::c_longlong { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); unsafe extern "C" { fn vtk_object_get_number_of_generations_from_base( sself: *mut core::ffi::c_void, - type_: core::ffi::c_char, - ) -> core::ffi::c_uchar; + type_: *const core::ffi::c_char, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_object_get_number_of_generations_from_base(self.0, c_type.as_ptr()) } - unsafe { vtk_object_get_number_of_generations_from_base(self.0, type_) } } fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -17371,22 +7476,6 @@ impl VtkObject for vtkObject { } unsafe { vtk_object_add_observer(self.0, event, p1, priority) } } - fn add_observer( - &mut self, - event: core::ffi::c_char, - p1: *mut core::ffi::c_void, - priority: core::ffi::c_float, - ) -> core::ffi::c_ulong { - unsafe extern "C" { - fn vtk_object_add_observer( - sself: *mut core::ffi::c_void, - event: core::ffi::c_char, - p1: *mut core::ffi::c_void, - priority: core::ffi::c_float, - ) -> core::ffi::c_ulong; - } - unsafe { vtk_object_add_observer(self.0, event, p1, priority) } - } fn get_command(&mut self, tag: core::ffi::c_ulong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_object_get_command( @@ -17415,148 +7504,29 @@ impl VtkObject for vtkObject { sself: *mut core::ffi::c_void, event: core::ffi::c_ulong, p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_object_remove_observers(self.0, event, p1) } - } - fn remove_observers( - &mut self, - event: core::ffi::c_char, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_object_remove_observers( - sself: *mut core::ffi::c_void, - event: core::ffi::c_char, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_object_remove_observers(self.0, event, p1) } - } - fn has_observer( - &mut self, - event: core::ffi::c_ulong, - p1: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_object_has_observer( - sself: *mut core::ffi::c_void, - event: core::ffi::c_ulong, - p1: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_object_has_observer(self.0, event, p1) } - } - fn has_observer( - &mut self, - event: core::ffi::c_char, - p1: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_object_has_observer( - sself: *mut core::ffi::c_void, - event: core::ffi::c_char, - p1: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_object_has_observer(self.0, event, p1) } - } - fn remove_observer(&mut self, tag: core::ffi::c_ulong) -> () { - unsafe extern "C" { - fn vtk_object_remove_observer( - sself: *mut core::ffi::c_void, - tag: core::ffi::c_ulong, - ); - } - unsafe { vtk_object_remove_observer(self.0, tag) } - } - fn remove_observers(&mut self, event: core::ffi::c_ulong) -> () { - unsafe extern "C" { - fn vtk_object_remove_observers( - sself: *mut core::ffi::c_void, - event: core::ffi::c_ulong, - ); - } - unsafe { vtk_object_remove_observers(self.0, event) } - } - fn remove_observers(&mut self, event: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_object_remove_observers( - sself: *mut core::ffi::c_void, - event: core::ffi::c_char, - ); - } - unsafe { vtk_object_remove_observers(self.0, event) } - } - fn remove_all_observers(&mut self) -> () { - unsafe extern "C" { - fn vtk_object_remove_all_observers(sself: *mut core::ffi::c_void); - } - unsafe { vtk_object_remove_all_observers(self.0) } - } - fn has_observer(&mut self, event: core::ffi::c_ulong) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_object_has_observer( - sself: *mut core::ffi::c_void, - event: core::ffi::c_ulong, - ) -> core::ffi::c_int; - } - unsafe { vtk_object_has_observer(self.0, event) } - } - fn has_observer(&mut self, event: core::ffi::c_char) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_object_has_observer( - sself: *mut core::ffi::c_void, - event: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { vtk_object_has_observer(self.0, event) } - } - fn invoke_event( - &mut self, - event: core::ffi::c_ulong, - callData: (), - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_object_invoke_event( - sself: *mut core::ffi::c_void, - event: core::ffi::c_ulong, - callData: (), - ) -> core::ffi::c_int; + ); } - unsafe { vtk_object_invoke_event(self.0, event, callData) } + unsafe { vtk_object_remove_observers(self.0, event, p1) } } - fn invoke_event( + fn has_observer( &mut self, - event: core::ffi::c_char, - callData: (), + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, ) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_object_invoke_event( - sself: *mut core::ffi::c_void, - event: core::ffi::c_char, - callData: (), - ) -> core::ffi::c_int; - } - unsafe { vtk_object_invoke_event(self.0, event, callData) } - } - fn invoke_event(&mut self, event: core::ffi::c_ulong) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_object_invoke_event( + fn vtk_object_has_observer( sself: *mut core::ffi::c_void, event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, ) -> core::ffi::c_int; } - unsafe { vtk_object_invoke_event(self.0, event) } + unsafe { vtk_object_has_observer(self.0, event, p1) } } - fn invoke_event(&mut self, event: core::ffi::c_char) -> core::ffi::c_int { + fn remove_all_observers(&mut self) -> () { unsafe extern "C" { - fn vtk_object_invoke_event( - sself: *mut core::ffi::c_void, - event: core::ffi::c_char, - ) -> core::ffi::c_int; + fn vtk_object_remove_all_observers(sself: *mut core::ffi::c_void); } - unsafe { vtk_object_invoke_event(self.0, event) } + unsafe { vtk_object_remove_all_observers(self.0) } } } impl VtkObjectFactoryCollection for vtkObjectFactoryCollection { @@ -17602,15 +7572,6 @@ impl VtkObjectFactoryCollection for vtkObjectFactoryCollection { } unsafe { vtk_object_factory_collection_get_next_item(self.0) } } - fn get_next_object_factory(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_object_factory_collection_get_next_object_factory( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_object_factory_collection_get_next_object_factory(self.0, cookie) } - } } impl VtkOldStyleCallbackCommand for vtkOldStyleCallbackCommand { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -17638,31 +7599,6 @@ impl VtkOldStyleCallbackCommand for vtkOldStyleCallbackCommand { } unsafe { vtk_old_style_callback_command_new(self.0) } } - fn execute( - &mut self, - invoker: *mut core::ffi::c_void, - eid: core::ffi::c_ulong, - calldata: (), - ) -> () { - unsafe extern "C" { - fn vtk_old_style_callback_command_execute( - sself: *mut core::ffi::c_void, - invoker: *mut core::ffi::c_void, - eid: core::ffi::c_ulong, - calldata: (), - ); - } - unsafe { vtk_old_style_callback_command_execute(self.0, invoker, eid, calldata) } - } - fn set_client_data(&mut self, cd: ()) -> () { - unsafe extern "C" { - fn vtk_old_style_callback_command_set_client_data( - sself: *mut core::ffi::c_void, - cd: (), - ); - } - unsafe { vtk_old_style_callback_command_set_client_data(self.0, cd) } - } fn set_callback(&mut self, f: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_old_style_callback_command_set_callback( @@ -17727,50 +7663,55 @@ impl VtkOutputWindow for vtkOutputWindow { } unsafe { vtk_output_window_set_instance(self.0, instance) } } - fn display_text(&mut self, p0: core::ffi::c_char) -> () { + fn display_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); unsafe extern "C" { fn vtk_output_window_display_text( sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, + p0: *const core::ffi::c_char, ); } - unsafe { vtk_output_window_display_text(self.0, p0) } + unsafe { vtk_output_window_display_text(self.0, c_p0.as_ptr()) } } - fn display_error_text(&mut self, p0: core::ffi::c_char) -> () { + fn display_error_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); unsafe extern "C" { fn vtk_output_window_display_error_text( sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, + p0: *const core::ffi::c_char, ); } - unsafe { vtk_output_window_display_error_text(self.0, p0) } + unsafe { vtk_output_window_display_error_text(self.0, c_p0.as_ptr()) } } - fn display_warning_text(&mut self, p0: core::ffi::c_char) -> () { + fn display_warning_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); unsafe extern "C" { fn vtk_output_window_display_warning_text( sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, + p0: *const core::ffi::c_char, ); } - unsafe { vtk_output_window_display_warning_text(self.0, p0) } + unsafe { vtk_output_window_display_warning_text(self.0, c_p0.as_ptr()) } } - fn display_generic_warning_text(&mut self, p0: core::ffi::c_char) -> () { + fn display_generic_warning_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); unsafe extern "C" { fn vtk_output_window_display_generic_warning_text( sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, + p0: *const core::ffi::c_char, ); } - unsafe { vtk_output_window_display_generic_warning_text(self.0, p0) } + unsafe { vtk_output_window_display_generic_warning_text(self.0, c_p0.as_ptr()) } } - fn display_debug_text(&mut self, p0: core::ffi::c_char) -> () { + fn display_debug_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); unsafe extern "C" { fn vtk_output_window_display_debug_text( sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, + p0: *const core::ffi::c_char, ); } - unsafe { vtk_output_window_display_debug_text(self.0, p0) } + unsafe { vtk_output_window_display_debug_text(self.0, c_p0.as_ptr()) } } fn prompt_user_on(&mut self) -> () { unsafe extern "C" { @@ -17935,20 +7876,6 @@ impl VtkOverrideInformationCollection for vtkOverrideInformationCollection { } unsafe { vtk_override_information_collection_get_next_item(self.0) } } - fn get_next_override_information(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_override_information_collection_get_next_override_information( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { - vtk_override_information_collection_get_next_override_information( - self.0, - cookie, - ) - } - } } impl VtkPoints for vtkPoints { fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void { @@ -17960,12 +7887,6 @@ impl VtkPoints for vtkPoints { } unsafe { vtk_points_new(self.0, dataType) } } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_points_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtk_points_new(self.0) } - } fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_points_safe_down_cast( @@ -17985,14 +7906,14 @@ impl VtkPoints for vtkPoints { } fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_points_allocate( sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_points_allocate(self.0, sz, ext) } @@ -18103,15 +8024,6 @@ impl VtkPoints for vtkPoints { } unsafe { vtk_points_set_data_type_to_double(self.0) } } - fn get_void_pointer(&mut self, id: core::ffi::c_int) -> *mut () { - unsafe extern "C" { - fn vtk_points_get_void_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - ) -> *mut (); - } - unsafe { vtk_points_get_void_pointer(self.0, id) } - } fn squeeze(&mut self) -> () { unsafe extern "C" { fn vtk_points_squeeze(sself: *mut core::ffi::c_void); @@ -18150,56 +8062,17 @@ impl VtkPoints for vtkPoints { } unsafe { vtk_points_get_actual_memory_size(self.0) } } - fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_points_get_number_of_points( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_points_get_number_of_points(self.0) } } - fn get_point(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_points_get_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_points_get_point(self.0, id) } - } - fn get_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_points_get_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - ); - } - unsafe { vtk_points_get_point(self.0, id, x) } - } - fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_points_set_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_float, - ); - } - unsafe { vtk_points_set_point(self.0, id, x) } - } - fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_points_set_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - ); - } - unsafe { vtk_points_set_point(self.0, id, x) } - } fn set_point( &mut self, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, @@ -18207,7 +8080,7 @@ impl VtkPoints for vtkPoints { unsafe extern "C" { fn vtk_points_set_point( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, @@ -18215,29 +8088,9 @@ impl VtkPoints for vtkPoints { } unsafe { vtk_points_set_point(self.0, id, x, y, z) } } - fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_points_insert_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_float, - ); - } - unsafe { vtk_points_insert_point(self.0, id, x) } - } - fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_points_insert_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - ); - } - unsafe { vtk_points_insert_point(self.0, id, x) } - } fn insert_point( &mut self, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, @@ -18245,7 +8098,7 @@ impl VtkPoints for vtkPoints { unsafe extern "C" { fn vtk_points_insert_point( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, @@ -18269,72 +8122,36 @@ impl VtkPoints for vtkPoints { } unsafe { vtk_points_insert_points(self.0, dstIds, srcIds, source) } } - fn insert_points( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_points_insert_points( - sself: *mut core::ffi::c_void, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ); - } - unsafe { vtk_points_insert_points(self.0, dstStart, n, srcStart, source) } - } - fn insert_next_point(&mut self, x: core::ffi::c_float) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_points_insert_next_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_float, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_points_insert_next_point(self.0, x) } - } - fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_points_insert_next_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_points_insert_next_point(self.0, x) } - } fn insert_next_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_points_insert_next_point( sself: *mut core::ffi::c_void, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_points_insert_next_point(self.0, x, y, z) } } - fn set_number_of_points(&mut self, numPoints: core::ffi::c_uchar) -> () { + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_points_set_number_of_points( sself: *mut core::ffi::c_void, - numPoints: core::ffi::c_uchar, + numPoints: core::ffi::c_longlong, ); } unsafe { vtk_points_set_number_of_points(self.0, numPoints) } } - fn resize(&mut self, numPoints: core::ffi::c_uchar) -> core::ffi::c_int { + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_points_resize( sself: *mut core::ffi::c_void, - numPoints: core::ffi::c_uchar, + numPoints: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_points_resize(self.0, numPoints) } @@ -18359,23 +8176,6 @@ impl VtkPoints for vtkPoints { } unsafe { vtk_points_compute_bounds(self.0) } } - fn get_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_points_get_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_points_get_bounds(self.0) } - } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_points_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_points_get_bounds(self.0, bounds) } - } fn get_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_points_get_m_time( @@ -18401,14 +8201,6 @@ impl VtkPoints2D for vtkPoints2D { } unsafe { vtk_points_2_d_new(self.0, dataType) } } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_points_2_d_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_points_2_d_new(self.0) } - } fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_points_2_d_safe_down_cast( @@ -18428,14 +8220,14 @@ impl VtkPoints2D for vtkPoints2D { } fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_points_2_d_allocate( sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_points_2_d_allocate(self.0, sz, ext) } @@ -18554,15 +8346,6 @@ impl VtkPoints2D for vtkPoints2D { } unsafe { vtk_points_2_d_set_data_type_to_double(self.0) } } - fn get_void_pointer(&mut self, id: core::ffi::c_int) -> *mut () { - unsafe extern "C" { - fn vtk_points_2_d_get_void_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - ) -> *mut (); - } - unsafe { vtk_points_2_d_get_void_pointer(self.0, id) } - } fn squeeze(&mut self) -> () { unsafe extern "C" { fn vtk_points_2_d_squeeze(sself: *mut core::ffi::c_void); @@ -18601,160 +8384,83 @@ impl VtkPoints2D for vtkPoints2D { } unsafe { vtk_points_2_d_get_actual_memory_size(self.0) } } - fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_points_2_d_get_number_of_points( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_points_2_d_get_number_of_points(self.0) } } - fn get_point(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_points_2_d_get_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_points_2_d_get_point(self.0, id) } - } - fn get_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_points_2_d_get_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - ); - } - unsafe { vtk_points_2_d_get_point(self.0, id, x) } - } - fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_points_2_d_set_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_float, - ); - } - unsafe { vtk_points_2_d_set_point(self.0, id, x) } - } - fn set_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_points_2_d_set_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - ); - } - unsafe { vtk_points_2_d_set_point(self.0, id, x) } - } fn set_point( &mut self, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, ) -> () { unsafe extern "C" { fn vtk_points_2_d_set_point( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, ); } unsafe { vtk_points_2_d_set_point(self.0, id, x, y) } } - fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_points_2_d_insert_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_float, - ); - } - unsafe { vtk_points_2_d_insert_point(self.0, id, x) } - } - fn insert_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_points_2_d_insert_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - ); - } - unsafe { vtk_points_2_d_insert_point(self.0, id, x) } - } fn insert_point( &mut self, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, ) -> () { unsafe extern "C" { fn vtk_points_2_d_insert_point( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, ); } unsafe { vtk_points_2_d_insert_point(self.0, id, x, y) } } - fn insert_next_point(&mut self, x: core::ffi::c_float) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_points_2_d_insert_next_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_float, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_points_2_d_insert_next_point(self.0, x) } - } - fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_points_2_d_insert_next_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_points_2_d_insert_next_point(self.0, x) } - } fn insert_next_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_points_2_d_insert_next_point( sself: *mut core::ffi::c_void, x: core::ffi::c_double, y: core::ffi::c_double, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_points_2_d_insert_next_point(self.0, x, y) } } - fn remove_point(&mut self, id: core::ffi::c_uchar) -> () { + fn remove_point(&mut self, id: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_points_2_d_remove_point( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ); } unsafe { vtk_points_2_d_remove_point(self.0, id) } } - fn set_number_of_points(&mut self, numPoints: core::ffi::c_uchar) -> () { + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_points_2_d_set_number_of_points( sself: *mut core::ffi::c_void, - numPoints: core::ffi::c_uchar, + numPoints: core::ffi::c_longlong, ); } unsafe { vtk_points_2_d_set_number_of_points(self.0, numPoints) } } - fn resize(&mut self, numPoints: core::ffi::c_uchar) -> core::ffi::c_int { + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_points_2_d_resize( sself: *mut core::ffi::c_void, - numPoints: core::ffi::c_uchar, + numPoints: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_points_2_d_resize(self.0, numPoints) } @@ -18779,23 +8485,6 @@ impl VtkPoints2D for vtkPoints2D { } unsafe { vtk_points_2_d_compute_bounds(self.0) } } - fn get_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_points_2_d_get_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_points_2_d_get_bounds(self.0) } - } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_points_2_d_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_points_2_d_get_bounds(self.0, bounds) } - } } impl VtkPriorityQueue for vtkPriorityQueue { fn new(&mut self) -> *mut core::ffi::c_void { @@ -18823,95 +8512,81 @@ impl VtkPriorityQueue for vtkPriorityQueue { } unsafe { vtk_priority_queue_new_instance(self.0) } } - fn allocate(&mut self, sz: core::ffi::c_uchar, ext: core::ffi::c_uchar) -> () { + fn allocate(&mut self, sz: core::ffi::c_longlong, ext: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_priority_queue_allocate( sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ); } unsafe { vtk_priority_queue_allocate(self.0, sz, ext) } } - fn insert(&mut self, priority: core::ffi::c_double, id: core::ffi::c_uchar) -> () { + fn insert( + &mut self, + priority: core::ffi::c_double, + id: core::ffi::c_longlong, + ) -> () { unsafe extern "C" { fn vtk_priority_queue_insert( sself: *mut core::ffi::c_void, priority: core::ffi::c_double, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ); } unsafe { vtk_priority_queue_insert(self.0, priority, id) } } fn pop( &mut self, - location: core::ffi::c_uchar, - priority: core::ffi::c_double, - ) -> core::ffi::c_uchar { + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_priority_queue_pop( sself: *mut core::ffi::c_void, - location: core::ffi::c_uchar, - priority: core::ffi::c_double, - ) -> core::ffi::c_uchar; + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; } unsafe { vtk_priority_queue_pop(self.0, location, priority) } } - fn pop(&mut self, location: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_priority_queue_pop( - sself: *mut core::ffi::c_void, - location: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_priority_queue_pop(self.0, location) } - } fn peek( &mut self, - location: core::ffi::c_uchar, - priority: core::ffi::c_double, - ) -> core::ffi::c_uchar { + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_priority_queue_peek( sself: *mut core::ffi::c_void, - location: core::ffi::c_uchar, - priority: core::ffi::c_double, - ) -> core::ffi::c_uchar; + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; } unsafe { vtk_priority_queue_peek(self.0, location, priority) } } - fn peek(&mut self, location: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_priority_queue_peek( - sself: *mut core::ffi::c_void, - location: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_priority_queue_peek(self.0, location) } - } - fn delete_id(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double { + fn delete_id(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double { unsafe extern "C" { fn vtk_priority_queue_delete_id( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ) -> core::ffi::c_double; } unsafe { vtk_priority_queue_delete_id(self.0, id) } } - fn get_priority(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_double { + fn get_priority(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double { unsafe extern "C" { fn vtk_priority_queue_get_priority( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ) -> core::ffi::c_double; } unsafe { vtk_priority_queue_get_priority(self.0, id) } } - fn get_number_of_items(&mut self) -> core::ffi::c_uchar { + fn get_number_of_items(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_priority_queue_get_number_of_items( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_priority_queue_get_number_of_items(self.0) } } @@ -18965,139 +8640,92 @@ impl VtkRandomPool for vtkRandomPool { } unsafe { vtk_random_pool_get_sequence(self.0) } } - fn set_size(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_size(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_random_pool_set_size( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_random_pool_set_size(self.0, _arg) } } - fn get_size_min_value(&mut self) -> core::ffi::c_uchar { + fn get_size_min_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_random_pool_get_size_min_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_random_pool_get_size_min_value(self.0) } } - fn get_size_max_value(&mut self) -> core::ffi::c_uchar { + fn get_size_max_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_random_pool_get_size_max_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_random_pool_get_size_max_value(self.0) } } - fn get_size(&mut self) -> core::ffi::c_uchar { + fn get_size(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_random_pool_get_size( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_random_pool_get_size(self.0) } } - fn set_number_of_components(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_number_of_components(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_random_pool_set_number_of_components( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_random_pool_set_number_of_components(self.0, _arg) } } - fn get_number_of_components_min_value(&mut self) -> core::ffi::c_uchar { + fn get_number_of_components_min_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_random_pool_get_number_of_components_min_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_random_pool_get_number_of_components_min_value(self.0) } } - fn get_number_of_components_max_value(&mut self) -> core::ffi::c_uchar { + fn get_number_of_components_max_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_random_pool_get_number_of_components_max_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_random_pool_get_number_of_components_max_value(self.0) } } - fn get_number_of_components(&mut self) -> core::ffi::c_uchar { + fn get_number_of_components(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_random_pool_get_number_of_components( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_random_pool_get_number_of_components(self.0) } } - fn get_total_size(&mut self) -> core::ffi::c_uchar { + fn get_total_size(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_random_pool_get_total_size( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_random_pool_get_total_size(self.0) } } - fn generate_pool(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_random_pool_generate_pool( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_random_pool_generate_pool(self.0) } - } - fn get_pool(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_random_pool_get_pool( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_random_pool_get_pool(self.0) } - } - fn get_value(&mut self, i: core::ffi::c_uchar) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_random_pool_get_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - ) -> core::ffi::c_double; - } - unsafe { vtk_random_pool_get_value(self.0, i) } - } - fn get_value( - &mut self, - i: core::ffi::c_uchar, - compNum: core::ffi::c_int, - ) -> core::ffi::c_double { + fn get_value(&mut self, i: core::ffi::c_longlong) -> core::ffi::c_double { unsafe extern "C" { fn vtk_random_pool_get_value( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - compNum: core::ffi::c_int, - ) -> core::ffi::c_double; - } - unsafe { vtk_random_pool_get_value(self.0, i, compNum) } - } - fn populate_data_array( - &mut self, - da: *mut core::ffi::c_void, - minRange: core::ffi::c_double, - maxRange: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_random_pool_populate_data_array( - sself: *mut core::ffi::c_void, - da: *mut core::ffi::c_void, - minRange: core::ffi::c_double, - maxRange: core::ffi::c_double, - ); + i: core::ffi::c_longlong, + ) -> core::ffi::c_double; } - unsafe { vtk_random_pool_populate_data_array(self.0, da, minRange, maxRange) } + unsafe { vtk_random_pool_get_value(self.0, i) } } fn populate_data_array( &mut self, da: *mut core::ffi::c_void, - compNumber: core::ffi::c_int, minRange: core::ffi::c_double, maxRange: core::ffi::c_double, ) -> () { @@ -19105,51 +8733,42 @@ impl VtkRandomPool for vtkRandomPool { fn vtk_random_pool_populate_data_array( sself: *mut core::ffi::c_void, da: *mut core::ffi::c_void, - compNumber: core::ffi::c_int, minRange: core::ffi::c_double, maxRange: core::ffi::c_double, ); } - unsafe { - vtk_random_pool_populate_data_array( - self.0, - da, - compNumber, - minRange, - maxRange, - ) - } + unsafe { vtk_random_pool_populate_data_array(self.0, da, minRange, maxRange) } } - fn set_chunk_size(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_chunk_size(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_random_pool_set_chunk_size( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_random_pool_set_chunk_size(self.0, _arg) } } - fn get_chunk_size_min_value(&mut self) -> core::ffi::c_uchar { + fn get_chunk_size_min_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_random_pool_get_chunk_size_min_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_random_pool_get_chunk_size_min_value(self.0) } } - fn get_chunk_size_max_value(&mut self) -> core::ffi::c_uchar { + fn get_chunk_size_max_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_random_pool_get_chunk_size_max_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_random_pool_get_chunk_size_max_value(self.0) } } - fn get_chunk_size(&mut self) -> core::ffi::c_uchar { + fn get_chunk_size(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_random_pool_get_chunk_size( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_random_pool_get_chunk_size(self.0) } } @@ -19215,36 +8834,12 @@ impl VtkScalarsToColors for vtkScalarsToColors { } unsafe { vtk_scalars_to_colors_is_opaque(self.0) } } - fn is_opaque( - &mut self, - scalars: *mut core::ffi::c_void, - colorMode: core::ffi::c_int, - component: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_scalars_to_colors_is_opaque( - sself: *mut core::ffi::c_void, - scalars: *mut core::ffi::c_void, - colorMode: core::ffi::c_int, - component: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_scalars_to_colors_is_opaque(self.0, scalars, colorMode, component) } - } fn build(&mut self) -> () { unsafe extern "C" { fn vtk_scalars_to_colors_build(sself: *mut core::ffi::c_void); } unsafe { vtk_scalars_to_colors_build(self.0) } } - fn get_range(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_scalars_to_colors_get_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_scalars_to_colors_get_range(self.0) } - } fn set_range(&mut self, min: core::ffi::c_double, max: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_scalars_to_colors_set_range( @@ -19255,43 +8850,6 @@ impl VtkScalarsToColors for vtkScalarsToColors { } unsafe { vtk_scalars_to_colors_set_range(self.0, min, max) } } - fn set_range(&mut self, rng: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_scalars_to_colors_set_range( - sself: *mut core::ffi::c_void, - rng: core::ffi::c_double, - ); - } - unsafe { vtk_scalars_to_colors_set_range(self.0, rng) } - } - fn map_value(&mut self, v: core::ffi::c_double) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_scalars_to_colors_map_value( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_scalars_to_colors_map_value(self.0, v) } - } - fn get_color(&mut self, v: core::ffi::c_double, rgb: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_scalars_to_colors_get_color( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - rgb: core::ffi::c_double, - ); - } - unsafe { vtk_scalars_to_colors_get_color(self.0, v, rgb) } - } - fn get_color(&mut self, v: core::ffi::c_double) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_scalars_to_colors_get_color( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_scalars_to_colors_get_color(self.0, v) } - } fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { unsafe extern "C" { fn vtk_scalars_to_colors_get_opacity( @@ -19353,32 +8911,6 @@ impl VtkScalarsToColors for vtkScalarsToColors { ) } } - fn map_scalars( - &mut self, - scalars: *mut core::ffi::c_void, - colorMode: core::ffi::c_int, - component: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_scalars_to_colors_map_scalars( - sself: *mut core::ffi::c_void, - scalars: *mut core::ffi::c_void, - colorMode: core::ffi::c_int, - component: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { - vtk_scalars_to_colors_map_scalars( - self.0, - scalars, - colorMode, - component, - outputFormat, - ) - } - } fn set_vector_mode(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_scalars_to_colors_set_vector_mode( @@ -19454,179 +8986,6 @@ impl VtkScalarsToColors for vtkScalarsToColors { } unsafe { vtk_scalars_to_colors_get_vector_size(self.0) } } - fn map_vectors_through_table( - &mut self, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - vectorComponent: core::ffi::c_int, - vectorSize: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_scalars_to_colors_map_vectors_through_table( - sself: *mut core::ffi::c_void, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - vectorComponent: core::ffi::c_int, - vectorSize: core::ffi::c_int, - ); - } - unsafe { - vtk_scalars_to_colors_map_vectors_through_table( - self.0, - input, - output, - inputDataType, - numberOfValues, - inputIncrement, - outputFormat, - vectorComponent, - vectorSize, - ) - } - } - fn map_vectors_through_table( - &mut self, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_scalars_to_colors_map_vectors_through_table( - sself: *mut core::ffi::c_void, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ); - } - unsafe { - vtk_scalars_to_colors_map_vectors_through_table( - self.0, - input, - output, - inputDataType, - numberOfValues, - inputIncrement, - outputFormat, - ) - } - } - fn map_scalars_through_table( - &mut self, - scalars: *mut core::ffi::c_void, - output: core::ffi::c_uchar, - outputFormat: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_scalars_to_colors_map_scalars_through_table( - sself: *mut core::ffi::c_void, - scalars: *mut core::ffi::c_void, - output: core::ffi::c_uchar, - outputFormat: core::ffi::c_int, - ); - } - unsafe { - vtk_scalars_to_colors_map_scalars_through_table( - self.0, - scalars, - output, - outputFormat, - ) - } - } - fn map_scalars_through_table( - &mut self, - scalars: *mut core::ffi::c_void, - output: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_scalars_to_colors_map_scalars_through_table( - sself: *mut core::ffi::c_void, - scalars: *mut core::ffi::c_void, - output: core::ffi::c_uchar, - ); - } - unsafe { - vtk_scalars_to_colors_map_scalars_through_table(self.0, scalars, output) - } - } - fn map_scalars_through_table( - &mut self, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_scalars_to_colors_map_scalars_through_table( - sself: *mut core::ffi::c_void, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ); - } - unsafe { - vtk_scalars_to_colors_map_scalars_through_table( - self.0, - input, - output, - inputDataType, - numberOfValues, - inputIncrement, - outputFormat, - ) - } - } - fn map_scalars_through_table_2( - &mut self, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_scalars_to_colors_map_scalars_through_table_2( - sself: *mut core::ffi::c_void, - input: (), - output: core::ffi::c_uchar, - inputDataType: core::ffi::c_int, - numberOfValues: core::ffi::c_int, - inputIncrement: core::ffi::c_int, - outputFormat: core::ffi::c_int, - ); - } - unsafe { - vtk_scalars_to_colors_map_scalars_through_table_2( - self.0, - input, - output, - inputDataType, - numberOfValues, - inputIncrement, - outputFormat, - ) - } - } fn deep_copy(&mut self, o: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_scalars_to_colors_deep_copy( @@ -19644,11 +9003,11 @@ impl VtkScalarsToColors for vtkScalarsToColors { } unsafe { vtk_scalars_to_colors_using_log_scale(self.0) } } - fn get_number_of_available_colors(&mut self) -> core::ffi::c_uchar { + fn get_number_of_available_colors(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_scalars_to_colors_get_number_of_available_colors( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_scalars_to_colors_get_number_of_available_colors(self.0) } } @@ -19682,124 +9041,14 @@ impl VtkScalarsToColors for vtkScalarsToColors { } unsafe { vtk_scalars_to_colors_get_annotations(self.0) } } - fn set_annotation( - &mut self, - value: *mut core::ffi::c_void, - annotation: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_scalars_to_colors_set_annotation( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - annotation: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_scalars_to_colors_set_annotation(self.0, value, annotation) } - } - fn set_annotation( - &mut self, - value: *mut core::ffi::c_void, - annotation: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_scalars_to_colors_set_annotation( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - annotation: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_scalars_to_colors_set_annotation(self.0, value, annotation) } - } - fn get_number_of_annotated_values(&mut self) -> core::ffi::c_uchar { + fn get_number_of_annotated_values(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_scalars_to_colors_get_number_of_annotated_values( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_scalars_to_colors_get_number_of_annotated_values(self.0) } } - fn get_annotated_value( - &mut self, - idx: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_scalars_to_colors_get_annotated_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_scalars_to_colors_get_annotated_value(self.0, idx) } - } - fn get_annotation(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_scalars_to_colors_get_annotation( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_scalars_to_colors_get_annotation(self.0, idx) } - } - fn get_annotation_color( - &mut self, - val: vtkVariant, - rgba: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_scalars_to_colors_get_annotation_color( - sself: *mut core::ffi::c_void, - val: vtkVariant, - rgba: core::ffi::c_double, - ); - } - unsafe { vtk_scalars_to_colors_get_annotation_color(self.0, val, rgba) } - } - fn get_annotated_value_index( - &mut self, - val: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_scalars_to_colors_get_annotated_value_index( - sself: *mut core::ffi::c_void, - val: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_scalars_to_colors_get_annotated_value_index(self.0, val) } - } - fn get_annotated_value_index_internal( - &mut self, - val: vtkVariant, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_scalars_to_colors_get_annotated_value_index_internal( - sself: *mut core::ffi::c_void, - val: vtkVariant, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_scalars_to_colors_get_annotated_value_index_internal(self.0, val) } - } - fn get_indexed_color( - &mut self, - i: core::ffi::c_uchar, - rgba: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_scalars_to_colors_get_indexed_color( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - rgba: core::ffi::c_double, - ); - } - unsafe { vtk_scalars_to_colors_get_indexed_color(self.0, i, rgba) } - } - fn remove_annotation(&mut self, value: *mut core::ffi::c_void) -> bool { - unsafe extern "C" { - fn vtk_scalars_to_colors_remove_annotation( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_scalars_to_colors_remove_annotation(self.0, value) } - } fn reset_annotations(&mut self) -> () { unsafe extern "C" { fn vtk_scalars_to_colors_reset_annotations(sself: *mut core::ffi::c_void); @@ -19854,205 +9103,77 @@ impl VtkShortArray for vtkShortArray { } unsafe { vtk_short_array_new_instance(self.0) } } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_short_array_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_short_array_new(self.0) } - } - fn extended_new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_short_array_extended_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_short_array_extended_new(self.0) } - } - fn get_data_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_short_array_get_data_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_short_array_get_data_type(self.0) } - } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_short, - ) -> () { - unsafe extern "C" { - fn vtk_short_array_get_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_short, - ); - } - unsafe { vtk_short_array_get_typed_tuple(self.0, i, tuple) } - } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_short, - ) -> () { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_short_array_set_typed_tuple( + fn vtk_short_array_new( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_short, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_short_array_set_typed_tuple(self.0, i, tuple) } + unsafe { vtk_short_array_new(self.0) } } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_short, - ) -> () { + fn extended_new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_short_array_insert_typed_tuple( + fn vtk_short_array_extended_new( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_short, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_short_array_insert_typed_tuple(self.0, i, tuple) } + unsafe { vtk_short_array_extended_new(self.0) } } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_short, - ) -> core::ffi::c_uchar { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_short_array_insert_next_typed_tuple( + fn vtk_short_array_get_data_type( sself: *mut core::ffi::c_void, - tuple: core::ffi::c_short, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_int; } - unsafe { vtk_short_array_insert_next_typed_tuple(self.0, tuple) } + unsafe { vtk_short_array_get_data_type(self.0) } } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_short { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_short { unsafe extern "C" { fn vtk_short_array_get_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ) -> core::ffi::c_short; } unsafe { vtk_short_array_get_value(self.0, id) } } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_short) -> () { + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_short) -> () { unsafe extern "C" { fn vtk_short_array_set_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, value: core::ffi::c_short, ); } unsafe { vtk_short_array_set_value(self.0, id, value) } } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { fn vtk_short_array_set_number_of_values( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_short_array_set_number_of_values(self.0, number) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_short) -> () { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_short) -> () { unsafe extern "C" { fn vtk_short_array_insert_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, f: core::ffi::c_short, ); } unsafe { vtk_short_array_insert_value(self.0, id, f) } } - fn insert_next_value(&mut self, f: core::ffi::c_short) -> core::ffi::c_uchar { + fn insert_next_value(&mut self, f: core::ffi::c_short) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_short_array_insert_next_value( sself: *mut core::ffi::c_void, f: core::ffi::c_short, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_short_array_insert_next_value(self.0, f) } } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_short { - unsafe extern "C" { - fn vtk_short_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_short; - } - unsafe { vtk_short_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_short { - unsafe extern "C" { - fn vtk_short_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_short; - } - unsafe { vtk_short_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_short { - unsafe extern "C" { - fn vtk_short_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_short; - } - unsafe { vtk_short_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_short { - unsafe extern "C" { - fn vtk_short_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_short; - } - unsafe { vtk_short_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_short, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_short_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_short, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_short_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_short, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_short_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_short, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { vtk_short_array_set_array(self.0, array, size, save, deleteMethod) } - } fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, @@ -20124,183 +9245,53 @@ impl VtkSignedCharArray for vtkSignedCharArray { } unsafe { vtk_signed_char_array_get_data_type(self.0) } } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ) -> () { - unsafe extern "C" { - fn vtk_signed_char_array_get_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ); - } - unsafe { vtk_signed_char_array_get_typed_tuple(self.0, i, tuple) } - } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ) -> () { - unsafe extern "C" { - fn vtk_signed_char_array_set_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ); - } - unsafe { vtk_signed_char_array_set_typed_tuple(self.0, i, tuple) } - } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ) -> () { - unsafe extern "C" { - fn vtk_signed_char_array_insert_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_char, - ); - } - unsafe { vtk_signed_char_array_insert_typed_tuple(self.0, i, tuple) } - } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_char, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_signed_char_array_insert_next_typed_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_char, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_signed_char_array_insert_next_typed_tuple(self.0, tuple) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_char { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_schar { unsafe extern "C" { fn vtk_signed_char_array_get_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> core::ffi::c_char; + id: core::ffi::c_longlong, + ) -> core::ffi::c_schar; } unsafe { vtk_signed_char_array_get_value(self.0, id) } } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> () { + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_schar) -> () { unsafe extern "C" { fn vtk_signed_char_array_set_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_char, + id: core::ffi::c_longlong, + value: core::ffi::c_schar, ); } unsafe { vtk_signed_char_array_set_value(self.0, id, value) } } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { fn vtk_signed_char_array_set_number_of_values( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_signed_char_array_set_number_of_values(self.0, number) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_char) -> () { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_schar) -> () { unsafe extern "C" { fn vtk_signed_char_array_insert_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - f: core::ffi::c_char, + id: core::ffi::c_longlong, + f: core::ffi::c_schar, ); } unsafe { vtk_signed_char_array_insert_value(self.0, id, f) } } - fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar { + fn insert_next_value(&mut self, f: core::ffi::c_schar) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_signed_char_array_insert_next_value( sself: *mut core::ffi::c_void, - f: core::ffi::c_char, - ) -> core::ffi::c_uchar; + f: core::ffi::c_schar, + ) -> core::ffi::c_longlong; } unsafe { vtk_signed_char_array_insert_next_value(self.0, f) } } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_signed_char_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_signed_char_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_signed_char_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_signed_char_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_signed_char_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_signed_char_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_signed_char_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_signed_char_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_signed_char_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_signed_char_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_signed_char_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_char, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { - vtk_signed_char_array_set_array(self.0, array, size, save, deleteMethod) - } - } fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, @@ -20313,19 +9304,19 @@ impl VtkSignedCharArray for vtkSignedCharArray { } unsafe { vtk_signed_char_array_fast_down_cast(self.0, source) } } - fn get_data_type_value_min(&mut self) -> core::ffi::c_char { + fn get_data_type_value_min(&mut self) -> core::ffi::c_schar { unsafe extern "C" { fn vtk_signed_char_array_get_data_type_value_min( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_char; + ) -> core::ffi::c_schar; } unsafe { vtk_signed_char_array_get_data_type_value_min(self.0) } } - fn get_data_type_value_max(&mut self) -> core::ffi::c_char { + fn get_data_type_value_max(&mut self) -> core::ffi::c_schar { unsafe extern "C" { fn vtk_signed_char_array_get_data_type_value_max( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_char; + ) -> core::ffi::c_schar; } unsafe { vtk_signed_char_array_get_data_type_value_max(self.0) } } @@ -20365,95 +9356,6 @@ impl VtkSortDataArray for vtkSortDataArray { } unsafe { vtk_sort_data_array_sort(self.0, keys) } } - fn sort(&mut self, keys: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_sort( - sself: *mut core::ffi::c_void, - keys: *mut core::ffi::c_void, - ); - } - unsafe { vtk_sort_data_array_sort(self.0, keys) } - } - fn sort(&mut self, keys: *mut core::ffi::c_void, dir: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_sort( - sself: *mut core::ffi::c_void, - keys: *mut core::ffi::c_void, - dir: core::ffi::c_int, - ); - } - unsafe { vtk_sort_data_array_sort(self.0, keys, dir) } - } - fn sort(&mut self, keys: *mut core::ffi::c_void, dir: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_sort( - sself: *mut core::ffi::c_void, - keys: *mut core::ffi::c_void, - dir: core::ffi::c_int, - ); - } - unsafe { vtk_sort_data_array_sort(self.0, keys, dir) } - } - fn sort( - &mut self, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_sort( - sself: *mut core::ffi::c_void, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - ); - } - unsafe { vtk_sort_data_array_sort(self.0, keys, values) } - } - fn sort( - &mut self, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_sort( - sself: *mut core::ffi::c_void, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - ); - } - unsafe { vtk_sort_data_array_sort(self.0, keys, values) } - } - fn sort( - &mut self, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - dir: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_sort( - sself: *mut core::ffi::c_void, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - dir: core::ffi::c_int, - ); - } - unsafe { vtk_sort_data_array_sort(self.0, keys, values, dir) } - } - fn sort( - &mut self, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - dir: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_sort( - sself: *mut core::ffi::c_void, - keys: *mut core::ffi::c_void, - values: *mut core::ffi::c_void, - dir: core::ffi::c_int, - ); - } - unsafe { vtk_sort_data_array_sort(self.0, keys, values, dir) } - } fn sort_array_by_component( &mut self, arr: *mut core::ffi::c_void, @@ -20468,123 +9370,6 @@ impl VtkSortDataArray for vtkSortDataArray { } unsafe { vtk_sort_data_array_sort_array_by_component(self.0, arr, k) } } - fn sort_array_by_component( - &mut self, - arr: *mut core::ffi::c_void, - k: core::ffi::c_int, - dir: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_sort_array_by_component( - sself: *mut core::ffi::c_void, - arr: *mut core::ffi::c_void, - k: core::ffi::c_int, - dir: core::ffi::c_int, - ); - } - unsafe { vtk_sort_data_array_sort_array_by_component(self.0, arr, k, dir) } - } - fn initialize_sort_indices( - &mut self, - numKeys: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_sort_data_array_initialize_sort_indices( - sself: *mut core::ffi::c_void, - numKeys: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_sort_data_array_initialize_sort_indices(self.0, numKeys) } - } - fn generate_sort_indices( - &mut self, - dataType: core::ffi::c_int, - dataIn: (), - numKeys: core::ffi::c_uchar, - numComp: core::ffi::c_int, - k: core::ffi::c_int, - idx: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_generate_sort_indices( - sself: *mut core::ffi::c_void, - dataType: core::ffi::c_int, - dataIn: (), - numKeys: core::ffi::c_uchar, - numComp: core::ffi::c_int, - k: core::ffi::c_int, - idx: core::ffi::c_uchar, - ); - } - unsafe { - vtk_sort_data_array_generate_sort_indices( - self.0, - dataType, - dataIn, - numKeys, - numComp, - k, - idx, - ) - } - } - fn shuffle_array( - &mut self, - idx: core::ffi::c_uchar, - dataType: core::ffi::c_int, - numKeys: core::ffi::c_uchar, - numComp: core::ffi::c_int, - arr: *mut core::ffi::c_void, - dataIn: (), - dir: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_shuffle_array( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - dataType: core::ffi::c_int, - numKeys: core::ffi::c_uchar, - numComp: core::ffi::c_int, - arr: *mut core::ffi::c_void, - dataIn: (), - dir: core::ffi::c_int, - ); - } - unsafe { - vtk_sort_data_array_shuffle_array( - self.0, - idx, - dataType, - numKeys, - numComp, - arr, - dataIn, - dir, - ) - } - } - fn shuffle_id_list( - &mut self, - idx: core::ffi::c_uchar, - sze: core::ffi::c_uchar, - arrayIn: *mut core::ffi::c_void, - dataIn: core::ffi::c_uchar, - dir: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_sort_data_array_shuffle_id_list( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - sze: core::ffi::c_uchar, - arrayIn: *mut core::ffi::c_void, - dataIn: core::ffi::c_uchar, - dir: core::ffi::c_int, - ); - } - unsafe { - vtk_sort_data_array_shuffle_id_list(self.0, idx, sze, arrayIn, dataIn, dir) - } - } } impl VtkStringArray for vtkStringArray { fn new(&mut self) -> *mut core::ffi::c_void { @@ -20656,26 +9441,26 @@ impl VtkStringArray for vtkStringArray { } unsafe { vtk_string_array_squeeze(self.0) } } - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int { + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_string_array_resize( sself: *mut core::ffi::c_void, - numTuples: core::ffi::c_uchar, + numTuples: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_string_array_resize(self.0, numTuples) } } fn set_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_string_array_set_tuple( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ); } @@ -20683,15 +9468,15 @@ impl VtkStringArray for vtkStringArray { } fn insert_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_string_array_insert_tuple( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ); } @@ -20713,82 +9498,20 @@ impl VtkStringArray for vtkStringArray { } unsafe { vtk_string_array_insert_tuples(self.0, dstIds, srcIds, source) } } - fn insert_tuples( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_string_array_insert_tuples( - sself: *mut core::ffi::c_void, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ); - } - unsafe { vtk_string_array_insert_tuples(self.0, dstStart, n, srcStart, source) } - } fn insert_next_tuple( &mut self, - j: core::ffi::c_uchar, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_string_array_insert_next_tuple( sself: *mut core::ffi::c_void, - j: core::ffi::c_uchar, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_string_array_insert_next_tuple(self.0, j, source) } } - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_string_array_interpolate_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_string_array_interpolate_tuple(self.0, i, ptIndices, source, weights) - } - } - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_string_array_interpolate_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ); - } - unsafe { - vtk_string_array_interpolate_tuple(self.0, i, id1, source1, id2, source2, t) - } - } fn get_tuples( &mut self, ptIds: *mut core::ffi::c_void, @@ -20803,92 +9526,34 @@ impl VtkStringArray for vtkStringArray { } unsafe { vtk_string_array_get_tuples(self.0, ptIds, output) } } - fn get_tuples( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - output: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_string_array_get_tuples( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - output: *mut core::ffi::c_void, - ); - } - unsafe { vtk_string_array_get_tuples(self.0, p1, p2, output) } - } fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_string_array_allocate( sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_string_array_allocate(self.0, sz, ext) } } - fn get_value(&mut self, id: core::ffi::c_uchar) -> vtkStdString { - unsafe extern "C" { - fn vtk_string_array_get_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> vtkStdString; - } - unsafe { vtk_string_array_get_value(self.0, id) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_string_array_get_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_string_array_get_value(self.0, id) } - } - fn set_value( - &mut self, - id: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_string_array_set_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_string_array_set_value(self.0, id, value) } - } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_string_array_set_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: core::ffi::c_char, - ); - } - unsafe { vtk_string_array_set_value(self.0, id, value) } - } - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> () { + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_string_array_set_number_of_tuples( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ); } unsafe { vtk_string_array_set_number_of_tuples(self.0, number) } } - fn get_number_of_values(&mut self) -> core::ffi::c_uchar { + fn get_number_of_values(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_string_array_get_number_of_values( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_string_array_get_number_of_values(self.0) } } @@ -20908,104 +9573,29 @@ impl VtkStringArray for vtkStringArray { } unsafe { vtk_string_array_get_element_component_size(self.0) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_string_array_insert_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - f: *mut core::ffi::c_void, - ); - } - unsafe { vtk_string_array_insert_value(self.0, id, f) } - } - fn insert_value(&mut self, id: core::ffi::c_uchar, val: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_string_array_insert_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - val: core::ffi::c_char, - ); - } - unsafe { vtk_string_array_insert_value(self.0, id, val) } - } - fn set_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_string_array_set_variant_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_string_array_set_variant_value(self.0, idx, value) } - } - fn insert_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_string_array_insert_variant_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_string_array_insert_variant_value(self.0, idx, value) } - } - fn insert_next_value(&mut self, f: *mut core::ffi::c_void) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_string_array_insert_next_value( - sself: *mut core::ffi::c_void, - f: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_string_array_insert_next_value(self.0, f) } - } - fn insert_next_value(&mut self, f: core::ffi::c_char) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_string_array_insert_next_value( - sself: *mut core::ffi::c_void, - f: core::ffi::c_char, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_string_array_insert_next_value(self.0, f) } - } fn write_pointer( &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, + id: core::ffi::c_longlong, + number: core::ffi::c_longlong, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_string_array_write_pointer( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, + id: core::ffi::c_longlong, + number: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_string_array_write_pointer(self.0, id, number) } } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_pointer(&mut self, id: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_string_array_get_pointer( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_string_array_get_pointer(self.0, id) } } - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut () { - unsafe extern "C" { - fn vtk_string_array_get_void_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut (); - } - unsafe { vtk_string_array_get_void_pointer(self.0, id) } - } fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_string_array_deep_copy( @@ -21018,7 +9608,7 @@ impl VtkStringArray for vtkStringArray { fn set_array( &mut self, array: *mut core::ffi::c_void, - size: core::ffi::c_uchar, + size: core::ffi::c_longlong, save: core::ffi::c_int, deleteMethod: core::ffi::c_int, ) -> () { @@ -21026,29 +9616,13 @@ impl VtkStringArray for vtkStringArray { fn vtk_string_array_set_array( sself: *mut core::ffi::c_void, array: *mut core::ffi::c_void, - size: core::ffi::c_uchar, + size: core::ffi::c_longlong, save: core::ffi::c_int, deleteMethod: core::ffi::c_int, ); } unsafe { vtk_string_array_set_array(self.0, array, size, save, deleteMethod) } } - fn set_void_array( - &mut self, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_string_array_set_void_array( - sself: *mut core::ffi::c_void, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_string_array_set_void_array(self.0, array, size, save) } - } fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_string_array_set_array_free_function( @@ -21074,90 +9648,25 @@ impl VtkStringArray for vtkStringArray { } unsafe { vtk_string_array_new_iterator(self.0) } } - fn get_data_size(&mut self) -> core::ffi::c_uchar { + fn get_data_size(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_string_array_get_data_size( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_string_array_get_data_size(self.0) } } - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_string_array_lookup_value( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_string_array_lookup_value(self.0, value) } - } - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_string_array_lookup_value( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ); - } - unsafe { vtk_string_array_lookup_value(self.0, value, ids) } - } - fn lookup_value(&mut self, value: vtkStdString) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_string_array_lookup_value( - sself: *mut core::ffi::c_void, - value: vtkStdString, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_string_array_lookup_value(self.0, value) } - } - fn lookup_value(&mut self, value: vtkStdString, ids: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_string_array_lookup_value( - sself: *mut core::ffi::c_void, - value: vtkStdString, - ids: *mut core::ffi::c_void, - ); - } - unsafe { vtk_string_array_lookup_value(self.0, value, ids) } - } - fn lookup_value(&mut self, value: core::ffi::c_char) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_string_array_lookup_value( - sself: *mut core::ffi::c_void, - value: core::ffi::c_char, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_string_array_lookup_value(self.0, value) } - } - fn lookup_value( - &mut self, - value: core::ffi::c_char, - ids: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_string_array_lookup_value( - sself: *mut core::ffi::c_void, - value: core::ffi::c_char, - ids: *mut core::ffi::c_void, - ); - } - unsafe { vtk_string_array_lookup_value(self.0, value, ids) } - } fn data_changed(&mut self) -> () { unsafe extern "C" { fn vtk_string_array_data_changed(sself: *mut core::ffi::c_void); } unsafe { vtk_string_array_data_changed(self.0) } } - fn data_element_changed(&mut self, id: core::ffi::c_uchar) -> () { + fn data_element_changed(&mut self, id: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_string_array_data_element_changed( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ); } unsafe { vtk_string_array_data_element_changed(self.0, id) } @@ -21195,26 +9704,15 @@ impl VtkStringOutputWindow for vtkStringOutputWindow { } unsafe { vtk_string_output_window_new(self.0) } } - fn display_text(&mut self, p0: core::ffi::c_char) -> () { + fn display_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); unsafe extern "C" { fn vtk_string_output_window_display_text( sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, + p0: *const core::ffi::c_char, ); } - unsafe { vtk_string_output_window_display_text(self.0, p0) } - } - fn get_output(&mut self) -> &str { - unsafe extern "C" { - fn vtk_string_output_window_get_output( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { vtk_string_output_window_get_output(self.0) }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + unsafe { vtk_string_output_window_display_text(self.0, c_p0.as_ptr()) } } } impl VtkTimePointUtility for vtkTimePointUtility { @@ -21323,17 +9821,17 @@ impl VtkTimePointUtility for vtkTimePointUtility { fn get_date( &mut self, time: core::ffi::c_ulonglong, - year: core::ffi::c_int, - month: core::ffi::c_int, - day: core::ffi::c_int, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, ) -> () { unsafe extern "C" { fn vtk_time_point_utility_get_date( sself: *mut core::ffi::c_void, time: core::ffi::c_ulonglong, - year: core::ffi::c_int, - month: core::ffi::c_int, - day: core::ffi::c_int, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, ); } unsafe { vtk_time_point_utility_get_date(self.0, time, year, month, day) } @@ -21341,19 +9839,19 @@ impl VtkTimePointUtility for vtkTimePointUtility { fn get_time( &mut self, time: core::ffi::c_ulonglong, - hour: core::ffi::c_int, - minute: core::ffi::c_int, - second: core::ffi::c_int, - millis: core::ffi::c_int, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, ) -> () { unsafe extern "C" { fn vtk_time_point_utility_get_time( sself: *mut core::ffi::c_void, time: core::ffi::c_ulonglong, - hour: core::ffi::c_int, - minute: core::ffi::c_int, - second: core::ffi::c_int, - millis: core::ffi::c_int, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, ); } unsafe { @@ -21363,25 +9861,25 @@ impl VtkTimePointUtility for vtkTimePointUtility { fn get_date_time( &mut self, time: core::ffi::c_ulonglong, - year: core::ffi::c_int, - month: core::ffi::c_int, - day: core::ffi::c_int, - hour: core::ffi::c_int, - minute: core::ffi::c_int, - second: core::ffi::c_int, - millis: core::ffi::c_int, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, ) -> () { unsafe extern "C" { fn vtk_time_point_utility_get_date_time( sself: *mut core::ffi::c_void, time: core::ffi::c_ulonglong, - year: core::ffi::c_int, - month: core::ffi::c_int, - day: core::ffi::c_int, - hour: core::ffi::c_int, - minute: core::ffi::c_int, - second: core::ffi::c_int, - millis: core::ffi::c_int, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, ); } unsafe { @@ -21461,25 +9959,11 @@ impl VtkTimePointUtility for vtkTimePointUtility { } unsafe { vtk_time_point_utility_get_millisecond(self.0, time) } } - fn iso_8601_to_time_point( - &mut self, - str: core::ffi::c_char, - ok: bool, - ) -> core::ffi::c_ulonglong { - unsafe extern "C" { - fn vtk_time_point_utility_iso_8601_to_time_point( - sself: *mut core::ffi::c_void, - str: core::ffi::c_char, - ok: bool, - ) -> core::ffi::c_ulonglong; - } - unsafe { vtk_time_point_utility_iso_8601_to_time_point(self.0, str, ok) } - } fn time_point_to_iso_8601( &mut self, p0: core::ffi::c_ulonglong, format: core::ffi::c_int, - ) -> *const core::ffi::c_char { + ) -> &str { unsafe extern "C" { fn vtk_time_point_utility_time_point_to_iso_8601( sself: *mut core::ffi::c_void, @@ -21487,7 +9971,13 @@ impl VtkTimePointUtility for vtkTimePointUtility { format: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_time_point_utility_time_point_to_iso_8601(self.0, p0, format) } + let ptr = unsafe { + vtk_time_point_utility_time_point_to_iso_8601(self.0, p0, format) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } } impl VtkTypeFloat32Array for vtkTypeFloat32Array { @@ -21916,14 +10406,14 @@ impl VtkUnicodeStringArray for vtkUnicodeStringArray { } fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_unicode_string_array_allocate( sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_unicode_string_array_allocate(self.0, sz, ext) } @@ -21958,26 +10448,26 @@ impl VtkUnicodeStringArray for vtkUnicodeStringArray { } unsafe { vtk_unicode_string_array_get_element_component_size(self.0) } } - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> () { + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_unicode_string_array_set_number_of_tuples( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ); } unsafe { vtk_unicode_string_array_set_number_of_tuples(self.0, number) } } fn set_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_unicode_string_array_set_tuple( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ); } @@ -21985,15 +10475,15 @@ impl VtkUnicodeStringArray for vtkUnicodeStringArray { } fn insert_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_unicode_string_array_insert_tuple( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ); } @@ -22015,106 +10505,19 @@ impl VtkUnicodeStringArray for vtkUnicodeStringArray { } unsafe { vtk_unicode_string_array_insert_tuples(self.0, dstIds, srcIds, source) } } - fn insert_tuples( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unicode_string_array_insert_tuples( - sself: *mut core::ffi::c_void, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_unicode_string_array_insert_tuples(self.0, dstStart, n, srcStart, source) - } - } fn insert_next_tuple( &mut self, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unicode_string_array_insert_next_tuple( - sself: *mut core::ffi::c_void, - j: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_unicode_string_array_insert_next_tuple(self.0, j, source) } - } - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut () { - unsafe extern "C" { - fn vtk_unicode_string_array_get_void_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut (); - } - unsafe { vtk_unicode_string_array_get_void_pointer(self.0, id) } - } - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_unicode_string_array_interpolate_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_unicode_string_array_interpolate_tuple( - self.0, - i, - ptIndices, - source, - weights, - ) - } - } - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ) -> () { + ) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_unicode_string_array_interpolate_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ); - } - unsafe { - vtk_unicode_string_array_interpolate_tuple( - self.0, - i, - id1, - source1, - id2, - source2, - t, - ) + fn vtk_unicode_string_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; } + unsafe { vtk_unicode_string_array_insert_next_tuple(self.0, j, source) } } fn squeeze(&mut self) -> () { unsafe extern "C" { @@ -22122,31 +10525,15 @@ impl VtkUnicodeStringArray for vtkUnicodeStringArray { } unsafe { vtk_unicode_string_array_squeeze(self.0) } } - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int { + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_unicode_string_array_resize( sself: *mut core::ffi::c_void, - numTuples: core::ffi::c_uchar, + numTuples: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_unicode_string_array_resize(self.0, numTuples) } } - fn set_void_array( - &mut self, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unicode_string_array_set_void_array( - sself: *mut core::ffi::c_void, - array: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_unicode_string_array_set_void_array(self.0, array, size, save) } - } fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_unicode_string_array_set_array_free_function( @@ -22180,66 +10567,6 @@ impl VtkUnicodeStringArray for vtkUnicodeStringArray { } unsafe { vtk_unicode_string_array_new_iterator(self.0) } } - fn get_variant_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_unicode_string_array_get_variant_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_unicode_string_array_get_variant_value(self.0, idx) } - } - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unicode_string_array_lookup_value( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_unicode_string_array_lookup_value(self.0, value) } - } - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unicode_string_array_lookup_value( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ); - } - unsafe { vtk_unicode_string_array_lookup_value(self.0, value, ids) } - } - fn set_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unicode_string_array_set_variant_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_unicode_string_array_set_variant_value(self.0, idx, value) } - } - fn insert_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unicode_string_array_insert_variant_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_unicode_string_array_insert_variant_value(self.0, idx, value) } - } fn data_changed(&mut self) -> () { unsafe extern "C" { fn vtk_unicode_string_array_data_changed(sself: *mut core::ffi::c_void); @@ -22252,71 +10579,41 @@ impl VtkUnicodeStringArray for vtkUnicodeStringArray { } unsafe { vtk_unicode_string_array_clear_lookup(self.0) } } - fn insert_next_value(&mut self, p0: vtkUnicodeString) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unicode_string_array_insert_next_value( - sself: *mut core::ffi::c_void, - p0: vtkUnicodeString, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_unicode_string_array_insert_next_value(self.0, p0) } - } - fn insert_value(&mut self, idx: core::ffi::c_uchar, p1: vtkUnicodeString) -> () { - unsafe extern "C" { - fn vtk_unicode_string_array_insert_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - p1: vtkUnicodeString, - ); - } - unsafe { vtk_unicode_string_array_insert_value(self.0, idx, p1) } - } - fn set_value(&mut self, i: core::ffi::c_uchar, p1: vtkUnicodeString) -> () { - unsafe extern "C" { - fn vtk_unicode_string_array_set_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - p1: vtkUnicodeString, - ); - } - unsafe { vtk_unicode_string_array_set_value(self.0, i, p1) } - } - fn get_value(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_unicode_string_array_get_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_unicode_string_array_get_value(self.0, i) } - } - fn insert_next_utf_8_value(&mut self, p0: core::ffi::c_char) -> () { + fn insert_next_utf_8_value(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); unsafe extern "C" { fn vtk_unicode_string_array_insert_next_utf_8_value( sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, + p0: *const core::ffi::c_char, ); } - unsafe { vtk_unicode_string_array_insert_next_utf_8_value(self.0, p0) } + unsafe { + vtk_unicode_string_array_insert_next_utf_8_value(self.0, c_p0.as_ptr()) + } } - fn set_utf_8_value(&mut self, i: core::ffi::c_uchar, p1: core::ffi::c_char) -> () { + fn set_utf_8_value(&mut self, i: core::ffi::c_longlong, p1: &str) -> () { + let c_p1 = std::ffi::CString::new(p1).expect("CString::new failed"); unsafe extern "C" { fn vtk_unicode_string_array_set_utf_8_value( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - p1: core::ffi::c_char, + i: core::ffi::c_longlong, + p1: *const core::ffi::c_char, ); } - unsafe { vtk_unicode_string_array_set_utf_8_value(self.0, i, p1) } + unsafe { vtk_unicode_string_array_set_utf_8_value(self.0, i, c_p1.as_ptr()) } } - fn get_utf_8_value(&mut self, i: core::ffi::c_uchar) -> *const core::ffi::c_char { + fn get_utf_8_value(&mut self, i: core::ffi::c_longlong) -> &str { unsafe extern "C" { fn vtk_unicode_string_array_get_utf_8_value( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, + i: core::ffi::c_longlong, ) -> *const core::ffi::c_char; } - unsafe { vtk_unicode_string_array_get_utf_8_value(self.0, i) } + let ptr = unsafe { vtk_unicode_string_array_get_utf_8_value(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } } impl VtkUnsignedCharArray for vtkUnsignedCharArray { @@ -22361,183 +10658,53 @@ impl VtkUnsignedCharArray for vtkUnsignedCharArray { } unsafe { vtk_unsigned_char_array_get_data_type(self.0) } } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_char_array_get_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ); - } - unsafe { vtk_unsigned_char_array_get_typed_tuple(self.0, i, tuple) } - } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_char_array_set_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ); - } - unsafe { vtk_unsigned_char_array_set_typed_tuple(self.0, i, tuple) } - } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_char_array_insert_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uchar, - ); - } - unsafe { vtk_unsigned_char_array_insert_typed_tuple(self.0, i, tuple) } - } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unsigned_char_array_insert_next_typed_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_unsigned_char_array_insert_next_typed_tuple(self.0, tuple) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_unsigned_char_array_get_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_unsigned_char_array_get_value(self.0, id) } } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uchar) -> () { + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_uchar) -> () { unsafe extern "C" { fn vtk_unsigned_char_array_set_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, value: core::ffi::c_uchar, ); } unsafe { vtk_unsigned_char_array_set_value(self.0, id, value) } } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { fn vtk_unsigned_char_array_set_number_of_values( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_unsigned_char_array_set_number_of_values(self.0, number) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uchar) -> () { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_uchar) -> () { unsafe extern "C" { fn vtk_unsigned_char_array_insert_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, f: core::ffi::c_uchar, ); } unsafe { vtk_unsigned_char_array_insert_value(self.0, id, f) } } - fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_unsigned_char_array_insert_next_value( sself: *mut core::ffi::c_void, f: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_unsigned_char_array_insert_next_value(self.0, f) } } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unsigned_char_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_unsigned_char_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unsigned_char_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_unsigned_char_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unsigned_char_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_unsigned_char_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unsigned_char_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_unsigned_char_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_char_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_unsigned_char_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_char_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_uchar, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { - vtk_unsigned_char_array_set_array(self.0, array, size, save, deleteMethod) - } - } fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, @@ -22609,183 +10776,53 @@ impl VtkUnsignedIntArray for vtkUnsignedIntArray { } unsafe { vtk_unsigned_int_array_get_data_type(self.0) } } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uint, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_int_array_get_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uint, - ); - } - unsafe { vtk_unsigned_int_array_get_typed_tuple(self.0, i, tuple) } - } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uint, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_int_array_set_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uint, - ); - } - unsafe { vtk_unsigned_int_array_set_typed_tuple(self.0, i, tuple) } - } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uint, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_int_array_insert_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_uint, - ); - } - unsafe { vtk_unsigned_int_array_insert_typed_tuple(self.0, i, tuple) } - } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_uint, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unsigned_int_array_insert_next_typed_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_uint, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_unsigned_int_array_insert_next_typed_tuple(self.0, tuple) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_uint { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_uint { unsafe extern "C" { fn vtk_unsigned_int_array_get_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ) -> core::ffi::c_uint; } unsafe { vtk_unsigned_int_array_get_value(self.0, id) } } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_uint) -> () { + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_uint) -> () { unsafe extern "C" { fn vtk_unsigned_int_array_set_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, value: core::ffi::c_uint, ); } unsafe { vtk_unsigned_int_array_set_value(self.0, id, value) } } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { fn vtk_unsigned_int_array_set_number_of_values( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_unsigned_int_array_set_number_of_values(self.0, number) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_uint) -> () { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_uint) -> () { unsafe extern "C" { fn vtk_unsigned_int_array_insert_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, f: core::ffi::c_uint, ); } unsafe { vtk_unsigned_int_array_insert_value(self.0, id, f) } } - fn insert_next_value(&mut self, f: core::ffi::c_uint) -> core::ffi::c_uchar { + fn insert_next_value(&mut self, f: core::ffi::c_uint) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_unsigned_int_array_insert_next_value( sself: *mut core::ffi::c_void, f: core::ffi::c_uint, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_unsigned_int_array_insert_next_value(self.0, f) } } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_uint { - unsafe extern "C" { - fn vtk_unsigned_int_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_uint; - } - unsafe { vtk_unsigned_int_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_uint { - unsafe extern "C" { - fn vtk_unsigned_int_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_uint; - } - unsafe { vtk_unsigned_int_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uint { - unsafe extern "C" { - fn vtk_unsigned_int_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uint; - } - unsafe { vtk_unsigned_int_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_uint { - unsafe extern "C" { - fn vtk_unsigned_int_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uint; - } - unsafe { vtk_unsigned_int_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_uint, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_int_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_uint, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_unsigned_int_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_uint, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_int_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_uint, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { - vtk_unsigned_int_array_set_array(self.0, array, size, save, deleteMethod) - } - } fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, @@ -22827,213 +10864,83 @@ impl VtkUnsignedLongArray for vtkUnsignedLongArray { } fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_unsigned_long_array_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_unsigned_long_array_new_instance(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_unsigned_long_array_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_unsigned_long_array_new(self.0) } - } - fn extended_new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_unsigned_long_array_extended_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_unsigned_long_array_extended_new(self.0) } - } - fn get_data_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_unsigned_long_array_get_data_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_unsigned_long_array_get_data_type(self.0) } - } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulong, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_long_array_get_typed_tuple( + fn vtk_unsigned_long_array_new_instance( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulong, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_unsigned_long_array_get_typed_tuple(self.0, i, tuple) } + unsafe { vtk_unsigned_long_array_new_instance(self.0) } } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulong, - ) -> () { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_unsigned_long_array_set_typed_tuple( + fn vtk_unsigned_long_array_new( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulong, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_unsigned_long_array_set_typed_tuple(self.0, i, tuple) } + unsafe { vtk_unsigned_long_array_new(self.0) } } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulong, - ) -> () { + fn extended_new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_unsigned_long_array_insert_typed_tuple( + fn vtk_unsigned_long_array_extended_new( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulong, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_unsigned_long_array_insert_typed_tuple(self.0, i, tuple) } + unsafe { vtk_unsigned_long_array_extended_new(self.0) } } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_ulong, - ) -> core::ffi::c_uchar { + fn get_data_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_unsigned_long_array_insert_next_typed_tuple( + fn vtk_unsigned_long_array_get_data_type( sself: *mut core::ffi::c_void, - tuple: core::ffi::c_ulong, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_int; } - unsafe { vtk_unsigned_long_array_insert_next_typed_tuple(self.0, tuple) } + unsafe { vtk_unsigned_long_array_get_data_type(self.0) } } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ulong { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_unsigned_long_array_get_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ) -> core::ffi::c_ulong; } unsafe { vtk_unsigned_long_array_get_value(self.0, id) } } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_ulong) -> () { + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_ulong) -> () { unsafe extern "C" { fn vtk_unsigned_long_array_set_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, value: core::ffi::c_ulong, ); } unsafe { vtk_unsigned_long_array_set_value(self.0, id, value) } } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { fn vtk_unsigned_long_array_set_number_of_values( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_unsigned_long_array_set_number_of_values(self.0, number) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ulong) -> () { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_ulong) -> () { unsafe extern "C" { fn vtk_unsigned_long_array_insert_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, f: core::ffi::c_ulong, ); } unsafe { vtk_unsigned_long_array_insert_value(self.0, id, f) } } - fn insert_next_value(&mut self, f: core::ffi::c_ulong) -> core::ffi::c_uchar { + fn insert_next_value(&mut self, f: core::ffi::c_ulong) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_unsigned_long_array_insert_next_value( sself: *mut core::ffi::c_void, f: core::ffi::c_ulong, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_unsigned_long_array_insert_next_value(self.0, f) } } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_ulong { - unsafe extern "C" { - fn vtk_unsigned_long_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_ulong; - } - unsafe { vtk_unsigned_long_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_ulong { - unsafe extern "C" { - fn vtk_unsigned_long_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_ulong; - } - unsafe { vtk_unsigned_long_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ulong { - unsafe extern "C" { - fn vtk_unsigned_long_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ulong; - } - unsafe { vtk_unsigned_long_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ulong { - unsafe extern "C" { - fn vtk_unsigned_long_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ulong; - } - unsafe { vtk_unsigned_long_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_ulong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_long_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_ulong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_unsigned_long_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_ulong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_long_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_ulong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { - vtk_unsigned_long_array_set_array(self.0, array, size, save, deleteMethod) - } - } fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, @@ -23105,196 +11012,61 @@ impl VtkUnsignedLongLongArray for vtkUnsignedLongLongArray { } unsafe { vtk_unsigned_long_long_array_get_data_type(self.0) } } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulonglong, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_long_long_array_get_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulonglong, - ); - } - unsafe { vtk_unsigned_long_long_array_get_typed_tuple(self.0, i, tuple) } - } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulonglong, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_long_long_array_set_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulonglong, - ); - } - unsafe { vtk_unsigned_long_long_array_set_typed_tuple(self.0, i, tuple) } - } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulonglong, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_long_long_array_insert_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ulonglong, - ); - } - unsafe { vtk_unsigned_long_long_array_insert_typed_tuple(self.0, i, tuple) } - } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_ulonglong, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unsigned_long_long_array_insert_next_typed_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_ulonglong, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_unsigned_long_long_array_insert_next_typed_tuple(self.0, tuple) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ulonglong { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ulonglong { unsafe extern "C" { fn vtk_unsigned_long_long_array_get_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ) -> core::ffi::c_ulonglong; } unsafe { vtk_unsigned_long_long_array_get_value(self.0, id) } } fn set_value( &mut self, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, value: core::ffi::c_ulonglong, ) -> () { unsafe extern "C" { fn vtk_unsigned_long_long_array_set_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, value: core::ffi::c_ulonglong, ); } unsafe { vtk_unsigned_long_long_array_set_value(self.0, id, value) } } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { fn vtk_unsigned_long_long_array_set_number_of_values( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_unsigned_long_long_array_set_number_of_values(self.0, number) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ulonglong) -> () { + fn insert_value( + &mut self, + id: core::ffi::c_longlong, + f: core::ffi::c_ulonglong, + ) -> () { unsafe extern "C" { fn vtk_unsigned_long_long_array_insert_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, f: core::ffi::c_ulonglong, ); } unsafe { vtk_unsigned_long_long_array_insert_value(self.0, id, f) } } - fn insert_next_value(&mut self, f: core::ffi::c_ulonglong) -> core::ffi::c_uchar { + fn insert_next_value(&mut self, f: core::ffi::c_ulonglong) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_unsigned_long_long_array_insert_next_value( sself: *mut core::ffi::c_void, f: core::ffi::c_ulonglong, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_unsigned_long_long_array_insert_next_value(self.0, f) } } - fn get_value_range( - &mut self, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_ulonglong { - unsafe extern "C" { - fn vtk_unsigned_long_long_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_ulonglong; - } - unsafe { vtk_unsigned_long_long_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_ulonglong { - unsafe extern "C" { - fn vtk_unsigned_long_long_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_ulonglong; - } - unsafe { vtk_unsigned_long_long_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ulonglong { - unsafe extern "C" { - fn vtk_unsigned_long_long_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ulonglong; - } - unsafe { vtk_unsigned_long_long_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ulonglong { - unsafe extern "C" { - fn vtk_unsigned_long_long_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ulonglong; - } - unsafe { vtk_unsigned_long_long_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_ulonglong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_long_long_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_ulonglong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_unsigned_long_long_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_ulonglong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_long_long_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_ulonglong, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { - vtk_unsigned_long_long_array_set_array( - self.0, - array, - size, - save, - deleteMethod, - ) - } - } fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, @@ -23366,183 +11138,57 @@ impl VtkUnsignedShortArray for vtkUnsignedShortArray { } unsafe { vtk_unsigned_short_array_get_data_type(self.0) } } - fn get_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ushort, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_short_array_get_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ushort, - ); - } - unsafe { vtk_unsigned_short_array_get_typed_tuple(self.0, i, tuple) } - } - fn set_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ushort, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_short_array_set_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ushort, - ); - } - unsafe { vtk_unsigned_short_array_set_typed_tuple(self.0, i, tuple) } - } - fn insert_typed_tuple( - &mut self, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ushort, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_short_array_insert_typed_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - tuple: core::ffi::c_ushort, - ); - } - unsafe { vtk_unsigned_short_array_insert_typed_tuple(self.0, i, tuple) } - } - fn insert_next_typed_tuple( - &mut self, - tuple: core::ffi::c_ushort, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unsigned_short_array_insert_next_typed_tuple( - sself: *mut core::ffi::c_void, - tuple: core::ffi::c_ushort, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_unsigned_short_array_insert_next_typed_tuple(self.0, tuple) } - } - fn get_value(&mut self, id: core::ffi::c_uchar) -> core::ffi::c_ushort { + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ushort { unsafe extern "C" { fn vtk_unsigned_short_array_get_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ) -> core::ffi::c_ushort; } unsafe { vtk_unsigned_short_array_get_value(self.0, id) } } - fn set_value(&mut self, id: core::ffi::c_uchar, value: core::ffi::c_ushort) -> () { + fn set_value( + &mut self, + id: core::ffi::c_longlong, + value: core::ffi::c_ushort, + ) -> () { unsafe extern "C" { fn vtk_unsigned_short_array_set_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, value: core::ffi::c_ushort, ); } unsafe { vtk_unsigned_short_array_set_value(self.0, id, value) } } - fn set_number_of_values(&mut self, number: core::ffi::c_uchar) -> bool { + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { unsafe extern "C" { fn vtk_unsigned_short_array_set_number_of_values( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_unsigned_short_array_set_number_of_values(self.0, number) } } - fn insert_value(&mut self, id: core::ffi::c_uchar, f: core::ffi::c_ushort) -> () { + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_ushort) -> () { unsafe extern "C" { fn vtk_unsigned_short_array_insert_value( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, f: core::ffi::c_ushort, ); } unsafe { vtk_unsigned_short_array_insert_value(self.0, id, f) } } - fn insert_next_value(&mut self, f: core::ffi::c_ushort) -> core::ffi::c_uchar { + fn insert_next_value(&mut self, f: core::ffi::c_ushort) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_unsigned_short_array_insert_next_value( sself: *mut core::ffi::c_void, f: core::ffi::c_ushort, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_unsigned_short_array_insert_next_value(self.0, f) } } - fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_ushort { - unsafe extern "C" { - fn vtk_unsigned_short_array_get_value_range( - sself: *mut core::ffi::c_void, - comp: core::ffi::c_int, - ) -> *mut core::ffi::c_ushort; - } - unsafe { vtk_unsigned_short_array_get_value_range(self.0, comp) } - } - fn get_value_range(&mut self) -> *mut core::ffi::c_ushort { - unsafe extern "C" { - fn vtk_unsigned_short_array_get_value_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_ushort; - } - unsafe { vtk_unsigned_short_array_get_value_range(self.0) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ushort { - unsafe extern "C" { - fn vtk_unsigned_short_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ushort; - } - unsafe { vtk_unsigned_short_array_write_pointer(self.0, id, number) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_ushort { - unsafe extern "C" { - fn vtk_unsigned_short_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_ushort; - } - unsafe { vtk_unsigned_short_array_get_pointer(self.0, id) } - } - fn set_array( - &mut self, - array: core::ffi::c_ushort, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_short_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_ushort, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_unsigned_short_array_set_array(self.0, array, size, save) } - } - fn set_array( - &mut self, - array: core::ffi::c_ushort, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_unsigned_short_array_set_array( - sself: *mut core::ffi::c_void, - array: core::ffi::c_ushort, - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteMethod: core::ffi::c_int, - ); - } - unsafe { - vtk_unsigned_short_array_set_array(self.0, array, size, save, deleteMethod) - } - } fn fast_down_cast( &mut self, source: *mut core::ffi::c_void, @@ -23608,14 +11254,14 @@ impl VtkVariantArray for vtkVariantArray { } fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_variant_array_allocate( sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_variant_array_allocate(self.0, sz, ext) } @@ -23650,26 +11296,26 @@ impl VtkVariantArray for vtkVariantArray { } unsafe { vtk_variant_array_get_element_component_size(self.0) } } - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> () { + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_variant_array_set_number_of_tuples( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ); } unsafe { vtk_variant_array_set_number_of_tuples(self.0, number) } } fn set_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_variant_array_set_tuple( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ); } @@ -23677,15 +11323,15 @@ impl VtkVariantArray for vtkVariantArray { } fn insert_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_variant_array_insert_tuple( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ); } @@ -23707,99 +11353,28 @@ impl VtkVariantArray for vtkVariantArray { } unsafe { vtk_variant_array_insert_tuples(self.0, dstIds, srcIds, source) } } - fn insert_tuples( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_variant_array_insert_tuples( - sself: *mut core::ffi::c_void, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ); - } - unsafe { vtk_variant_array_insert_tuples(self.0, dstStart, n, srcStart, source) } - } fn insert_next_tuple( &mut self, - j: core::ffi::c_uchar, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_variant_array_insert_next_tuple( sself: *mut core::ffi::c_void, - j: core::ffi::c_uchar, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_variant_array_insert_next_tuple(self.0, j, source) } } - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut () { - unsafe extern "C" { - fn vtk_variant_array_get_void_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut (); - } - unsafe { vtk_variant_array_get_void_pointer(self.0, id) } - } fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_variant_array_deep_copy( sself: *mut core::ffi::c_void, - da: *mut core::ffi::c_void, - ); - } - unsafe { vtk_variant_array_deep_copy(self.0, da) } - } - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_variant_array_interpolate_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_variant_array_interpolate_tuple(self.0, i, ptIndices, source, weights) - } - } - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_variant_array_interpolate_tuple( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, + da: *mut core::ffi::c_void, ); } - unsafe { - vtk_variant_array_interpolate_tuple(self.0, i, id1, source1, id2, source2, t) - } + unsafe { vtk_variant_array_deep_copy(self.0, da) } } fn squeeze(&mut self) -> () { unsafe extern "C" { @@ -23807,49 +11382,15 @@ impl VtkVariantArray for vtkVariantArray { } unsafe { vtk_variant_array_squeeze(self.0) } } - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int { + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_variant_array_resize( sself: *mut core::ffi::c_void, - numTuples: core::ffi::c_uchar, + numTuples: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_variant_array_resize(self.0, numTuples) } } - fn set_void_array( - &mut self, - arr: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_variant_array_set_void_array( - sself: *mut core::ffi::c_void, - arr: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - ); - } - unsafe { vtk_variant_array_set_void_array(self.0, arr, size, save) } - } - fn set_void_array( - &mut self, - arr: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteM: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_variant_array_set_void_array( - sself: *mut core::ffi::c_void, - arr: (), - size: core::ffi::c_uchar, - save: core::ffi::c_int, - deleteM: core::ffi::c_int, - ); - } - unsafe { vtk_variant_array_set_void_array(self.0, arr, size, save, deleteM) } - } fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_variant_array_get_actual_memory_size( @@ -23874,88 +11415,11 @@ impl VtkVariantArray for vtkVariantArray { } unsafe { vtk_variant_array_new_iterator(self.0) } } - fn get_value(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_variant_array_get_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_variant_array_get_value(self.0, id) } - } - fn set_value( - &mut self, - id: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_variant_array_set_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_variant_array_set_value(self.0, id, value) } - } - fn insert_value( - &mut self, - id: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_variant_array_insert_value( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_variant_array_insert_value(self.0, id, value) } - } - fn set_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_variant_array_set_variant_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_variant_array_set_variant_value(self.0, idx, value) } - } - fn insert_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_variant_array_insert_variant_value( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_variant_array_insert_variant_value(self.0, idx, value) } - } - fn insert_next_value( - &mut self, - value: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_variant_array_insert_next_value( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_variant_array_insert_next_value(self.0, value) } - } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_pointer(&mut self, id: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_variant_array_get_pointer( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_variant_array_get_pointer(self.0, id) } @@ -23963,7 +11427,7 @@ impl VtkVariantArray for vtkVariantArray { fn set_array( &mut self, arr: *mut core::ffi::c_void, - size: core::ffi::c_uchar, + size: core::ffi::c_longlong, save: core::ffi::c_int, deleteMethod: core::ffi::c_int, ) -> () { @@ -23971,7 +11435,7 @@ impl VtkVariantArray for vtkVariantArray { fn vtk_variant_array_set_array( sself: *mut core::ffi::c_void, arr: *mut core::ffi::c_void, - size: core::ffi::c_uchar, + size: core::ffi::c_longlong, save: core::ffi::c_int, deleteMethod: core::ffi::c_int, ); @@ -23987,48 +11451,25 @@ impl VtkVariantArray for vtkVariantArray { } unsafe { vtk_variant_array_set_array_free_function(self.0, callback) } } - fn get_number_of_values(&mut self) -> core::ffi::c_uchar { + fn get_number_of_values(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_variant_array_get_number_of_values( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_variant_array_get_number_of_values(self.0) } } - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_variant_array_lookup_value( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_variant_array_lookup_value(self.0, value) } - } - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_variant_array_lookup_value( - sself: *mut core::ffi::c_void, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ); - } - unsafe { vtk_variant_array_lookup_value(self.0, value, ids) } - } fn data_changed(&mut self) -> () { unsafe extern "C" { fn vtk_variant_array_data_changed(sself: *mut core::ffi::c_void); } unsafe { vtk_variant_array_data_changed(self.0) } } - fn data_element_changed(&mut self, id: core::ffi::c_uchar) -> () { + fn data_element_changed(&mut self, id: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_variant_array_data_element_changed( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ); } unsafe { vtk_variant_array_data_element_changed(self.0, id) } @@ -24064,21 +11505,29 @@ impl VtkVersion for vtkVersion { } unsafe { vtk_version_new_instance(self.0) } } - fn get_vtk_version(&mut self) -> *const core::ffi::c_char { + fn get_vtk_version(&mut self) -> &str { unsafe extern "C" { fn vtk_version_get_vtk_version( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_version_get_vtk_version(self.0) } + let ptr = unsafe { vtk_version_get_vtk_version(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn get_vtk_version_full(&mut self) -> *const core::ffi::c_char { + fn get_vtk_version_full(&mut self) -> &str { unsafe extern "C" { fn vtk_version_get_vtk_version_full( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_version_get_vtk_version_full(self.0) } + let ptr = unsafe { vtk_version_get_vtk_version_full(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn get_vtk_major_version(&mut self) -> core::ffi::c_int { unsafe extern "C" { @@ -24104,13 +11553,17 @@ impl VtkVersion for vtkVersion { } unsafe { vtk_version_get_vtk_build_version(self.0) } } - fn get_vtk_source_version(&mut self) -> *const core::ffi::c_char { + fn get_vtk_source_version(&mut self) -> &str { unsafe extern "C" { fn vtk_version_get_vtk_source_version( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_version_get_vtk_source_version(self.0) } + let ptr = unsafe { vtk_version_get_vtk_source_version(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } } impl VtkVoidArray for vtkVoidArray { @@ -24149,14 +11602,14 @@ impl VtkVoidArray for vtkVoidArray { } fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_void_array_allocate( sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_void_array_allocate(self.0, sz, ext) } @@ -24183,61 +11636,23 @@ impl VtkVoidArray for vtkVoidArray { } unsafe { vtk_void_array_get_data_type_size(self.0) } } - fn set_number_of_pointers(&mut self, number: core::ffi::c_uchar) -> () { + fn set_number_of_pointers(&mut self, number: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_void_array_set_number_of_pointers( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ); } unsafe { vtk_void_array_set_number_of_pointers(self.0, number) } } - fn get_number_of_pointers(&mut self) -> core::ffi::c_uchar { + fn get_number_of_pointers(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_void_array_get_number_of_pointers( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_void_array_get_number_of_pointers(self.0) } } - fn get_void_pointer(&mut self, id: core::ffi::c_uchar) -> *mut () { - unsafe extern "C" { - fn vtk_void_array_get_void_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut (); - } - unsafe { vtk_void_array_get_void_pointer(self.0, id) } - } - fn set_void_pointer(&mut self, id: core::ffi::c_uchar, ptr: ()) -> () { - unsafe extern "C" { - fn vtk_void_array_set_void_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ptr: (), - ); - } - unsafe { vtk_void_array_set_void_pointer(self.0, id, ptr) } - } - fn insert_void_pointer(&mut self, i: core::ffi::c_uchar, ptr: ()) -> () { - unsafe extern "C" { - fn vtk_void_array_insert_void_pointer( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - ptr: (), - ); - } - unsafe { vtk_void_array_insert_void_pointer(self.0, i, ptr) } - } - fn insert_next_void_pointer(&mut self, tuple: ()) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_void_array_insert_next_void_pointer( - sself: *mut core::ffi::c_void, - tuple: (), - ) -> core::ffi::c_uchar; - } - unsafe { vtk_void_array_insert_next_void_pointer(self.0, tuple) } - } fn reset(&mut self) -> () { unsafe extern "C" { fn vtk_void_array_reset(sself: *mut core::ffi::c_void); @@ -24250,29 +11665,6 @@ impl VtkVoidArray for vtkVoidArray { } unsafe { vtk_void_array_squeeze(self.0) } } - fn get_pointer(&mut self, id: core::ffi::c_uchar) -> *mut &mut () { - unsafe extern "C" { - fn vtk_void_array_get_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - ) -> *mut &mut (); - } - unsafe { vtk_void_array_get_pointer(self.0, id) } - } - fn write_pointer( - &mut self, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut &mut () { - unsafe extern "C" { - fn vtk_void_array_write_pointer( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - number: core::ffi::c_uchar, - ) -> *mut &mut (); - } - unsafe { vtk_void_array_write_pointer(self.0, id, number) } - } fn deep_copy(&mut self, va: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_void_array_deep_copy( @@ -24353,23 +11745,25 @@ impl VtkXMLFileOutputWindow for vtkXMLFileOutputWindow { } unsafe { vtk_xml_file_output_window_new(self.0) } } - fn display_text(&mut self, p0: core::ffi::c_char) -> () { + fn display_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_file_output_window_display_text( sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, + p0: *const core::ffi::c_char, ); } - unsafe { vtk_xml_file_output_window_display_text(self.0, p0) } + unsafe { vtk_xml_file_output_window_display_text(self.0, c_p0.as_ptr()) } } - fn display_tag(&mut self, p0: core::ffi::c_char) -> () { + fn display_tag(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_file_output_window_display_tag( sself: *mut core::ffi::c_void, - p0: core::ffi::c_char, + p0: *const core::ffi::c_char, ); } - unsafe { vtk_xml_file_output_window_display_tag(self.0, p0) } + unsafe { vtk_xml_file_output_window_display_tag(self.0, c_p0.as_ptr()) } } } /// a seqin an animation. @@ -24395,22 +11789,13 @@ impl VtkXMLFileOutputWindow for vtkXMLFileOutputWindow { #[allow(non_camel_case_types)] pub struct vtkAnimationCue(*mut core::ffi::c_void); impl vtkAnimationCue { - /// Creates a new [vtkAnimationCue] wrapped inside `vtkNew` + /// Creates a new [vtkAnimationCue] via `vtkAnimationCue::New()` #[doc(alias = "vtkAnimationCue")] pub fn new() -> Self { unsafe extern "C" { fn vtkAnimationCue_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAnimationCue_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAnimationCue_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAnimationCue_get_ptr(self.0) } + Self(unsafe { vtkAnimationCue_new() }) } } impl std::default::Default for vtkAnimationCue { @@ -24430,12 +11815,8 @@ impl Drop for vtkAnimationCue { #[test] fn test_vtkAnimationCue_create_drop() { let obj = vtkAnimationCue::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAnimationCue(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Writes an archive /// @@ -24449,22 +11830,13 @@ fn test_vtkAnimationCue_create_drop() { #[allow(non_camel_case_types)] pub struct vtkArchiver(*mut core::ffi::c_void); impl vtkArchiver { - /// Creates a new [vtkArchiver] wrapped inside `vtkNew` + /// Creates a new [vtkArchiver] via `vtkArchiver::New()` #[doc(alias = "vtkArchiver")] pub fn new() -> Self { unsafe extern "C" { fn vtkArchiver_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkArchiver_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkArchiver_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkArchiver_get_ptr(self.0) } + Self(unsafe { vtkArchiver_new() }) } } impl std::default::Default for vtkArchiver { @@ -24484,12 +11856,8 @@ impl Drop for vtkArchiver { #[test] fn test_vtkArchiver_create_drop() { let obj = vtkArchiver::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkArchiver(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of bits /// @@ -24501,22 +11869,13 @@ fn test_vtkArchiver_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBitArray(*mut core::ffi::c_void); impl vtkBitArray { - /// Creates a new [vtkBitArray] wrapped inside `vtkNew` + /// Creates a new [vtkBitArray] via `vtkBitArray::New()` #[doc(alias = "vtkBitArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkBitArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBitArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBitArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBitArray_get_ptr(self.0) } + Self(unsafe { vtkBitArray_new() }) } } impl std::default::Default for vtkBitArray { @@ -24536,12 +11895,8 @@ impl Drop for vtkBitArray { #[test] fn test_vtkBitArray_create_drop() { let obj = vtkBitArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBitArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterator for vtkBitArray. /// @@ -24550,22 +11905,13 @@ fn test_vtkBitArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBitArrayIterator(*mut core::ffi::c_void); impl vtkBitArrayIterator { - /// Creates a new [vtkBitArrayIterator] wrapped inside `vtkNew` + /// Creates a new [vtkBitArrayIterator] via `vtkBitArrayIterator::New()` #[doc(alias = "vtkBitArrayIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkBitArrayIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBitArrayIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBitArrayIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBitArrayIterator_get_ptr(self.0) } + Self(unsafe { vtkBitArrayIterator_new() }) } } impl std::default::Default for vtkBitArrayIterator { @@ -24585,12 +11931,8 @@ impl Drop for vtkBitArrayIterator { #[test] fn test_vtkBitArrayIterator_create_drop() { let obj = vtkBitArrayIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBitArrayIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform /// @@ -24604,22 +11946,13 @@ fn test_vtkBitArrayIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBoxMuellerRandomSequence(*mut core::ffi::c_void); impl vtkBoxMuellerRandomSequence { - /// Creates a new [vtkBoxMuellerRandomSequence] wrapped inside `vtkNew` + /// Creates a new [vtkBoxMuellerRandomSequence] via `vtkBoxMuellerRandomSequence::New()` #[doc(alias = "vtkBoxMuellerRandomSequence")] pub fn new() -> Self { unsafe extern "C" { fn vtkBoxMuellerRandomSequence_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBoxMuellerRandomSequence_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBoxMuellerRandomSequence_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBoxMuellerRandomSequence_get_ptr(self.0) } + Self(unsafe { vtkBoxMuellerRandomSequence_new() }) } } impl std::default::Default for vtkBoxMuellerRandomSequence { @@ -24639,12 +11972,8 @@ impl Drop for vtkBoxMuellerRandomSequence { #[test] fn test_vtkBoxMuellerRandomSequence_create_drop() { let obj = vtkBoxMuellerRandomSequence::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBoxMuellerRandomSequence(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// perform machine dependent byte swapping /// @@ -24655,22 +11984,13 @@ fn test_vtkBoxMuellerRandomSequence_create_drop() { #[allow(non_camel_case_types)] pub struct vtkByteSwap(*mut core::ffi::c_void); impl vtkByteSwap { - /// Creates a new [vtkByteSwap] wrapped inside `vtkNew` + /// Creates a new [vtkByteSwap] via `vtkByteSwap::New()` #[doc(alias = "vtkByteSwap")] pub fn new() -> Self { unsafe extern "C" { fn vtkByteSwap_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkByteSwap_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkByteSwap_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkByteSwap_get_ptr(self.0) } + Self(unsafe { vtkByteSwap_new() }) } } impl std::default::Default for vtkByteSwap { @@ -24690,12 +12010,8 @@ impl Drop for vtkByteSwap { #[test] fn test_vtkByteSwap_create_drop() { let obj = vtkByteSwap::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkByteSwap(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// supports function callbacks /// @@ -24720,22 +12036,13 @@ fn test_vtkByteSwap_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCallbackCommand(*mut core::ffi::c_void); impl vtkCallbackCommand { - /// Creates a new [vtkCallbackCommand] wrapped inside `vtkNew` + /// Creates a new [vtkCallbackCommand] via `vtkCallbackCommand::New()` #[doc(alias = "vtkCallbackCommand")] pub fn new() -> Self { unsafe extern "C" { fn vtkCallbackCommand_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCallbackCommand_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCallbackCommand_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCallbackCommand_get_ptr(self.0) } + Self(unsafe { vtkCallbackCommand_new() }) } } impl std::default::Default for vtkCallbackCommand { @@ -24755,12 +12062,8 @@ impl Drop for vtkCallbackCommand { #[test] fn test_vtkCallbackCommand_create_drop() { let obj = vtkCallbackCommand::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCallbackCommand(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of char /// @@ -24784,22 +12087,13 @@ fn test_vtkCallbackCommand_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCharArray(*mut core::ffi::c_void); impl vtkCharArray { - /// Creates a new [vtkCharArray] wrapped inside `vtkNew` + /// Creates a new [vtkCharArray] via `vtkCharArray::New()` #[doc(alias = "vtkCharArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkCharArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCharArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCharArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCharArray_get_ptr(self.0) } + Self(unsafe { vtkCharArray_new() }) } } impl std::default::Default for vtkCharArray { @@ -24819,12 +12113,8 @@ impl Drop for vtkCharArray { #[test] fn test_vtkCharArray_create_drop() { let obj = vtkCharArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCharArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// create and manipulate ordered lists of objects /// @@ -24842,22 +12132,13 @@ fn test_vtkCharArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCollection(*mut core::ffi::c_void); impl vtkCollection { - /// Creates a new [vtkCollection] wrapped inside `vtkNew` + /// Creates a new [vtkCollection] via `vtkCollection::New()` #[doc(alias = "vtkCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCollection_get_ptr(self.0) } + Self(unsafe { vtkCollection_new() }) } } impl std::default::Default for vtkCollection { @@ -24877,12 +12158,8 @@ impl Drop for vtkCollection { #[test] fn test_vtkCollection_create_drop() { let obj = vtkCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// iterator through a vtkCollection. /// @@ -24897,22 +12174,13 @@ fn test_vtkCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCollectionIterator(*mut core::ffi::c_void); impl vtkCollectionIterator { - /// Creates a new [vtkCollectionIterator] wrapped inside `vtkNew` + /// Creates a new [vtkCollectionIterator] via `vtkCollectionIterator::New()` #[doc(alias = "vtkCollectionIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkCollectionIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCollectionIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCollectionIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCollectionIterator_get_ptr(self.0) } + Self(unsafe { vtkCollectionIterator_new() }) } } impl std::default::Default for vtkCollectionIterator { @@ -24932,12 +12200,8 @@ impl Drop for vtkCollectionIterator { #[test] fn test_vtkCollectionIterator_create_drop() { let obj = vtkCollectionIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCollectionIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Critical section locking class /// @@ -24960,22 +12224,13 @@ fn test_vtkCollectionIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCriticalSection(*mut core::ffi::c_void); impl vtkCriticalSection { - /// Creates a new [vtkCriticalSection] wrapped inside `vtkNew` + /// Creates a new [vtkCriticalSection] via `vtkCriticalSection::New()` #[doc(alias = "vtkCriticalSection")] pub fn new() -> Self { unsafe extern "C" { fn vtkCriticalSection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCriticalSection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCriticalSection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCriticalSection_get_ptr(self.0) } + Self(unsafe { vtkCriticalSection_new() }) } } impl std::default::Default for vtkCriticalSection { @@ -24995,12 +12250,8 @@ impl Drop for vtkCriticalSection { #[test] fn test_vtkCriticalSection_create_drop() { let obj = vtkCriticalSection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCriticalSection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain an ordered list of dataarray objects /// @@ -25010,22 +12261,13 @@ fn test_vtkCriticalSection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataArrayCollection(*mut core::ffi::c_void); impl vtkDataArrayCollection { - /// Creates a new [vtkDataArrayCollection] wrapped inside `vtkNew` + /// Creates a new [vtkDataArrayCollection] via `vtkDataArrayCollection::New()` #[doc(alias = "vtkDataArrayCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataArrayCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataArrayCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataArrayCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataArrayCollection_get_ptr(self.0) } + Self(unsafe { vtkDataArrayCollection_new() }) } } impl std::default::Default for vtkDataArrayCollection { @@ -25045,12 +12287,8 @@ impl Drop for vtkDataArrayCollection { #[test] fn test_vtkDataArrayCollection_create_drop() { let obj = vtkDataArrayCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataArrayCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// iterator through a vtkDataArrayCollection. /// @@ -25061,22 +12299,13 @@ fn test_vtkDataArrayCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataArrayCollectionIterator(*mut core::ffi::c_void); impl vtkDataArrayCollectionIterator { - /// Creates a new [vtkDataArrayCollectionIterator] wrapped inside `vtkNew` + /// Creates a new [vtkDataArrayCollectionIterator] via `vtkDataArrayCollectionIterator::New()` #[doc(alias = "vtkDataArrayCollectionIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataArrayCollectionIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataArrayCollectionIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataArrayCollectionIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataArrayCollectionIterator_get_ptr(self.0) } + Self(unsafe { vtkDataArrayCollectionIterator_new() }) } } impl std::default::Default for vtkDataArrayCollectionIterator { @@ -25096,12 +12325,8 @@ impl Drop for vtkDataArrayCollectionIterator { #[test] fn test_vtkDataArrayCollectionIterator_create_drop() { let obj = vtkDataArrayCollectionIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataArrayCollectionIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Store on/off settings for data arrays for a vtkSource. /// @@ -25114,22 +12339,13 @@ fn test_vtkDataArrayCollectionIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataArraySelection(*mut core::ffi::c_void); impl vtkDataArraySelection { - /// Creates a new [vtkDataArraySelection] wrapped inside `vtkNew` + /// Creates a new [vtkDataArraySelection] via `vtkDataArraySelection::New()` #[doc(alias = "vtkDataArraySelection")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataArraySelection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataArraySelection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataArraySelection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataArraySelection_get_ptr(self.0) } + Self(unsafe { vtkDataArraySelection_new() }) } } impl std::default::Default for vtkDataArraySelection { @@ -25149,12 +12365,8 @@ impl Drop for vtkDataArraySelection { #[test] fn test_vtkDataArraySelection_create_drop() { let obj = vtkDataArraySelection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataArraySelection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// identify memory leaks at program termination /// @@ -25190,22 +12402,13 @@ fn test_vtkDataArraySelection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDebugLeaks(*mut core::ffi::c_void); impl vtkDebugLeaks { - /// Creates a new [vtkDebugLeaks] wrapped inside `vtkNew` + /// Creates a new [vtkDebugLeaks] via `vtkDebugLeaks::New()` #[doc(alias = "vtkDebugLeaks")] pub fn new() -> Self { unsafe extern "C" { fn vtkDebugLeaks_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDebugLeaks_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDebugLeaks_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDebugLeaks_get_ptr(self.0) } + Self(unsafe { vtkDebugLeaks_new() }) } } impl std::default::Default for vtkDebugLeaks { @@ -25225,12 +12428,8 @@ impl Drop for vtkDebugLeaks { #[test] fn test_vtkDebugLeaks_create_drop() { let obj = vtkDebugLeaks::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDebugLeaks(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of double /// @@ -25241,22 +12440,13 @@ fn test_vtkDebugLeaks_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDoubleArray(*mut core::ffi::c_void); impl vtkDoubleArray { - /// Creates a new [vtkDoubleArray] wrapped inside `vtkNew` + /// Creates a new [vtkDoubleArray] via `vtkDoubleArray::New()` #[doc(alias = "vtkDoubleArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkDoubleArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDoubleArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDoubleArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDoubleArray_get_ptr(self.0) } + Self(unsafe { vtkDoubleArray_new() }) } } impl std::default::Default for vtkDoubleArray { @@ -25276,12 +12466,8 @@ impl Drop for vtkDoubleArray { #[test] fn test_vtkDoubleArray_create_drop() { let obj = vtkDoubleArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDoubleArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// class interface to system dynamic libraries /// @@ -25293,22 +12479,13 @@ fn test_vtkDoubleArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDynamicLoader(*mut core::ffi::c_void); impl vtkDynamicLoader { - /// Creates a new [vtkDynamicLoader] wrapped inside `vtkNew` + /// Creates a new [vtkDynamicLoader] via `vtkDynamicLoader::New()` #[doc(alias = "vtkDynamicLoader")] pub fn new() -> Self { unsafe extern "C" { fn vtkDynamicLoader_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDynamicLoader_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDynamicLoader_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDynamicLoader_get_ptr(self.0) } + Self(unsafe { vtkDynamicLoader_new() }) } } impl std::default::Default for vtkDynamicLoader { @@ -25328,33 +12505,20 @@ impl Drop for vtkDynamicLoader { #[test] fn test_vtkDynamicLoader_create_drop() { let obj = vtkDynamicLoader::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDynamicLoader(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkEventDataDevice3D(*mut core::ffi::c_void); impl vtkEventDataDevice3D { - /// Creates a new [vtkEventDataDevice3D] wrapped inside `vtkNew` + /// Creates a new [vtkEventDataDevice3D] via `vtkEventDataDevice3D::New()` #[doc(alias = "vtkEventDataDevice3D")] pub fn new() -> Self { unsafe extern "C" { fn vtkEventDataDevice3D_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEventDataDevice3D_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEventDataDevice3D_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEventDataDevice3D_get_ptr(self.0) } + Self(unsafe { vtkEventDataDevice3D_new() }) } } impl std::default::Default for vtkEventDataDevice3D { @@ -25374,33 +12538,20 @@ impl Drop for vtkEventDataDevice3D { #[test] fn test_vtkEventDataDevice3D_create_drop() { let obj = vtkEventDataDevice3D::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEventDataDevice3D(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkEventDataForDevice(*mut core::ffi::c_void); impl vtkEventDataForDevice { - /// Creates a new [vtkEventDataForDevice] wrapped inside `vtkNew` + /// Creates a new [vtkEventDataForDevice] via `vtkEventDataForDevice::New()` #[doc(alias = "vtkEventDataForDevice")] pub fn new() -> Self { unsafe extern "C" { fn vtkEventDataForDevice_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEventDataForDevice_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEventDataForDevice_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEventDataForDevice_get_ptr(self.0) } + Self(unsafe { vtkEventDataForDevice_new() }) } } impl std::default::Default for vtkEventDataForDevice { @@ -25420,12 +12571,8 @@ impl Drop for vtkEventDataForDevice { #[test] fn test_vtkEventDataForDevice_create_drop() { let obj = vtkEventDataForDevice::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEventDataForDevice(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a simple event forwarder command /// @@ -25440,22 +12587,13 @@ fn test_vtkEventDataForDevice_create_drop() { #[allow(non_camel_case_types)] pub struct vtkEventForwarderCommand(*mut core::ffi::c_void); impl vtkEventForwarderCommand { - /// Creates a new [vtkEventForwarderCommand] wrapped inside `vtkNew` + /// Creates a new [vtkEventForwarderCommand] via `vtkEventForwarderCommand::New()` #[doc(alias = "vtkEventForwarderCommand")] pub fn new() -> Self { unsafe extern "C" { fn vtkEventForwarderCommand_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEventForwarderCommand_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEventForwarderCommand_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEventForwarderCommand_get_ptr(self.0) } + Self(unsafe { vtkEventForwarderCommand_new() }) } } impl std::default::Default for vtkEventForwarderCommand { @@ -25475,12 +12613,8 @@ impl Drop for vtkEventForwarderCommand { #[test] fn test_vtkEventForwarderCommand_create_drop() { let obj = vtkEventForwarderCommand::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEventForwarderCommand(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// File Specific output window class /// @@ -25490,22 +12624,13 @@ fn test_vtkEventForwarderCommand_create_drop() { #[allow(non_camel_case_types)] pub struct vtkFileOutputWindow(*mut core::ffi::c_void); impl vtkFileOutputWindow { - /// Creates a new [vtkFileOutputWindow] wrapped inside `vtkNew` + /// Creates a new [vtkFileOutputWindow] via `vtkFileOutputWindow::New()` #[doc(alias = "vtkFileOutputWindow")] pub fn new() -> Self { unsafe extern "C" { fn vtkFileOutputWindow_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkFileOutputWindow_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkFileOutputWindow_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkFileOutputWindow_get_ptr(self.0) } + Self(unsafe { vtkFileOutputWindow_new() }) } } impl std::default::Default for vtkFileOutputWindow { @@ -25525,12 +12650,8 @@ impl Drop for vtkFileOutputWindow { #[test] fn test_vtkFileOutputWindow_create_drop() { let obj = vtkFileOutputWindow::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkFileOutputWindow(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of float /// @@ -25541,22 +12662,13 @@ fn test_vtkFileOutputWindow_create_drop() { #[allow(non_camel_case_types)] pub struct vtkFloatArray(*mut core::ffi::c_void); impl vtkFloatArray { - /// Creates a new [vtkFloatArray] wrapped inside `vtkNew` + /// Creates a new [vtkFloatArray] via `vtkFloatArray::New()` #[doc(alias = "vtkFloatArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkFloatArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkFloatArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkFloatArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkFloatArray_get_ptr(self.0) } + Self(unsafe { vtkFloatArray_new() }) } } impl std::default::Default for vtkFloatArray { @@ -25576,12 +12688,8 @@ impl Drop for vtkFloatArray { #[test] fn test_vtkFloatArray_create_drop() { let obj = vtkFloatArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkFloatArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Detect and break reference loops /// @@ -25647,22 +12755,13 @@ fn test_vtkFloatArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGarbageCollector(*mut core::ffi::c_void); impl vtkGarbageCollector { - /// Creates a new [vtkGarbageCollector] wrapped inside `vtkNew` + /// Creates a new [vtkGarbageCollector] via `vtkGarbageCollector::New()` #[doc(alias = "vtkGarbageCollector")] pub fn new() -> Self { unsafe extern "C" { fn vtkGarbageCollector_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGarbageCollector_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGarbageCollector_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGarbageCollector_get_ptr(self.0) } + Self(unsafe { vtkGarbageCollector_new() }) } } impl std::default::Default for vtkGarbageCollector { @@ -25682,12 +12781,8 @@ impl Drop for vtkGarbageCollector { #[test] fn test_vtkGarbageCollector_create_drop() { let obj = vtkGarbageCollector::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGarbageCollector(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// list of point or cell ids /// @@ -25698,22 +12793,13 @@ fn test_vtkGarbageCollector_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIdList(*mut core::ffi::c_void); impl vtkIdList { - /// Creates a new [vtkIdList] wrapped inside `vtkNew` + /// Creates a new [vtkIdList] via `vtkIdList::New()` #[doc(alias = "vtkIdList")] pub fn new() -> Self { unsafe extern "C" { fn vtkIdList_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIdList_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIdList_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIdList_get_ptr(self.0) } + Self(unsafe { vtkIdList_new() }) } } impl std::default::Default for vtkIdList { @@ -25733,12 +12819,8 @@ impl Drop for vtkIdList { #[test] fn test_vtkIdList_create_drop() { let obj = vtkIdList::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIdList(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain an ordered list of IdList objects /// @@ -25748,22 +12830,13 @@ fn test_vtkIdList_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIdListCollection(*mut core::ffi::c_void); impl vtkIdListCollection { - /// Creates a new [vtkIdListCollection] wrapped inside `vtkNew` + /// Creates a new [vtkIdListCollection] via `vtkIdListCollection::New()` #[doc(alias = "vtkIdListCollection")] pub fn new() -> Self { unsafe extern "C" { - fn vtkIdListCollection_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkIdListCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIdListCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + fn vtkIdListCollection_new() -> *mut core::ffi::c_void; } - unsafe { vtkIdListCollection_get_ptr(self.0) } + Self(unsafe { vtkIdListCollection_new() }) } } impl std::default::Default for vtkIdListCollection { @@ -25783,12 +12856,8 @@ impl Drop for vtkIdListCollection { #[test] fn test_vtkIdListCollection_create_drop() { let obj = vtkIdListCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIdListCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of vtkIdType /// @@ -25799,22 +12868,13 @@ fn test_vtkIdListCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIdTypeArray(*mut core::ffi::c_void); impl vtkIdTypeArray { - /// Creates a new [vtkIdTypeArray] wrapped inside `vtkNew` + /// Creates a new [vtkIdTypeArray] via `vtkIdTypeArray::New()` #[doc(alias = "vtkIdTypeArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkIdTypeArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIdTypeArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIdTypeArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIdTypeArray_get_ptr(self.0) } + Self(unsafe { vtkIdTypeArray_new() }) } } impl std::default::Default for vtkIdTypeArray { @@ -25834,12 +12894,8 @@ impl Drop for vtkIdTypeArray { #[test] fn test_vtkIdTypeArray_create_drop() { let obj = vtkIdTypeArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIdTypeArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Store vtkAlgorithm input/output information. /// @@ -25854,22 +12910,13 @@ fn test_vtkIdTypeArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkInformation(*mut core::ffi::c_void); impl vtkInformation { - /// Creates a new [vtkInformation] wrapped inside `vtkNew` + /// Creates a new [vtkInformation] via `vtkInformation::New()` #[doc(alias = "vtkInformation")] pub fn new() -> Self { unsafe extern "C" { fn vtkInformation_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkInformation_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkInformation_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkInformation_get_ptr(self.0) } + Self(unsafe { vtkInformation_new() }) } } impl std::default::Default for vtkInformation { @@ -25889,12 +12936,8 @@ impl Drop for vtkInformation { #[test] fn test_vtkInformation_create_drop() { let obj = vtkInformation::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkInformation(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates over keys of an information object /// @@ -25908,22 +12951,13 @@ fn test_vtkInformation_create_drop() { #[allow(non_camel_case_types)] pub struct vtkInformationIterator(*mut core::ffi::c_void); impl vtkInformationIterator { - /// Creates a new [vtkInformationIterator] wrapped inside `vtkNew` + /// Creates a new [vtkInformationIterator] via `vtkInformationIterator::New()` #[doc(alias = "vtkInformationIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkInformationIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkInformationIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkInformationIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkInformationIterator_get_ptr(self.0) } + Self(unsafe { vtkInformationIterator_new() }) } } impl std::default::Default for vtkInformationIterator { @@ -25943,12 +12977,8 @@ impl Drop for vtkInformationIterator { #[test] fn test_vtkInformationIterator_create_drop() { let obj = vtkInformationIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkInformationIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Find vtkInformationKeys from name and /// @@ -25956,22 +12986,13 @@ fn test_vtkInformationIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkInformationKeyLookup(*mut core::ffi::c_void); impl vtkInformationKeyLookup { - /// Creates a new [vtkInformationKeyLookup] wrapped inside `vtkNew` + /// Creates a new [vtkInformationKeyLookup] via `vtkInformationKeyLookup::New()` #[doc(alias = "vtkInformationKeyLookup")] pub fn new() -> Self { unsafe extern "C" { fn vtkInformationKeyLookup_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkInformationKeyLookup_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkInformationKeyLookup_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkInformationKeyLookup_get_ptr(self.0) } + Self(unsafe { vtkInformationKeyLookup_new() }) } } impl std::default::Default for vtkInformationKeyLookup { @@ -25991,12 +13012,8 @@ impl Drop for vtkInformationKeyLookup { #[test] fn test_vtkInformationKeyLookup_create_drop() { let obj = vtkInformationKeyLookup::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkInformationKeyLookup(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Store zero or more vtkInformation instances. /// @@ -26009,22 +13026,13 @@ fn test_vtkInformationKeyLookup_create_drop() { #[allow(non_camel_case_types)] pub struct vtkInformationVector(*mut core::ffi::c_void); impl vtkInformationVector { - /// Creates a new [vtkInformationVector] wrapped inside `vtkNew` + /// Creates a new [vtkInformationVector] via `vtkInformationVector::New()` #[doc(alias = "vtkInformationVector")] pub fn new() -> Self { unsafe extern "C" { fn vtkInformationVector_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkInformationVector_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkInformationVector_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkInformationVector_get_ptr(self.0) } + Self(unsafe { vtkInformationVector_new() }) } } impl std::default::Default for vtkInformationVector { @@ -26044,12 +13052,8 @@ impl Drop for vtkInformationVector { #[test] fn test_vtkInformationVector_create_drop() { let obj = vtkInformationVector::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkInformationVector(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of int /// @@ -26064,22 +13068,13 @@ fn test_vtkInformationVector_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIntArray(*mut core::ffi::c_void); impl vtkIntArray { - /// Creates a new [vtkIntArray] wrapped inside `vtkNew` + /// Creates a new [vtkIntArray] via `vtkIntArray::New()` #[doc(alias = "vtkIntArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkIntArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIntArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIntArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIntArray_get_ptr(self.0) } + Self(unsafe { vtkIntArray_new() }) } } impl std::default::Default for vtkIntArray { @@ -26099,12 +13094,8 @@ impl Drop for vtkIntArray { #[test] fn test_vtkIntArray_create_drop() { let obj = vtkIntArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIntArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of long /// @@ -26120,22 +13111,13 @@ fn test_vtkIntArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLongArray(*mut core::ffi::c_void); impl vtkLongArray { - /// Creates a new [vtkLongArray] wrapped inside `vtkNew` + /// Creates a new [vtkLongArray] via `vtkLongArray::New()` #[doc(alias = "vtkLongArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkLongArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLongArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLongArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLongArray_get_ptr(self.0) } + Self(unsafe { vtkLongArray_new() }) } } impl std::default::Default for vtkLongArray { @@ -26155,12 +13137,8 @@ impl Drop for vtkLongArray { #[test] fn test_vtkLongArray_create_drop() { let obj = vtkLongArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLongArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of long long /// @@ -26175,22 +13153,13 @@ fn test_vtkLongArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLongLongArray(*mut core::ffi::c_void); impl vtkLongLongArray { - /// Creates a new [vtkLongLongArray] wrapped inside `vtkNew` + /// Creates a new [vtkLongLongArray] via `vtkLongLongArray::New()` #[doc(alias = "vtkLongLongArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkLongLongArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLongLongArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLongLongArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLongLongArray_get_ptr(self.0) } + Self(unsafe { vtkLongLongArray_new() }) } } impl std::default::Default for vtkLongLongArray { @@ -26210,12 +13179,8 @@ impl Drop for vtkLongLongArray { #[test] fn test_vtkLongLongArray_create_drop() { let obj = vtkLongLongArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLongLongArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// map scalar values into colors via a lookup table /// @@ -26256,22 +13221,13 @@ fn test_vtkLongLongArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLookupTable(*mut core::ffi::c_void); impl vtkLookupTable { - /// Creates a new [vtkLookupTable] wrapped inside `vtkNew` + /// Creates a new [vtkLookupTable] via `vtkLookupTable::New()` #[doc(alias = "vtkLookupTable")] pub fn new() -> Self { unsafe extern "C" { fn vtkLookupTable_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLookupTable_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLookupTable_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLookupTable_get_ptr(self.0) } + Self(unsafe { vtkLookupTable_new() }) } } impl std::default::Default for vtkLookupTable { @@ -26291,12 +13247,8 @@ impl Drop for vtkLookupTable { #[test] fn test_vtkLookupTable_create_drop() { let obj = vtkLookupTable::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLookupTable(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// performs common math operations /// @@ -26312,20 +13264,13 @@ fn test_vtkLookupTable_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMath(*mut core::ffi::c_void); impl vtkMath { - /// Creates a new [vtkMath] wrapped inside `vtkNew` + /// Creates a new [vtkMath] via `vtkMath::New()` #[doc(alias = "vtkMath")] pub fn new() -> Self { unsafe extern "C" { fn vtkMath_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMath_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMath_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkMath_get_ptr(self.0) } + Self(unsafe { vtkMath_new() }) } } impl std::default::Default for vtkMath { @@ -26345,12 +13290,8 @@ impl Drop for vtkMath { #[test] fn test_vtkMath_create_drop() { let obj = vtkMath::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMath(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generator for Mersenne Twister pseudorandom numbers /// @@ -26376,22 +13317,13 @@ fn test_vtkMath_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMersenneTwister(*mut core::ffi::c_void); impl vtkMersenneTwister { - /// Creates a new [vtkMersenneTwister] wrapped inside `vtkNew` + /// Creates a new [vtkMersenneTwister] via `vtkMersenneTwister::New()` #[doc(alias = "vtkMersenneTwister")] pub fn new() -> Self { unsafe extern "C" { fn vtkMersenneTwister_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMersenneTwister_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMersenneTwister_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMersenneTwister_get_ptr(self.0) } + Self(unsafe { vtkMersenneTwister_new() }) } } impl std::default::Default for vtkMersenneTwister { @@ -26411,12 +13343,8 @@ impl Drop for vtkMersenneTwister { #[test] fn test_vtkMersenneTwister_create_drop() { let obj = vtkMersenneTwister::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMersenneTwister(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Park and Miller Sequence of pseudo random numbers /// @@ -26439,22 +13367,13 @@ fn test_vtkMersenneTwister_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMinimalStandardRandomSequence(*mut core::ffi::c_void); impl vtkMinimalStandardRandomSequence { - /// Creates a new [vtkMinimalStandardRandomSequence] wrapped inside `vtkNew` + /// Creates a new [vtkMinimalStandardRandomSequence] via `vtkMinimalStandardRandomSequence::New()` #[doc(alias = "vtkMinimalStandardRandomSequence")] pub fn new() -> Self { unsafe extern "C" { fn vtkMinimalStandardRandomSequence_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMinimalStandardRandomSequence_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMinimalStandardRandomSequence_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMinimalStandardRandomSequence_get_ptr(self.0) } + Self(unsafe { vtkMinimalStandardRandomSequence_new() }) } } impl std::default::Default for vtkMinimalStandardRandomSequence { @@ -26476,12 +13395,8 @@ impl Drop for vtkMinimalStandardRandomSequence { #[test] fn test_vtkMinimalStandardRandomSequence_create_drop() { let obj = vtkMinimalStandardRandomSequence::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMinimalStandardRandomSequence(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A class for performing multithreaded execution /// @@ -26493,22 +13408,13 @@ fn test_vtkMinimalStandardRandomSequence_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMultiThreader(*mut core::ffi::c_void); impl vtkMultiThreader { - /// Creates a new [vtkMultiThreader] wrapped inside `vtkNew` + /// Creates a new [vtkMultiThreader] via `vtkMultiThreader::New()` #[doc(alias = "vtkMultiThreader")] pub fn new() -> Self { unsafe extern "C" { fn vtkMultiThreader_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMultiThreader_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMultiThreader_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMultiThreader_get_ptr(self.0) } + Self(unsafe { vtkMultiThreader_new() }) } } impl std::default::Default for vtkMultiThreader { @@ -26528,12 +13434,8 @@ impl Drop for vtkMultiThreader { #[test] fn test_vtkMultiThreader_create_drop() { let obj = vtkMultiThreader::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMultiThreader(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// abstract base class for most VTK objects /// @@ -26561,22 +13463,13 @@ fn test_vtkMultiThreader_create_drop() { #[allow(non_camel_case_types)] pub struct vtkObject(*mut core::ffi::c_void); impl vtkObject { - /// Creates a new [vtkObject] wrapped inside `vtkNew` + /// Creates a new [vtkObject] via `vtkObject::New()` #[doc(alias = "vtkObject")] pub fn new() -> Self { unsafe extern "C" { fn vtkObject_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkObject_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkObject_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkObject_get_ptr(self.0) } + Self(unsafe { vtkObject_new() }) } } impl std::default::Default for vtkObject { @@ -26596,12 +13489,8 @@ impl Drop for vtkObject { #[test] fn test_vtkObject_create_drop() { let obj = vtkObject::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkObject(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of object factories /// @@ -26614,22 +13503,13 @@ fn test_vtkObject_create_drop() { #[allow(non_camel_case_types)] pub struct vtkObjectFactoryCollection(*mut core::ffi::c_void); impl vtkObjectFactoryCollection { - /// Creates a new [vtkObjectFactoryCollection] wrapped inside `vtkNew` + /// Creates a new [vtkObjectFactoryCollection] via `vtkObjectFactoryCollection::New()` #[doc(alias = "vtkObjectFactoryCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkObjectFactoryCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkObjectFactoryCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkObjectFactoryCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkObjectFactoryCollection_get_ptr(self.0) } + Self(unsafe { vtkObjectFactoryCollection_new() }) } } impl std::default::Default for vtkObjectFactoryCollection { @@ -26649,12 +13529,8 @@ impl Drop for vtkObjectFactoryCollection { #[test] fn test_vtkObjectFactoryCollection_create_drop() { let obj = vtkObjectFactoryCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkObjectFactoryCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// supports legacy function callbacks for VTK /// @@ -26675,22 +13551,13 @@ fn test_vtkObjectFactoryCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOldStyleCallbackCommand(*mut core::ffi::c_void); impl vtkOldStyleCallbackCommand { - /// Creates a new [vtkOldStyleCallbackCommand] wrapped inside `vtkNew` + /// Creates a new [vtkOldStyleCallbackCommand] via `vtkOldStyleCallbackCommand::New()` #[doc(alias = "vtkOldStyleCallbackCommand")] pub fn new() -> Self { unsafe extern "C" { fn vtkOldStyleCallbackCommand_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOldStyleCallbackCommand_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOldStyleCallbackCommand_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOldStyleCallbackCommand_get_ptr(self.0) } + Self(unsafe { vtkOldStyleCallbackCommand_new() }) } } impl std::default::Default for vtkOldStyleCallbackCommand { @@ -26710,12 +13577,8 @@ impl Drop for vtkOldStyleCallbackCommand { #[test] fn test_vtkOldStyleCallbackCommand_create_drop() { let obj = vtkOldStyleCallbackCommand::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOldStyleCallbackCommand(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// base class for writing debug output to a console /// @@ -26727,22 +13590,13 @@ fn test_vtkOldStyleCallbackCommand_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOutputWindow(*mut core::ffi::c_void); impl vtkOutputWindow { - /// Creates a new [vtkOutputWindow] wrapped inside `vtkNew` + /// Creates a new [vtkOutputWindow] via `vtkOutputWindow::New()` #[doc(alias = "vtkOutputWindow")] pub fn new() -> Self { unsafe extern "C" { fn vtkOutputWindow_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOutputWindow_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOutputWindow_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOutputWindow_get_ptr(self.0) } + Self(unsafe { vtkOutputWindow_new() }) } } impl std::default::Default for vtkOutputWindow { @@ -26762,12 +13616,8 @@ impl Drop for vtkOutputWindow { #[test] fn test_vtkOutputWindow_create_drop() { let obj = vtkOutputWindow::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOutputWindow(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of override information objects /// @@ -26779,22 +13629,13 @@ fn test_vtkOutputWindow_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOverrideInformationCollection(*mut core::ffi::c_void); impl vtkOverrideInformationCollection { - /// Creates a new [vtkOverrideInformationCollection] wrapped inside `vtkNew` + /// Creates a new [vtkOverrideInformationCollection] via `vtkOverrideInformationCollection::New()` #[doc(alias = "vtkOverrideInformationCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkOverrideInformationCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOverrideInformationCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOverrideInformationCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOverrideInformationCollection_get_ptr(self.0) } + Self(unsafe { vtkOverrideInformationCollection_new() }) } } impl std::default::Default for vtkOverrideInformationCollection { @@ -26816,12 +13657,8 @@ impl Drop for vtkOverrideInformationCollection { #[test] fn test_vtkOverrideInformationCollection_create_drop() { let obj = vtkOverrideInformationCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOverrideInformationCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate 3D points /// @@ -26831,22 +13668,13 @@ fn test_vtkOverrideInformationCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPoints(*mut core::ffi::c_void); impl vtkPoints { - /// Creates a new [vtkPoints] wrapped inside `vtkNew` + /// Creates a new [vtkPoints] via `vtkPoints::New()` #[doc(alias = "vtkPoints")] pub fn new() -> Self { unsafe extern "C" { fn vtkPoints_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPoints_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPoints_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPoints_get_ptr(self.0) } + Self(unsafe { vtkPoints_new() }) } } impl std::default::Default for vtkPoints { @@ -26866,12 +13694,8 @@ impl Drop for vtkPoints { #[test] fn test_vtkPoints_create_drop() { let obj = vtkPoints::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPoints(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate 2D points /// @@ -26881,22 +13705,13 @@ fn test_vtkPoints_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPoints2D(*mut core::ffi::c_void); impl vtkPoints2D { - /// Creates a new [vtkPoints2D] wrapped inside `vtkNew` + /// Creates a new [vtkPoints2D] via `vtkPoints2D::New()` #[doc(alias = "vtkPoints2D")] pub fn new() -> Self { unsafe extern "C" { fn vtkPoints2D_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPoints2D_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPoints2D_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPoints2D_get_ptr(self.0) } + Self(unsafe { vtkPoints2D_new() }) } } impl std::default::Default for vtkPoints2D { @@ -26916,12 +13731,8 @@ impl Drop for vtkPoints2D { #[test] fn test_vtkPoints2D_create_drop() { let obj = vtkPoints2D::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPoints2D(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a list of ids arranged in priority order /// @@ -26946,22 +13757,13 @@ fn test_vtkPoints2D_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPriorityQueue(*mut core::ffi::c_void); impl vtkPriorityQueue { - /// Creates a new [vtkPriorityQueue] wrapped inside `vtkNew` + /// Creates a new [vtkPriorityQueue] via `vtkPriorityQueue::New()` #[doc(alias = "vtkPriorityQueue")] pub fn new() -> Self { unsafe extern "C" { fn vtkPriorityQueue_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPriorityQueue_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPriorityQueue_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPriorityQueue_get_ptr(self.0) } + Self(unsafe { vtkPriorityQueue_new() }) } } impl std::default::Default for vtkPriorityQueue { @@ -26981,12 +13783,8 @@ impl Drop for vtkPriorityQueue { #[test] fn test_vtkPriorityQueue_create_drop() { let obj = vtkPriorityQueue::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPriorityQueue(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// convenience class to quickly generate a pool of random numbers /// @@ -27012,22 +13810,13 @@ fn test_vtkPriorityQueue_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRandomPool(*mut core::ffi::c_void); impl vtkRandomPool { - /// Creates a new [vtkRandomPool] wrapped inside `vtkNew` + /// Creates a new [vtkRandomPool] via `vtkRandomPool::New()` #[doc(alias = "vtkRandomPool")] pub fn new() -> Self { unsafe extern "C" { fn vtkRandomPool_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRandomPool_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRandomPool_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRandomPool_get_ptr(self.0) } + Self(unsafe { vtkRandomPool_new() }) } } impl std::default::Default for vtkRandomPool { @@ -27047,12 +13836,8 @@ impl Drop for vtkRandomPool { #[test] fn test_vtkRandomPool_create_drop() { let obj = vtkRandomPool::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRandomPool(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Obsolete / empty subclass of object. /// @@ -27063,22 +13848,13 @@ fn test_vtkRandomPool_create_drop() { #[allow(non_camel_case_types)] pub struct vtkReferenceCount(*mut core::ffi::c_void); impl vtkReferenceCount { - /// Creates a new [vtkReferenceCount] wrapped inside `vtkNew` + /// Creates a new [vtkReferenceCount] via `vtkReferenceCount::New()` #[doc(alias = "vtkReferenceCount")] pub fn new() -> Self { unsafe extern "C" { fn vtkReferenceCount_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkReferenceCount_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkReferenceCount_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkReferenceCount_get_ptr(self.0) } + Self(unsafe { vtkReferenceCount_new() }) } } impl std::default::Default for vtkReferenceCount { @@ -27098,12 +13874,8 @@ impl Drop for vtkReferenceCount { #[test] fn test_vtkReferenceCount_create_drop() { let obj = vtkReferenceCount::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkReferenceCount(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for mapping scalar values to colors /// @@ -27136,22 +13908,13 @@ fn test_vtkReferenceCount_create_drop() { #[allow(non_camel_case_types)] pub struct vtkScalarsToColors(*mut core::ffi::c_void); impl vtkScalarsToColors { - /// Creates a new [vtkScalarsToColors] wrapped inside `vtkNew` + /// Creates a new [vtkScalarsToColors] via `vtkScalarsToColors::New()` #[doc(alias = "vtkScalarsToColors")] pub fn new() -> Self { unsafe extern "C" { fn vtkScalarsToColors_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkScalarsToColors_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkScalarsToColors_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkScalarsToColors_get_ptr(self.0) } + Self(unsafe { vtkScalarsToColors_new() }) } } impl std::default::Default for vtkScalarsToColors { @@ -27171,12 +13934,8 @@ impl Drop for vtkScalarsToColors { #[test] fn test_vtkScalarsToColors_create_drop() { let obj = vtkScalarsToColors::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkScalarsToColors(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of short /// @@ -27191,22 +13950,13 @@ fn test_vtkScalarsToColors_create_drop() { #[allow(non_camel_case_types)] pub struct vtkShortArray(*mut core::ffi::c_void); impl vtkShortArray { - /// Creates a new [vtkShortArray] wrapped inside `vtkNew` + /// Creates a new [vtkShortArray] via `vtkShortArray::New()` #[doc(alias = "vtkShortArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkShortArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkShortArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkShortArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkShortArray_get_ptr(self.0) } + Self(unsafe { vtkShortArray_new() }) } } impl std::default::Default for vtkShortArray { @@ -27226,12 +13976,8 @@ impl Drop for vtkShortArray { #[test] fn test_vtkShortArray_create_drop() { let obj = vtkShortArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkShortArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of signed char /// @@ -27242,22 +13988,13 @@ fn test_vtkShortArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSignedCharArray(*mut core::ffi::c_void); impl vtkSignedCharArray { - /// Creates a new [vtkSignedCharArray] wrapped inside `vtkNew` + /// Creates a new [vtkSignedCharArray] via `vtkSignedCharArray::New()` #[doc(alias = "vtkSignedCharArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkSignedCharArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSignedCharArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSignedCharArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSignedCharArray_get_ptr(self.0) } + Self(unsafe { vtkSignedCharArray_new() }) } } impl std::default::Default for vtkSignedCharArray { @@ -27277,12 +14014,8 @@ impl Drop for vtkSignedCharArray { #[test] fn test_vtkSignedCharArray_create_drop() { let obj = vtkSignedCharArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSignedCharArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// provides several methods for sorting VTK arrays. /// @@ -27325,22 +14058,13 @@ fn test_vtkSignedCharArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSortDataArray(*mut core::ffi::c_void); impl vtkSortDataArray { - /// Creates a new [vtkSortDataArray] wrapped inside `vtkNew` + /// Creates a new [vtkSortDataArray] via `vtkSortDataArray::New()` #[doc(alias = "vtkSortDataArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkSortDataArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSortDataArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSortDataArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSortDataArray_get_ptr(self.0) } + Self(unsafe { vtkSortDataArray_new() }) } } impl std::default::Default for vtkSortDataArray { @@ -27360,12 +14084,8 @@ impl Drop for vtkSortDataArray { #[test] fn test_vtkSortDataArray_create_drop() { let obj = vtkSortDataArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSortDataArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a vtkAbstractArray subclass for strings /// @@ -27378,22 +14098,13 @@ fn test_vtkSortDataArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStringArray(*mut core::ffi::c_void); impl vtkStringArray { - /// Creates a new [vtkStringArray] wrapped inside `vtkNew` + /// Creates a new [vtkStringArray] via `vtkStringArray::New()` #[doc(alias = "vtkStringArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkStringArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStringArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStringArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStringArray_get_ptr(self.0) } + Self(unsafe { vtkStringArray_new() }) } } impl std::default::Default for vtkStringArray { @@ -27413,12 +14124,8 @@ impl Drop for vtkStringArray { #[test] fn test_vtkStringArray_create_drop() { let obj = vtkStringArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStringArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// File Specific output window class /// @@ -27428,22 +14135,13 @@ fn test_vtkStringArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStringOutputWindow(*mut core::ffi::c_void); impl vtkStringOutputWindow { - /// Creates a new [vtkStringOutputWindow] wrapped inside `vtkNew` + /// Creates a new [vtkStringOutputWindow] via `vtkStringOutputWindow::New()` #[doc(alias = "vtkStringOutputWindow")] pub fn new() -> Self { unsafe extern "C" { fn vtkStringOutputWindow_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStringOutputWindow_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStringOutputWindow_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStringOutputWindow_get_ptr(self.0) } + Self(unsafe { vtkStringOutputWindow_new() }) } } impl std::default::Default for vtkStringOutputWindow { @@ -27463,12 +14161,8 @@ impl Drop for vtkStringOutputWindow { #[test] fn test_vtkStringOutputWindow_create_drop() { let obj = vtkStringOutputWindow::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStringOutputWindow(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// performs common time operations /// @@ -27478,22 +14172,13 @@ fn test_vtkStringOutputWindow_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTimePointUtility(*mut core::ffi::c_void); impl vtkTimePointUtility { - /// Creates a new [vtkTimePointUtility] wrapped inside `vtkNew` + /// Creates a new [vtkTimePointUtility] via `vtkTimePointUtility::New()` #[doc(alias = "vtkTimePointUtility")] pub fn new() -> Self { unsafe extern "C" { fn vtkTimePointUtility_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTimePointUtility_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTimePointUtility_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTimePointUtility_get_ptr(self.0) } + Self(unsafe { vtkTimePointUtility_new() }) } } impl std::default::Default for vtkTimePointUtility { @@ -27513,33 +14198,20 @@ impl Drop for vtkTimePointUtility { #[test] fn test_vtkTimePointUtility_create_drop() { let obj = vtkTimePointUtility::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTimePointUtility(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeFloat32Array(*mut core::ffi::c_void); impl vtkTypeFloat32Array { - /// Creates a new [vtkTypeFloat32Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeFloat32Array] via `vtkTypeFloat32Array::New()` #[doc(alias = "vtkTypeFloat32Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeFloat32Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeFloat32Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeFloat32Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeFloat32Array_get_ptr(self.0) } + Self(unsafe { vtkTypeFloat32Array_new() }) } } impl std::default::Default for vtkTypeFloat32Array { @@ -27559,33 +14231,20 @@ impl Drop for vtkTypeFloat32Array { #[test] fn test_vtkTypeFloat32Array_create_drop() { let obj = vtkTypeFloat32Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeFloat32Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeFloat64Array(*mut core::ffi::c_void); impl vtkTypeFloat64Array { - /// Creates a new [vtkTypeFloat64Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeFloat64Array] via `vtkTypeFloat64Array::New()` #[doc(alias = "vtkTypeFloat64Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeFloat64Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeFloat64Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeFloat64Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeFloat64Array_get_ptr(self.0) } + Self(unsafe { vtkTypeFloat64Array_new() }) } } impl std::default::Default for vtkTypeFloat64Array { @@ -27605,33 +14264,20 @@ impl Drop for vtkTypeFloat64Array { #[test] fn test_vtkTypeFloat64Array_create_drop() { let obj = vtkTypeFloat64Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeFloat64Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeInt16Array(*mut core::ffi::c_void); impl vtkTypeInt16Array { - /// Creates a new [vtkTypeInt16Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeInt16Array] via `vtkTypeInt16Array::New()` #[doc(alias = "vtkTypeInt16Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeInt16Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeInt16Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeInt16Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeInt16Array_get_ptr(self.0) } + Self(unsafe { vtkTypeInt16Array_new() }) } } impl std::default::Default for vtkTypeInt16Array { @@ -27651,33 +14297,20 @@ impl Drop for vtkTypeInt16Array { #[test] fn test_vtkTypeInt16Array_create_drop() { let obj = vtkTypeInt16Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeInt16Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeInt32Array(*mut core::ffi::c_void); impl vtkTypeInt32Array { - /// Creates a new [vtkTypeInt32Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeInt32Array] via `vtkTypeInt32Array::New()` #[doc(alias = "vtkTypeInt32Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeInt32Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeInt32Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeInt32Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeInt32Array_get_ptr(self.0) } + Self(unsafe { vtkTypeInt32Array_new() }) } } impl std::default::Default for vtkTypeInt32Array { @@ -27697,33 +14330,20 @@ impl Drop for vtkTypeInt32Array { #[test] fn test_vtkTypeInt32Array_create_drop() { let obj = vtkTypeInt32Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeInt32Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeInt64Array(*mut core::ffi::c_void); impl vtkTypeInt64Array { - /// Creates a new [vtkTypeInt64Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeInt64Array] via `vtkTypeInt64Array::New()` #[doc(alias = "vtkTypeInt64Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeInt64Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeInt64Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeInt64Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeInt64Array_get_ptr(self.0) } + Self(unsafe { vtkTypeInt64Array_new() }) } } impl std::default::Default for vtkTypeInt64Array { @@ -27743,33 +14363,20 @@ impl Drop for vtkTypeInt64Array { #[test] fn test_vtkTypeInt64Array_create_drop() { let obj = vtkTypeInt64Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeInt64Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeInt8Array(*mut core::ffi::c_void); impl vtkTypeInt8Array { - /// Creates a new [vtkTypeInt8Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeInt8Array] via `vtkTypeInt8Array::New()` #[doc(alias = "vtkTypeInt8Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeInt8Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeInt8Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeInt8Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeInt8Array_get_ptr(self.0) } + Self(unsafe { vtkTypeInt8Array_new() }) } } impl std::default::Default for vtkTypeInt8Array { @@ -27789,33 +14396,20 @@ impl Drop for vtkTypeInt8Array { #[test] fn test_vtkTypeInt8Array_create_drop() { let obj = vtkTypeInt8Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeInt8Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeUInt16Array(*mut core::ffi::c_void); impl vtkTypeUInt16Array { - /// Creates a new [vtkTypeUInt16Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeUInt16Array] via `vtkTypeUInt16Array::New()` #[doc(alias = "vtkTypeUInt16Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeUInt16Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeUInt16Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeUInt16Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeUInt16Array_get_ptr(self.0) } + Self(unsafe { vtkTypeUInt16Array_new() }) } } impl std::default::Default for vtkTypeUInt16Array { @@ -27835,33 +14429,20 @@ impl Drop for vtkTypeUInt16Array { #[test] fn test_vtkTypeUInt16Array_create_drop() { let obj = vtkTypeUInt16Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeUInt16Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeUInt32Array(*mut core::ffi::c_void); impl vtkTypeUInt32Array { - /// Creates a new [vtkTypeUInt32Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeUInt32Array] via `vtkTypeUInt32Array::New()` #[doc(alias = "vtkTypeUInt32Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeUInt32Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeUInt32Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeUInt32Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeUInt32Array_get_ptr(self.0) } + Self(unsafe { vtkTypeUInt32Array_new() }) } } impl std::default::Default for vtkTypeUInt32Array { @@ -27881,33 +14462,20 @@ impl Drop for vtkTypeUInt32Array { #[test] fn test_vtkTypeUInt32Array_create_drop() { let obj = vtkTypeUInt32Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeUInt32Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeUInt64Array(*mut core::ffi::c_void); impl vtkTypeUInt64Array { - /// Creates a new [vtkTypeUInt64Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeUInt64Array] via `vtkTypeUInt64Array::New()` #[doc(alias = "vtkTypeUInt64Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeUInt64Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeUInt64Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeUInt64Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeUInt64Array_get_ptr(self.0) } + Self(unsafe { vtkTypeUInt64Array_new() }) } } impl std::default::Default for vtkTypeUInt64Array { @@ -27927,33 +14495,20 @@ impl Drop for vtkTypeUInt64Array { #[test] fn test_vtkTypeUInt64Array_create_drop() { let obj = vtkTypeUInt64Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeUInt64Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeUInt8Array(*mut core::ffi::c_void); impl vtkTypeUInt8Array { - /// Creates a new [vtkTypeUInt8Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeUInt8Array] via `vtkTypeUInt8Array::New()` #[doc(alias = "vtkTypeUInt8Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeUInt8Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeUInt8Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeUInt8Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeUInt8Array_get_ptr(self.0) } + Self(unsafe { vtkTypeUInt8Array_new() }) } } impl std::default::Default for vtkTypeUInt8Array { @@ -27973,12 +14528,8 @@ impl Drop for vtkTypeUInt8Array { #[test] fn test_vtkTypeUInt8Array_create_drop() { let obj = vtkTypeUInt8Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeUInt8Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Subclass of vtkAbstractArray that holds vtkUnicodeStrings /// @@ -27990,22 +14541,13 @@ fn test_vtkTypeUInt8Array_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnicodeStringArray(*mut core::ffi::c_void); impl vtkUnicodeStringArray { - /// Creates a new [vtkUnicodeStringArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnicodeStringArray] via `vtkUnicodeStringArray::New()` #[doc(alias = "vtkUnicodeStringArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnicodeStringArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnicodeStringArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnicodeStringArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnicodeStringArray_get_ptr(self.0) } + Self(unsafe { vtkUnicodeStringArray_new() }) } } impl std::default::Default for vtkUnicodeStringArray { @@ -28025,12 +14567,8 @@ impl Drop for vtkUnicodeStringArray { #[test] fn test_vtkUnicodeStringArray_create_drop() { let obj = vtkUnicodeStringArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnicodeStringArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of unsigned char /// @@ -28041,22 +14579,13 @@ fn test_vtkUnicodeStringArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnsignedCharArray(*mut core::ffi::c_void); impl vtkUnsignedCharArray { - /// Creates a new [vtkUnsignedCharArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnsignedCharArray] via `vtkUnsignedCharArray::New()` #[doc(alias = "vtkUnsignedCharArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnsignedCharArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnsignedCharArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnsignedCharArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnsignedCharArray_get_ptr(self.0) } + Self(unsafe { vtkUnsignedCharArray_new() }) } } impl std::default::Default for vtkUnsignedCharArray { @@ -28076,12 +14605,8 @@ impl Drop for vtkUnsignedCharArray { #[test] fn test_vtkUnsignedCharArray_create_drop() { let obj = vtkUnsignedCharArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnsignedCharArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of unsigned int /// @@ -28096,22 +14621,13 @@ fn test_vtkUnsignedCharArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnsignedIntArray(*mut core::ffi::c_void); impl vtkUnsignedIntArray { - /// Creates a new [vtkUnsignedIntArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnsignedIntArray] via `vtkUnsignedIntArray::New()` #[doc(alias = "vtkUnsignedIntArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnsignedIntArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnsignedIntArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnsignedIntArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnsignedIntArray_get_ptr(self.0) } + Self(unsafe { vtkUnsignedIntArray_new() }) } } impl std::default::Default for vtkUnsignedIntArray { @@ -28131,12 +14647,8 @@ impl Drop for vtkUnsignedIntArray { #[test] fn test_vtkUnsignedIntArray_create_drop() { let obj = vtkUnsignedIntArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnsignedIntArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of unsigned long /// @@ -28153,22 +14665,13 @@ fn test_vtkUnsignedIntArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnsignedLongArray(*mut core::ffi::c_void); impl vtkUnsignedLongArray { - /// Creates a new [vtkUnsignedLongArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnsignedLongArray] via `vtkUnsignedLongArray::New()` #[doc(alias = "vtkUnsignedLongArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnsignedLongArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnsignedLongArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnsignedLongArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnsignedLongArray_get_ptr(self.0) } + Self(unsafe { vtkUnsignedLongArray_new() }) } } impl std::default::Default for vtkUnsignedLongArray { @@ -28188,12 +14691,8 @@ impl Drop for vtkUnsignedLongArray { #[test] fn test_vtkUnsignedLongArray_create_drop() { let obj = vtkUnsignedLongArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnsignedLongArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of unsigned long long /// @@ -28208,22 +14707,13 @@ fn test_vtkUnsignedLongArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnsignedLongLongArray(*mut core::ffi::c_void); impl vtkUnsignedLongLongArray { - /// Creates a new [vtkUnsignedLongLongArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnsignedLongLongArray] via `vtkUnsignedLongLongArray::New()` #[doc(alias = "vtkUnsignedLongLongArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnsignedLongLongArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnsignedLongLongArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnsignedLongLongArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnsignedLongLongArray_get_ptr(self.0) } + Self(unsafe { vtkUnsignedLongLongArray_new() }) } } impl std::default::Default for vtkUnsignedLongLongArray { @@ -28243,12 +14733,8 @@ impl Drop for vtkUnsignedLongLongArray { #[test] fn test_vtkUnsignedLongLongArray_create_drop() { let obj = vtkUnsignedLongLongArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnsignedLongLongArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of unsigned short /// @@ -28263,22 +14749,13 @@ fn test_vtkUnsignedLongLongArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnsignedShortArray(*mut core::ffi::c_void); impl vtkUnsignedShortArray { - /// Creates a new [vtkUnsignedShortArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnsignedShortArray] via `vtkUnsignedShortArray::New()` #[doc(alias = "vtkUnsignedShortArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnsignedShortArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnsignedShortArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnsignedShortArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnsignedShortArray_get_ptr(self.0) } + Self(unsafe { vtkUnsignedShortArray_new() }) } } impl std::default::Default for vtkUnsignedShortArray { @@ -28298,12 +14775,8 @@ impl Drop for vtkUnsignedShortArray { #[test] fn test_vtkUnsignedShortArray_create_drop() { let obj = vtkUnsignedShortArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnsignedShortArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// An array holding vtkVariants. /// @@ -28316,22 +14789,13 @@ fn test_vtkUnsignedShortArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVariantArray(*mut core::ffi::c_void); impl vtkVariantArray { - /// Creates a new [vtkVariantArray] wrapped inside `vtkNew` + /// Creates a new [vtkVariantArray] via `vtkVariantArray::New()` #[doc(alias = "vtkVariantArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkVariantArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVariantArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVariantArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkVariantArray_get_ptr(self.0) } + Self(unsafe { vtkVariantArray_new() }) } } impl std::default::Default for vtkVariantArray { @@ -28351,12 +14815,8 @@ impl Drop for vtkVariantArray { #[test] fn test_vtkVariantArray_create_drop() { let obj = vtkVariantArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVariantArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Versioning class for vtk /// @@ -28370,22 +14830,13 @@ fn test_vtkVariantArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVersion(*mut core::ffi::c_void); impl vtkVersion { - /// Creates a new [vtkVersion] wrapped inside `vtkNew` + /// Creates a new [vtkVersion] via `vtkVersion::New()` #[doc(alias = "vtkVersion")] pub fn new() -> Self { unsafe extern "C" { fn vtkVersion_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVersion_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVersion_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkVersion_get_ptr(self.0) } + Self(unsafe { vtkVersion_new() }) } } impl std::default::Default for vtkVersion { @@ -28405,12 +14856,8 @@ impl Drop for vtkVersion { #[test] fn test_vtkVersion_create_drop() { let obj = vtkVersion::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVersion(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of void* pointers /// @@ -28421,22 +14868,13 @@ fn test_vtkVersion_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVoidArray(*mut core::ffi::c_void); impl vtkVoidArray { - /// Creates a new [vtkVoidArray] wrapped inside `vtkNew` + /// Creates a new [vtkVoidArray] via `vtkVoidArray::New()` #[doc(alias = "vtkVoidArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkVoidArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVoidArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVoidArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkVoidArray_get_ptr(self.0) } + Self(unsafe { vtkVoidArray_new() }) } } impl std::default::Default for vtkVoidArray { @@ -28456,12 +14894,8 @@ impl Drop for vtkVoidArray { #[test] fn test_vtkVoidArray_create_drop() { let obj = vtkVoidArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVoidArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Utility class to hold a weak reference to a vtkObject. /// @@ -28471,22 +14905,13 @@ fn test_vtkVoidArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkWeakReference(*mut core::ffi::c_void); impl vtkWeakReference { - /// Creates a new [vtkWeakReference] wrapped inside `vtkNew` + /// Creates a new [vtkWeakReference] via `vtkWeakReference::New()` #[doc(alias = "vtkWeakReference")] pub fn new() -> Self { unsafe extern "C" { fn vtkWeakReference_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkWeakReference_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkWeakReference_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkWeakReference_get_ptr(self.0) } + Self(unsafe { vtkWeakReference_new() }) } } impl std::default::Default for vtkWeakReference { @@ -28506,12 +14931,8 @@ impl Drop for vtkWeakReference { #[test] fn test_vtkWeakReference_create_drop() { let obj = vtkWeakReference::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkWeakReference(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// XML File Specific output window class /// @@ -28535,22 +14956,13 @@ fn test_vtkWeakReference_create_drop() { #[allow(non_camel_case_types)] pub struct vtkXMLFileOutputWindow(*mut core::ffi::c_void); impl vtkXMLFileOutputWindow { - /// Creates a new [vtkXMLFileOutputWindow] wrapped inside `vtkNew` + /// Creates a new [vtkXMLFileOutputWindow] via `vtkXMLFileOutputWindow::New()` #[doc(alias = "vtkXMLFileOutputWindow")] pub fn new() -> Self { unsafe extern "C" { fn vtkXMLFileOutputWindow_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkXMLFileOutputWindow_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkXMLFileOutputWindow_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkXMLFileOutputWindow_get_ptr(self.0) } + Self(unsafe { vtkXMLFileOutputWindow_new() }) } } impl std::default::Default for vtkXMLFileOutputWindow { @@ -28570,10 +14982,6 @@ impl Drop for vtkXMLFileOutputWindow { #[test] fn test_vtkXMLFileOutputWindow_create_drop() { let obj = vtkXMLFileOutputWindow::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkXMLFileOutputWindow(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonDataModel.rs b/vtk-rs-9.1/src/vtkCommonDataModel.rs index 87d8e1b..92ffc6c 100644 --- a/vtk-rs-9.1/src/vtkCommonDataModel.rs +++ b/vtk-rs-9.1/src/vtkCommonDataModel.rs @@ -11,42 +11,11 @@ pub trait VtkAMRBox { khi: core::ffi::c_int, desc: core::ffi::c_int, ) -> (); - fn set_dimensions( - &mut self, - lo: core::ffi::c_int, - hi: core::ffi::c_int, - desc: core::ffi::c_int, - ) -> (); - fn set_dimensions(&mut self, dims: core::ffi::c_int, desc: core::ffi::c_int) -> (); - fn get_dimensions(&mut self, lo: core::ffi::c_int, hi: core::ffi::c_int) -> (); - fn get_dimensions(&mut self, dims: core::ffi::c_int) -> (); - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; - fn get_number_of_cells(&mut self, num: core::ffi::c_int) -> (); - fn get_number_of_nodes(&mut self, ext: core::ffi::c_int) -> (); - fn get_number_of_nodes(&mut self) -> core::ffi::c_uchar; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_number_of_nodes(&mut self) -> core::ffi::c_longlong; fn compute_dimension(&mut self) -> core::ffi::c_int; - fn get_lo_corner(&mut self) -> *const core::ffi::c_int; - fn get_hi_corner(&mut self) -> *const core::ffi::c_int; - fn get_valid_hi_corner(&mut self, hi: core::ffi::c_int) -> (); fn empty(&mut self) -> bool; fn is_invalid(&mut self) -> bool; - fn serialize( - &mut self, - buffer: core::ffi::c_uchar, - bytesize: core::ffi::c_uchar, - ) -> (); - fn serialize(&mut self, buffer: core::ffi::c_int) -> (); - fn deserialize( - &mut self, - buffer: core::ffi::c_uchar, - bytesize: core::ffi::c_uchar, - ) -> (); - fn does_box_intersect_along_dimension( - &mut self, - other: vtkAMRBox, - q: core::ffi::c_int, - ) -> bool; - fn does_intersect(&mut self, other: vtkAMRBox) -> bool; fn coarsen(&mut self, r: core::ffi::c_int) -> (); fn refine(&mut self, r: core::ffi::c_int) -> (); fn grow(&mut self, byN: core::ffi::c_int) -> (); @@ -57,59 +26,14 @@ pub trait VtkAMRBox { j: core::ffi::c_int, k: core::ffi::c_int, ) -> (); - fn shift(&mut self, I: core::ffi::c_int) -> (); - fn intersect(&mut self, other: vtkAMRBox) -> bool; fn contains( &mut self, i: core::ffi::c_int, j: core::ffi::c_int, k: core::ffi::c_int, ) -> bool; - fn contains(&mut self, I: core::ffi::c_int) -> bool; - fn contains(&mut self, p0: vtkAMRBox) -> bool; - fn get_ghost_vector(&mut self, r: core::ffi::c_int, nghost: core::ffi::c_int) -> (); fn remove_ghosts(&mut self, r: core::ffi::c_int) -> (); - fn get_bytesize(&mut self) -> core::ffi::c_uchar; - fn get_cell_linear_index( - &mut self, - box_: vtkAMRBox, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - imageDimension: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_bounds( - &mut self, - box_: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - bounds: core::ffi::c_double, - ) -> (); - fn get_box_origin( - &mut self, - box_: vtkAMRBox, - X0: core::ffi::c_double, - spacing: core::ffi::c_double, - x0: core::ffi::c_double, - ) -> (); - fn has_point( - &mut self, - box_: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> bool; - fn compute_structured_coordinates( - &mut self, - box_: vtkAMRBox, - dataOrigin: core::ffi::c_double, - h: core::ffi::c_double, - x: core::ffi::c_double, - ijk: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; + fn get_bytesize(&mut self) -> core::ffi::c_longlong; } pub trait VtkAMRDataInternals { fn new(&mut self) -> *mut core::ffi::c_void; @@ -125,23 +49,13 @@ pub trait VtkAMRDataInternals { fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn empty(&mut self) -> bool; fn get_number_of_blocks(&mut self) -> core::ffi::c_uint; - fn get_block(&mut self, i: core::ffi::c_uint) -> Block; - fn get_all_blocks(&mut self) -> Vec; } pub trait VtkAMRInformation { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn initialize( - &mut self, - numLevels: core::ffi::c_int, - blocksPerLevel: core::ffi::c_int, - ) -> (); fn get_grid_description(&mut self) -> core::ffi::c_int; fn set_grid_description(&mut self, description: core::ffi::c_int) -> (); - fn get_origin(&mut self, origin: core::ffi::c_double) -> (); - fn get_origin(&mut self) -> *mut core::ffi::c_double; - fn set_origin(&mut self, origin: core::ffi::c_double) -> (); fn get_number_of_levels(&mut self) -> core::ffi::c_uint; fn get_number_of_data_sets(&mut self, level: core::ffi::c_uint) -> core::ffi::c_uint; fn get_total_number_of_blocks(&mut self) -> core::ffi::c_uint; @@ -153,45 +67,10 @@ pub trait VtkAMRInformation { fn compute_index_pair( &mut self, index: core::ffi::c_uint, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - ) -> (); - fn get_bounds(&mut self) -> *const core::ffi::c_double; - fn get_bounds( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - bb: core::ffi::c_double, - ) -> (); - fn get_origin( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - origin: core::ffi::c_double, - ) -> bool; - fn get_spacing( - &mut self, - level: core::ffi::c_uint, - spacing: core::ffi::c_double, + level: &mut core::ffi::c_uint, + id: &mut core::ffi::c_uint, ) -> (); fn has_spacing(&mut self, level: core::ffi::c_uint) -> bool; - fn set_amr_box( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - box_: vtkAMRBox, - ) -> (); - fn get_amr_box( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - ) -> vtkAMRBox; - fn get_coarsened_amr_box( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - box_: *mut core::ffi::c_void, - ) -> bool; fn get_amr_block_source_index( &mut self, index: core::ffi::c_int, @@ -209,20 +88,7 @@ pub trait VtkAMRInformation { ratio: core::ffi::c_int, ) -> (); fn get_refinement_ratio(&mut self, level: core::ffi::c_uint) -> core::ffi::c_int; - fn set_spacing(&mut self, level: core::ffi::c_uint, h: core::ffi::c_double) -> (); fn has_children_information(&mut self) -> bool; - fn get_parents( - &mut self, - level: core::ffi::c_uint, - index: core::ffi::c_uint, - numParents: core::ffi::c_uint, - ) -> *mut core::ffi::c_uint; - fn get_children( - &mut self, - level: core::ffi::c_uint, - index: core::ffi::c_uint, - numChildren: core::ffi::c_uint, - ) -> *mut core::ffi::c_uint; fn print_parent_child_info( &mut self, level: core::ffi::c_uint, @@ -230,30 +96,6 @@ pub trait VtkAMRInformation { ) -> (); fn generate_parent_child_information(&mut self) -> (); fn audit(&mut self) -> bool; - fn find_cell( - &mut self, - q: core::ffi::c_double, - level: core::ffi::c_uint, - index: core::ffi::c_uint, - cellIdx: core::ffi::c_int, - ) -> bool; - fn find_grid( - &mut self, - q: core::ffi::c_double, - level: core::ffi::c_int, - gridId: core::ffi::c_uint, - ) -> bool; - fn find_grid( - &mut self, - q: core::ffi::c_double, - level: core::ffi::c_uint, - gridId: core::ffi::c_uint, - ) -> bool; - fn get_num_blocks(&mut self) -> Vec; - fn get_children_at_level( - &mut self, - i: core::ffi::c_uint, - ) -> Vec>; fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); } pub trait VtkAMRUtilities { @@ -281,22 +123,17 @@ pub trait VtkAbstractCellLinks { fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn compute_type( &mut self, - maxPtId: core::ffi::c_uchar, - maxCellId: core::ffi::c_uchar, + maxPtId: core::ffi::c_longlong, + maxCellId: core::ffi::c_longlong, ca: *mut core::ffi::c_void, ) -> core::ffi::c_int; fn get_type(&mut self) -> core::ffi::c_int; - fn select_cells( - &mut self, - minMaxDegree: core::ffi::c_uchar, - cellSelection: core::ffi::c_uchar, - ) -> (); fn set_sequential_processing(&mut self, _arg: bool) -> (); fn get_sequential_processing(&mut self) -> bool; fn sequential_processing_on(&mut self) -> (); fn sequential_processing_off(&mut self) -> (); } -pub trait VtkAbstractCellLocator: VtkLocator { +pub trait VtkAbstractCellLocator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn set_number_of_cells_per_node(&mut self, _arg: core::ffi::c_int) -> (); @@ -319,159 +156,33 @@ pub trait VtkAbstractCellLocator: VtkLocator { fn get_use_existing_search_structure(&mut self) -> core::ffi::c_int; fn use_existing_search_structure_on(&mut self) -> (); fn use_existing_search_structure_off(&mut self) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - points: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - ) -> (); - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - ) -> (); - fn find_closest_point_within_radius( - &mut self, - x: core::ffi::c_double, - radius: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - x: core::ffi::c_double, - radius: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - x: core::ffi::c_double, - radius: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - inside: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn find_cells_within_bounds( - &mut self, - bbox: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ) -> (); - fn find_cells_along_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tolerance: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ) -> (); - fn find_cell(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_cell( - &mut self, - x: core::ffi::c_double, - tol2: core::ffi::c_double, - GenCell: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn inside_cell_bounds( - &mut self, - x: core::ffi::c_double, - cell_ID: core::ffi::c_uchar, - ) -> bool; } -pub trait VtkAbstractElectronicData: VtkDataObject { +pub trait VtkAbstractElectronicData { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; - fn get_number_of_m_os(&mut self) -> core::ffi::c_uchar; - fn get_number_of_electrons(&mut self) -> core::ffi::c_uchar; - fn get_mo(&mut self, orbitalNumber: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_number_of_m_os(&mut self) -> core::ffi::c_longlong; + fn get_number_of_electrons(&mut self) -> core::ffi::c_longlong; + fn get_mo(&mut self, orbitalNumber: core::ffi::c_longlong) -> *mut core::ffi::c_void; fn get_electron_density(&mut self) -> *mut core::ffi::c_void; fn get_homo(&mut self) -> *mut core::ffi::c_void; fn get_lumo(&mut self) -> *mut core::ffi::c_void; - fn get_homo_orbital_number(&mut self) -> core::ffi::c_uchar; - fn get_lumo_orbital_number(&mut self) -> core::ffi::c_uchar; - fn is_homo(&mut self, orbitalNumber: core::ffi::c_uchar) -> bool; - fn is_lumo(&mut self, orbitalNumber: core::ffi::c_uchar) -> bool; + fn get_homo_orbital_number(&mut self) -> core::ffi::c_longlong; + fn get_lumo_orbital_number(&mut self) -> core::ffi::c_longlong; + fn is_homo(&mut self, orbitalNumber: core::ffi::c_longlong) -> bool; + fn is_lumo(&mut self, orbitalNumber: core::ffi::c_longlong) -> bool; fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); fn get_padding(&mut self) -> core::ffi::c_double; } -pub trait VtkAbstractPointLocator: VtkLocator { +pub trait VtkAbstractPointLocator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; fn find_closest_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); + ) -> core::ffi::c_longlong; fn find_closest_n_points( &mut self, N: core::ffi::c_int, @@ -480,12 +191,6 @@ pub trait VtkAbstractPointLocator: VtkLocator { z: core::ffi::c_double, result: *mut core::ffi::c_void, ) -> (); - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); fn find_points_within_radius( &mut self, R: core::ffi::c_double, @@ -494,33 +199,22 @@ pub trait VtkAbstractPointLocator: VtkLocator { z: core::ffi::c_double, result: *mut core::ffi::c_void, ) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_bounds(&mut self, p0: core::ffi::c_double) -> (); - fn get_number_of_buckets(&mut self) -> core::ffi::c_uchar; + fn get_number_of_buckets(&mut self) -> core::ffi::c_longlong; } pub trait VtkAdjacentVertexIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> (); + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> (); fn get_graph(&mut self) -> *mut core::ffi::c_void; - fn get_vertex(&mut self) -> core::ffi::c_uchar; - fn next(&mut self) -> core::ffi::c_uchar; + fn get_vertex(&mut self) -> core::ffi::c_longlong; + fn next(&mut self) -> core::ffi::c_longlong; fn has_next(&mut self) -> bool; } -pub trait VtkAngularPeriodicDataArray: VtkPeriodicDataArray { +pub trait VtkAngularPeriodicDataArray { fn new(&mut self) -> *mut core::ffi::c_void; fn set_angle(&mut self, angle: core::ffi::c_double) -> (); fn get_angle(&mut self) -> core::ffi::c_double; - fn set_center(&mut self, center: core::ffi::c_double) -> (); - fn get_center(&mut self) -> *mut core::ffi::c_double; - fn get_center( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_center(&mut self, _arg: core::ffi::c_double) -> (); fn set_axis(&mut self, axis: core::ffi::c_int) -> (); fn get_axis(&mut self) -> core::ffi::c_int; fn set_axis_to_x(&mut self) -> (); @@ -549,7 +243,7 @@ pub trait VtkAnimationScene { fn set_time_mode(&mut self, mode: core::ffi::c_int) -> (); fn is_in_play(&mut self) -> core::ffi::c_int; } -pub trait VtkAnnotation: VtkDataObject { +pub trait VtkAnnotation { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -557,11 +251,6 @@ pub trait VtkAnnotation: VtkDataObject { fn get_selection(&mut self) -> *mut core::ffi::c_void; fn set_selection(&mut self, selection: *mut core::ffi::c_void) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn label(&mut self) -> *mut core::ffi::c_void; fn color(&mut self) -> *mut core::ffi::c_void; fn opacity(&mut self) -> *mut core::ffi::c_void; @@ -574,7 +263,7 @@ pub trait VtkAnnotation: VtkDataObject { fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; } -pub trait VtkAnnotationLayers: VtkDataObject { +pub trait VtkAnnotationLayers { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -591,50 +280,35 @@ pub trait VtkAnnotationLayers: VtkDataObject { fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_m_time(&mut self) -> core::ffi::c_ulong; } -pub trait VtkArrayData: VtkDataObject { +pub trait VtkArrayData { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn add_array(&mut self, p0: *mut core::ffi::c_void) -> (); fn clear_arrays(&mut self) -> (); - fn get_number_of_arrays(&mut self) -> core::ffi::c_uchar; - fn get_array(&mut self, index: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_array_by_name(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; + fn get_number_of_arrays(&mut self) -> core::ffi::c_longlong; + fn get_array(&mut self, index: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_array_by_name(&mut self, name: &str) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); } pub trait VtkAtom { - fn get_id(&mut self) -> core::ffi::c_uchar; + fn get_id(&mut self) -> core::ffi::c_longlong; fn get_molecule(&mut self) -> *mut core::ffi::c_void; fn get_atomic_number(&mut self) -> core::ffi::c_ushort; fn set_atomic_number(&mut self, atomicNum: core::ffi::c_ushort) -> (); - fn get_position(&mut self, pos: core::ffi::c_float) -> (); - fn get_position(&mut self, pos: core::ffi::c_double) -> (); - fn set_position(&mut self, pos: core::ffi::c_float) -> (); fn set_position( &mut self, x: core::ffi::c_float, y: core::ffi::c_float, z: core::ffi::c_float, ) -> (); - fn get_position(&mut self) -> *mut core::ffi::c_void; - fn set_position(&mut self, pos: vtkVector3f) -> (); } -pub trait VtkAttributesErrorMetric: VtkGenericSubdivisionErrorMetric { +pub trait VtkAttributesErrorMetric { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -642,52 +316,14 @@ pub trait VtkAttributesErrorMetric: VtkGenericSubdivisionErrorMetric { fn set_absolute_attribute_tolerance(&mut self, value: core::ffi::c_double) -> (); fn get_attribute_tolerance(&mut self) -> core::ffi::c_double; fn set_attribute_tolerance(&mut self, value: core::ffi::c_double) -> (); - fn requires_edge_subdivision( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_error( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_double; } -pub trait VtkBSPCuts: VtkDataObject { +pub trait VtkBSPCuts { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; - fn create_cuts( - &mut self, - bounds: core::ffi::c_double, - ncuts: core::ffi::c_int, - dim: core::ffi::c_int, - coord: core::ffi::c_double, - lower: core::ffi::c_int, - upper: core::ffi::c_int, - lowerDataCoord: core::ffi::c_double, - upperDataCoord: core::ffi::c_double, - npoints: core::ffi::c_int, - ) -> (); - fn create_cuts(&mut self, kd: *mut core::ffi::c_void) -> (); fn get_kd_node_tree(&mut self) -> *mut core::ffi::c_void; fn get_number_of_cuts(&mut self) -> core::ffi::c_int; - fn get_arrays( - &mut self, - len: core::ffi::c_int, - dim: core::ffi::c_int, - coord: core::ffi::c_double, - lower: core::ffi::c_int, - upper: core::ffi::c_int, - lowerDataCoord: core::ffi::c_double, - upperDataCoord: core::ffi::c_double, - npoints: core::ffi::c_int, - ) -> core::ffi::c_int; fn equals( &mut self, other: *mut core::ffi::c_void, @@ -696,11 +332,6 @@ pub trait VtkBSPCuts: VtkDataObject { fn print_tree(&mut self) -> (); fn print_arrays(&mut self) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); } pub trait VtkBSPIntersections { @@ -709,50 +340,7 @@ pub trait VtkBSPIntersections { fn new(&mut self) -> *mut core::ffi::c_void; fn set_cuts(&mut self, cuts: *mut core::ffi::c_void) -> (); fn get_cuts(&mut self) -> *mut core::ffi::c_void; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> core::ffi::c_int; fn get_number_of_regions(&mut self) -> core::ffi::c_int; - fn get_region_bounds( - &mut self, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_region_data_bounds( - &mut self, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersects_box( - &mut self, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersects_box( - &mut self, - regionId: core::ffi::c_int, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - y0: core::ffi::c_double, - y1: core::ffi::c_double, - z0: core::ffi::c_double, - z1: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersects_box( - &mut self, - ids: core::ffi::c_int, - len: core::ffi::c_int, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersects_box( - &mut self, - ids: core::ffi::c_int, - len: core::ffi::c_int, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - y0: core::ffi::c_double, - y1: core::ffi::c_double, - z0: core::ffi::c_double, - z1: core::ffi::c_double, - ) -> core::ffi::c_int; fn intersects_sphere_2( &mut self, regionId: core::ffi::c_int, @@ -761,336 +349,106 @@ pub trait VtkBSPIntersections { z: core::ffi::c_double, rSquared: core::ffi::c_double, ) -> core::ffi::c_int; - fn intersects_sphere_2( - &mut self, - ids: core::ffi::c_int, - len: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - rSquared: core::ffi::c_double, - ) -> core::ffi::c_int; fn intersects_cell( &mut self, regionId: core::ffi::c_int, cell: *mut core::ffi::c_void, cellRegion: core::ffi::c_int, ) -> core::ffi::c_int; - fn intersects_cell( - &mut self, - ids: core::ffi::c_int, - len: core::ffi::c_int, - cell: *mut core::ffi::c_void, - cellRegion: core::ffi::c_int, - ) -> core::ffi::c_int; fn get_compute_intersections_using_data_bounds(&mut self) -> core::ffi::c_int; fn set_compute_intersections_using_data_bounds(&mut self, c: core::ffi::c_int) -> (); fn compute_intersections_using_data_bounds_on(&mut self) -> (); fn compute_intersections_using_data_bounds_off(&mut self) -> (); } -pub trait VtkBezierCurve: VtkHigherOrderCurve + VtkNonLinearCell + VtkCell { +pub trait VtkBezierCurve { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, + numPts: core::ffi::c_longlong, ) -> (); fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkBezierHexahedron: VtkHigherOrderHexahedron + VtkNonLinearCell + VtkCell { +pub trait VtkBezierHexahedron { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ) -> (); fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; fn get_face_cell(&mut self) -> *mut core::ffi::c_void; fn get_interpolation(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkBezierInterpolation: VtkHigherOrderInterpolation { +pub trait VtkBezierInterpolation { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn flatten_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - coord: vtkVector3i, - ) -> core::ffi::c_int; - fn flatten_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - coord: vtkVector3i, - ) -> core::ffi::c_int; - fn unflatten_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - flat: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn un_flatten_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - flat: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn de_casteljau_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn de_casteljau_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn de_casteljau_simplex_deriv( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn de_casteljau_simplex_deriv( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn evaluate_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> (); - fn evaluate_shape_and_gradient( - &mut self, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - grad: core::ffi::c_double, - ) -> (); - fn tensor_1_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_1_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_2_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_2_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_3_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_3_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_3_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ) -> (); - fn wedge_shape_functions( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> (); - fn wedge_shape_derivatives( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn wedge_evaluate( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldAtPCoords: core::ffi::c_double, - ) -> (); - fn wedge_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ) -> (); } -pub trait VtkBezierQuadrilateral: VtkHigherOrderQuadrilateral + VtkNonLinearCell + VtkCell { +pub trait VtkBezierQuadrilateral { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ) -> (); fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkBezierTetra: VtkHigherOrderTetra + VtkNonLinearCell + VtkCell { +pub trait VtkBezierTetra { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, + numPts: core::ffi::c_longlong, ) -> (); fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; fn get_face_cell(&mut self) -> *mut core::ffi::c_void; fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkBezierTriangle: VtkHigherOrderTriangle + VtkNonLinearCell + VtkCell { +pub trait VtkBezierTriangle { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, + numPts: core::ffi::c_longlong, ) -> (); fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkBezierWedge: VtkHigherOrderWedge + VtkNonLinearCell + VtkCell { +pub trait VtkBezierWedge { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ) -> (); fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void; fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void; @@ -1098,7 +456,7 @@ pub trait VtkBezierWedge: VtkHigherOrderWedge + VtkNonLinearCell + VtkCell { fn get_interpolation(&mut self) -> *mut core::ffi::c_void; fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkBiQuadraticQuad: VtkNonLinearCell + VtkCell { +pub trait VtkBiQuadraticQuad { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -1108,42 +466,12 @@ pub trait VtkBiQuadraticQuad: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn contour( &mut self, value: core::ffi::c_double, @@ -1155,7 +483,7 @@ pub trait VtkBiQuadraticQuad: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -1167,36 +495,12 @@ pub trait VtkBiQuadraticQuad: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkBiQuadraticQuadraticHexahedron: VtkNonLinearCell + VtkCell { +pub trait VtkBiQuadraticQuadraticHexahedron { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -1206,12 +510,6 @@ pub trait VtkBiQuadraticQuadraticHexahedron: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -1223,39 +521,15 @@ pub trait VtkBiQuadraticQuadraticHexahedron: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -1265,56 +539,12 @@ pub trait VtkBiQuadraticQuadraticHexahedron: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkBiQuadraticQuadraticWedge: VtkNonLinearCell + VtkCell { +pub trait VtkBiQuadraticQuadraticWedge { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -1324,12 +554,6 @@ pub trait VtkBiQuadraticQuadraticWedge: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -1341,39 +565,15 @@ pub trait VtkBiQuadraticQuadraticWedge: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -1383,60 +583,12 @@ pub trait VtkBiQuadraticQuadraticWedge: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkBiQuadraticTriangle: VtkNonLinearCell + VtkCell { +pub trait VtkBiQuadraticTriangle { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -1446,12 +598,6 @@ pub trait VtkBiQuadraticTriangle: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -1463,39 +609,15 @@ pub trait VtkBiQuadraticTriangle: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -1505,63 +627,20 @@ pub trait VtkBiQuadraticTriangle: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } pub trait VtkBond { - fn get_id(&mut self) -> core::ffi::c_uchar; + fn get_id(&mut self) -> core::ffi::c_longlong; fn get_molecule(&mut self) -> *mut core::ffi::c_void; - fn get_begin_atom_id(&mut self) -> core::ffi::c_uchar; - fn get_end_atom_id(&mut self) -> core::ffi::c_uchar; - fn get_begin_atom(&mut self) -> *mut core::ffi::c_void; - fn get_end_atom(&mut self) -> *mut core::ffi::c_void; - fn get_begin_atom(&mut self) -> *mut core::ffi::c_void; - fn get_end_atom(&mut self) -> *mut core::ffi::c_void; + fn get_begin_atom_id(&mut self) -> core::ffi::c_longlong; + fn get_end_atom_id(&mut self) -> core::ffi::c_longlong; fn get_order(&mut self) -> core::ffi::c_ushort; fn get_length(&mut self) -> core::ffi::c_double; } pub trait VtkBoundingBox { - fn set_bounds(&mut self, bounds: core::ffi::c_double) -> (); fn set_bounds( &mut self, xMin: core::ffi::c_double, @@ -1571,125 +650,47 @@ pub trait VtkBoundingBox { zMin: core::ffi::c_double, zMax: core::ffi::c_double, ) -> (); - fn compute_bounds( - &mut self, - pts: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ) -> (); - fn compute_bounds( - &mut self, - pts: *mut core::ffi::c_void, - ptUses: core::ffi::c_uchar, - bounds: core::ffi::c_double, - ) -> (); fn compute_bounds(&mut self, pts: *mut core::ffi::c_void) -> (); - fn compute_bounds( - &mut self, - pts: *mut core::ffi::c_void, - ptUses: core::ffi::c_uchar, - ) -> (); - fn compute_local_bounds( - &mut self, - points: *mut core::ffi::c_void, - u: core::ffi::c_double, - v: core::ffi::c_double, - w: core::ffi::c_double, - outputBounds: core::ffi::c_double, - ) -> (); fn set_min_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn set_min_point(&mut self, p: core::ffi::c_double) -> (); fn set_max_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn set_max_point(&mut self, p: core::ffi::c_double) -> (); fn is_valid(&mut self) -> core::ffi::c_int; - fn is_valid(&mut self, bounds: core::ffi::c_double) -> core::ffi::c_int; - fn add_point(&mut self, p: core::ffi::c_double) -> (); fn add_point( &mut self, px: core::ffi::c_double, py: core::ffi::c_double, pz: core::ffi::c_double, ) -> (); - fn add_box(&mut self, bbox: vtkBoundingBox) -> (); - fn add_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn is_subset_of(&mut self, bbox: vtkBoundingBox) -> bool; - fn intersect_box(&mut self, bbox: vtkBoundingBox) -> core::ffi::c_int; - fn intersects(&mut self, bbox: vtkBoundingBox) -> core::ffi::c_int; - fn intersect_plane( - &mut self, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - ) -> bool; - fn intersects_sphere( - &mut self, - center: core::ffi::c_double, - squaredRadius: core::ffi::c_double, - ) -> bool; - fn intersects_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - ) -> bool; fn compute_inner_dimension(&mut self) -> core::ffi::c_int; - fn contains(&mut self, bbox: vtkBoundingBox) -> core::ffi::c_int; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); fn get_bounds( &mut self, - xMin: core::ffi::c_double, - xMax: core::ffi::c_double, - yMin: core::ffi::c_double, - yMax: core::ffi::c_double, - zMin: core::ffi::c_double, - zMax: core::ffi::c_double, + xMin: &mut core::ffi::c_double, + xMax: &mut core::ffi::c_double, + yMin: &mut core::ffi::c_double, + yMax: &mut core::ffi::c_double, + zMin: &mut core::ffi::c_double, + zMax: &mut core::ffi::c_double, ) -> (); fn get_bound(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; - fn get_min_point(&mut self) -> *const core::ffi::c_double; - fn get_min_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> (); - fn get_min_point(&mut self, x: core::ffi::c_double) -> (); - fn get_max_point(&mut self) -> *const core::ffi::c_double; - fn get_max_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> (); - fn get_max_point(&mut self, x: core::ffi::c_double) -> (); - fn get_corner(&mut self, corner: core::ffi::c_int, p: core::ffi::c_double) -> (); - fn contains_point(&mut self, p: core::ffi::c_double) -> core::ffi::c_int; fn contains_point( &mut self, px: core::ffi::c_double, py: core::ffi::c_double, pz: core::ffi::c_double, ) -> core::ffi::c_int; - fn get_center(&mut self, center: core::ffi::c_double) -> (); - fn get_lengths(&mut self, lengths: core::ffi::c_double) -> (); fn get_length(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; fn get_max_length(&mut self) -> core::ffi::c_double; fn get_diagonal_length(&mut self) -> core::ffi::c_double; fn inflate(&mut self, delta: core::ffi::c_double) -> (); - fn inflate( - &mut self, - deltaX: core::ffi::c_double, - deltaY: core::ffi::c_double, - deltaZ: core::ffi::c_double, - ) -> (); - fn inflate(&mut self) -> (); - fn scale(&mut self, s: core::ffi::c_double) -> (); fn scale( &mut self, sx: core::ffi::c_double, @@ -1697,63 +698,35 @@ pub trait VtkBoundingBox { sz: core::ffi::c_double, ) -> (); fn scale_about_center(&mut self, s: core::ffi::c_double) -> (); - fn scale_about_center(&mut self, s: core::ffi::c_double) -> (); - fn scale_about_center( - &mut self, - sx: core::ffi::c_double, - sy: core::ffi::c_double, - sz: core::ffi::c_double, - ) -> (); - fn compute_divisions( - &mut self, - totalBins: core::ffi::c_uchar, - bounds: core::ffi::c_double, - divs: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn clamp_divisions( - &mut self, - targetBins: core::ffi::c_uchar, - divs: core::ffi::c_int, - ) -> (); fn reset(&mut self) -> (); } -pub trait VtkBox: VtkImplicitFunction { +pub trait VtkBox { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); - fn set_x_min(&mut self, p: core::ffi::c_double) -> (); fn set_x_min( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn get_x_min(&mut self, p: core::ffi::c_double) -> (); fn get_x_min( &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, ) -> (); - fn set_x_max(&mut self, p: core::ffi::c_double) -> (); fn set_x_max( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn get_x_max(&mut self, p: core::ffi::c_double) -> (); fn get_x_max( &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, ) -> (); fn set_bounds( &mut self, @@ -1764,122 +737,35 @@ pub trait VtkBox: VtkImplicitFunction { zMin: core::ffi::c_double, zMax: core::ffi::c_double, ) -> (); - fn set_bounds(&mut self, bounds: core::ffi::c_double) -> (); fn get_bounds( &mut self, - xMin: core::ffi::c_double, - xMax: core::ffi::c_double, - yMin: core::ffi::c_double, - yMax: core::ffi::c_double, - zMin: core::ffi::c_double, - zMax: core::ffi::c_double, + xMin: &mut core::ffi::c_double, + xMax: &mut core::ffi::c_double, + yMin: &mut core::ffi::c_double, + yMax: &mut core::ffi::c_double, + zMin: &mut core::ffi::c_double, + zMax: &mut core::ffi::c_double, ) -> (); - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; - fn add_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn intersect_box( - &mut self, - bounds: core::ffi::c_double, - origin: core::ffi::c_double, - dir: core::ffi::c_double, - coord: core::ffi::c_double, - t: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_char; - fn intersect_with_line( - &mut self, - bounds: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - plane1: core::ffi::c_int, - plane2: core::ffi::c_int, - ) -> core::ffi::c_int; - fn intersect_with_infinite_line( - &mut self, - bounds: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - plane1: core::ffi::c_int, - plane2: core::ffi::c_int, - ) -> bool; - fn intersect_with_plane( - &mut self, - bounds: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersect_with_plane( - &mut self, - bounds: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - xout: core::ffi::c_double, - ) -> core::ffi::c_int; - fn is_box_in_frustum( - &mut self, - planes: core::ffi::c_double, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; } pub trait VtkCell { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn initialize( - &mut self, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - p: *mut core::ffi::c_void, - ) -> (); - fn initialize(&mut self, npts: core::ffi::c_int, p: *mut core::ffi::c_void) -> (); fn shallow_copy(&mut self, c: *mut core::ffi::c_void) -> (); fn deep_copy(&mut self, c: *mut core::ffi::c_void) -> (); fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_cell_dimension(&mut self) -> core::ffi::c_int; fn is_linear(&mut self) -> core::ffi::c_int; fn requires_initialization(&mut self) -> core::ffi::c_int; - fn initialize(&mut self) -> (); fn is_explicit_cell(&mut self) -> core::ffi::c_int; fn requires_explicit_face_representation(&mut self) -> core::ffi::c_int; - fn set_faces(&mut self, faces: core::ffi::c_uchar) -> (); - fn get_faces(&mut self) -> *mut core::ffi::c_uchar; fn get_points(&mut self) -> *mut core::ffi::c_void; - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_point_ids(&mut self) -> *mut core::ffi::c_void; - fn get_point_id(&mut self, ptId: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_point_id(&mut self, ptId: core::ffi::c_int) -> core::ffi::c_longlong; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn contour( &mut self, value: core::ffi::c_double, @@ -1891,7 +777,7 @@ pub trait VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -1903,117 +789,29 @@ pub trait VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; - fn compute_bounding_sphere( - &mut self, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn intersect_with_cell( &mut self, other: *mut core::ffi::c_void, tol: core::ffi::c_double, ) -> core::ffi::c_int; - fn intersect_with_cell( - &mut self, - other: *mut core::ffi::c_void, - boudingBox: vtkBoundingBox, - otherBoundingBox: vtkBoundingBox, - tol: core::ffi::c_double, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; fn get_length_2(&mut self) -> core::ffi::c_double; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; fn is_primary_cell(&mut self) -> core::ffi::c_int; - fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weight: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkCell3D: VtkCell { +pub trait VtkCell3D { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> (); - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; fn is_inside_out(&mut self) -> bool; - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; fn contour( &mut self, value: core::ffi::c_double, @@ -2025,7 +823,7 @@ pub trait VtkCell3D: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -2037,7 +835,7 @@ pub trait VtkCell3D: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); @@ -2054,43 +852,38 @@ pub trait VtkCellArray { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; fn allocate_estimate( &mut self, - numCells: core::ffi::c_uchar, - maxCellSize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, ) -> bool; fn allocate_exact( &mut self, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool; fn allocate_copy(&mut self, other: *mut core::ffi::c_void) -> bool; fn resize_exact( &mut self, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool; fn initialize(&mut self) -> (); fn reset(&mut self) -> (); fn squeeze(&mut self) -> (); fn is_valid(&mut self) -> bool; - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; - fn get_number_of_offsets(&mut self) -> core::ffi::c_uchar; - fn get_number_of_connectivity_ids(&mut self) -> core::ffi::c_uchar; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_number_of_offsets(&mut self) -> core::ffi::c_longlong; + fn get_number_of_connectivity_ids(&mut self) -> core::ffi::c_longlong; fn new_iterator(&mut self) -> *mut core::ffi::c_void; fn set_data( &mut self, offsets: *mut core::ffi::c_void, connectivity: *mut core::ffi::c_void, ) -> bool; - fn set_data( - &mut self, - cellSize: core::ffi::c_uchar, - connectivity: *mut core::ffi::c_void, - ) -> bool; fn is_storage_64_bit(&mut self) -> bool; fn is_storage_shareable(&mut self) -> bool; fn use_32_bit_storage(&mut self) -> (); @@ -2109,115 +902,54 @@ pub trait VtkCellArray { fn get_connectivity_array(&mut self) -> *mut core::ffi::c_void; fn get_connectivity_array_32(&mut self) -> *mut core::ffi::c_void; fn get_connectivity_array_64(&mut self) -> *mut core::ffi::c_void; - fn is_homogeneous(&mut self) -> core::ffi::c_uchar; + fn is_homogeneous(&mut self) -> core::ffi::c_longlong; fn init_traversal(&mut self) -> (); - fn get_next_cell( - &mut self, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn get_next_cell(&mut self, pts: *mut core::ffi::c_void) -> core::ffi::c_int; - fn get_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - cellSize: core::ffi::c_uchar, - cellPoints: core::ffi::c_uchar, - ) -> (); - fn get_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - pts: *mut core::ffi::c_void, - ) -> (); - fn get_cell_size(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn insert_next_cell(&mut self, cell: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn get_cell_size(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_longlong; fn insert_next_cell( &mut self, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn insert_next_cell(&mut self, pts: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn insert_next_cell( - &mut self, - cell: std::collections::LinkedList, - ) -> core::ffi::c_uchar; - fn insert_next_cell(&mut self, npts: core::ffi::c_int) -> core::ffi::c_uchar; - fn insert_cell_point(&mut self, id: core::ffi::c_uchar) -> (); + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn insert_cell_point(&mut self, id: core::ffi::c_longlong) -> (); fn update_cell_count(&mut self, npts: core::ffi::c_int) -> (); - fn get_traversal_cell_id(&mut self) -> core::ffi::c_uchar; - fn set_traversal_cell_id(&mut self, cellId: core::ffi::c_uchar) -> (); - fn reverse_cell_at_id(&mut self, cellId: core::ffi::c_uchar) -> (); + fn get_traversal_cell_id(&mut self) -> core::ffi::c_longlong; + fn set_traversal_cell_id(&mut self, cellId: core::ffi::c_longlong) -> (); + fn reverse_cell_at_id(&mut self, cellId: core::ffi::c_longlong) -> (); fn replace_cell_at_id( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, list: *mut core::ffi::c_void, ) -> (); - fn replace_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - cellSize: core::ffi::c_uchar, - cellPoints: core::ffi::c_uchar, - ) -> (); - fn replace_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - cell: std::collections::LinkedList, - ) -> (); fn get_max_cell_size(&mut self) -> core::ffi::c_int; fn deep_copy(&mut self, ca: *mut core::ffi::c_void) -> (); fn shallow_copy(&mut self, ca: *mut core::ffi::c_void) -> (); fn append( &mut self, src: *mut core::ffi::c_void, - pointOffset: core::ffi::c_uchar, + pointOffset: core::ffi::c_longlong, ) -> (); fn export_legacy_format(&mut self, data: *mut core::ffi::c_void) -> (); fn import_legacy_format(&mut self, data: *mut core::ffi::c_void) -> (); - fn import_legacy_format( - &mut self, - data: core::ffi::c_uchar, - len: core::ffi::c_uchar, - ) -> (); fn append_legacy_format( &mut self, data: *mut core::ffi::c_void, - ptOffset: core::ffi::c_uchar, - ) -> (); - fn append_legacy_format( - &mut self, - data: core::ffi::c_uchar, - len: core::ffi::c_uchar, - ptOffset: core::ffi::c_uchar, + ptOffset: core::ffi::c_longlong, ) -> (); fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; - fn set_number_of_cells(&mut self, p0: core::ffi::c_uchar) -> (); + fn set_number_of_cells(&mut self, p0: core::ffi::c_longlong) -> (); fn estimate_size( &mut self, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, maxPtsPerCell: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn get_size(&mut self) -> core::ffi::c_uchar; - fn get_number_of_connectivity_entries(&mut self) -> core::ffi::c_uchar; - fn get_cell( - &mut self, - loc: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_cell(&mut self, loc: core::ffi::c_uchar, pts: *mut core::ffi::c_void) -> (); - fn get_insert_location(&mut self, npts: core::ffi::c_int) -> core::ffi::c_uchar; - fn get_traversal_location(&mut self) -> core::ffi::c_uchar; - fn get_traversal_location(&mut self, npts: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn set_traversal_location(&mut self, loc: core::ffi::c_uchar) -> (); - fn reverse_cell(&mut self, loc: core::ffi::c_uchar) -> (); - fn replace_cell( - &mut self, - loc: core::ffi::c_uchar, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> (); + ) -> core::ffi::c_longlong; + fn get_size(&mut self) -> core::ffi::c_longlong; + fn get_number_of_connectivity_entries(&mut self) -> core::ffi::c_longlong; + fn get_insert_location(&mut self, npts: core::ffi::c_int) -> core::ffi::c_longlong; + fn get_traversal_location(&mut self) -> core::ffi::c_longlong; + fn set_traversal_location(&mut self, loc: core::ffi::c_longlong) -> (); + fn reverse_cell(&mut self, loc: core::ffi::c_longlong) -> (); fn set_cells( &mut self, - ncells: core::ffi::c_uchar, + ncells: core::ffi::c_longlong, cells: *mut core::ffi::c_void, ) -> (); fn get_data(&mut self) -> *mut core::ffi::c_void; @@ -2227,39 +959,15 @@ pub trait VtkCellArrayIterator { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_cell_array(&mut self) -> *mut core::ffi::c_void; - fn go_to_cell(&mut self, cellId: core::ffi::c_uchar) -> (); - fn get_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - numCellPts: core::ffi::c_uchar, - cellPts: core::ffi::c_uchar, - ) -> (); - fn get_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - cellIds: *mut core::ffi::c_void, - ) -> (); - fn get_cell_at_id(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn go_to_cell(&mut self, cellId: core::ffi::c_longlong) -> (); fn go_to_first_cell(&mut self) -> (); fn go_to_next_cell(&mut self) -> (); fn is_done_with_traversal(&mut self) -> bool; - fn get_current_cell_id(&mut self) -> core::ffi::c_uchar; - fn get_current_cell( - &mut self, - cellSize: core::ffi::c_uchar, - cellPoints: core::ffi::c_uchar, - ) -> (); - fn get_current_cell(&mut self, ids: *mut core::ffi::c_void) -> (); - fn get_current_cell(&mut self) -> *mut core::ffi::c_void; + fn get_current_cell_id(&mut self) -> core::ffi::c_longlong; fn replace_current_cell(&mut self, list: *mut core::ffi::c_void) -> (); - fn replace_current_cell( - &mut self, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); fn reverse_current_cell(&mut self) -> (); } -pub trait VtkCellData: VtkDataSetAttributes + VtkFieldData { +pub trait VtkCellData { fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -2273,49 +981,46 @@ pub trait VtkCellIterator { fn is_done_with_traversal(&mut self) -> bool; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_cell_dimension(&mut self) -> core::ffi::c_int; - fn get_cell_id(&mut self) -> core::ffi::c_uchar; + fn get_cell_id(&mut self) -> core::ffi::c_longlong; fn get_point_ids(&mut self) -> *mut core::ffi::c_void; fn get_points(&mut self) -> *mut core::ffi::c_void; fn get_faces(&mut self) -> *mut core::ffi::c_void; fn get_cell(&mut self, cell: *mut core::ffi::c_void) -> (); - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; - fn get_number_of_faces(&mut self) -> core::ffi::c_uchar; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_faces(&mut self) -> core::ffi::c_longlong; } -pub trait VtkCellLinks: VtkAbstractCellLinks { +pub trait VtkCellLinks { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn build_links(&mut self, data: *mut core::ffi::c_void) -> (); - fn allocate(&mut self, numLinks: core::ffi::c_uchar, ext: core::ffi::c_uchar) -> (); - fn initialize(&mut self) -> (); - fn get_link(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_ncells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_cells(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn select_cells( + fn allocate( &mut self, - minMaxDegree: core::ffi::c_uchar, - cellSelection: core::ffi::c_uchar, + numLinks: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> (); - fn insert_next_point(&mut self, numLinks: core::ffi::c_int) -> core::ffi::c_uchar; + fn initialize(&mut self) -> (); + fn get_ncells(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn insert_next_point(&mut self, numLinks: core::ffi::c_int) -> core::ffi::c_longlong; fn insert_next_cell_reference( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> (); - fn delete_point(&mut self, ptId: core::ffi::c_uchar) -> (); + fn delete_point(&mut self, ptId: core::ffi::c_longlong) -> (); fn remove_cell_reference( &mut self, - cellId: core::ffi::c_uchar, - ptId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, ) -> (); fn add_cell_reference( &mut self, - cellId: core::ffi::c_uchar, - ptId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, ) -> (); fn resize_cell_list( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, size: core::ffi::c_int, ) -> (); fn squeeze(&mut self) -> (); @@ -2323,53 +1028,14 @@ pub trait VtkCellLinks: VtkAbstractCellLinks { fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); } -pub trait VtkCellLocator: VtkAbstractCellLocator + VtkLocator { +pub trait VtkCellLocator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn set_number_of_cells_per_bucket(&mut self, N: core::ffi::c_int) -> (); fn get_number_of_cells_per_bucket(&mut self) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - ) -> (); - fn find_closest_point_within_radius( - &mut self, - x: core::ffi::c_double, - radius: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - inside: core::ffi::c_int, - ) -> core::ffi::c_uchar; fn get_cells(&mut self, bucket: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_number_of_buckets(&mut self) -> core::ffi::c_int; - fn find_cells_along_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tolerance: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ) -> (); fn free_search_structure(&mut self) -> (); fn build_locator(&mut self) -> (); fn build_locator_if_needed(&mut self) -> (); @@ -2381,22 +1047,11 @@ pub trait VtkCellLocator: VtkAbstractCellLocator + VtkLocator { pd: *mut core::ffi::c_void, ) -> (); } -pub trait VtkCellLocatorStrategy: VtkFindCellStrategy { +pub trait VtkCellLocatorStrategy { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; fn set_cell_locator(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_cell_locator(&mut self) -> *mut core::ffi::c_void; } @@ -2406,243 +1061,160 @@ pub trait VtkCellTypes { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; fn insert_cell( &mut self, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, type_: core::ffi::c_uchar, - loc: core::ffi::c_uchar, + loc: core::ffi::c_longlong, ) -> (); fn insert_next_cell( &mut self, type_: core::ffi::c_uchar, - loc: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + loc: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn set_cell_types( &mut self, - ncells: core::ffi::c_uchar, + ncells: core::ffi::c_longlong, cellTypes: *mut core::ffi::c_void, cellLocations: *mut core::ffi::c_void, ) -> (); - fn set_cell_types( + fn get_cell_location( &mut self, - ncells: core::ffi::c_uchar, - cellTypes: *mut core::ffi::c_void, - cellLocations: *mut core::ffi::c_void, - ) -> (); - fn get_cell_location(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn delete_cell(&mut self, cellId: core::ffi::c_uchar) -> (); - fn get_number_of_types(&mut self) -> core::ffi::c_uchar; + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn delete_cell(&mut self, cellId: core::ffi::c_longlong) -> (); + fn get_number_of_types(&mut self) -> core::ffi::c_longlong; fn is_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int; - fn insert_next_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn insert_next_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_longlong; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; fn squeeze(&mut self) -> (); fn reset(&mut self) -> (); fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); - fn get_class_name_from_type_id( - &mut self, - typeId: core::ffi::c_int, - ) -> *const core::ffi::c_char; - fn get_type_id_from_class_name( - &mut self, - classname: core::ffi::c_char, - ) -> core::ffi::c_int; + fn get_class_name_from_type_id(&mut self, typeId: core::ffi::c_int) -> &str; + fn get_type_id_from_class_name(&mut self, classname: &str) -> core::ffi::c_int; fn is_linear(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int; fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void; fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkClosestNPointsStrategy: VtkClosestPointStrategy + VtkFindCellStrategy { +pub trait VtkClosestNPointsStrategy { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; fn set_closest_n_points(&mut self, _arg: core::ffi::c_int) -> (); fn get_closest_n_points_min_value(&mut self) -> core::ffi::c_int; fn get_closest_n_points_max_value(&mut self) -> core::ffi::c_int; fn get_closest_n_points(&mut self) -> core::ffi::c_int; } -pub trait VtkClosestPointStrategy: VtkFindCellStrategy { +pub trait VtkClosestPointStrategy { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; fn set_point_locator(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_point_locator(&mut self) -> *mut core::ffi::c_void; fn select_cell( &mut self, self_: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, cell: *mut core::ffi::c_void, gencell: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } -pub trait VtkColor3 { - fn set(&mut self, red: T, green: T, blue: T) -> (); - fn set_red(&mut self, red: T) -> (); - fn get_red(&mut self) -> T; - fn set_green(&mut self, green: T) -> (); - fn get_green(&mut self) -> T; - fn set_blue(&mut self, blue: T) -> (); - fn get_blue(&mut self) -> T; -} -pub trait VtkColor3d: VtkColor3 { +pub trait VtkColor3 {} +pub trait VtkColor3d { fn set( &mut self, - red: core::ffi::c_double, - green: core::ffi::c_double, - blue: core::ffi::c_double, + red: &core::ffi::c_double, + green: &core::ffi::c_double, + blue: &core::ffi::c_double, ) -> (); - fn set_red(&mut self, red: core::ffi::c_double) -> (); + fn set_red(&mut self, red: &core::ffi::c_double) -> (); fn get_red(&mut self) -> core::ffi::c_double; - fn set_green(&mut self, green: core::ffi::c_double) -> (); + fn set_green(&mut self, green: &core::ffi::c_double) -> (); fn get_green(&mut self) -> core::ffi::c_double; - fn set_blue(&mut self, blue: core::ffi::c_double) -> (); + fn set_blue(&mut self, blue: &core::ffi::c_double) -> (); fn get_blue(&mut self) -> core::ffi::c_double; - fn get_data(&mut self) -> *mut core::ffi::c_double; - fn get_data(&mut self) -> *const core::ffi::c_double; } -pub trait VtkColor3f: VtkColor3 { +pub trait VtkColor3f { fn set( &mut self, - red: core::ffi::c_float, - green: core::ffi::c_float, - blue: core::ffi::c_float, + red: &core::ffi::c_float, + green: &core::ffi::c_float, + blue: &core::ffi::c_float, ) -> (); - fn set_red(&mut self, red: core::ffi::c_float) -> (); + fn set_red(&mut self, red: &core::ffi::c_float) -> (); fn get_red(&mut self) -> core::ffi::c_float; - fn set_green(&mut self, green: core::ffi::c_float) -> (); + fn set_green(&mut self, green: &core::ffi::c_float) -> (); fn get_green(&mut self) -> core::ffi::c_float; - fn set_blue(&mut self, blue: core::ffi::c_float) -> (); + fn set_blue(&mut self, blue: &core::ffi::c_float) -> (); fn get_blue(&mut self) -> core::ffi::c_float; - fn get_data(&mut self) -> *mut core::ffi::c_float; - fn get_data(&mut self) -> *const core::ffi::c_float; } -pub trait VtkColor3ub: VtkColor3 { +pub trait VtkColor3ub { fn set( &mut self, - red: core::ffi::c_uchar, - green: core::ffi::c_uchar, - blue: core::ffi::c_uchar, + red: &core::ffi::c_uchar, + green: &core::ffi::c_uchar, + blue: &core::ffi::c_uchar, ) -> (); - fn set_red(&mut self, red: core::ffi::c_uchar) -> (); + fn set_red(&mut self, red: &core::ffi::c_uchar) -> (); fn get_red(&mut self) -> core::ffi::c_uchar; - fn set_green(&mut self, green: core::ffi::c_uchar) -> (); + fn set_green(&mut self, green: &core::ffi::c_uchar) -> (); fn get_green(&mut self) -> core::ffi::c_uchar; - fn set_blue(&mut self, blue: core::ffi::c_uchar) -> (); + fn set_blue(&mut self, blue: &core::ffi::c_uchar) -> (); fn get_blue(&mut self) -> core::ffi::c_uchar; - fn get_data(&mut self) -> *mut core::ffi::c_uchar; - fn get_data(&mut self) -> *const core::ffi::c_uchar; -} -pub trait VtkColor4 { - fn set(&mut self, red: T, green: T, blue: T) -> (); - fn set(&mut self, red: T, green: T, blue: T, alpha: T) -> (); - fn set_red(&mut self, red: T) -> (); - fn get_red(&mut self) -> T; - fn set_green(&mut self, green: T) -> (); - fn get_green(&mut self) -> T; - fn set_blue(&mut self, blue: T) -> (); - fn get_blue(&mut self) -> T; - fn set_alpha(&mut self, alpha: T) -> (); - fn get_alpha(&mut self) -> T; -} -pub trait VtkColor4d: VtkColor4 { - fn set( - &mut self, - red: core::ffi::c_double, - green: core::ffi::c_double, - blue: core::ffi::c_double, - ) -> (); +} +pub trait VtkColor4 {} +pub trait VtkColor4d { fn set( &mut self, - red: core::ffi::c_double, - green: core::ffi::c_double, - blue: core::ffi::c_double, - alpha: core::ffi::c_double, + red: &core::ffi::c_double, + green: &core::ffi::c_double, + blue: &core::ffi::c_double, ) -> (); - fn set_red(&mut self, red: core::ffi::c_double) -> (); + fn set_red(&mut self, red: &core::ffi::c_double) -> (); fn get_red(&mut self) -> core::ffi::c_double; - fn set_green(&mut self, green: core::ffi::c_double) -> (); + fn set_green(&mut self, green: &core::ffi::c_double) -> (); fn get_green(&mut self) -> core::ffi::c_double; - fn set_blue(&mut self, blue: core::ffi::c_double) -> (); + fn set_blue(&mut self, blue: &core::ffi::c_double) -> (); fn get_blue(&mut self) -> core::ffi::c_double; - fn set_alpha(&mut self, alpha: core::ffi::c_double) -> (); + fn set_alpha(&mut self, alpha: &core::ffi::c_double) -> (); fn get_alpha(&mut self) -> core::ffi::c_double; - fn get_data(&mut self) -> *mut core::ffi::c_double; - fn get_data(&mut self) -> *const core::ffi::c_double; } -pub trait VtkColor4f: VtkColor4 { - fn set( - &mut self, - red: core::ffi::c_float, - green: core::ffi::c_float, - blue: core::ffi::c_float, - ) -> (); +pub trait VtkColor4f { fn set( &mut self, - red: core::ffi::c_float, - green: core::ffi::c_float, - blue: core::ffi::c_float, - alpha: core::ffi::c_float, + red: &core::ffi::c_float, + green: &core::ffi::c_float, + blue: &core::ffi::c_float, ) -> (); - fn set_red(&mut self, red: core::ffi::c_float) -> (); + fn set_red(&mut self, red: &core::ffi::c_float) -> (); fn get_red(&mut self) -> core::ffi::c_float; - fn set_green(&mut self, green: core::ffi::c_float) -> (); + fn set_green(&mut self, green: &core::ffi::c_float) -> (); fn get_green(&mut self) -> core::ffi::c_float; - fn set_blue(&mut self, blue: core::ffi::c_float) -> (); + fn set_blue(&mut self, blue: &core::ffi::c_float) -> (); fn get_blue(&mut self) -> core::ffi::c_float; - fn set_alpha(&mut self, alpha: core::ffi::c_float) -> (); + fn set_alpha(&mut self, alpha: &core::ffi::c_float) -> (); fn get_alpha(&mut self) -> core::ffi::c_float; - fn get_data(&mut self) -> *mut core::ffi::c_float; - fn get_data(&mut self) -> *const core::ffi::c_float; } -pub trait VtkColor4ub: VtkColor4 { +pub trait VtkColor4ub { fn set( &mut self, - red: core::ffi::c_uchar, - green: core::ffi::c_uchar, - blue: core::ffi::c_uchar, + red: &core::ffi::c_uchar, + green: &core::ffi::c_uchar, + blue: &core::ffi::c_uchar, ) -> (); - fn set( - &mut self, - red: core::ffi::c_uchar, - green: core::ffi::c_uchar, - blue: core::ffi::c_uchar, - alpha: core::ffi::c_uchar, - ) -> (); - fn set_red(&mut self, red: core::ffi::c_uchar) -> (); + fn set_red(&mut self, red: &core::ffi::c_uchar) -> (); fn get_red(&mut self) -> core::ffi::c_uchar; - fn set_green(&mut self, green: core::ffi::c_uchar) -> (); + fn set_green(&mut self, green: &core::ffi::c_uchar) -> (); fn get_green(&mut self) -> core::ffi::c_uchar; - fn set_blue(&mut self, blue: core::ffi::c_uchar) -> (); + fn set_blue(&mut self, blue: &core::ffi::c_uchar) -> (); fn get_blue(&mut self) -> core::ffi::c_uchar; - fn set_alpha(&mut self, alpha: core::ffi::c_uchar) -> (); + fn set_alpha(&mut self, alpha: &core::ffi::c_uchar) -> (); fn get_alpha(&mut self) -> core::ffi::c_uchar; - fn get_data(&mut self) -> *mut core::ffi::c_uchar; - fn get_data(&mut self) -> *const core::ffi::c_uchar; } pub trait VtkCompositeDataIterator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -2664,7 +1236,7 @@ pub trait VtkCompositeDataIterator { fn get_current_flat_index(&mut self) -> core::ffi::c_uint; fn get_reverse(&mut self) -> core::ffi::c_int; } -pub trait VtkCompositeDataSet: VtkDataObject { +pub trait VtkCompositeDataSet { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new_iterator(&mut self) -> *mut core::ffi::c_void; @@ -2678,78 +1250,27 @@ pub trait VtkCompositeDataSet: VtkDataObject { fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; fn name(&mut self) -> *mut core::ffi::c_void; fn current_process_can_load_block(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkCone: VtkImplicitFunction { +pub trait VtkCone { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); fn set_angle(&mut self, _arg: core::ffi::c_double) -> (); fn get_angle_min_value(&mut self) -> core::ffi::c_double; fn get_angle_max_value(&mut self) -> core::ffi::c_double; fn get_angle(&mut self) -> core::ffi::c_double; } -pub trait VtkConvexPointSet: VtkCell3D + VtkCell { +pub trait VtkConvexPointSet { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn has_fixed_topology(&mut self) -> core::ffi::c_int; - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; - fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double; fn get_cell_type(&mut self) -> core::ffi::c_int; fn requires_initialization(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; @@ -2767,7 +1288,7 @@ pub trait VtkConvexPointSet: VtkCell3D + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -2779,68 +1300,19 @@ pub trait VtkConvexPointSet: VtkCell3D + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; fn is_primary_cell(&mut self) -> core::ffi::c_int; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> (); } -pub trait VtkCubicLine: VtkNonLinearCell + VtkCell { +pub trait VtkCubicLine { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -2850,12 +1322,6 @@ pub trait VtkCubicLine: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -2867,43 +1333,15 @@ pub trait VtkCubicLine: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; fn clip( &mut self, value: core::ffi::c_double, @@ -2913,55 +1351,15 @@ pub trait VtkCubicLine: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkCylinder: VtkImplicitFunction { +pub trait VtkCylinder { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); fn get_radius(&mut self) -> core::ffi::c_double; fn set_center( @@ -2970,51 +1368,23 @@ pub trait VtkCylinder: VtkImplicitFunction { _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_center(&mut self, _arg: core::ffi::c_double) -> (); - fn get_center(&mut self) -> *mut core::ffi::c_double; - fn get_center( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_center(&mut self, _arg: core::ffi::c_double) -> (); fn set_axis( &mut self, ax: core::ffi::c_double, ay: core::ffi::c_double, az: core::ffi::c_double, ) -> (); - fn set_axis(&mut self, a: core::ffi::c_double) -> (); - fn get_axis(&mut self) -> *mut core::ffi::c_double; - fn get_axis( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_axis(&mut self, _arg: core::ffi::c_double) -> (); } pub trait VtkDataAssembly { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn initialize(&mut self) -> (); - fn initialize_from_xml(&mut self, xmlcontents: core::ffi::c_char) -> bool; - fn serialize_to_xml(&mut self, indent: *mut core::ffi::c_void) -> &str; + fn initialize_from_xml(&mut self, xmlcontents: &str) -> bool; fn get_root_node(&mut self) -> core::ffi::c_int; - fn set_root_node_name(&mut self, name: core::ffi::c_char) -> (); - fn get_root_node_name(&mut self) -> *const core::ffi::c_char; - fn add_node( - &mut self, - name: core::ffi::c_char, - parent: core::ffi::c_int, - ) -> core::ffi::c_int; - fn add_nodes( - &mut self, - names: Vec, - parent: core::ffi::c_int, - ) -> Vec; + fn set_root_node_name(&mut self, name: &str) -> (); + fn get_root_node_name(&mut self) -> &str; + fn add_node(&mut self, name: &str, parent: core::ffi::c_int) -> core::ffi::c_int; fn add_subtree( &mut self, parent: core::ffi::c_int, @@ -3022,20 +1392,14 @@ pub trait VtkDataAssembly { otherParent: core::ffi::c_int, ) -> core::ffi::c_int; fn remove_node(&mut self, id: core::ffi::c_int) -> bool; - fn set_node_name(&mut self, id: core::ffi::c_int, name: core::ffi::c_char) -> (); - fn get_node_name(&mut self, id: core::ffi::c_int) -> *const core::ffi::c_char; - fn get_node_path(&mut self, id: core::ffi::c_int) -> &str; - fn get_first_node_by_path(&mut self, path: core::ffi::c_char) -> core::ffi::c_int; + fn set_node_name(&mut self, id: core::ffi::c_int, name: &str) -> (); + fn get_node_name(&mut self, id: core::ffi::c_int) -> &str; + fn get_first_node_by_path(&mut self, path: &str) -> core::ffi::c_int; fn add_data_set_index( &mut self, id: core::ffi::c_int, dataset_index: core::ffi::c_uint, ) -> bool; - fn add_data_set_indices( - &mut self, - id: core::ffi::c_int, - dataset_indices: Vec, - ) -> bool; fn add_data_set_index_range( &mut self, id: core::ffi::c_int, @@ -3054,20 +1418,9 @@ pub trait VtkDataAssembly { ) -> bool; fn find_first_node_with_name( &mut self, - name: core::ffi::c_char, + name: &str, traversal_order: core::ffi::c_int, ) -> core::ffi::c_int; - fn find_nodes_with_name( - &mut self, - name: core::ffi::c_char, - sort_order: core::ffi::c_int, - ) -> Vec; - fn get_child_nodes( - &mut self, - parent: core::ffi::c_int, - traverse_subtree: bool, - traversal_order: core::ffi::c_int, - ) -> Vec; fn get_number_of_children(&mut self, parent: core::ffi::c_int) -> core::ffi::c_int; fn get_child( &mut self, @@ -3080,150 +1433,35 @@ pub trait VtkDataAssembly { child: core::ffi::c_int, ) -> core::ffi::c_int; fn get_parent(&mut self, id: core::ffi::c_int) -> core::ffi::c_int; - fn has_attribute(&mut self, id: core::ffi::c_int, name: core::ffi::c_char) -> bool; - fn set_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_char, - ) -> (); - fn set_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_int, - ) -> (); - fn set_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uint, - ) -> (); - fn set_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uchar, - ) -> (); - fn get_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_char, - ) -> bool; - fn get_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_int, - ) -> bool; - fn get_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uint, - ) -> bool; - fn get_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uchar, - ) -> bool; - fn get_attribute_or_default( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_char, - ) -> *const core::ffi::c_char; + fn has_attribute(&mut self, id: core::ffi::c_int, name: &str) -> bool; + fn set_attribute(&mut self, id: core::ffi::c_int, name: &str, value: &str) -> (); + fn get_attribute(&mut self, id: core::ffi::c_int, name: &str, value: &str) -> bool; fn get_attribute_or_default( &mut self, id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_attribute_or_default( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_uint, - ) -> core::ffi::c_uint; - fn get_attribute_or_default( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn visit( - &mut self, - visitor: *mut core::ffi::c_void, - traversal_order: core::ffi::c_int, - ) -> (); + name: &str, + default_value: &str, + ) -> &str; fn visit( &mut self, - id: core::ffi::c_int, visitor: *mut core::ffi::c_void, traversal_order: core::ffi::c_int, ) -> (); - fn get_data_set_indices( - &mut self, - id: core::ffi::c_int, - traverse_subtree: bool, - traversal_order: core::ffi::c_int, - ) -> Vec; - fn get_data_set_indices( - &mut self, - ids: Vec, - traverse_subtree: bool, - traversal_order: core::ffi::c_int, - ) -> Vec; - fn select_nodes( - &mut self, - path_queries: Vec, - traversal_order: core::ffi::c_int, - ) -> Vec; - fn remap_data_set_indices( - &mut self, - mapping: std::collections::HashMap, - remove_unmapped: bool, - ) -> bool; - fn subset_copy( - &mut self, - other: *mut core::ffi::c_void, - selected_branches: Vec, - ) -> (); fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); - fn is_node_name_valid(&mut self, name: core::ffi::c_char) -> bool; - fn make_valid_node_name(&mut self, name: core::ffi::c_char) -> &str; - fn is_node_name_reserved(&mut self, name: core::ffi::c_char) -> bool; + fn is_node_name_valid(&mut self, name: &str) -> bool; + fn is_node_name_reserved(&mut self, name: &str) -> bool; } pub trait VtkDataAssemblyUtilities { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn hierarchy_name(&mut self) -> *const core::ffi::c_char; + fn hierarchy_name(&mut self) -> &str; fn generate_hierarchy( &mut self, input: *mut core::ffi::c_void, hierarchy: *mut core::ffi::c_void, output: *mut core::ffi::c_void, ) -> bool; - fn get_selected_composite_ids( - &mut self, - selectors: Vec, - hierarchyOrAssembly: *mut core::ffi::c_void, - data: *mut core::ffi::c_void, - leaf_nodes_only: bool, - ) -> Vec; - fn get_selector_for_composite_id( - &mut self, - id: core::ffi::c_uint, - hierarchy: *mut core::ffi::c_void, - ) -> &str; - fn get_selectors_for_composite_ids( - &mut self, - ids: Vec, - hierarchy: *mut core::ffi::c_void, - ) -> Vec; } pub trait VtkDataAssemblyVisitor { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -3260,19 +1498,19 @@ pub trait VtkDataObject { &mut self, info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, - name: core::ffi::c_char, + name: &str, ) -> *mut core::ffi::c_void; fn remove_named_field_information( &mut self, info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, - name: core::ffi::c_char, + name: &str, ) -> (); fn set_active_attribute( &mut self, info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, - attributeName: core::ffi::c_char, + attributeName: &str, attributeType: core::ffi::c_int, ) -> *mut core::ffi::c_void; fn set_active_attribute_info( @@ -3280,7 +1518,7 @@ pub trait VtkDataObject { info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, attributeType: core::ffi::c_int, - name: core::ffi::c_char, + name: &str, arrayType: core::ffi::c_int, numComponents: core::ffi::c_int, numTuples: core::ffi::c_int, @@ -3296,7 +1534,6 @@ pub trait VtkDataObject { fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn get_extent_type(&mut self) -> core::ffi::c_int; - fn crop(&mut self, updateExtent: core::ffi::c_int) -> (); fn get_attributes(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_ghost_array(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_attributes_as_field_data( @@ -3307,14 +1544,17 @@ pub trait VtkDataObject { &mut self, arr: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; fn get_association_type_as_string( &mut self, associationType: core::ffi::c_int, - ) -> *const core::ffi::c_char; + ) -> &str; fn get_association_type_from_string( &mut self, - associationName: core::ffi::c_char, + associationName: &str, ) -> core::ffi::c_int; fn data_type_name(&mut self) -> *mut core::ffi::c_void; fn data_object(&mut self) -> *mut core::ffi::c_void; @@ -3345,11 +1585,6 @@ pub trait VtkDataObject { fn bounding_box(&mut self) -> *mut core::ffi::c_void; fn sil(&mut self) -> *mut core::ffi::c_void; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } pub trait VtkDataObjectCollection { fn new(&mut self) -> *mut core::ffi::c_void; @@ -3358,10 +1593,9 @@ pub trait VtkDataObjectCollection { fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); fn get_next_item(&mut self) -> *mut core::ffi::c_void; fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_next_data_object(&mut self, cookie: ()) -> *mut core::ffi::c_void; fn get_number_of_items(&mut self) -> core::ffi::c_int; } -pub trait VtkDataObjectTree: VtkCompositeDataSet + VtkDataObject { +pub trait VtkDataObjectTree { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new_tree_iterator(&mut self) -> *mut core::ffi::c_void; @@ -3380,16 +1614,11 @@ pub trait VtkDataObjectTree: VtkCompositeDataSet + VtkDataObject { fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; } -pub trait VtkDataObjectTreeIterator: VtkCompositeDataIterator { +pub trait VtkDataObjectTreeIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -3413,19 +1642,9 @@ pub trait VtkDataObjectTypes { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_class_name_from_type_id( - &mut self, - typeId: core::ffi::c_int, - ) -> *const core::ffi::c_char; - fn get_type_id_from_class_name( - &mut self, - classname: core::ffi::c_char, - ) -> core::ffi::c_int; - fn new_data_object( - &mut self, - classname: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn new_data_object(&mut self, typeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_class_name_from_type_id(&mut self, typeId: core::ffi::c_int) -> &str; + fn get_type_id_from_class_name(&mut self, classname: &str) -> core::ffi::c_int; + fn new_data_object(&mut self, classname: &str) -> *mut core::ffi::c_void; fn type_id_is_a( &mut self, typeId: core::ffi::c_int, @@ -3437,53 +1656,35 @@ pub trait VtkDataObjectTypes { typeB: core::ffi::c_int, ) -> core::ffi::c_int; } -pub trait VtkDataSet: VtkDataObject { +pub trait VtkDataSet { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); fn copy_attributes(&mut self, ds: *mut core::ffi::c_void) -> (); - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; - fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_point(&mut self, id: core::ffi::c_uchar, x: core::ffi::c_double) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; fn new_cell_iterator(&mut self) -> *mut core::ffi::c_void; - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_cell( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> *mut core::ffi::c_void; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; fn set_cell_order_and_rational_weights( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, cell: *mut core::ffi::c_void, ) -> (); - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> (); - fn get_cell_bounds( - &mut self, - cellId: core::ffi::c_uchar, - bounds: core::ffi::c_double, - ) -> (); - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> (); fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> (); fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> (); fn get_cell_neighbors( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellIds: *mut core::ffi::c_void, ) -> (); @@ -3492,65 +1693,20 @@ pub trait VtkDataSet: VtkDataObject { x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_and_get_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> *mut core::ffi::c_void; + ) -> core::ffi::c_longlong; fn get_m_time(&mut self) -> core::ffi::c_ulong; fn get_cell_data(&mut self) -> *mut core::ffi::c_void; fn get_point_data(&mut self) -> *mut core::ffi::c_void; fn squeeze(&mut self) -> (); fn compute_bounds(&mut self) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_center(&mut self) -> *mut core::ffi::c_double; - fn get_center(&mut self, center: core::ffi::c_double) -> (); fn get_length(&mut self) -> core::ffi::c_double; fn initialize(&mut self) -> (); - fn get_scalar_range(&mut self, range: core::ffi::c_double) -> (); - fn get_scalar_range(&mut self) -> *mut core::ffi::c_double; fn get_max_cell_size(&mut self) -> core::ffi::c_int; fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; fn get_data_object_type(&mut self) -> core::ffi::c_int; fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn check_attributes(&mut self) -> core::ffi::c_int; - fn generate_ghost_array(&mut self, zeroExt: core::ffi::c_int) -> (); - fn generate_ghost_array(&mut self, zeroExt: core::ffi::c_int, cellOnly: bool) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn has_any_ghost_cells(&mut self) -> bool; fn has_any_ghost_points(&mut self) -> bool; fn has_any_blank_cells(&mut self) -> bool; @@ -3562,7 +1718,7 @@ pub trait VtkDataSet: VtkDataObject { fn update_cell_ghost_array_cache(&mut self) -> (); fn allocate_cell_ghost_array(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkDataSetAttributes: VtkFieldData { +pub trait VtkDataSetAttributes { fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -3571,73 +1727,45 @@ pub trait VtkDataSetAttributes: VtkFieldData { fn update(&mut self) -> (); fn deep_copy(&mut self, pd: *mut core::ffi::c_void) -> (); fn shallow_copy(&mut self, pd: *mut core::ffi::c_void) -> (); - fn ghost_array_name(&mut self) -> *const core::ffi::c_char; + fn ghost_array_name(&mut self) -> &str; fn set_scalars(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set_active_scalars(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn set_active_scalars(&mut self, name: &str) -> core::ffi::c_int; fn get_scalars(&mut self) -> *mut core::ffi::c_void; fn set_vectors(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set_active_vectors(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn set_active_vectors(&mut self, name: &str) -> core::ffi::c_int; fn get_vectors(&mut self) -> *mut core::ffi::c_void; fn set_normals(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set_active_normals(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn set_active_normals(&mut self, name: &str) -> core::ffi::c_int; fn get_normals(&mut self) -> *mut core::ffi::c_void; fn set_tangents(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set_active_tangents(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn set_active_tangents(&mut self, name: &str) -> core::ffi::c_int; fn get_tangents(&mut self) -> *mut core::ffi::c_void; fn set_t_coords(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set_active_t_coords(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn set_active_t_coords(&mut self, name: &str) -> core::ffi::c_int; fn get_t_coords(&mut self) -> *mut core::ffi::c_void; fn set_tensors(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set_active_tensors(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn set_active_tensors(&mut self, name: &str) -> core::ffi::c_int; fn get_tensors(&mut self) -> *mut core::ffi::c_void; fn set_global_ids(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set_active_global_ids(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn set_active_global_ids(&mut self, name: &str) -> core::ffi::c_int; fn get_global_ids(&mut self) -> *mut core::ffi::c_void; fn set_pedigree_ids(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set_active_pedigree_ids(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn set_active_pedigree_ids(&mut self, name: &str) -> core::ffi::c_int; fn get_pedigree_ids(&mut self) -> *mut core::ffi::c_void; fn set_rational_weights(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; - fn set_active_rational_weights( - &mut self, - name: core::ffi::c_char, - ) -> core::ffi::c_int; + fn set_active_rational_weights(&mut self, name: &str) -> core::ffi::c_int; fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; fn set_higher_order_degrees( &mut self, da: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn set_active_higher_order_degrees( - &mut self, - name: core::ffi::c_char, - ) -> core::ffi::c_int; + fn set_active_higher_order_degrees(&mut self, name: &str) -> core::ffi::c_int; fn get_higher_order_degrees(&mut self) -> *mut core::ffi::c_void; - fn get_scalars(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; - fn get_vectors(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; - fn get_normals(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; - fn get_tangents(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; - fn get_t_coords(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; - fn get_tensors(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; - fn get_global_ids(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; - fn get_pedigree_ids(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; - fn get_rational_weights( - &mut self, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn get_higher_order_degrees( - &mut self, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn set_active_attribute( - &mut self, - name: core::ffi::c_char, - attributeType: core::ffi::c_int, - ) -> core::ffi::c_int; fn set_active_attribute( &mut self, - index: core::ffi::c_int, + name: &str, attributeType: core::ffi::c_int, ) -> core::ffi::c_int; - fn get_attribute_indices(&mut self, indexArray: core::ffi::c_int) -> (); fn is_array_an_attribute(&mut self, idx: core::ffi::c_int) -> core::ffi::c_int; fn set_attribute( &mut self, @@ -3652,14 +1780,11 @@ pub trait VtkDataSetAttributes: VtkFieldData { &mut self, attributeType: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get_attribute_type_as_string( - &mut self, - attributeType: core::ffi::c_int, - ) -> *const core::ffi::c_char; + fn get_attribute_type_as_string(&mut self, attributeType: core::ffi::c_int) -> &str; fn get_long_attribute_type_as_string( &mut self, attributeType: core::ffi::c_int, - ) -> *const core::ffi::c_char; + ) -> &str; fn set_copy_attribute( &mut self, index: core::ffi::c_int, @@ -3736,49 +1861,22 @@ pub trait VtkDataSetAttributes: VtkFieldData { fn copy_allocate( &mut self, pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> (); - fn copy_allocate( - &mut self, - pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - shallowCopyArrays: core::ffi::c_int, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> (); fn setup_for_copy(&mut self, pd: *mut core::ffi::c_void) -> (); - fn copy_structured_data( - &mut self, - inDsa: *mut core::ffi::c_void, - inExt: core::ffi::c_int, - outExt: core::ffi::c_int, - setSize: bool, - ) -> (); - fn copy_data( - &mut self, - fromPd: *mut core::ffi::c_void, - fromId: core::ffi::c_uchar, - toId: core::ffi::c_uchar, - ) -> (); fn copy_data( &mut self, fromPd: *mut core::ffi::c_void, - fromIds: *mut core::ffi::c_void, - toIds: *mut core::ffi::c_void, - ) -> (); - fn copy_data( - &mut self, - fromPd: *mut core::ffi::c_void, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, ) -> (); fn copy_tuple( &mut self, fromData: *mut core::ffi::c_void, toData: *mut core::ffi::c_void, - fromId: core::ffi::c_uchar, - toId: core::ffi::c_uchar, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, ) -> (); fn copy_tuples( &mut self, @@ -3787,87 +1885,27 @@ pub trait VtkDataSetAttributes: VtkFieldData { fromIds: *mut core::ffi::c_void, toIds: *mut core::ffi::c_void, ) -> (); - fn copy_tuples( - &mut self, - fromData: *mut core::ffi::c_void, - toData: *mut core::ffi::c_void, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - ) -> (); fn interpolate_allocate( &mut self, pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> (); - fn interpolate_allocate( - &mut self, - pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - shallowCopyArrays: core::ffi::c_int, - ) -> (); - fn interpolate_point( - &mut self, - fromPd: *mut core::ffi::c_void, - toId: core::ffi::c_uchar, - ids: *mut core::ffi::c_void, - weights: core::ffi::c_double, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> (); fn interpolate_edge( &mut self, fromPd: *mut core::ffi::c_void, - toId: core::ffi::c_uchar, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, + toId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, t: core::ffi::c_double, ) -> (); fn interpolate_time( &mut self, from1: *mut core::ffi::c_void, from2: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, t: core::ffi::c_double, ) -> (); - fn copy_allocate( - &mut self, - list: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> (); - fn copy_data( - &mut self, - list: *mut core::ffi::c_void, - dsa: *mut core::ffi::c_void, - idx: core::ffi::c_int, - fromId: core::ffi::c_uchar, - toId: core::ffi::c_uchar, - ) -> (); - fn copy_data( - &mut self, - list: *mut core::ffi::c_void, - dsa: *mut core::ffi::c_void, - idx: core::ffi::c_int, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - ) -> (); - fn interpolate_allocate( - &mut self, - list: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> (); - fn interpolate_point( - &mut self, - list: *mut core::ffi::c_void, - fromPd: *mut core::ffi::c_void, - idx: core::ffi::c_int, - toId: core::ffi::c_uchar, - ids: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> (); } pub trait VtkDataSetAttributesFieldList { fn reset(&mut self) -> (); @@ -3878,42 +1916,24 @@ pub trait VtkDataSetAttributesFieldList { &mut self, output: *mut core::ffi::c_void, ctype: core::ffi::c_int, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> (); fn copy_data( &mut self, inputIndex: core::ffi::c_int, input: *mut core::ffi::c_void, - fromId: core::ffi::c_uchar, + fromId: core::ffi::c_longlong, output: *mut core::ffi::c_void, - toId: core::ffi::c_uchar, - ) -> (); - fn copy_data( - &mut self, - inputIndex: core::ffi::c_int, - input: *mut core::ffi::c_void, - inputStart: core::ffi::c_uchar, - numValues: core::ffi::c_uchar, - output: *mut core::ffi::c_void, - outStart: core::ffi::c_uchar, - ) -> (); - fn interpolate_point( - &mut self, - inputIndex: core::ffi::c_int, - input: *mut core::ffi::c_void, - inputIds: *mut core::ffi::c_void, - weights: core::ffi::c_double, - output: *mut core::ffi::c_void, - toId: core::ffi::c_uchar, + toId: core::ffi::c_longlong, ) -> (); } -pub trait VtkDataSetCellIterator: VtkCellIterator { +pub trait VtkDataSetCellIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn is_done_with_traversal(&mut self) -> bool; - fn get_cell_id(&mut self) -> core::ffi::c_uchar; + fn get_cell_id(&mut self) -> core::ffi::c_longlong; } pub trait VtkDataSetCollection { fn new(&mut self) -> *mut core::ffi::c_void; @@ -3924,53 +1944,33 @@ pub trait VtkDataSetCollection { fn get_next_data_set(&mut self) -> *mut core::ffi::c_void; fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_data_set(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_next_data_set(&mut self, cookie: ()) -> *mut core::ffi::c_void; fn get_number_of_items(&mut self) -> core::ffi::c_int; } -pub trait VtkDirectedAcyclicGraph: VtkDirectedGraph + VtkGraph + VtkDataObject { +pub trait VtkDirectedAcyclicGraph { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } -pub trait VtkDirectedGraph: VtkGraph + VtkDataObject { +pub trait VtkDirectedGraph { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool; } pub trait VtkDistributedGraphHelper { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_vertex_owner(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_vertex_index(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_edge_owner(&mut self, e_id: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_edge_index(&mut self, e_id: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_vertex_owner(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_vertex_index(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_edge_owner(&mut self, e_id: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_edge_index(&mut self, e_id: core::ffi::c_longlong) -> core::ffi::c_longlong; fn make_distributed_id( &mut self, owner: core::ffi::c_int, - local: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn set_vertex_pedigree_id_distribution( - &mut self, - Func: *mut core::ffi::c_void, - userData: (), - ) -> (); - fn get_vertex_owner_by_pedigree_id( - &mut self, - pedigreeId: vtkVariant, - ) -> core::ffi::c_uchar; + local: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn synchronize(&mut self) -> (); fn clone(&mut self) -> *mut core::ffi::c_void; fn distributedvertexids(&mut self) -> *mut core::ffi::c_void; @@ -3982,7 +1982,6 @@ pub trait VtkEdgeListIterator { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_graph(&mut self) -> *mut core::ffi::c_void; fn set_graph(&mut self, graph: *mut core::ffi::c_void) -> (); - fn next(&mut self) -> *mut core::ffi::c_void; fn next_graph_edge(&mut self) -> *mut core::ffi::c_void; fn has_next(&mut self) -> bool; } @@ -3993,60 +1992,34 @@ pub trait VtkEdgeTable { fn initialize(&mut self) -> (); fn init_edge_insertion( &mut self, - numPoints: core::ffi::c_uchar, + numPoints: core::ffi::c_longlong, storeAttributes: core::ffi::c_int, ) -> core::ffi::c_int; fn insert_edge( &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn insert_edge( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - attributeId: core::ffi::c_uchar, - ) -> (); - fn insert_edge( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ptr: (), - ) -> (); + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn is_edge( &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn is_edge(&mut self, p1: core::ffi::c_uchar, p2: core::ffi::c_uchar, ptr: ()) -> (); + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn init_point_insertion( &mut self, newPts: *mut core::ffi::c_void, - estSize: core::ffi::c_uchar, + estSize: core::ffi::c_longlong, ) -> core::ffi::c_int; - fn insert_unique_point( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn get_number_of_edges(&mut self) -> core::ffi::c_uchar; + fn get_number_of_edges(&mut self) -> core::ffi::c_longlong; fn init_traversal(&mut self) -> (); fn get_next_edge( &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_next_edge( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ptr: (), - ) -> core::ffi::c_int; + p1: &mut core::ffi::c_longlong, + p2: &mut core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn reset(&mut self) -> (); } -pub trait VtkEmptyCell: VtkCell { +pub trait VtkEmptyCell { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -4056,12 +2029,6 @@ pub trait VtkEmptyCell: VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -4073,7 +2040,7 @@ pub trait VtkEmptyCell: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -4085,72 +2052,33 @@ pub trait VtkEmptyCell: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkExplicitStructuredGrid: VtkPointSet + VtkDataSet + VtkDataObject { +pub trait VtkExplicitStructuredGrid { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; fn initialize(&mut self) -> (); - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> (); - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> (); fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> (); fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); @@ -4161,9 +2089,6 @@ pub trait VtkExplicitStructuredGrid: VtkPointSet + VtkDataSet + VtkDataObject { j: core::ffi::c_int, k: core::ffi::c_int, ) -> (); - fn set_dimensions(&mut self, dim: core::ffi::c_int) -> (); - fn get_dimensions(&mut self, dim: core::ffi::c_int) -> (); - fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> (); fn get_extent_type(&mut self) -> core::ffi::c_int; fn set_extent( &mut self, @@ -4174,41 +2099,16 @@ pub trait VtkExplicitStructuredGrid: VtkPointSet + VtkDataSet + VtkDataObject { z0: core::ffi::c_int, z1: core::ffi::c_int, ) -> (); - fn set_extent(&mut self, extent: core::ffi::c_int) -> (); - fn get_extent(&mut self) -> *mut core::ffi::c_int; - fn get_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> (); - fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); fn set_cells(&mut self, cells: *mut core::ffi::c_void) -> (); fn get_cells(&mut self) -> *mut core::ffi::c_void; fn build_links(&mut self) -> (); fn get_links(&mut self) -> *mut core::ffi::c_void; - fn get_cell_points(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn get_cell_points( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - neighbors: core::ffi::c_uchar, - wholeExtent: core::ffi::c_int, - ) -> (); fn compute_cell_structured_coords( &mut self, - cellId: core::ffi::c_uchar, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, + cellId: core::ffi::c_longlong, + i: &mut core::ffi::c_int, + j: &mut core::ffi::c_int, + k: &mut core::ffi::c_int, adjustForExtent: bool, ) -> (); fn compute_cell_id( @@ -4217,29 +2117,16 @@ pub trait VtkExplicitStructuredGrid: VtkPointSet + VtkDataSet + VtkDataObject { j: core::ffi::c_int, k: core::ffi::c_int, adjustForExtent: bool, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn compute_faces_connectivity_flags_array(&mut self) -> (); - fn set_faces_connectivity_flags_array_name(&mut self, _arg: core::ffi::c_char) -> (); - fn get_faces_connectivity_flags_array_name(&mut self) -> *mut core::ffi::c_char; - fn blank_cell(&mut self, cellId: core::ffi::c_uchar) -> (); - fn un_blank_cell(&mut self, cellId: core::ffi::c_uchar) -> (); + fn set_faces_connectivity_flags_array_name(&mut self, _arg: &str) -> (); + fn blank_cell(&mut self, cellId: core::ffi::c_longlong) -> (); + fn un_blank_cell(&mut self, cellId: core::ffi::c_longlong) -> (); fn has_any_blank_cells(&mut self) -> bool; - fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn is_cell_ghost(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn is_cell_ghost(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; fn has_any_ghost_cells(&mut self) -> bool; - fn crop(&mut self, updateExtent: core::ffi::c_int) -> (); - fn crop( - &mut self, - input: *mut core::ffi::c_void, - updateExtent: core::ffi::c_int, - generateOriginalCellIds: bool, - ) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; fn check_and_reorder_faces(&mut self) -> (); } @@ -4247,24 +2134,6 @@ pub trait VtkExtractStructuredGridHelper { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_output_whole_extent(&mut self) -> *mut core::ffi::c_int; - fn get_output_whole_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> (); - fn get_output_whole_extent(&mut self, _arg: core::ffi::c_int) -> (); - fn initialize( - &mut self, - voi: core::ffi::c_int, - wholeExt: core::ffi::c_int, - sampleRate: core::ffi::c_int, - includeBoundary: bool, - ) -> (); fn is_valid(&mut self) -> bool; fn get_size(&mut self, dim: core::ffi::c_int) -> core::ffi::c_int; fn get_mapped_index( @@ -4287,46 +2156,6 @@ pub trait VtkExtractStructuredGridHelper { dim: core::ffi::c_int, outIdx: core::ffi::c_int, ) -> core::ffi::c_int; - fn compute_begin_and_end( - &mut self, - inExt: core::ffi::c_int, - voi: core::ffi::c_int, - begin: core::ffi::c_int, - end: core::ffi::c_int, - ) -> (); - fn copy_points_and_point_data( - &mut self, - inExt: core::ffi::c_int, - outExt: core::ffi::c_int, - pd: *mut core::ffi::c_void, - inpnts: *mut core::ffi::c_void, - outPD: *mut core::ffi::c_void, - outpnts: *mut core::ffi::c_void, - ) -> (); - fn copy_cell_data( - &mut self, - inExt: core::ffi::c_int, - outExt: core::ffi::c_int, - cd: *mut core::ffi::c_void, - outCD: *mut core::ffi::c_void, - ) -> (); - fn get_partitioned_voi( - &mut self, - globalVOI: core::ffi::c_int, - partitionedExtent: core::ffi::c_int, - sampleRate: core::ffi::c_int, - includeBoundary: bool, - partitionedVOI: core::ffi::c_int, - ) -> (); - fn get_partitioned_output_extent( - &mut self, - globalVOI: core::ffi::c_int, - partitionedVOI: core::ffi::c_int, - outputWholeExtent: core::ffi::c_int, - sampleRate: core::ffi::c_int, - includeBoundary: bool, - partitionedOutputExtent: core::ffi::c_int, - ) -> (); } pub trait VtkFieldData { fn new(&mut self) -> *mut core::ffi::c_void; @@ -4336,38 +2165,22 @@ pub trait VtkFieldData { fn initialize(&mut self) -> (); fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> (); fn allocate_arrays(&mut self, num: core::ffi::c_int) -> (); fn get_number_of_arrays(&mut self) -> core::ffi::c_int; fn add_array(&mut self, array: *mut core::ffi::c_void) -> core::ffi::c_int; - fn null_data(&mut self, id: core::ffi::c_uchar) -> (); - fn remove_array(&mut self, name: core::ffi::c_char) -> (); - fn remove_array(&mut self, index: core::ffi::c_int) -> (); + fn null_data(&mut self, id: core::ffi::c_longlong) -> (); + fn remove_array(&mut self, name: &str) -> (); fn get_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_array( - &mut self, - arrayName: core::ffi::c_char, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_array(&mut self, arrayName: core::ffi::c_char) -> *mut core::ffi::c_void; fn get_abstract_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_abstract_array( - &mut self, - arrayName: core::ffi::c_char, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_abstract_array( - &mut self, - arrayName: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn has_array(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; - fn get_array_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char; + fn has_array(&mut self, name: &str) -> core::ffi::c_int; + fn get_array_name(&mut self, i: core::ffi::c_int) -> &str; fn pass_data(&mut self, fd: *mut core::ffi::c_void) -> (); - fn copy_field_on(&mut self, name: core::ffi::c_char) -> (); - fn copy_field_off(&mut self, name: core::ffi::c_char) -> (); + fn copy_field_on(&mut self, name: &str) -> (); + fn copy_field_off(&mut self, name: &str) -> (); fn copy_all_on(&mut self, unused: core::ffi::c_int) -> (); fn copy_all_off(&mut self, unused: core::ffi::c_int) -> (); fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); @@ -4384,49 +2197,38 @@ pub trait VtkFieldData { fn get_array_containing_component( &mut self, i: core::ffi::c_int, - arrayComp: core::ffi::c_int, + arrayComp: &mut core::ffi::c_int, ) -> core::ffi::c_int; fn get_number_of_components(&mut self) -> core::ffi::c_int; - fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar; - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); fn set_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> (); fn insert_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> (); fn insert_next_tuple( &mut self, - j: core::ffi::c_uchar, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } pub trait VtkFindCellStrategy { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; } pub trait VtkGenericAdaptorCell { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_id(&mut self) -> core::ffi::c_uchar; + fn get_id(&mut self) -> core::ffi::c_longlong; fn is_in_data_set(&mut self) -> core::ffi::c_int; fn get_type(&mut self) -> core::ffi::c_int; fn get_dimension(&mut self) -> core::ffi::c_int; @@ -4450,44 +2252,11 @@ pub trait VtkGenericAdaptorCell { dim: core::ffi::c_int, ) -> (); fn count_neighbors(&mut self, boundary: *mut core::ffi::c_void) -> core::ffi::c_int; - fn count_edge_neighbors(&mut self, sharing: core::ffi::c_int) -> (); fn get_neighbors( &mut self, boundary: *mut core::ffi::c_void, neighbors: *mut core::ffi::c_void, ) -> (); - fn find_closest_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - boundary: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - ) -> (); - fn interpolate_tuple( - &mut self, - a: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - val: core::ffi::c_double, - ) -> (); - fn interpolate_tuple( - &mut self, - c: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - val: core::ffi::c_double, - ) -> (); fn contour( &mut self, values: *mut core::ffi::c_void, @@ -4519,35 +2288,7 @@ pub trait VtkGenericAdaptorCell { secondaryPd: *mut core::ffi::c_void, secondaryCd: *mut core::ffi::c_void, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - attribute: *mut core::ffi::c_void, - derivs: core::ffi::c_double, - ) -> (); - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; fn get_length_2(&mut self) -> core::ffi::c_double; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double; fn tessellate( &mut self, attributes: *mut core::ffi::c_void, @@ -4560,9 +2301,8 @@ pub trait VtkGenericAdaptorCell { cd: *mut core::ffi::c_void, types: *mut core::ffi::c_void, ) -> (); - fn is_face_on_boundary(&mut self, faceId: core::ffi::c_uchar) -> core::ffi::c_int; + fn is_face_on_boundary(&mut self, faceId: core::ffi::c_longlong) -> core::ffi::c_int; fn is_on_boundary(&mut self) -> core::ffi::c_int; - fn get_point_ids(&mut self, id: core::ffi::c_uchar) -> (); fn triangulate_face( &mut self, attributes: *mut core::ffi::c_void, @@ -4575,53 +2315,22 @@ pub trait VtkGenericAdaptorCell { pd: *mut core::ffi::c_void, cd: *mut core::ffi::c_void, ) -> (); - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; fn get_number_of_vertices_on_face( &mut self, faceId: core::ffi::c_int, ) -> core::ffi::c_int; - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; } pub trait VtkGenericAttribute { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_name(&mut self) -> *const core::ffi::c_char; + fn get_name(&mut self) -> &str; fn get_number_of_components(&mut self) -> core::ffi::c_int; fn get_centering(&mut self) -> core::ffi::c_int; fn get_type(&mut self) -> core::ffi::c_int; fn get_component_type(&mut self) -> core::ffi::c_int; - fn get_size(&mut self) -> core::ffi::c_uchar; + fn get_size(&mut self) -> core::ffi::c_longlong; fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; - fn get_range(&mut self, component: core::ffi::c_int) -> *mut core::ffi::c_double; - fn get_range( - &mut self, - component: core::ffi::c_int, - range: core::ffi::c_double, - ) -> (); fn get_max_norm(&mut self) -> core::ffi::c_double; - fn get_tuple(&mut self, c: *mut core::ffi::c_void) -> *mut core::ffi::c_double; - fn get_tuple(&mut self, c: *mut core::ffi::c_void, tuple: core::ffi::c_double) -> (); - fn get_tuple(&mut self, c: *mut core::ffi::c_void) -> *mut core::ffi::c_double; - fn get_tuple(&mut self, c: *mut core::ffi::c_void, tuple: core::ffi::c_double) -> (); - fn get_tuple(&mut self, p: *mut core::ffi::c_void) -> *mut core::ffi::c_double; - fn get_tuple(&mut self, p: *mut core::ffi::c_void, tuple: core::ffi::c_double) -> (); - fn get_component( - &mut self, - i: core::ffi::c_int, - c: *mut core::ffi::c_void, - values: core::ffi::c_double, - ) -> (); - fn get_component( - &mut self, - i: core::ffi::c_int, - p: *mut core::ffi::c_void, - ) -> core::ffi::c_double; fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); } @@ -4636,7 +2345,7 @@ pub trait VtkGenericAttributeCollection { fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; fn is_empty(&mut self) -> core::ffi::c_int; fn get_attribute(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn find_attribute(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn find_attribute(&mut self, name: &str) -> core::ffi::c_int; fn get_attribute_index(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; fn insert_next_attribute(&mut self, a: *mut core::ffi::c_void) -> (); fn insert_attribute(&mut self, i: core::ffi::c_int, a: *mut core::ffi::c_void) -> (); @@ -4653,21 +2362,9 @@ pub trait VtkGenericAttributeCollection { component: core::ffi::c_int, ) -> (); fn get_number_of_attributes_to_interpolate(&mut self) -> core::ffi::c_int; - fn get_attributes_to_interpolate(&mut self) -> *mut core::ffi::c_int; - fn has_attribute( - &mut self, - size: core::ffi::c_int, - attributes: core::ffi::c_int, - attribute: core::ffi::c_int, - ) -> core::ffi::c_int; - fn set_attributes_to_interpolate( - &mut self, - size: core::ffi::c_int, - attributes: core::ffi::c_int, - ) -> (); fn set_attributes_to_interpolate_to_all(&mut self) -> (); } -pub trait VtkGenericCell: VtkCell { +pub trait VtkGenericCell { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -4680,28 +2377,6 @@ pub trait VtkGenericCell: VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn contour( &mut self, value: core::ffi::c_double, @@ -4713,7 +2388,7 @@ pub trait VtkGenericCell: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -4725,39 +2400,16 @@ pub trait VtkGenericCell: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn set_cell_type(&mut self, cellType: core::ffi::c_int) -> (); fn set_cell_type_to_empty_cell(&mut self) -> (); fn set_cell_type_to_vertex(&mut self) -> (); @@ -4817,7 +2469,6 @@ pub trait VtkGenericCellIterator { fn is_at_end(&mut self) -> core::ffi::c_int; fn new_cell(&mut self) -> *mut core::ffi::c_void; fn get_cell(&mut self, c: *mut core::ffi::c_void) -> (); - fn get_cell(&mut self) -> *mut core::ffi::c_void; fn next(&mut self) -> (); } pub trait VtkGenericCellTessellator { @@ -4827,7 +2478,7 @@ pub trait VtkGenericCellTessellator { &mut self, cell: *mut core::ffi::c_void, att: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, points: *mut core::ffi::c_void, cellArray: *mut core::ffi::c_void, internalPd: *mut core::ffi::c_void, @@ -4854,13 +2505,12 @@ pub trait VtkGenericCellTessellator { fn init_error_metrics(&mut self, ds: *mut core::ffi::c_void) -> (); fn get_measurement(&mut self) -> core::ffi::c_int; fn set_measurement(&mut self, _arg: core::ffi::c_int) -> (); - fn get_max_errors(&mut self, errors: core::ffi::c_double) -> (); } -pub trait VtkGenericDataSet: VtkDataObject { +pub trait VtkGenericDataSet { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; - fn get_number_of_cells(&mut self, dim: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_cells(&mut self, dim: core::ffi::c_int) -> core::ffi::c_longlong; fn get_cell_dimension(&mut self) -> core::ffi::c_int; fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> (); fn new_cell_iterator(&mut self, dim: core::ffi::c_int) -> *mut core::ffi::c_void; @@ -4870,35 +2520,16 @@ pub trait VtkGenericDataSet: VtkDataObject { exteriorOnly: core::ffi::c_int, ) -> *mut core::ffi::c_void; fn new_point_iterator(&mut self) -> *mut core::ffi::c_void; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn find_point(&mut self, x: core::ffi::c_double, p: *mut core::ffi::c_void) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; fn compute_bounds(&mut self) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_center(&mut self) -> *mut core::ffi::c_double; - fn get_center(&mut self, center: core::ffi::c_double) -> (); fn get_length(&mut self) -> core::ffi::c_double; fn get_attributes(&mut self) -> *mut core::ffi::c_void; - fn get_attributes(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_tessellator(&mut self, tessellator: *mut core::ffi::c_void) -> (); fn get_tessellator(&mut self) -> *mut core::ffi::c_void; fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; fn get_data_object_type(&mut self) -> core::ffi::c_int; - fn get_estimated_size(&mut self) -> core::ffi::c_uchar; + fn get_estimated_size(&mut self) -> core::ffi::c_longlong; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } pub trait VtkGenericEdgeTable { fn new(&mut self) -> *mut core::ffi::c_void; @@ -4906,64 +2537,40 @@ pub trait VtkGenericEdgeTable { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn insert_edge( &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, - ref_: core::ffi::c_int, - ptId: core::ffi::c_uchar, - ) -> (); - fn insert_edge( - &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ref_: core::ffi::c_int, + ptId: &mut core::ffi::c_longlong, ) -> (); fn remove_edge( &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, ) -> core::ffi::c_int; fn check_edge( &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - ptId: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ptId: &mut core::ffi::c_longlong, ) -> core::ffi::c_int; fn increment_edge_reference_count( &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int; fn check_edge_reference_count( &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, ) -> core::ffi::c_int; - fn initialize(&mut self, start: core::ffi::c_uchar) -> (); + fn initialize(&mut self, start: core::ffi::c_longlong) -> (); fn get_number_of_components(&mut self) -> core::ffi::c_int; fn set_number_of_components(&mut self, count: core::ffi::c_int) -> (); - fn check_point(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_int; - fn check_point( - &mut self, - ptId: core::ffi::c_uchar, - point: core::ffi::c_double, - scalar: core::ffi::c_double, - ) -> core::ffi::c_int; - fn insert_point( - &mut self, - ptId: core::ffi::c_uchar, - point: core::ffi::c_double, - ) -> (); - fn insert_point_and_scalar( - &mut self, - ptId: core::ffi::c_uchar, - pt: core::ffi::c_double, - s: core::ffi::c_double, - ) -> (); - fn remove_point(&mut self, ptId: core::ffi::c_uchar) -> (); - fn increment_point_reference_count(&mut self, ptId: core::ffi::c_uchar) -> (); + fn check_point(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_int; + fn remove_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn increment_point_reference_count(&mut self, ptId: core::ffi::c_longlong) -> (); fn dump_table(&mut self) -> (); fn load_factor(&mut self) -> (); } @@ -4971,26 +2578,16 @@ pub trait VtkGenericInterpolatedVelocityField { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn function_values( - &mut self, - x: core::ffi::c_double, - f: core::ffi::c_double, - ) -> core::ffi::c_int; fn add_data_set(&mut self, dataset: *mut core::ffi::c_void) -> (); fn clear_last_cell(&mut self) -> (); fn get_last_cell(&mut self) -> *mut core::ffi::c_void; - fn get_last_local_coordinates( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; fn get_caching(&mut self) -> core::ffi::c_int; fn set_caching(&mut self, _arg: core::ffi::c_int) -> (); fn caching_on(&mut self) -> (); fn caching_off(&mut self) -> (); fn get_cache_hit(&mut self) -> core::ffi::c_int; fn get_cache_miss(&mut self) -> core::ffi::c_int; - fn get_vectors_selection(&mut self) -> *mut core::ffi::c_char; - fn select_vectors(&mut self, fieldName: core::ffi::c_char) -> (); + fn select_vectors(&mut self, fieldName: &str) -> (); fn get_last_data_set(&mut self) -> *mut core::ffi::c_void; fn copy_parameters(&mut self, from: *mut core::ffi::c_void) -> (); } @@ -5000,33 +2597,17 @@ pub trait VtkGenericPointIterator { fn begin(&mut self) -> (); fn is_at_end(&mut self) -> core::ffi::c_int; fn next(&mut self) -> (); - fn get_position(&mut self) -> *mut core::ffi::c_double; - fn get_position(&mut self, x: core::ffi::c_double) -> (); - fn get_id(&mut self) -> core::ffi::c_uchar; + fn get_id(&mut self) -> core::ffi::c_longlong; } pub trait VtkGenericSubdivisionErrorMetric { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn requires_edge_subdivision( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_error( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_double; fn set_generic_cell(&mut self, cell: *mut core::ffi::c_void) -> (); fn get_generic_cell(&mut self) -> *mut core::ffi::c_void; fn set_data_set(&mut self, ds: *mut core::ffi::c_void) -> (); fn get_data_set(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkGeometricErrorMetric: VtkGenericSubdivisionErrorMetric { +pub trait VtkGeometricErrorMetric { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -5037,76 +2618,43 @@ pub trait VtkGeometricErrorMetric: VtkGenericSubdivisionErrorMetric { value: core::ffi::c_double, ds: *mut core::ffi::c_void, ) -> (); - fn requires_edge_subdivision( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_error( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_double; fn get_relative(&mut self) -> core::ffi::c_int; } -pub trait VtkGraph: VtkDataObject { +pub trait VtkGraph { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_vertex_data(&mut self) -> *mut core::ffi::c_void; fn get_edge_data(&mut self) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; fn initialize(&mut self) -> (); - fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> (); fn get_points(&mut self) -> *mut core::ffi::c_void; fn set_points(&mut self, points: *mut core::ffi::c_void) -> (); fn compute_bounds(&mut self) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; - fn get_out_edges(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> (); - fn get_degree(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_out_degree(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_out_edge( - &mut self, - v: core::ffi::c_uchar, - index: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn get_out_edge( + fn get_out_edges( &mut self, - v: core::ffi::c_uchar, - index: core::ffi::c_uchar, - e: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, ) -> (); - fn get_in_edges(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> (); - fn get_in_degree(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_in_edge( - &mut self, - v: core::ffi::c_uchar, - index: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn get_in_edge( + fn get_degree(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_out_degree(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_in_edges( &mut self, - v: core::ffi::c_uchar, - index: core::ffi::c_uchar, - e: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, ) -> (); + fn get_in_degree(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; fn get_adjacent_vertices( &mut self, - v: core::ffi::c_uchar, + v: core::ffi::c_longlong, it: *mut core::ffi::c_void, ) -> (); fn get_edges(&mut self, it: *mut core::ffi::c_void) -> (); - fn get_number_of_edges(&mut self) -> core::ffi::c_uchar; + fn get_number_of_edges(&mut self) -> core::ffi::c_longlong; fn get_vertices(&mut self, it: *mut core::ffi::c_void) -> (); - fn get_number_of_vertices(&mut self) -> core::ffi::c_uchar; + fn get_number_of_vertices(&mut self) -> core::ffi::c_longlong; fn set_distributed_graph_helper(&mut self, helper: *mut core::ffi::c_void) -> (); fn get_distributed_graph_helper(&mut self) -> *mut core::ffi::c_void; - fn find_vertex(&mut self, pedigreeID: vtkVariant) -> core::ffi::c_uchar; fn shallow_copy(&mut self, obj: *mut core::ffi::c_void) -> (); fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); fn copy_structure(&mut self, g: *mut core::ffi::c_void) -> (); @@ -5114,56 +2662,30 @@ pub trait VtkGraph: VtkDataObject { fn checked_deep_copy(&mut self, g: *mut core::ffi::c_void) -> bool; fn squeeze(&mut self) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn reorder_out_vertices( &mut self, - v: core::ffi::c_uchar, + v: core::ffi::c_longlong, vertices: *mut core::ffi::c_void, ) -> (); fn is_same_structure(&mut self, other: *mut core::ffi::c_void) -> bool; - fn get_source_vertex(&mut self, e: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_target_vertex(&mut self, e: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn set_edge_points( - &mut self, - e: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_double, - ) -> (); - fn get_edge_points( - &mut self, - e: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_double, - ) -> (); - fn get_number_of_edge_points(&mut self, e: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_edge_point( + fn get_source_vertex(&mut self, e: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_target_vertex(&mut self, e: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_number_of_edge_points( &mut self, - e: core::ffi::c_uchar, - i: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - fn clear_edge_points(&mut self, e: core::ffi::c_uchar) -> (); + e: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn clear_edge_points(&mut self, e: core::ffi::c_longlong) -> (); fn set_edge_point( &mut self, - e: core::ffi::c_uchar, - i: core::ffi::c_uchar, - x: core::ffi::c_double, - ) -> (); - fn set_edge_point( - &mut self, - e: core::ffi::c_uchar, - i: core::ffi::c_uchar, + e: core::ffi::c_longlong, + i: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn add_edge_point(&mut self, e: core::ffi::c_uchar, x: core::ffi::c_double) -> (); fn add_edge_point( &mut self, - e: core::ffi::c_uchar, + e: core::ffi::c_longlong, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, @@ -5176,13 +2698,16 @@ pub trait VtkGraph: VtkDataObject { verts: *mut core::ffi::c_void, edges: *mut core::ffi::c_void, ) -> (); - fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; fn dump(&mut self) -> (); fn get_edge_id( &mut self, - a: core::ffi::c_uchar, - b: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + a: core::ffi::c_longlong, + b: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn to_directed_graph(&mut self, g: *mut core::ffi::c_void) -> bool; fn to_undirected_graph(&mut self, g: *mut core::ffi::c_void) -> bool; } @@ -5190,371 +2715,63 @@ pub trait VtkGraphEdge { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set_source(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_source(&mut self) -> core::ffi::c_uchar; - fn set_target(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_target(&mut self) -> core::ffi::c_uchar; - fn set_id(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_id(&mut self) -> core::ffi::c_uchar; + fn set_source(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_source(&mut self) -> core::ffi::c_longlong; + fn set_target(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_target(&mut self) -> core::ffi::c_longlong; + fn set_id(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_id(&mut self) -> core::ffi::c_longlong; } pub trait VtkGraphInternals { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn remove_edge_from_out_list( - &mut self, - e: core::ffi::c_uchar, - outEdges: Vec, - ) -> (); - fn remove_edge_from_in_list( - &mut self, - e: core::ffi::c_uchar, - inEdges: Vec, - ) -> (); - fn replace_edge_from_out_list( - &mut self, - from: core::ffi::c_uchar, - to: core::ffi::c_uchar, - outEdges: Vec, - ) -> (); - fn replace_edge_from_in_list( - &mut self, - from: core::ffi::c_uchar, - to: core::ffi::c_uchar, - inEdges: Vec, - ) -> (); } -pub trait VtkHexagonalPrism: VtkCell3D + VtkCell { +pub trait VtkHexagonalPrism { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkHexahedron: VtkCell3D + VtkCell { +pub trait VtkHexahedron { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkHierarchicalBoxDataIterator: VtkUniformGridAMRDataIterator + VtkCompositeDataIterator { +pub trait VtkHierarchicalBoxDataIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkHierarchicalBoxDataSet: VtkOverlappingAMR + VtkUniformGridAMR + VtkCompositeDataSet + VtkDataObject { +pub trait VtkHierarchicalBoxDataSet { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new_iterator(&mut self) -> *mut core::ffi::c_void; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } -pub trait VtkHigherOrderCurve: VtkNonLinearCell + VtkCell { +pub trait VtkHigherOrderCurve { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_dimension(&mut self) -> core::ffi::c_int; @@ -5562,28 +2779,6 @@ pub trait VtkHigherOrderCurve: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn contour( &mut self, value: core::ffi::c_double, @@ -5595,7 +2790,7 @@ pub trait VtkHigherOrderCurve: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -5607,98 +2802,30 @@ pub trait VtkHigherOrderCurve: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn set_parametric_coords(&mut self) -> (); - fn get_parametric_center(&mut self, center: core::ffi::c_double) -> core::ffi::c_int; - fn get_order(&mut self) -> *const core::ffi::c_int; - fn get_order(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn sub_cell_coordinates_from_id( - &mut self, - ijk: *mut core::ffi::c_void, - subId: core::ffi::c_int, - ) -> bool; - fn sub_cell_coordinates_from_id( - &mut self, - i: core::ffi::c_int, - subId: core::ffi::c_int, - ) -> bool; fn point_index_from_ijk( &mut self, i: core::ffi::c_int, p1: core::ffi::c_int, p2: core::ffi::c_int, ) -> core::ffi::c_int; - fn transform_approx_to_cell_params( - &mut self, - subCell: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> bool; } -pub trait VtkHigherOrderHexahedron: VtkNonLinearCell + VtkCell { +pub trait VtkHigherOrderHexahedron { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_dimension(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn contour( &mut self, value: core::ffi::c_double, @@ -5710,7 +2837,7 @@ pub trait VtkHigherOrderHexahedron: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -5722,336 +2849,62 @@ pub trait VtkHigherOrderHexahedron: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn set_parametric_coords(&mut self) -> (); - fn get_parametric_center(&mut self, center: core::ffi::c_double) -> core::ffi::c_int; fn set_order_from_cell_data( &mut self, cell_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, - cell_id: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, + cell_id: core::ffi::c_longlong, ) -> (); - fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_uchar) -> (); + fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_longlong) -> (); fn set_order( &mut self, s: core::ffi::c_int, t: core::ffi::c_int, u: core::ffi::c_int, ) -> (); - fn get_order(&mut self) -> *const core::ffi::c_int; - fn get_order(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn sub_cell_coordinates_from_id( - &mut self, - ijk: *mut core::ffi::c_void, - subId: core::ffi::c_int, - ) -> bool; - fn sub_cell_coordinates_from_id( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - subId: core::ffi::c_int, - ) -> bool; - fn point_index_from_ijk( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - order: core::ffi::c_int, - ) -> core::ffi::c_int; - fn point_index_from_ijk( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> core::ffi::c_int; - fn transform_approx_to_cell_params( - &mut self, - subCell: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> bool; - fn transform_face_to_cell_params( - &mut self, - bdyFace: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> bool; - fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; fn get_face_cell(&mut self) -> *mut core::ffi::c_void; - fn get_face_cell(&mut self) -> *mut core::ffi::c_void; fn get_interpolation(&mut self) -> *mut core::ffi::c_void; fn get_interp(&mut self) -> *mut core::ffi::c_void; - fn node_numbering_mapping_from_vtk_8_to_9( - &mut self, - order: core::ffi::c_int, - node_id_vtk8: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; } pub trait VtkHigherOrderInterpolation { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn tensor_1_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - function_evaluate_shape_functions: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn tensor_1_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - function_evaluate_shape_and_gradient: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn tensor_2_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - function_evaluate_shape_functions: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn tensor_2_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - function_evaluate_shape_and_gradient: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn tensor_3_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - function_evaluate_shape_functions: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn tensor_3_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - function_evaluate_shape_and_gradient: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn tensor_3_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ) -> (); - fn tensor_3_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - function_evaluate_shape_and_gradient: *mut core::ffi::c_void, - ) -> (); - fn wedge_shape_functions( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - tri: *mut core::ffi::c_void, - function_evaluate_shape_functions: *mut core::ffi::c_void, - ) -> (); - fn wedge_shape_derivatives( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - tri: *mut core::ffi::c_void, - function_evaluate_shape_and_gradient: *mut core::ffi::c_void, - ) -> (); - fn jacobian_inverse( - &mut self, - points: *mut core::ffi::c_void, - derivs: core::ffi::c_double, - inverse: core::ffi::c_double, - ) -> core::ffi::c_int; - fn jacobian_inverse_wedge( - &mut self, - points: *mut core::ffi::c_void, - derivs: core::ffi::c_double, - inverse: core::ffi::c_double, - ) -> core::ffi::c_int; - fn wedge_evaluate( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldAtPCoords: core::ffi::c_double, - ) -> (); - fn wedge_evaluate( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldAtPCoords: core::ffi::c_double, - tri: *mut core::ffi::c_void, - function_evaluate_shape_functions: *mut core::ffi::c_void, - ) -> (); - fn wedge_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ) -> (); - fn wedge_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - tri: *mut core::ffi::c_void, - function_evaluate_shape_and_gradient: *mut core::ffi::c_void, - ) -> (); - fn get_parametric_hex_coordinates( - &mut self, - vertexId: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_point_indices_bounding_hex_edge( - &mut self, - edgeId: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_varying_parameter_of_hex_edge( &mut self, edgeId: core::ffi::c_int, ) -> core::ffi::c_int; - fn get_fixed_parameters_of_hex_edge( - &mut self, - edgeId: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_point_indices_bounding_hex_face( - &mut self, - faceId: core::ffi::c_int, - ) -> *const core::ffi::c_int; - fn get_edge_indices_bounding_hex_face( - &mut self, - faceId: core::ffi::c_int, - ) -> *const core::ffi::c_int; - fn get_varying_parameters_of_hex_face( - &mut self, - faceId: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_fixed_parameter_of_hex_face( &mut self, faceId: core::ffi::c_int, ) -> core::ffi::c_int; - fn get_parametric_wedge_coordinates( - &mut self, - vertexId: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_point_indices_bounding_wedge_edge( - &mut self, - edgeId: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_varying_parameter_of_wedge_edge( &mut self, edgeId: core::ffi::c_int, ) -> core::ffi::c_int; - fn get_fixed_parameters_of_wedge_edge( - &mut self, - edgeId: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_point_indices_bounding_wedge_face( - &mut self, - faceId: core::ffi::c_int, - ) -> *const core::ffi::c_int; - fn get_edge_indices_bounding_wedge_face( - &mut self, - faceId: core::ffi::c_int, - ) -> *const core::ffi::c_int; - fn get_varying_parameters_of_wedge_face( - &mut self, - faceId: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_fixed_parameter_of_wedge_face( &mut self, faceId: core::ffi::c_int, ) -> core::ffi::c_int; } -pub trait VtkHigherOrderQuadrilateral: VtkNonLinearCell + VtkCell { +pub trait VtkHigherOrderQuadrilateral { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_dimension(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn contour( &mut self, value: core::ffi::c_double, @@ -6063,7 +2916,7 @@ pub trait VtkHigherOrderQuadrilateral: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -6075,116 +2928,39 @@ pub trait VtkHigherOrderQuadrilateral: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn set_parametric_coords(&mut self) -> (); - fn get_parametric_center(&mut self, center: core::ffi::c_double) -> core::ffi::c_int; fn set_order_from_cell_data( &mut self, cell_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, - cell_id: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, + cell_id: core::ffi::c_longlong, ) -> (); - fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_uchar) -> (); + fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_longlong) -> (); fn set_order(&mut self, s: core::ffi::c_int, t: core::ffi::c_int) -> (); - fn get_order(&mut self) -> *const core::ffi::c_int; - fn get_order(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn sub_cell_coordinates_from_id( - &mut self, - ijk: *mut core::ffi::c_void, - subId: core::ffi::c_int, - ) -> bool; - fn sub_cell_coordinates_from_id( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - subId: core::ffi::c_int, - ) -> bool; fn point_index_from_ijk( &mut self, i: core::ffi::c_int, j: core::ffi::c_int, k: core::ffi::c_int, ) -> core::ffi::c_int; - fn point_index_from_ijk( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - order: core::ffi::c_int, - ) -> core::ffi::c_int; - fn transform_approx_to_cell_params( - &mut self, - subCell: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> bool; - fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkHigherOrderTetra: VtkNonLinearCell + VtkCell { +pub trait VtkHigherOrderTetra { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_dimension(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn contour( &mut self, value: core::ffi::c_double, @@ -6196,7 +2972,7 @@ pub trait VtkHigherOrderTetra: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -6208,105 +2984,29 @@ pub trait VtkHigherOrderTetra: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn set_parametric_coords(&mut self) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_order(&mut self) -> core::ffi::c_uchar; - fn compute_order(&mut self) -> core::ffi::c_uchar; - fn compute_order(&mut self, nPoints: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn to_barycentric_index( - &mut self, - index: core::ffi::c_uchar, - bindex: core::ffi::c_uchar, - ) -> (); - fn to_index(&mut self, bindex: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn barycentric_index( - &mut self, - index: core::ffi::c_uchar, - bindex: core::ffi::c_uchar, - order: core::ffi::c_uchar, - ) -> (); - fn index( - &mut self, - bindex: core::ffi::c_uchar, - order: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + fn get_order(&mut self) -> core::ffi::c_longlong; + fn compute_order(&mut self) -> core::ffi::c_longlong; fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; - fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; - fn get_face_cell(&mut self) -> *mut core::ffi::c_void; fn get_face_cell(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkHigherOrderTriangle: VtkNonLinearCell + VtkCell { +pub trait VtkHigherOrderTriangle { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_dimension(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn contour( &mut self, value: core::ffi::c_double, @@ -6318,7 +3018,7 @@ pub trait VtkHigherOrderTriangle: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -6330,125 +3030,45 @@ pub trait VtkHigherOrderTriangle: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn set_parametric_coords(&mut self) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_order(&mut self) -> core::ffi::c_uchar; - fn compute_order(&mut self) -> core::ffi::c_uchar; - fn to_barycentric_index( - &mut self, - index: core::ffi::c_uchar, - bindex: core::ffi::c_uchar, - ) -> (); - fn to_index(&mut self, bindex: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn barycentric_index( - &mut self, - index: core::ffi::c_uchar, - bindex: core::ffi::c_uchar, - order: core::ffi::c_uchar, - ) -> (); - fn index( - &mut self, - bindex: core::ffi::c_uchar, - order: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn eta( - &mut self, - n: core::ffi::c_uchar, - chi: core::ffi::c_uchar, - sigma: core::ffi::c_double, - ) -> core::ffi::c_double; + fn get_order(&mut self) -> core::ffi::c_longlong; + fn compute_order(&mut self) -> core::ffi::c_longlong; fn eta( &mut self, - n: core::ffi::c_uchar, - chi: core::ffi::c_uchar, + n: core::ffi::c_longlong, + chi: core::ffi::c_longlong, sigma: core::ffi::c_double, ) -> core::ffi::c_double; fn d_eta( &mut self, - n: core::ffi::c_uchar, - chi: core::ffi::c_uchar, + n: core::ffi::c_longlong, + chi: core::ffi::c_longlong, sigma: core::ffi::c_double, ) -> core::ffi::c_double; fn deta( &mut self, - n: core::ffi::c_uchar, - chi: core::ffi::c_uchar, + n: core::ffi::c_longlong, + chi: core::ffi::c_longlong, sigma: core::ffi::c_double, ) -> core::ffi::c_double; fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; - fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkHigherOrderWedge: VtkNonLinearCell + VtkCell { +pub trait VtkHigherOrderWedge { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_dimension(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn contour( &mut self, value: core::ffi::c_double, @@ -6460,7 +3080,7 @@ pub trait VtkHigherOrderWedge: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -6472,108 +3092,36 @@ pub trait VtkHigherOrderWedge: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn set_parametric_coords(&mut self) -> (); - fn get_parametric_center(&mut self, center: core::ffi::c_double) -> core::ffi::c_int; fn set_order_from_cell_data( &mut self, cell_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, - cell_id: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, + cell_id: core::ffi::c_longlong, ) -> (); - fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_uchar) -> (); + fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_longlong) -> (); fn set_order( &mut self, s: core::ffi::c_int, t: core::ffi::c_int, u: core::ffi::c_int, - numPts: core::ffi::c_uchar, - ) -> (); - fn get_order(&mut self) -> *const core::ffi::c_int; - fn get_order(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, + numPts: core::ffi::c_longlong, ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn sub_cell_coordinates_from_id( - &mut self, - ijk: *mut core::ffi::c_void, - subId: core::ffi::c_int, - ) -> bool; - fn sub_cell_coordinates_from_id( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - subId: core::ffi::c_int, - ) -> bool; - fn point_index_from_ijk( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - order: core::ffi::c_int, - ) -> core::ffi::c_int; - fn point_index_from_ijk( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> core::ffi::c_int; - fn transform_approx_to_cell_params( - &mut self, - subCell: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> bool; - fn transform_face_to_cell_params( - &mut self, - bdyFace: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> bool; - fn get_number_of_approximating_wedges( - &mut self, - order: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_number_of_approximating_wedges(&mut self) -> core::ffi::c_int; fn get_bdy_quad(&mut self) -> *mut core::ffi::c_void; fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void; fn get_bdy_tri(&mut self) -> *mut core::ffi::c_void; fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void; fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; - fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; fn get_interp(&mut self) -> *mut core::ffi::c_void; fn get_interpolation(&mut self) -> *mut core::ffi::c_void; } @@ -6588,9 +3136,9 @@ pub trait VtkHyperTree { ) -> (); fn initialize_for_reader( &mut self, - numberOfLevels: core::ffi::c_uchar, - nbVertices: core::ffi::c_uchar, - nbVerticesOfLastLevel: core::ffi::c_uchar, + numberOfLevels: core::ffi::c_longlong, + nbVertices: core::ffi::c_longlong, + nbVerticesOfLastLevel: core::ffi::c_longlong, isParent: *mut core::ffi::c_void, isMasked: *mut core::ffi::c_void, outIsMasked: *mut core::ffi::c_void, @@ -6598,8 +3146,8 @@ pub trait VtkHyperTree { fn build_from_breadth_first_order_descriptor( &mut self, descriptor: *mut core::ffi::c_void, - numberOfBits: core::ffi::c_uchar, - startIndex: core::ffi::c_uchar, + numberOfBits: core::ffi::c_longlong, + startIndex: core::ffi::c_longlong, ) -> (); fn compute_breadth_first_order_descriptor( &mut self, @@ -6609,17 +3157,16 @@ pub trait VtkHyperTree { breadthFirstIdMap: *mut core::ffi::c_void, ) -> (); fn copy_structure(&mut self, ht: *mut core::ffi::c_void) -> (); - fn freeze(&mut self, mode: core::ffi::c_char) -> *mut core::ffi::c_void; - fn set_tree_index(&mut self, treeIndex: core::ffi::c_uchar) -> (); - fn get_tree_index(&mut self) -> core::ffi::c_uchar; + fn freeze(&mut self, mode: &str) -> *mut core::ffi::c_void; + fn set_tree_index(&mut self, treeIndex: core::ffi::c_longlong) -> (); + fn get_tree_index(&mut self) -> core::ffi::c_longlong; fn get_number_of_levels(&mut self) -> core::ffi::c_uint; - fn get_number_of_vertices(&mut self) -> core::ffi::c_uchar; - fn get_number_of_nodes(&mut self) -> core::ffi::c_uchar; - fn get_number_of_leaves(&mut self) -> core::ffi::c_uchar; + fn get_number_of_vertices(&mut self) -> core::ffi::c_longlong; + fn get_number_of_nodes(&mut self) -> core::ffi::c_longlong; + fn get_number_of_leaves(&mut self) -> core::ffi::c_longlong; fn get_branch_factor(&mut self) -> core::ffi::c_int; fn get_dimension(&mut self) -> core::ffi::c_int; - fn get_number_of_children(&mut self) -> core::ffi::c_uchar; - fn get_scale(&mut self, s: core::ffi::c_double) -> (); + fn get_number_of_children(&mut self) -> core::ffi::c_longlong; fn get_scale(&mut self, d: core::ffi::c_uint) -> core::ffi::c_double; fn create_instance( &mut self, @@ -6629,33 +3176,29 @@ pub trait VtkHyperTree { fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong; fn get_actual_memory_size(&mut self) -> core::ffi::c_uint; fn is_global_index_implicit(&mut self) -> bool; - fn set_global_index_start(&mut self, start: core::ffi::c_uchar) -> (); - fn get_global_index_start(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, start: core::ffi::c_longlong) -> (); + fn get_global_index_start(&mut self) -> core::ffi::c_longlong; fn set_global_index_from_local( &mut self, - index: core::ffi::c_uchar, - global: core::ffi::c_uchar, + index: core::ffi::c_longlong, + global: core::ffi::c_longlong, ) -> (); fn get_global_index_from_local( &mut self, - index: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_global_node_index_max(&mut self) -> core::ffi::c_uchar; - fn is_leaf(&mut self, index: core::ffi::c_uchar) -> bool; + index: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn get_global_node_index_max(&mut self) -> core::ffi::c_longlong; + fn is_leaf(&mut self, index: core::ffi::c_longlong) -> bool; fn subdivide_leaf( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, level: core::ffi::c_uint, ) -> (); - fn is_terminal_node(&mut self, index: core::ffi::c_uchar) -> bool; + fn is_terminal_node(&mut self, index: core::ffi::c_longlong) -> bool; fn get_elder_child_index( &mut self, index_parent: core::ffi::c_uint, - ) -> core::ffi::c_uchar; - fn get_elder_child_index_array( - &mut self, - nbElements: usize, - ) -> *const core::ffi::c_uint; + ) -> core::ffi::c_longlong; fn has_scales(&mut self) -> bool; } pub trait VtkHyperTreeCursor { @@ -6663,7 +3206,7 @@ pub trait VtkHyperTreeCursor { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn set_tree(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_tree(&mut self) -> *mut core::ffi::c_void; - fn get_vertex_id(&mut self) -> core::ffi::c_uchar; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; fn is_leaf(&mut self) -> bool; fn is_root(&mut self) -> bool; fn get_level(&mut self) -> core::ffi::c_uint; @@ -6678,7 +3221,7 @@ pub trait VtkHyperTreeCursor { fn get_number_of_children(&mut self) -> core::ffi::c_int; fn get_dimension(&mut self) -> core::ffi::c_int; } -pub trait VtkHyperTreeGrid: VtkDataObject { +pub trait VtkHyperTreeGrid { fn levels(&mut self) -> *mut core::ffi::c_void; fn dimension(&mut self) -> *mut core::ffi::c_void; fn orientation(&mut self) -> *mut core::ffi::c_void; @@ -6686,30 +3229,17 @@ pub trait VtkHyperTreeGrid: VtkDataObject { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set_mode_squeeze(&mut self, _arg: core::ffi::c_char) -> (); - fn get_mode_squeeze(&mut self) -> *mut core::ffi::c_char; + fn set_mode_squeeze(&mut self, _arg: &str) -> (); fn squeeze(&mut self) -> (); fn get_data_object_type(&mut self) -> core::ffi::c_int; fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> (); fn copy_empty_structure(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_dimensions(&mut self, dims: core::ffi::c_uint) -> (); - fn set_dimensions(&mut self, dims: core::ffi::c_int) -> (); fn set_dimensions( &mut self, i: core::ffi::c_uint, j: core::ffi::c_uint, k: core::ffi::c_uint, ) -> (); - fn set_dimensions( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> (); - fn get_dimensions(&mut self) -> *const core::ffi::c_uint; - fn get_dimensions(&mut self, dim: core::ffi::c_int) -> (); - fn get_dimensions(&mut self, dim: core::ffi::c_uint) -> (); - fn set_extent(&mut self, extent: core::ffi::c_int) -> (); fn set_extent( &mut self, x1: core::ffi::c_int, @@ -6719,24 +3249,13 @@ pub trait VtkHyperTreeGrid: VtkDataObject { z1: core::ffi::c_int, z2: core::ffi::c_int, ) -> (); - fn get_extent(&mut self) -> *mut core::ffi::c_int; - fn get_extent( + fn get_dimension(&mut self) -> core::ffi::c_uint; + fn get_1_d_axis(&mut self, axis: &mut core::ffi::c_uint) -> (); + fn get_2_d_axes( &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, + axis1: &mut core::ffi::c_uint, + axis2: &mut core::ffi::c_uint, ) -> (); - fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); - fn get_cell_dims(&mut self) -> *const core::ffi::c_uint; - fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> (); - fn get_cell_dims(&mut self, cellDims: core::ffi::c_uint) -> (); - fn get_dimension(&mut self) -> core::ffi::c_uint; - fn get_1_d_axis(&mut self, axis: core::ffi::c_uint) -> (); - fn get_2_d_axes(&mut self, axis1: core::ffi::c_uint, axis2: core::ffi::c_uint) -> (); - fn get_axes(&mut self) -> *const core::ffi::c_uint; fn get_number_of_children(&mut self) -> core::ffi::c_uint; fn set_transposed_root_indexing(&mut self, _arg: bool) -> (); fn get_transposed_root_indexing(&mut self) -> bool; @@ -6746,19 +3265,17 @@ pub trait VtkHyperTreeGrid: VtkDataObject { fn get_freeze_state(&mut self) -> bool; fn set_branch_factor(&mut self, p0: core::ffi::c_uint) -> (); fn get_branch_factor(&mut self) -> core::ffi::c_uint; - fn get_max_number_of_trees(&mut self) -> core::ffi::c_uchar; - fn get_number_of_vertices(&mut self) -> core::ffi::c_uchar; - fn get_number_of_non_empty_trees(&mut self) -> core::ffi::c_uchar; - fn get_number_of_leaves(&mut self) -> core::ffi::c_uchar; - fn get_number_of_levels(&mut self, p0: core::ffi::c_uchar) -> core::ffi::c_uint; - fn get_number_of_levels(&mut self) -> core::ffi::c_uint; + fn get_max_number_of_trees(&mut self) -> core::ffi::c_longlong; + fn get_number_of_vertices(&mut self) -> core::ffi::c_longlong; + fn get_number_of_non_empty_trees(&mut self) -> core::ffi::c_longlong; + fn get_number_of_leaves(&mut self) -> core::ffi::c_longlong; + fn get_number_of_levels(&mut self, p0: core::ffi::c_longlong) -> core::ffi::c_uint; fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_x_coordinates(&mut self) -> *mut core::ffi::c_void; fn set_y_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_y_coordinates(&mut self) -> *mut core::ffi::c_void; fn set_z_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_z_coordinates(&mut self) -> *mut core::ffi::c_void; - fn copy_coordinates(&mut self, output: vtkHyperTreeGrid) -> (); fn set_fixed_coordinates( &mut self, axis: core::ffi::c_uint, @@ -6771,114 +3288,108 @@ pub trait VtkHyperTreeGrid: VtkDataObject { fn get_has_interface(&mut self) -> bool; fn has_interface_on(&mut self) -> (); fn has_interface_off(&mut self) -> (); - fn set_interface_normals_name(&mut self, _arg: core::ffi::c_char) -> (); - fn get_interface_normals_name(&mut self) -> *mut core::ffi::c_char; - fn set_interface_intercepts_name(&mut self, _arg: core::ffi::c_char) -> (); - fn get_interface_intercepts_name(&mut self) -> *mut core::ffi::c_char; + fn set_interface_normals_name(&mut self, _arg: &str) -> (); + fn set_interface_intercepts_name(&mut self, _arg: &str) -> (); fn set_depth_limiter(&mut self, _arg: core::ffi::c_uint) -> (); fn get_depth_limiter(&mut self) -> core::ffi::c_uint; fn initialize_oriented_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> (); fn new_oriented_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; fn initialize_oriented_geometry_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> (); fn new_oriented_geometry_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; fn initialize_non_oriented_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> (); fn new_non_oriented_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; fn initialize_non_oriented_geometry_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> (); fn new_non_oriented_geometry_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; - fn find_non_oriented_geometry_cursor( - &mut self, - x: core::ffi::c_double, - ) -> *mut core::ffi::c_void; fn find_dichotomic_x(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint; fn find_dichotomic_y(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint; fn find_dichotomic_z(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint; fn initialize_non_oriented_von_neumann_super_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> (); fn new_non_oriented_von_neumann_super_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; fn initialize_non_oriented_von_neumann_super_cursor_light( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> (); fn new_non_oriented_von_neumann_super_cursor_light( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; fn initialize_non_oriented_moore_super_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> (); fn new_non_oriented_moore_super_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; fn initialize_non_oriented_moore_super_cursor_light( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> (); fn new_non_oriented_moore_super_cursor_light( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; fn initialize(&mut self) -> (); fn get_tree( &mut self, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; - fn set_tree(&mut self, p0: core::ffi::c_uchar, p1: *mut core::ffi::c_void) -> (); + fn set_tree(&mut self, p0: core::ffi::c_longlong, p1: *mut core::ffi::c_void) -> (); fn shallow_copy(&mut self, p0: *mut core::ffi::c_void) -> (); fn deep_copy(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_extent_type(&mut self) -> core::ffi::c_int; @@ -6893,59 +3404,41 @@ pub trait VtkHyperTreeGrid: VtkDataObject { fn get_child_mask(&mut self, p0: core::ffi::c_uint) -> core::ffi::c_uint; fn get_index_from_level_zero_coordinates( &mut self, - p0: core::ffi::c_uchar, + p0: &mut core::ffi::c_longlong, p1: core::ffi::c_uint, p2: core::ffi::c_uint, p3: core::ffi::c_uint, ) -> (); fn get_shifted_level_zero_index( &mut self, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, p1: core::ffi::c_uint, p2: core::ffi::c_uint, p3: core::ffi::c_uint, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn get_level_zero_coordinates_from_index( &mut self, - p0: core::ffi::c_uchar, - p1: core::ffi::c_uint, - p2: core::ffi::c_uint, - p3: core::ffi::c_uint, - ) -> (); - fn get_level_zero_origin_and_size_from_index( - &mut self, - p0: core::ffi::c_uchar, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - ) -> (); - fn get_level_zero_origin_from_index( - &mut self, - p0: core::ffi::c_uchar, - p1: core::ffi::c_double, + p0: core::ffi::c_longlong, + p1: &mut core::ffi::c_uint, + p2: &mut core::ffi::c_uint, + p3: &mut core::ffi::c_uint, ) -> (); - fn get_global_node_index_max(&mut self) -> core::ffi::c_uchar; + fn get_global_node_index_max(&mut self) -> core::ffi::c_longlong; fn initialize_local_index_node(&mut self) -> (); fn has_any_ghost_cells(&mut self) -> bool; fn get_ghost_cells(&mut self) -> *mut core::ffi::c_void; fn get_tree_ghost_array(&mut self) -> *mut core::ffi::c_void; fn allocate_tree_ghost_array(&mut self) -> *mut core::ffi::c_void; - fn initialize_tree_iterator(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_center(&mut self) -> *mut core::ffi::c_double; - fn get_center(&mut self, center: core::ffi::c_double) -> (); fn get_cell_data(&mut self) -> *mut core::ffi::c_void; fn get_attributes_as_field_data( &mut self, type_: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; } pub trait VtkHyperTreeGridNonOrientedCursor { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -6955,32 +3448,18 @@ pub trait VtkHyperTreeGridNonOrientedCursor { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> (); - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ) -> (); - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - ) -> (); fn get_grid(&mut self) -> *mut core::ffi::c_void; fn has_tree(&mut self) -> bool; fn get_tree(&mut self) -> *mut core::ffi::c_void; - fn get_vertex_id(&mut self) -> core::ffi::c_uchar; - fn get_global_node_index(&mut self) -> core::ffi::c_uchar; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; fn get_dimension(&mut self) -> core::ffi::c_uchar; fn get_number_of_children(&mut self) -> core::ffi::c_uchar; - fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); - fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); fn set_mask(&mut self, state: bool) -> (); fn is_masked(&mut self) -> bool; fn is_leaf(&mut self) -> bool; @@ -6999,37 +3478,17 @@ pub trait VtkHyperTreeGridNonOrientedGeometryCursor { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> (); - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ) -> (); - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - origin: core::ffi::c_double, - ) -> (); - fn initialize(&mut self, cursor: *mut core::ffi::c_void) -> (); fn has_tree(&mut self) -> bool; fn get_tree(&mut self) -> *mut core::ffi::c_void; - fn get_vertex_id(&mut self) -> core::ffi::c_uchar; - fn get_global_node_index(&mut self) -> core::ffi::c_uchar; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; fn get_dimension(&mut self) -> core::ffi::c_uchar; fn get_number_of_children(&mut self) -> core::ffi::c_uchar; - fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); - fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); - fn get_origin(&mut self) -> *mut core::ffi::c_double; - fn get_size(&mut self) -> *mut core::ffi::c_double; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_point(&mut self, point: core::ffi::c_double) -> (); + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); fn set_mask(&mut self, state: bool) -> (); fn is_masked(&mut self) -> bool; fn is_leaf(&mut self) -> bool; @@ -7040,14 +3499,14 @@ pub trait VtkHyperTreeGridNonOrientedGeometryCursor { fn to_root(&mut self) -> (); fn to_parent(&mut self) -> (); } -pub trait VtkHyperTreeGridNonOrientedMooreSuperCursor: VtkHyperTreeGridNonOrientedSuperCursor { +pub trait VtkHyperTreeGridNonOrientedMooreSuperCursor { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> (); fn get_corner_cursors( @@ -7057,14 +3516,14 @@ pub trait VtkHyperTreeGridNonOrientedMooreSuperCursor: VtkHyperTreeGridNonOrient p2: *mut core::ffi::c_void, ) -> bool; } -pub trait VtkHyperTreeGridNonOrientedMooreSuperCursorLight: VtkHyperTreeGridNonOrientedSuperCursorLight { +pub trait VtkHyperTreeGridNonOrientedMooreSuperCursorLight { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> (); fn get_corner_cursors( @@ -7081,56 +3540,31 @@ pub trait VtkHyperTreeGridNonOrientedSuperCursor { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> (); fn get_grid(&mut self) -> *mut core::ffi::c_void; fn has_tree(&mut self) -> bool; - fn has_tree(&mut self, icursor: core::ffi::c_uint) -> bool; fn get_tree(&mut self) -> *mut core::ffi::c_void; - fn get_tree(&mut self, icursor: core::ffi::c_uint) -> *mut core::ffi::c_void; - fn get_vertex_id(&mut self) -> core::ffi::c_uchar; - fn get_vertex_id(&mut self, icursor: core::ffi::c_uint) -> core::ffi::c_uchar; - fn get_global_node_index(&mut self) -> core::ffi::c_uchar; - fn get_global_node_index( - &mut self, - icursor: core::ffi::c_uint, - ) -> core::ffi::c_uchar; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; fn get_information( &mut self, icursor: core::ffi::c_uint, - level: core::ffi::c_uint, - leaf: bool, - id: core::ffi::c_uchar, + level: &mut core::ffi::c_uint, + leaf: &mut bool, + id: &mut core::ffi::c_longlong, ) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_uchar; fn get_number_of_children(&mut self) -> core::ffi::c_uchar; - fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); - fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); - fn get_origin(&mut self) -> *mut core::ffi::c_double; - fn get_size(&mut self) -> *mut core::ffi::c_double; + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); fn set_mask(&mut self, state: bool) -> (); - fn set_mask(&mut self, icursor: core::ffi::c_uint, state: bool) -> (); fn is_masked(&mut self) -> bool; - fn is_masked(&mut self, icursor: core::ffi::c_uint) -> bool; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_bounds( - &mut self, - icursor: core::ffi::c_uint, - bounds: core::ffi::c_double, - ) -> (); - fn get_point(&mut self, point: core::ffi::c_double) -> (); - fn get_point( - &mut self, - icursor: core::ffi::c_uint, - point: core::ffi::c_double, - ) -> (); fn is_leaf(&mut self) -> bool; - fn is_leaf(&mut self, icursor: core::ffi::c_uint) -> bool; fn subdivide_leaf(&mut self) -> (); fn is_root(&mut self) -> bool; fn get_level(&mut self) -> core::ffi::c_uint; - fn get_level(&mut self, icursor: core::ffi::c_uint) -> core::ffi::c_uint; fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); fn to_root(&mut self) -> (); fn to_parent(&mut self) -> (); @@ -7143,70 +3577,55 @@ pub trait VtkHyperTreeGridNonOrientedSuperCursorLight { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> (); fn get_grid(&mut self) -> *mut core::ffi::c_void; fn has_tree(&mut self) -> bool; - fn has_tree(&mut self, icursor: core::ffi::c_uint) -> bool; fn get_tree(&mut self) -> *mut core::ffi::c_void; - fn get_tree(&mut self, icursor: core::ffi::c_uint) -> *mut core::ffi::c_void; - fn get_vertex_id(&mut self) -> core::ffi::c_uchar; - fn get_vertex_id(&mut self, icursor: core::ffi::c_uint) -> core::ffi::c_uchar; - fn get_global_node_index(&mut self) -> core::ffi::c_uchar; - fn get_global_node_index( - &mut self, - icursor: core::ffi::c_uint, - ) -> core::ffi::c_uchar; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; fn get_information( &mut self, icursor: core::ffi::c_uint, - level: core::ffi::c_uint, - leaf: bool, - id: core::ffi::c_uchar, + level: &mut core::ffi::c_uint, + leaf: &mut bool, + id: &mut core::ffi::c_longlong, ) -> *mut core::ffi::c_void; fn get_dimension(&mut self) -> core::ffi::c_uchar; fn get_number_of_children(&mut self) -> core::ffi::c_uchar; - fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); - fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); - fn get_origin(&mut self) -> *mut core::ffi::c_double; - fn get_size(&mut self) -> *mut core::ffi::c_double; + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); fn set_mask(&mut self, state: bool) -> (); - fn set_mask(&mut self, icursor: core::ffi::c_uint, state: bool) -> (); fn is_masked(&mut self) -> bool; - fn is_masked(&mut self, icursor: core::ffi::c_uint) -> bool; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_point(&mut self, point: core::ffi::c_double) -> (); fn is_leaf(&mut self) -> bool; - fn is_leaf(&mut self, icursor: core::ffi::c_uint) -> bool; fn subdivide_leaf(&mut self) -> (); fn is_root(&mut self) -> bool; fn get_level(&mut self) -> core::ffi::c_uint; - fn get_level(&mut self, icursor: core::ffi::c_uint) -> core::ffi::c_uint; fn to_child(&mut self, p0: core::ffi::c_uchar) -> (); fn to_root(&mut self) -> (); fn to_parent(&mut self) -> (); fn get_number_of_cursors(&mut self) -> core::ffi::c_uint; } -pub trait VtkHyperTreeGridNonOrientedVonNeumannSuperCursor: VtkHyperTreeGridNonOrientedSuperCursor { +pub trait VtkHyperTreeGridNonOrientedVonNeumannSuperCursor { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> (); } -pub trait VtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight: VtkHyperTreeGridNonOrientedSuperCursorLight { +pub trait VtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> (); } @@ -7218,32 +3637,18 @@ pub trait VtkHyperTreeGridOrientedCursor { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> (); - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - ) -> (); - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ) -> (); fn get_grid(&mut self) -> *mut core::ffi::c_void; fn has_tree(&mut self) -> bool; fn get_tree(&mut self) -> *mut core::ffi::c_void; - fn get_vertex_id(&mut self) -> core::ffi::c_uchar; - fn get_global_node_index(&mut self) -> core::ffi::c_uchar; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; fn get_dimension(&mut self) -> core::ffi::c_uchar; fn get_number_of_children(&mut self) -> core::ffi::c_uchar; - fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); - fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); fn set_mask(&mut self, state: bool) -> (); fn is_masked(&mut self) -> bool; fn is_leaf(&mut self) -> bool; @@ -7260,37 +3665,17 @@ pub trait VtkHyperTreeGridOrientedGeometryCursor { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> (); - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ) -> (); - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - origin: core::ffi::c_double, - ) -> (); - fn initialize(&mut self, cursor: *mut core::ffi::c_void) -> (); fn has_tree(&mut self) -> bool; fn get_tree(&mut self) -> *mut core::ffi::c_void; - fn get_vertex_id(&mut self) -> core::ffi::c_uchar; - fn get_global_node_index(&mut self) -> core::ffi::c_uchar; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; fn get_dimension(&mut self) -> core::ffi::c_uchar; fn get_number_of_children(&mut self) -> core::ffi::c_uchar; - fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> (); - fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> (); - fn get_origin(&mut self) -> *mut core::ffi::c_double; - fn get_size(&mut self) -> *mut core::ffi::c_double; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_point(&mut self, point: core::ffi::c_double) -> (); + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); fn set_mask(&mut self, state: bool) -> (); fn is_masked(&mut self) -> bool; fn is_leaf(&mut self) -> bool; @@ -7301,98 +3686,50 @@ pub trait VtkHyperTreeGridOrientedGeometryCursor { } pub trait VtkHyperTreeGridScales { fn get_branch_factor(&mut self) -> core::ffi::c_double; - fn get_scale(&mut self, level: core::ffi::c_uint) -> *mut core::ffi::c_double; fn get_scale_x(&mut self, level: core::ffi::c_uint) -> core::ffi::c_double; fn get_scale_y(&mut self, level: core::ffi::c_uint) -> core::ffi::c_double; fn get_scale_z(&mut self, level: core::ffi::c_uint) -> core::ffi::c_double; - fn get_scale(&mut self, level: core::ffi::c_uint, scale: core::ffi::c_double) -> (); fn get_current_fail_level(&mut self) -> core::ffi::c_uint; } -pub trait VtkImageData: VtkDataSet + VtkDataObject { +pub trait VtkImageData { fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); fn get_data_object_type(&mut self) -> core::ffi::c_int; - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; - fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> (); + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; fn find_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + ) -> core::ffi::c_longlong; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> (); fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> (); fn get_max_cell_size(&mut self) -> core::ffi::c_int; - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - seedLoc: core::ffi::c_int, - ) -> (); fn initialize(&mut self) -> (); - fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; fn has_any_blank_points(&mut self) -> bool; fn has_any_blank_cells(&mut self) -> bool; - fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> (); fn set_dimensions( &mut self, i: core::ffi::c_int, j: core::ffi::c_int, k: core::ffi::c_int, ) -> (); - fn set_dimensions(&mut self, dims: core::ffi::c_int) -> (); - fn get_dimensions(&mut self) -> *mut core::ffi::c_int; - fn get_dimensions(&mut self, dims: core::ffi::c_int) -> (); - fn get_dimensions(&mut self, dims: core::ffi::c_uchar) -> (); - fn compute_structured_coordinates( - &mut self, - x: core::ffi::c_double, - ijk: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; fn get_voxel_gradient( &mut self, i: core::ffi::c_int, @@ -7401,33 +3738,7 @@ pub trait VtkImageData: VtkDataSet + VtkDataObject { s: *mut core::ffi::c_void, g: *mut core::ffi::c_void, ) -> (); - fn get_point_gradient( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - s: *mut core::ffi::c_void, - g: core::ffi::c_double, - ) -> (); fn get_data_dimension(&mut self) -> core::ffi::c_int; - fn compute_point_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar; - fn compute_cell_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar; - fn set_axis_update_extent( - &mut self, - axis: core::ffi::c_int, - min: core::ffi::c_int, - max: core::ffi::c_int, - updateExtent: core::ffi::c_int, - axisUpdateExtent: core::ffi::c_int, - ) -> (); - fn get_axis_update_extent( - &mut self, - axis: core::ffi::c_int, - min: core::ffi::c_int, - max: core::ffi::c_int, - updateExtent: core::ffi::c_int, - ) -> (); - fn set_extent(&mut self, extent: core::ffi::c_int) -> (); fn set_extent( &mut self, x1: core::ffi::c_int, @@ -7437,88 +3748,21 @@ pub trait VtkImageData: VtkDataSet + VtkDataObject { z1: core::ffi::c_int, z2: core::ffi::c_int, ) -> (); - fn get_extent(&mut self) -> *mut core::ffi::c_int; - fn get_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> (); - fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); fn get_scalar_type_min( &mut self, meta_data: *mut core::ffi::c_void, ) -> core::ffi::c_double; - fn get_scalar_type_min(&mut self) -> core::ffi::c_double; fn get_scalar_type_max( &mut self, meta_data: *mut core::ffi::c_void, ) -> core::ffi::c_double; - fn get_scalar_type_max(&mut self) -> core::ffi::c_double; fn get_scalar_size(&mut self, meta_data: *mut core::ffi::c_void) -> core::ffi::c_int; - fn get_scalar_size(&mut self) -> core::ffi::c_int; - fn get_increments(&mut self) -> *mut core::ffi::c_uchar; - fn get_increments( - &mut self, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ) -> (); - fn get_increments(&mut self, inc: core::ffi::c_uchar) -> (); - fn get_increments( - &mut self, - scalars: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_uchar; - fn get_increments( - &mut self, - scalars: *mut core::ffi::c_void, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ) -> (); - fn get_increments( - &mut self, - scalars: *mut core::ffi::c_void, - inc: core::ffi::c_uchar, - ) -> (); - fn get_continuous_increments( - &mut self, - extent: core::ffi::c_int, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ) -> (); - fn get_continuous_increments( - &mut self, - scalars: *mut core::ffi::c_void, - extent: core::ffi::c_int, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ) -> (); - fn get_scalar_pointer_for_extent(&mut self, extent: core::ffi::c_int) -> *mut (); - fn get_scalar_pointer(&mut self, coordinates: core::ffi::c_int) -> *mut (); - fn get_scalar_pointer( - &mut self, - x: core::ffi::c_int, - y: core::ffi::c_int, - z: core::ffi::c_int, - ) -> *mut (); - fn get_scalar_pointer(&mut self) -> *mut (); - fn get_scalar_index_for_extent( - &mut self, - extent: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn get_scalar_index(&mut self, coordinates: core::ffi::c_int) -> core::ffi::c_uchar; fn get_scalar_index( &mut self, x: core::ffi::c_int, y: core::ffi::c_int, z: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn get_scalar_component_as_float( &mut self, x: core::ffi::c_int, @@ -7554,12 +3798,6 @@ pub trait VtkImageData: VtkDataSet + VtkDataObject { dataType: core::ffi::c_int, numComponents: core::ffi::c_int, ) -> (); - fn allocate_scalars(&mut self, pipeline_info: *mut core::ffi::c_void) -> (); - fn copy_and_cast_from( - &mut self, - inData: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> (); fn copy_and_cast_from( &mut self, inData: *mut core::ffi::c_void, @@ -7570,117 +3808,22 @@ pub trait VtkImageData: VtkDataSet + VtkDataObject { z0: core::ffi::c_int, z1: core::ffi::c_int, ) -> (); - fn crop(&mut self, updateExtent: core::ffi::c_int) -> (); - fn get_spacing(&mut self) -> *mut core::ffi::c_double; - fn get_spacing( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_spacing(&mut self, _arg: core::ffi::c_double) -> (); fn set_spacing( &mut self, i: core::ffi::c_double, j: core::ffi::c_double, k: core::ffi::c_double, ) -> (); - fn set_spacing(&mut self, ijk: core::ffi::c_double) -> (); - fn get_origin(&mut self) -> *mut core::ffi::c_double; - fn get_origin( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_origin(&mut self, _arg: core::ffi::c_double) -> (); fn set_origin( &mut self, i: core::ffi::c_double, j: core::ffi::c_double, k: core::ffi::c_double, ) -> (); - fn set_origin(&mut self, ijk: core::ffi::c_double) -> (); fn get_direction_matrix(&mut self) -> *mut core::ffi::c_void; fn set_direction_matrix(&mut self, m: *mut core::ffi::c_void) -> (); - fn set_direction_matrix(&mut self, elements: core::ffi::c_double) -> (); - fn set_direction_matrix( - &mut self, - e00: core::ffi::c_double, - e01: core::ffi::c_double, - e02: core::ffi::c_double, - e10: core::ffi::c_double, - e11: core::ffi::c_double, - e12: core::ffi::c_double, - e20: core::ffi::c_double, - e21: core::ffi::c_double, - e22: core::ffi::c_double, - ) -> (); fn get_index_to_physical_matrix(&mut self) -> *mut core::ffi::c_void; - fn transform_continuous_index_to_physical_point( - &mut self, - i: core::ffi::c_double, - j: core::ffi::c_double, - k: core::ffi::c_double, - xyz: core::ffi::c_double, - ) -> (); - fn transform_continuous_index_to_physical_point( - &mut self, - ijk: core::ffi::c_double, - xyz: core::ffi::c_double, - ) -> (); - fn transform_index_to_physical_point( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - xyz: core::ffi::c_double, - ) -> (); - fn transform_index_to_physical_point( - &mut self, - ijk: core::ffi::c_int, - xyz: core::ffi::c_double, - ) -> (); - fn transform_continuous_index_to_physical_point( - &mut self, - i: core::ffi::c_double, - j: core::ffi::c_double, - k: core::ffi::c_double, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - direction: core::ffi::c_double, - xyz: core::ffi::c_double, - ) -> (); fn get_physical_to_index_matrix(&mut self) -> *mut core::ffi::c_void; - fn transform_physical_point_to_continuous_index( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ijk: core::ffi::c_double, - ) -> (); - fn transform_physical_point_to_continuous_index( - &mut self, - xyz: core::ffi::c_double, - ijk: core::ffi::c_double, - ) -> (); - fn compute_index_to_physical_matrix( - &mut self, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - direction: core::ffi::c_double, - result: core::ffi::c_double, - ) -> (); - fn transform_physical_normal_to_continuous_index( - &mut self, - xyz: core::ffi::c_double, - ijk: core::ffi::c_double, - ) -> (); - fn transform_physical_plane_to_continuous_index( - &mut self, - pplane: core::ffi::c_double, - iplane: core::ffi::c_double, - ) -> (); fn set_scalar_type( &mut self, p0: core::ffi::c_int, @@ -7688,8 +3831,7 @@ pub trait VtkImageData: VtkDataSet + VtkDataObject { ) -> (); fn get_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> core::ffi::c_int; fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool; - fn get_scalar_type(&mut self) -> core::ffi::c_int; - fn get_scalar_type_as_string(&mut self) -> *const core::ffi::c_char; + fn get_scalar_type_as_string(&mut self) -> &str; fn set_number_of_scalar_components( &mut self, n: core::ffi::c_int, @@ -7703,7 +3845,6 @@ pub trait VtkImageData: VtkDataSet + VtkDataObject { &mut self, meta_data: *mut core::ffi::c_void, ) -> bool; - fn get_number_of_scalar_components(&mut self) -> core::ffi::c_int; fn copy_information_from_pipeline( &mut self, information: *mut core::ffi::c_void, @@ -7713,42 +3854,10 @@ pub trait VtkImageData: VtkDataSet + VtkDataObject { information: *mut core::ffi::c_void, ) -> (); fn prepare_for_new_data(&mut self) -> (); - fn get_array_pointer_for_extent( - &mut self, - array: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> *mut (); - fn get_array_pointer( - &mut self, - array: *mut core::ffi::c_void, - coordinates: core::ffi::c_int, - ) -> *mut (); - fn get_tuple_index( - &mut self, - array: *mut core::ffi::c_void, - coordinates: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn get_array_increments( - &mut self, - array: *mut core::ffi::c_void, - increments: core::ffi::c_uchar, - ) -> (); - fn compute_internal_extent( - &mut self, - intExt: core::ffi::c_int, - tgtExt: core::ffi::c_int, - bnds: core::ffi::c_int, - ) -> (); fn get_extent_type(&mut self) -> core::ffi::c_int; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } pub trait VtkImageIterator { - fn initialize(&mut self, id: *mut core::ffi::c_void, ext: core::ffi::c_int) -> (); fn next_span(&mut self) -> (); fn begin_span(&mut self) -> *mut core::ffi::c_void; fn end_span(&mut self) -> *mut core::ffi::c_void; @@ -7763,46 +3872,16 @@ pub trait VtkImageTransform { im: *mut core::ffi::c_void, ps: *mut core::ffi::c_void, ) -> (); - fn transform_point_set( - &mut self, - im: *mut core::ffi::c_void, - ps: *mut core::ffi::c_void, - transNormals: bool, - transVectors: bool, - ) -> (); - fn translate_points( - &mut self, - t: core::ffi::c_double, - da: *mut core::ffi::c_void, - ) -> (); fn transform_points( &mut self, m4: *mut core::ffi::c_void, da: *mut core::ffi::c_void, ) -> (); - fn transform_normals( - &mut self, - m3: *mut core::ffi::c_void, - spacing: core::ffi::c_double, - da: *mut core::ffi::c_void, - ) -> (); - fn transform_vectors( - &mut self, - m3: *mut core::ffi::c_void, - spacing: core::ffi::c_double, - da: *mut core::ffi::c_void, - ) -> (); } -pub trait VtkImplicitBoolean: VtkImplicitFunction { +pub trait VtkImplicitBoolean { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; fn add_function(&mut self, in_: *mut core::ffi::c_void) -> (); fn remove_function(&mut self, in_: *mut core::ffi::c_void) -> (); @@ -7815,19 +3894,13 @@ pub trait VtkImplicitBoolean: VtkImplicitFunction { fn set_operation_type_to_intersection(&mut self) -> (); fn set_operation_type_to_difference(&mut self) -> (); fn set_operation_type_to_union_of_magnitudes(&mut self) -> (); - fn get_operation_type_as_string(&mut self) -> *const core::ffi::c_char; + fn get_operation_type_as_string(&mut self) -> &str; } -pub trait VtkImplicitDataSet: VtkImplicitFunction { +pub trait VtkImplicitDataSet { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_m_time(&mut self) -> core::ffi::c_ulong; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_data_set(&mut self) -> *mut core::ffi::c_void; fn set_out_value(&mut self, _arg: core::ffi::c_double) -> (); @@ -7838,15 +3911,6 @@ pub trait VtkImplicitDataSet: VtkImplicitFunction { _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_out_gradient(&mut self, _arg: core::ffi::c_double) -> (); - fn get_out_gradient(&mut self) -> *mut core::ffi::c_double; - fn get_out_gradient( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_out_gradient(&mut self, _arg: core::ffi::c_double) -> (); } pub trait VtkImplicitFunction { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -7857,45 +3921,13 @@ pub trait VtkImplicitFunction { input: *mut core::ffi::c_void, output: *mut core::ffi::c_void, ) -> (); - fn function_value(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn function_value( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> core::ffi::c_double; - fn function_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); - fn function_gradient(&mut self, x: core::ffi::c_double) -> *mut core::ffi::c_double; - fn function_gradient( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> *mut core::ffi::c_double; fn set_transform(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_transform(&mut self, elements: core::ffi::c_double) -> (); fn get_transform(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; fn evaluate_function( &mut self, input: *mut core::ffi::c_void, output: *mut core::ffi::c_void, ) -> (); - fn evaluate_function( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); } pub trait VtkImplicitFunctionCollection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -7903,18 +3935,11 @@ pub trait VtkImplicitFunctionCollection { fn new(&mut self) -> *mut core::ffi::c_void; fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_next_item(&mut self) -> *mut core::ffi::c_void; - fn get_next_implicit_function(&mut self, cookie: ()) -> *mut core::ffi::c_void; } -pub trait VtkImplicitHalo: VtkImplicitFunction { +pub trait VtkImplicitHalo { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); fn get_radius(&mut self) -> core::ffi::c_double; fn set_center( @@ -7923,28 +3948,13 @@ pub trait VtkImplicitHalo: VtkImplicitFunction { _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_center(&mut self, _arg: core::ffi::c_double) -> (); - fn get_center(&mut self) -> *mut core::ffi::c_double; - fn get_center( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_center(&mut self, _arg: core::ffi::c_double) -> (); fn set_fade_out(&mut self, _arg: core::ffi::c_double) -> (); fn get_fade_out(&mut self) -> core::ffi::c_double; } -pub trait VtkImplicitSelectionLoop: VtkImplicitFunction { +pub trait VtkImplicitSelectionLoop { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); fn set_loop(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_loop(&mut self) -> *mut core::ffi::c_void; fn set_automatic_normal_generation(&mut self, _arg: core::ffi::c_int) -> (); @@ -7957,28 +3967,18 @@ pub trait VtkImplicitSelectionLoop: VtkImplicitFunction { _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_normal(&mut self, _arg: core::ffi::c_double) -> (); - fn get_normal(&mut self) -> *mut core::ffi::c_double; - fn get_normal(&mut self, data: core::ffi::c_double) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; } -pub trait VtkImplicitSum: VtkImplicitFunction { +pub trait VtkImplicitSum { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; fn add_function( &mut self, in_: *mut core::ffi::c_void, weight: core::ffi::c_double, ) -> (); - fn add_function(&mut self, in_: *mut core::ffi::c_void) -> (); fn remove_all_functions(&mut self) -> (); fn set_function_weight( &mut self, @@ -7990,17 +3990,11 @@ pub trait VtkImplicitSum: VtkImplicitFunction { fn normalize_by_weight_on(&mut self) -> (); fn normalize_by_weight_off(&mut self) -> (); } -pub trait VtkImplicitVolume: VtkImplicitFunction { +pub trait VtkImplicitVolume { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_m_time(&mut self) -> core::ffi::c_ulong; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); fn set_volume(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_volume(&mut self) -> *mut core::ffi::c_void; fn set_out_value(&mut self, _arg: core::ffi::c_double) -> (); @@ -8011,26 +4005,11 @@ pub trait VtkImplicitVolume: VtkImplicitFunction { _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_out_gradient(&mut self, _arg: core::ffi::c_double) -> (); - fn get_out_gradient(&mut self) -> *mut core::ffi::c_double; - fn get_out_gradient( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_out_gradient(&mut self, _arg: core::ffi::c_double) -> (); } -pub trait VtkImplicitWindowFunction: VtkImplicitFunction { +pub trait VtkImplicitWindowFunction { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); fn set_implicit_function(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_implicit_function(&mut self) -> *mut core::ffi::c_void; fn set_window_range( @@ -8038,17 +4017,11 @@ pub trait VtkImplicitWindowFunction: VtkImplicitFunction { _arg1: core::ffi::c_double, _arg2: core::ffi::c_double, ) -> (); - fn set_window_range(&mut self, _arg: core::ffi::c_double) -> (); - fn get_window_range(&mut self) -> *mut core::ffi::c_double; - fn get_window_range(&mut self, data: core::ffi::c_double) -> (); fn set_window_values( &mut self, _arg1: core::ffi::c_double, _arg2: core::ffi::c_double, ) -> (); - fn set_window_values(&mut self, _arg: core::ffi::c_double) -> (); - fn get_window_values(&mut self) -> *mut core::ffi::c_double; - fn get_window_values(&mut self, data: core::ffi::c_double) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; fn register(&mut self, o: *mut core::ffi::c_void) -> (); } @@ -8056,10 +4029,9 @@ pub trait VtkInEdgeIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> (); + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> (); fn get_graph(&mut self) -> *mut core::ffi::c_void; - fn get_vertex(&mut self) -> core::ffi::c_uchar; - fn next(&mut self) -> *mut core::ffi::c_void; + fn get_vertex(&mut self) -> core::ffi::c_longlong; fn next_graph_edge(&mut self) -> *mut core::ffi::c_void; fn has_next(&mut self) -> bool; } @@ -8079,79 +4051,17 @@ pub trait VtkIncrementalOctreeNode { z1: core::ffi::c_double, z2: core::ffi::c_double, ) -> (); - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_min_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_min_bounds( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_min_bounds(&mut self, _arg: core::ffi::c_double) -> (); - fn get_max_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_max_bounds( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_max_bounds(&mut self, _arg: core::ffi::c_double) -> (); - fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double; fn is_leaf(&mut self) -> core::ffi::c_int; - fn get_child_index(&mut self, point: core::ffi::c_double) -> core::ffi::c_int; fn get_child(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn contains_point(&mut self, pnt: core::ffi::c_double) -> core::ffi::c_int; - fn contains_point_by_data(&mut self, pnt: core::ffi::c_double) -> core::ffi::c_int; - fn insert_point( - &mut self, - points: *mut core::ffi::c_void, - newPnt: core::ffi::c_double, - maxPts: core::ffi::c_int, - pntId: core::ffi::c_uchar, - ptMode: core::ffi::c_int, - ) -> core::ffi::c_int; - fn insert_point( - &mut self, - points: *mut core::ffi::c_void, - newPnt: core::ffi::c_double, - maxPts: core::ffi::c_int, - pntId: core::ffi::c_uchar, - ptMode: core::ffi::c_int, - numberOfNodes: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_distance_2_to_inner_boundary( - &mut self, - point: core::ffi::c_double, - rootNode: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - fn get_distance_2_to_boundary( - &mut self, - point: core::ffi::c_double, - rootNode: *mut core::ffi::c_void, - checkData: core::ffi::c_int, - ) -> core::ffi::c_double; - fn get_distance_2_to_boundary( - &mut self, - point: core::ffi::c_double, - closest: core::ffi::c_double, - rootNode: *mut core::ffi::c_void, - checkData: core::ffi::c_int, - ) -> core::ffi::c_double; fn export_all_point_ids_by_insertion( &mut self, idList: *mut core::ffi::c_void, ) -> (); - fn export_all_point_ids_by_direct_set( - &mut self, - pntIdx: core::ffi::c_uchar, - idList: *mut core::ffi::c_void, - ) -> (); fn get_number_of_levels(&mut self) -> core::ffi::c_int; fn get_id(&mut self) -> core::ffi::c_int; fn get_point_ids(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkIncrementalOctreePointLocator: VtkIncrementalPointLocator + VtkAbstractPointLocator + VtkLocator { +pub trait VtkIncrementalOctreePointLocator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -8166,142 +4076,38 @@ pub trait VtkIncrementalOctreePointLocator: VtkIncrementalPointLocator + VtkAbst fn get_locator_points(&mut self) -> *mut core::ffi::c_void; fn initialize(&mut self) -> (); fn free_search_structure(&mut self) -> (); - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; fn get_number_of_points(&mut self) -> core::ffi::c_int; fn get_number_of_nodes(&mut self) -> core::ffi::c_int; - fn find_closest_inserted_point( - &mut self, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn generate_representation( - &mut self, - level: core::ffi::c_int, - polysData: *mut core::ffi::c_void, - ) -> (); fn generate_representation( &mut self, level: core::ffi::c_int, polysData: *mut core::ffi::c_void, - UserGetBounds: *mut core::ffi::c_void, - data: (), ) -> (); fn build_locator(&mut self) -> (); - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - miniDist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; fn find_closest_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - miniDist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_within_squared_radius( - &mut self, - radius2: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn find_points_within_squared_radius( - &mut self, - R2: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn init_point_insertion( - &mut self, - points: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - fn init_point_insertion( - &mut self, - points: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - estSize: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn is_inserted_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn insert_unique_point( - &mut self, - point: core::ffi::c_double, - pntId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn insert_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> (); - fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn insert_point_without_checking( - &mut self, - point: core::ffi::c_double, - pntId: core::ffi::c_uchar, - insert: core::ffi::c_int, - ) -> (); + ) -> core::ffi::c_longlong; fn get_root(&mut self) -> *mut core::ffi::c_void; fn get_number_of_levels(&mut self) -> core::ffi::c_int; } -pub trait VtkIncrementalPointLocator: VtkAbstractPointLocator + VtkLocator { +pub trait VtkIncrementalPointLocator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn find_closest_inserted_point( - &mut self, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn init_point_insertion( - &mut self, - newPts: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - fn init_point_insertion( - &mut self, - newPts: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - estSize: core::ffi::c_uchar, - ) -> core::ffi::c_int; fn is_inserted_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn insert_unique_point( - &mut self, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn insert_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> (); - fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } pub trait VtkInformationQuadratureSchemeDefinitionVectorKey { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -8321,22 +4127,6 @@ pub trait VtkInformationQuadratureSchemeDefinitionVectorKey { value: *mut core::ffi::c_void, i: core::ffi::c_int, ) -> (); - fn set_range( - &mut self, - info: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - from: core::ffi::c_int, - to: core::ffi::c_int, - n: core::ffi::c_int, - ) -> (); - fn get_range( - &mut self, - info: *mut core::ffi::c_void, - dest: *mut core::ffi::c_void, - from: core::ffi::c_int, - to: core::ffi::c_int, - n: core::ffi::c_int, - ) -> (); fn get( &mut self, info: *mut core::ffi::c_void, @@ -8388,7 +4178,7 @@ pub trait VtkIterativeClosestPointTransform { fn get_mean_distance_mode(&mut self) -> core::ffi::c_int; fn set_mean_distance_mode_to_rms(&mut self) -> (); fn set_mean_distance_mode_to_absolute_value(&mut self) -> (); - fn get_mean_distance_mode_as_string(&mut self) -> *const core::ffi::c_char; + fn get_mean_distance_mode_as_string(&mut self) -> &str; fn set_maximum_mean_distance(&mut self, _arg: core::ffi::c_double) -> (); fn get_maximum_mean_distance(&mut self) -> core::ffi::c_double; fn get_mean_distance(&mut self) -> core::ffi::c_double; @@ -8420,8 +4210,6 @@ pub trait VtkKdNode { z1: core::ffi::c_double, z2: core::ffi::c_double, ) -> (); - fn set_bounds(&mut self, b: core::ffi::c_double) -> (); - fn get_bounds(&mut self, b: core::ffi::c_double) -> (); fn set_data_bounds( &mut self, x1: core::ffi::c_double, @@ -8431,16 +4219,6 @@ pub trait VtkKdNode { z1: core::ffi::c_double, z2: core::ffi::c_double, ) -> (); - fn get_data_bounds(&mut self, b: core::ffi::c_double) -> (); - fn set_data_bounds(&mut self, v: core::ffi::c_float) -> (); - fn get_min_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_max_bounds(&mut self) -> *mut core::ffi::c_double; - fn set_min_bounds(&mut self, mb: core::ffi::c_double) -> (); - fn set_max_bounds(&mut self, mb: core::ffi::c_double) -> (); - fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double; - fn set_min_data_bounds(&mut self, mb: core::ffi::c_double) -> (); - fn set_max_data_bounds(&mut self, mb: core::ffi::c_double) -> (); fn set_id(&mut self, _arg: core::ffi::c_int) -> (); fn get_id(&mut self) -> core::ffi::c_int; fn get_min_id(&mut self) -> core::ffi::c_int; @@ -8482,13 +4260,6 @@ pub trait VtkKdNode { pi: *mut core::ffi::c_void, useDataBounds: core::ffi::c_int, ) -> core::ffi::c_int; - fn intersects_cell( - &mut self, - cell: *mut core::ffi::c_void, - useDataBounds: core::ffi::c_int, - cellRegion: core::ffi::c_int, - cellBounds: core::ffi::c_double, - ) -> core::ffi::c_int; fn contains_box( &mut self, x1: core::ffi::c_double, @@ -8513,14 +4284,6 @@ pub trait VtkKdNode { z: core::ffi::c_double, useDataBounds: core::ffi::c_int, ) -> core::ffi::c_double; - fn get_distance_2_to_boundary( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - boundaryPt: core::ffi::c_double, - useDataBounds: core::ffi::c_int, - ) -> core::ffi::c_double; fn get_distance_2_to_inner_boundary( &mut self, x: core::ffi::c_double, @@ -8530,7 +4293,7 @@ pub trait VtkKdNode { fn print_node(&mut self, depth: core::ffi::c_int) -> (); fn print_verbose_node(&mut self, depth: core::ffi::c_int) -> (); } -pub trait VtkKdTree: VtkLocator { +pub trait VtkKdTree { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -8558,47 +4321,15 @@ pub trait VtkKdTree: VtkLocator { fn set_data_set(&mut self, set: *mut core::ffi::c_void) -> (); fn add_data_set(&mut self, set: *mut core::ffi::c_void) -> (); fn remove_data_set(&mut self, index: core::ffi::c_int) -> (); - fn remove_data_set(&mut self, set: *mut core::ffi::c_void) -> (); fn remove_all_data_sets(&mut self) -> (); fn get_number_of_data_sets(&mut self) -> core::ffi::c_int; fn get_data_set(&mut self, n: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_data_set(&mut self) -> *mut core::ffi::c_void; fn get_data_sets(&mut self) -> *mut core::ffi::c_void; fn get_data_set_index(&mut self, set: *mut core::ffi::c_void) -> core::ffi::c_int; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn set_new_bounds(&mut self, bounds: core::ffi::c_double) -> (); fn get_number_of_regions(&mut self) -> core::ffi::c_int; - fn get_region_bounds( - &mut self, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> (); - fn get_region_data_bounds( - &mut self, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> (); fn print_tree(&mut self) -> (); fn print_verbose_tree(&mut self) -> (); fn print_region(&mut self, id: core::ffi::c_int) -> (); - fn create_cell_lists( - &mut self, - dataSetIndex: core::ffi::c_int, - regionReqList: core::ffi::c_int, - reqListSize: core::ffi::c_int, - ) -> (); - fn create_cell_lists( - &mut self, - set: *mut core::ffi::c_void, - regionReqList: core::ffi::c_int, - reqListSize: core::ffi::c_int, - ) -> (); - fn create_cell_lists( - &mut self, - regionReqList: core::ffi::c_int, - listSize: core::ffi::c_int, - ) -> (); - fn create_cell_lists(&mut self) -> (); fn set_include_region_boundary_cells(&mut self, _arg: core::ffi::c_int) -> (); fn get_include_region_boundary_cells(&mut self) -> core::ffi::c_int; fn include_region_boundary_cells_on(&mut self) -> (); @@ -8615,35 +4346,12 @@ pub trait VtkKdTree: VtkLocator { set: core::ffi::c_int, inRegionCells: *mut core::ffi::c_void, onBoundaryCells: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn get_cell_lists( - &mut self, - regions: *mut core::ffi::c_void, - set: *mut core::ffi::c_void, - inRegionCells: *mut core::ffi::c_void, - onBoundaryCells: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn get_cell_lists( - &mut self, - regions: *mut core::ffi::c_void, - inRegionCells: *mut core::ffi::c_void, - onBoundaryCells: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn get_region_containing_cell( &mut self, set: *mut core::ffi::c_void, - cellID: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn get_region_containing_cell( - &mut self, - set: core::ffi::c_int, - cellID: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn get_region_containing_cell( - &mut self, - cellID: core::ffi::c_uchar, + cellID: core::ffi::c_longlong, ) -> core::ffi::c_int; - fn all_get_region_containing_cell(&mut self) -> *mut core::ffi::c_int; fn get_region_containing_point( &mut self, x: core::ffi::c_double, @@ -8651,95 +4359,11 @@ pub trait VtkKdTree: VtkLocator { z: core::ffi::c_double, ) -> core::ffi::c_int; fn build_locator(&mut self) -> (); - fn minimal_number_of_convex_sub_regions( - &mut self, - regionIdList: *mut core::ffi::c_void, - convexRegionBounds: core::ffi::c_double, - ) -> core::ffi::c_int; - fn view_order_all_regions_in_direction( - &mut self, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn view_order_regions_in_direction( - &mut self, - regionIds: *mut core::ffi::c_void, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn view_order_all_regions_from_position( - &mut self, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn view_order_regions_from_position( - &mut self, - regionIds: *mut core::ffi::c_void, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn build_locator_from_points(&mut self, pointset: *mut core::ffi::c_void) -> (); - fn build_locator_from_points(&mut self, ptArray: *mut core::ffi::c_void) -> (); - fn build_locator_from_points( - &mut self, - ptArray: *mut core::ffi::c_void, - numPtArrays: core::ffi::c_int, - ) -> (); fn build_map_for_duplicate_points( &mut self, tolerance: core::ffi::c_float, ) -> *mut core::ffi::c_void; - fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_in_region( - &mut self, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_in_region( - &mut self, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); fn get_points_in_region( &mut self, regionId: core::ffi::c_int, @@ -8750,12 +4374,6 @@ pub trait VtkKdTree: VtkLocator { level: core::ffi::c_int, pd: *mut core::ffi::c_void, ) -> (); - fn generate_representation( - &mut self, - regionList: core::ffi::c_int, - len: core::ffi::c_int, - pd: *mut core::ffi::c_void, - ) -> (); fn generate_representation_using_data_bounds_on(&mut self) -> (); fn generate_representation_using_data_bounds_off(&mut self) -> (); fn set_generate_representation_using_data_bounds( @@ -8764,43 +4382,13 @@ pub trait VtkKdTree: VtkLocator { ) -> (); fn get_generate_representation_using_data_bounds(&mut self) -> core::ffi::c_int; fn new_geometry(&mut self) -> core::ffi::c_int; - fn new_geometry( - &mut self, - sets: *mut core::ffi::c_void, - numDataSets: core::ffi::c_int, - ) -> core::ffi::c_int; fn invalidate_geometry(&mut self) -> (); fn copy_tree(&mut self, kd: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn find_points_in_area( - &mut self, - area: core::ffi::c_double, - ids: *mut core::ffi::c_void, - clearArray: bool, - ) -> (); } -pub trait VtkKdTreePointLocator: VtkAbstractPointLocator + VtkLocator { +pub trait VtkKdTreePointLocator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); fn free_search_structure(&mut self) -> (); fn build_locator(&mut self) -> (); fn generate_representation( @@ -8809,187 +4397,67 @@ pub trait VtkKdTreePointLocator: VtkAbstractPointLocator + VtkLocator { pd: *mut core::ffi::c_void, ) -> (); } -pub trait VtkLagrangeCurve: VtkHigherOrderCurve + VtkNonLinearCell + VtkCell { +pub trait VtkLagrangeCurve { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); } -pub trait VtkLagrangeHexahedron: VtkHigherOrderHexahedron + VtkNonLinearCell + VtkCell { +pub trait VtkLagrangeHexahedron { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; fn get_face_cell(&mut self) -> *mut core::ffi::c_void; fn get_interpolation(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkLagrangeInterpolation: VtkHigherOrderInterpolation { +pub trait VtkLagrangeInterpolation { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn evaluate_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> (); - fn evaluate_shape_and_gradient( - &mut self, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - grad: core::ffi::c_double, - ) -> (); - fn tensor_1_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_1_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_2_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_2_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_3_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_3_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tensor_3_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ) -> (); - fn wedge_shape_functions( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> (); - fn wedge_shape_derivatives( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn wedge_evaluate( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldAtPCoords: core::ffi::c_double, - ) -> (); - fn wedge_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ) -> (); } -pub trait VtkLagrangeQuadrilateral: VtkHigherOrderQuadrilateral + VtkNonLinearCell + VtkCell { +pub trait VtkLagrangeQuadrilateral { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkLagrangeTetra: VtkHigherOrderTetra + VtkNonLinearCell + VtkCell { +pub trait VtkLagrangeTetra { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; fn get_face_cell(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkLagrangeTriangle: VtkHigherOrderTriangle + VtkNonLinearCell + VtkCell { +pub trait VtkLagrangeTriangle { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkLagrangeWedge: VtkHigherOrderWedge + VtkNonLinearCell + VtkCell { +pub trait VtkLagrangeWedge { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void; fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void; fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; fn get_interpolation(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkLine: VtkCell { +pub trait VtkLine { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -8999,12 +4467,6 @@ pub trait VtkLine: VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -9016,39 +4478,15 @@ pub trait VtkLine: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; fn clip( &mut self, @@ -9059,101 +4497,10 @@ pub trait VtkLine: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn intersection( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - u: core::ffi::c_double, - v: core::ffi::c_double, - tolerance: core::ffi::c_double, - toleranceType: core::ffi::c_int, - ) -> core::ffi::c_int; - fn intersection_3_d( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - u: core::ffi::c_double, - v: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_int; - fn distance_to_line( - &mut self, - x: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t: core::ffi::c_double, - closestPoint: core::ffi::c_double, - ) -> core::ffi::c_double; - fn distance_to_line( - &mut self, - x: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - ) -> core::ffi::c_double; - fn distance_between_lines( - &mut self, - l0: core::ffi::c_double, - l1: core::ffi::c_double, - m0: core::ffi::c_double, - m1: core::ffi::c_double, - closestPt1: core::ffi::c_double, - closestPt2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - ) -> core::ffi::c_double; - fn distance_between_line_segments( - &mut self, - l0: core::ffi::c_double, - l1: core::ffi::c_double, - m0: core::ffi::c_double, - m1: core::ffi::c_double, - closestPt1: core::ffi::c_double, - closestPt2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - ) -> core::ffi::c_double; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } pub trait VtkLocator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -9185,22 +4532,17 @@ pub trait VtkLocator { fn get_build_time(&mut self) -> core::ffi::c_ulong; fn register(&mut self, o: *mut core::ffi::c_void) -> (); } -pub trait VtkMappedUnstructuredGrid: VtkUnstructuredGridBase + VtkPointSet + VtkDataSet + VtkDataObject { - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> (); - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; +pub trait VtkMappedUnstructuredGrid { + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> (); fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> (); fn get_ids_of_cells_of_type( @@ -9211,127 +4553,48 @@ pub trait VtkMappedUnstructuredGrid: VtkUnstructuredGridBase + VtkPointSet + Vtk fn is_homogeneous(&mut self) -> core::ffi::c_int; fn allocate( &mut self, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, extSize: core::ffi::c_int, ) -> (); fn set_implementation(&mut self, impl_: *mut core::ffi::c_void) -> (); fn get_implementation(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkMappedUnstructuredGridCellIterator: VtkCellIterator { +pub trait VtkMappedUnstructuredGridCellIterator { fn is_done_with_traversal(&mut self) -> bool; - fn get_cell_id(&mut self) -> core::ffi::c_uchar; + fn get_cell_id(&mut self) -> core::ffi::c_longlong; } pub trait VtkMeanValueCoordinatesInterpolator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn compute_interpolation_weights( - &mut self, - x: core::ffi::c_double, - pts: *mut core::ffi::c_void, - tris: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> (); - fn compute_interpolation_weights( - &mut self, - x: core::ffi::c_double, - pts: *mut core::ffi::c_void, - tris: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> (); } -pub trait VtkMergePoints: VtkPointLocator + VtkIncrementalPointLocator + VtkAbstractPointLocator + VtkLocator { +pub trait VtkMergePoints { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn insert_unique_point( - &mut self, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; } -pub trait VtkMolecule: VtkUndirectedGraph + VtkGraph + VtkDataObject { +pub trait VtkMolecule { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn append_atom(&mut self) -> *mut core::ffi::c_void; - fn append_atom( - &mut self, - atomicNumber: core::ffi::c_ushort, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> *mut core::ffi::c_void; - fn append_atom( - &mut self, - atomicNumber: core::ffi::c_ushort, - pos: vtkVector3f, - ) -> *mut core::ffi::c_void; - fn append_atom( - &mut self, - atomicNumber: core::ffi::c_ushort, - pos: core::ffi::c_double, - ) -> *mut core::ffi::c_void; - fn get_atom(&mut self, atomId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_number_of_atoms(&mut self) -> core::ffi::c_uchar; - fn append_bond( - &mut self, - atom1: core::ffi::c_uchar, - atom2: core::ffi::c_uchar, - order: core::ffi::c_ushort, - ) -> *mut core::ffi::c_void; - fn append_bond( - &mut self, - atom1: vtkAtom, - atom2: vtkAtom, - order: core::ffi::c_ushort, - ) -> *mut core::ffi::c_void; - fn get_bond(&mut self, bondId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_number_of_bonds(&mut self) -> core::ffi::c_uchar; + fn get_number_of_atoms(&mut self) -> core::ffi::c_longlong; + fn get_number_of_bonds(&mut self) -> core::ffi::c_longlong; fn get_atom_atomic_number( &mut self, - atomId: core::ffi::c_uchar, + atomId: core::ffi::c_longlong, ) -> core::ffi::c_ushort; fn set_atom_atomic_number( &mut self, - atomId: core::ffi::c_uchar, + atomId: core::ffi::c_longlong, atomicNum: core::ffi::c_ushort, ) -> (); - fn set_atom_position(&mut self, atomId: core::ffi::c_uchar, pos: vtkVector3f) -> (); - fn set_atom_position( - &mut self, - atomId: core::ffi::c_uchar, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> (); - fn set_atom_position( - &mut self, - atomId: core::ffi::c_uchar, - pos: core::ffi::c_double, - ) -> (); - fn get_atom_position( - &mut self, - atomId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn get_atom_position( - &mut self, - atomId: core::ffi::c_uchar, - pos: core::ffi::c_float, - ) -> (); - fn get_atom_position( - &mut self, - atomId: core::ffi::c_uchar, - pos: core::ffi::c_double, - ) -> (); fn set_bond_order( &mut self, - bondId: core::ffi::c_uchar, + bondId: core::ffi::c_longlong, order: core::ffi::c_ushort, ) -> (); - fn get_bond_order(&mut self, bondId: core::ffi::c_uchar) -> core::ffi::c_ushort; - fn get_bond_length(&mut self, bondId: core::ffi::c_uchar) -> core::ffi::c_double; + fn get_bond_order(&mut self, bondId: core::ffi::c_longlong) -> core::ffi::c_ushort; + fn get_bond_length(&mut self, bondId: core::ffi::c_longlong) -> core::ffi::c_double; fn get_atomic_position_array(&mut self) -> *mut core::ffi::c_void; fn get_atomic_number_array(&mut self) -> *mut core::ffi::c_void; fn get_bond_orders_array(&mut self) -> *mut core::ffi::c_void; @@ -9343,39 +4606,10 @@ pub trait VtkMolecule: VtkUndirectedGraph + VtkGraph + VtkDataObject { fn deep_copy_structure(&mut self, m: *mut core::ffi::c_void) -> (); fn shallow_copy_attributes(&mut self, m: *mut core::ffi::c_void) -> (); fn deep_copy_attributes(&mut self, m: *mut core::ffi::c_void) -> (); - fn get_plane_from_bond( - &mut self, - bond: vtkBond, - normal: vtkVector3f, - plane: *mut core::ffi::c_void, - ) -> bool; - fn get_plane_from_bond( - &mut self, - atom1: vtkAtom, - atom2: vtkAtom, - normal: vtkVector3f, - plane: *mut core::ffi::c_void, - ) -> bool; fn has_lattice(&mut self) -> bool; fn clear_lattice(&mut self) -> (); fn set_lattice(&mut self, matrix: *mut core::ffi::c_void) -> (); - fn set_lattice(&mut self, a: vtkVector3d, b: vtkVector3d, c: vtkVector3d) -> (); fn get_lattice(&mut self) -> *mut core::ffi::c_void; - fn get_lattice( - &mut self, - a: *mut core::ffi::c_void, - b: *mut core::ffi::c_void, - c: *mut core::ffi::c_void, - ) -> (); - fn get_lattice( - &mut self, - a: *mut core::ffi::c_void, - b: *mut core::ffi::c_void, - c: *mut core::ffi::c_void, - origin: *mut core::ffi::c_void, - ) -> (); - fn get_lattice_origin(&mut self) -> *mut core::ffi::c_void; - fn set_lattice_origin(&mut self, _arg: *mut core::ffi::c_void) -> (); fn get_atom_ghost_array(&mut self) -> *mut core::ffi::c_void; fn allocate_atom_ghost_array(&mut self) -> (); fn get_bond_ghost_array(&mut self) -> *mut core::ffi::c_void; @@ -9386,31 +4620,18 @@ pub trait VtkMolecule: VtkUndirectedGraph + VtkGraph + VtkDataObject { atomicNumberArray: *mut core::ffi::c_void, atomData: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn initialize( - &mut self, - atomPositions: *mut core::ffi::c_void, - atomData: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn initialize(&mut self, molecule: *mut core::ffi::c_void) -> core::ffi::c_int; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_atom_data(&mut self) -> *mut core::ffi::c_void; fn get_bond_data(&mut self) -> *mut core::ffi::c_void; fn get_bond_id( &mut self, - a: core::ffi::c_uchar, - b: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn set_atomic_number_array_name(&mut self, _arg: core::ffi::c_char) -> (); - fn get_atomic_number_array_name(&mut self) -> *mut core::ffi::c_char; - fn set_bond_orders_array_name(&mut self, _arg: core::ffi::c_char) -> (); - fn get_bond_orders_array_name(&mut self) -> *mut core::ffi::c_char; + a: core::ffi::c_longlong, + b: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn set_atomic_number_array_name(&mut self, _arg: &str) -> (); + fn set_bond_orders_array_name(&mut self, _arg: &str) -> (); } -pub trait VtkMultiBlockDataSet: VtkDataObjectTree + VtkCompositeDataSet + VtkDataObject { +pub trait VtkMultiBlockDataSet { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -9426,15 +4647,8 @@ pub trait VtkMultiBlockDataSet: VtkDataObjectTree + VtkCompositeDataSet + VtkDat fn has_meta_data(&mut self, blockno: core::ffi::c_uint) -> core::ffi::c_int; fn get_meta_data(&mut self, blockno: core::ffi::c_uint) -> *mut core::ffi::c_void; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; } -pub trait VtkMultiPieceDataSet: VtkPartitionedDataSet + VtkDataObjectTree + VtkCompositeDataSet + VtkDataObject { +pub trait VtkMultiPieceDataSet { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -9451,208 +4665,87 @@ pub trait VtkMultiPieceDataSet: VtkPartitionedDataSet + VtkDataObjectTree + VtkC piece: *mut core::ffi::c_void, ) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } -pub trait VtkMutableDirectedGraph: VtkDirectedGraph + VtkGraph + VtkDataObject { +pub trait VtkMutableDirectedGraph { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn set_number_of_vertices( &mut self, - numVerts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn add_vertex(&mut self) -> core::ffi::c_uchar; - fn add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn add_vertex(&mut self, pedigreeId: vtkVariant) -> core::ffi::c_uchar; - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn add_edge( - &mut self, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn add_edge( - &mut self, - u: vtkVariant, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn add_vertex(&mut self) -> core::ffi::c_longlong; fn lazy_add_vertex(&mut self) -> (); - fn lazy_add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> (); - fn lazy_add_vertex(&mut self, pedigreeId: vtkVariant) -> (); - fn lazy_add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> (); - fn lazy_add_edge( - &mut self, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> (); - fn lazy_add_edge( - &mut self, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> (); fn lazy_add_edge( &mut self, - u: vtkVariant, - v: vtkVariant, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, propertyArr: *mut core::ffi::c_void, ) -> (); fn add_graph_edge( &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; fn add_child( &mut self, - parent: core::ffi::c_uchar, + parent: core::ffi::c_longlong, propertyArr: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn add_child(&mut self, parent: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn remove_vertex(&mut self, v: core::ffi::c_uchar) -> (); - fn remove_edge(&mut self, e: core::ffi::c_uchar) -> (); + ) -> core::ffi::c_longlong; + fn remove_vertex(&mut self, v: core::ffi::c_longlong) -> (); + fn remove_edge(&mut self, e: core::ffi::c_longlong) -> (); fn remove_vertices(&mut self, arr: *mut core::ffi::c_void) -> (); fn remove_edges(&mut self, arr: *mut core::ffi::c_void) -> (); } -pub trait VtkMutableUndirectedGraph: VtkUndirectedGraph + VtkGraph + VtkDataObject { +pub trait VtkMutableUndirectedGraph { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn set_number_of_vertices( &mut self, - numVerts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn add_vertex(&mut self) -> core::ffi::c_uchar; - fn add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn add_vertex(&mut self, pedigreeId: vtkVariant) -> core::ffi::c_uchar; - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn add_edge( - &mut self, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn add_edge( - &mut self, - u: vtkVariant, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn add_vertex(&mut self) -> core::ffi::c_longlong; fn lazy_add_vertex(&mut self) -> (); - fn lazy_add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> (); - fn lazy_add_vertex(&mut self, pedigreeId: vtkVariant) -> (); - fn lazy_add_edge(&mut self, u: core::ffi::c_uchar, v: core::ffi::c_uchar) -> (); - fn lazy_add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> (); - fn lazy_add_edge( - &mut self, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> (); - fn lazy_add_edge( - &mut self, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> (); fn lazy_add_edge( &mut self, - u: vtkVariant, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, ) -> (); fn add_graph_edge( &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; - fn remove_vertex(&mut self, v: core::ffi::c_uchar) -> (); - fn remove_edge(&mut self, e: core::ffi::c_uchar) -> (); + fn remove_vertex(&mut self, v: core::ffi::c_longlong) -> (); + fn remove_edge(&mut self, e: core::ffi::c_longlong) -> (); fn remove_vertices(&mut self, arr: *mut core::ffi::c_void) -> (); fn remove_edges(&mut self, arr: *mut core::ffi::c_void) -> (); } -pub trait VtkNonLinearCell: VtkCell { +pub trait VtkNonLinearCell { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn is_linear(&mut self) -> core::ffi::c_int; } -pub trait VtkNonMergingPointLocator: VtkPointLocator + VtkIncrementalPointLocator + VtkAbstractPointLocator + VtkLocator { +pub trait VtkNonMergingPointLocator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn is_inserted_point(&mut self, p0: core::ffi::c_double) -> core::ffi::c_uchar; fn is_inserted_point( &mut self, p0: core::ffi::c_double, p1: core::ffi::c_double, p2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn insert_unique_point( - &mut self, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; + ) -> core::ffi::c_longlong; } -pub trait VtkNonOverlappingAMR: VtkUniformGridAMR + VtkCompositeDataSet + VtkDataObject { +pub trait VtkNonOverlappingAMR { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } -pub trait VtkOctreePointLocator: VtkAbstractPointLocator + VtkLocator { +pub trait VtkOctreePointLocator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -9662,19 +4755,7 @@ pub trait VtkOctreePointLocator: VtkAbstractPointLocator + VtkLocator { fn get_create_cubic_octants(&mut self) -> core::ffi::c_int; fn get_fudge_factor(&mut self) -> core::ffi::c_double; fn set_fudge_factor(&mut self, _arg: core::ffi::c_double) -> (); - fn get_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); fn get_number_of_leaf_nodes(&mut self) -> core::ffi::c_int; - fn get_region_bounds( - &mut self, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> (); - fn get_region_data_bounds( - &mut self, - leafNodeID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> (); fn get_region_containing_point( &mut self, x: core::ffi::c_double, @@ -9682,46 +4763,13 @@ pub trait VtkOctreePointLocator: VtkAbstractPointLocator + VtkLocator { z: core::ffi::c_double, ) -> core::ffi::c_int; fn build_locator(&mut self) -> (); - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; fn find_closest_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_in_region( - &mut self, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_in_region( - &mut self, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_points_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); + dist2: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; fn get_points_in_region( &mut self, leafNodeId: core::ffi::c_int, @@ -9732,12 +4780,6 @@ pub trait VtkOctreePointLocator: VtkAbstractPointLocator + VtkLocator { level: core::ffi::c_int, pd: *mut core::ffi::c_void, ) -> (); - fn find_points_in_area( - &mut self, - area: core::ffi::c_double, - ids: *mut core::ffi::c_void, - clearArray: bool, - ) -> (); } pub trait VtkOctreePointLocatorNode { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -9754,8 +4796,6 @@ pub trait VtkOctreePointLocatorNode { zMin: core::ffi::c_double, zMax: core::ffi::c_double, ) -> (); - fn set_bounds(&mut self, b: core::ffi::c_double) -> (); - fn get_bounds(&mut self, b: core::ffi::c_double) -> (); fn set_data_bounds( &mut self, xMin: core::ffi::c_double, @@ -9765,15 +4805,6 @@ pub trait VtkOctreePointLocatorNode { zMin: core::ffi::c_double, zMax: core::ffi::c_double, ) -> (); - fn get_data_bounds(&mut self, b: core::ffi::c_double) -> (); - fn get_min_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_max_bounds(&mut self) -> *mut core::ffi::c_double; - fn set_min_bounds(&mut self, minBounds: core::ffi::c_double) -> (); - fn set_max_bounds(&mut self, maxBounds: core::ffi::c_double) -> (); - fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double; - fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double; - fn set_min_data_bounds(&mut self, minDataBounds: core::ffi::c_double) -> (); - fn set_max_data_bounds(&mut self, maxDataBounds: core::ffi::c_double) -> (); fn get_id(&mut self) -> core::ffi::c_int; fn get_min_id(&mut self) -> core::ffi::c_int; fn create_child_nodes(&mut self) -> (); @@ -9799,15 +4830,6 @@ pub trait VtkOctreePointLocatorNode { top: *mut core::ffi::c_void, useDataBounds: core::ffi::c_int, ) -> core::ffi::c_double; - fn get_distance_2_to_boundary( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - boundaryPt: core::ffi::c_double, - top: *mut core::ffi::c_void, - useDataBounds: core::ffi::c_int, - ) -> core::ffi::c_double; fn get_distance_2_to_inner_boundary( &mut self, x: core::ffi::c_double, @@ -9815,18 +4837,6 @@ pub trait VtkOctreePointLocatorNode { z: core::ffi::c_double, top: *mut core::ffi::c_void, ) -> core::ffi::c_double; - fn get_sub_octant_index( - &mut self, - point: core::ffi::c_double, - CheckContainment: core::ffi::c_int, - ) -> core::ffi::c_int; - fn compute_octree_node_information( - &mut self, - Parent: *mut core::ffi::c_void, - NextLeafId: core::ffi::c_int, - NextMinId: core::ffi::c_int, - coordinates: core::ffi::c_float, - ) -> (); } pub trait VtkOrderedTriangulator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -9842,35 +4852,6 @@ pub trait VtkOrderedTriangulator { zmax: core::ffi::c_double, numPts: core::ffi::c_int, ) -> (); - fn init_triangulation( - &mut self, - bounds: core::ffi::c_double, - numPts: core::ffi::c_int, - ) -> (); - fn insert_point( - &mut self, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - p: core::ffi::c_double, - type_: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn insert_point( - &mut self, - id: core::ffi::c_uchar, - sortid: core::ffi::c_uchar, - x: core::ffi::c_double, - p: core::ffi::c_double, - type_: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn insert_point( - &mut self, - id: core::ffi::c_uchar, - sortid: core::ffi::c_uchar, - sortid2: core::ffi::c_uchar, - x: core::ffi::c_double, - p: core::ffi::c_double, - type_: core::ffi::c_int, - ) -> core::ffi::c_uchar; fn triangulate(&mut self) -> (); fn template_triangulate( &mut self, @@ -9880,18 +4861,13 @@ pub trait VtkOrderedTriangulator { ) -> (); fn update_point_type( &mut self, - internalId: core::ffi::c_uchar, + internalId: core::ffi::c_longlong, type_: core::ffi::c_int, ) -> (); - fn get_point_position( + fn get_point_id( &mut self, - internalId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - fn get_point_location( - &mut self, - internalId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - fn get_point_id(&mut self, internalId: core::ffi::c_uchar) -> core::ffi::c_uchar; + internalId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn get_number_of_points(&mut self) -> core::ffi::c_int; fn set_use_templates(&mut self, _arg: core::ffi::c_int) -> (); fn get_use_templates(&mut self) -> core::ffi::c_int; @@ -9909,43 +4885,16 @@ pub trait VtkOrderedTriangulator { &mut self, classification: core::ffi::c_int, ugrid: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn add_tetras( &mut self, classification: core::ffi::c_int, ugrid: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn add_tetras( - &mut self, - classification: core::ffi::c_int, - connectivity: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn add_tetras( - &mut self, - classification: core::ffi::c_int, - locator: *mut core::ffi::c_void, - outConnectivity: *mut core::ffi::c_void, - inPD: *mut core::ffi::c_void, - outPD: *mut core::ffi::c_void, - inCD: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - outCD: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn add_tetras( - &mut self, - classification: core::ffi::c_int, - ptIds: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn add_triangles( - &mut self, - connectivity: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn add_triangles( &mut self, - id: core::ffi::c_uchar, connectivity: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn init_tetra_traversal(&mut self) -> (); fn get_next_tetra( &mut self, @@ -9959,59 +4908,18 @@ pub trait VtkOutEdgeIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> (); + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> (); fn get_graph(&mut self) -> *mut core::ffi::c_void; - fn get_vertex(&mut self) -> core::ffi::c_uchar; - fn next(&mut self) -> *mut core::ffi::c_void; + fn get_vertex(&mut self) -> core::ffi::c_longlong; fn next_graph_edge(&mut self) -> *mut core::ffi::c_void; fn has_next(&mut self) -> bool; } -pub trait VtkOverlappingAMR: VtkUniformGridAMR + VtkCompositeDataSet + VtkDataObject { +pub trait VtkOverlappingAMR { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set_origin(&mut self, origin: core::ffi::c_double) -> (); - fn get_origin(&mut self) -> *mut core::ffi::c_double; - fn set_spacing( - &mut self, - level: core::ffi::c_uint, - spacing: core::ffi::c_double, - ) -> (); - fn get_spacing( - &mut self, - level: core::ffi::c_uint, - spacing: core::ffi::c_double, - ) -> (); - fn set_amr_box( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - box_: vtkAMRBox, - ) -> (); - fn get_amr_box( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - ) -> vtkAMRBox; - fn get_bounds( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - bb: core::ffi::c_double, - ) -> (); - fn get_origin( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - origin: core::ffi::c_double, - ) -> (); fn number_of_blanked_points(&mut self) -> *mut core::ffi::c_void; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn set_refinement_ratio( &mut self, level: core::ffi::c_uint, @@ -10029,38 +4937,18 @@ pub trait VtkOverlappingAMR: VtkUniformGridAMR + VtkCompositeDataSet + VtkDataOb level: core::ffi::c_uint, id: core::ffi::c_uint, ) -> core::ffi::c_int; - fn get_refinement_ratio(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; fn has_children_information(&mut self) -> bool; fn generate_parent_child_information(&mut self) -> (); - fn get_parents( - &mut self, - level: core::ffi::c_uint, - index: core::ffi::c_uint, - numParents: core::ffi::c_uint, - ) -> *mut core::ffi::c_uint; - fn get_children( - &mut self, - level: core::ffi::c_uint, - index: core::ffi::c_uint, - numChildren: core::ffi::c_uint, - ) -> *mut core::ffi::c_uint; fn print_parent_child_info( &mut self, level: core::ffi::c_uint, index: core::ffi::c_uint, ) -> (); - fn get_bounds(&mut self, b: core::ffi::c_double) -> (); - fn find_grid( - &mut self, - q: core::ffi::c_double, - level: core::ffi::c_uint, - gridId: core::ffi::c_uint, - ) -> bool; fn get_amr_info(&mut self) -> *mut core::ffi::c_void; fn set_amr_info(&mut self, info: *mut core::ffi::c_void) -> (); fn audit(&mut self) -> (); } -pub trait VtkPartitionedDataSet: VtkDataObjectTree + VtkCompositeDataSet + VtkDataObject { +pub trait VtkPartitionedDataSet { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -10079,16 +4967,9 @@ pub trait VtkPartitionedDataSet: VtkDataObjectTree + VtkCompositeDataSet + VtkDa fn has_meta_data(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_int; fn get_meta_data(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; fn remove_null_partitions(&mut self) -> (); } -pub trait VtkPartitionedDataSetCollection: VtkDataObjectTree + VtkCompositeDataSet + VtkDataObject { +pub trait VtkPartitionedDataSetCollection { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -10134,37 +5015,15 @@ pub trait VtkPartitionedDataSetCollection: VtkDataObjectTree + VtkCompositeDataS fn get_data_assembly(&mut self) -> *mut core::ffi::c_void; fn set_data_assembly(&mut self, assembly: *mut core::ffi::c_void) -> (); fn get_composite_index(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_uint; - fn get_composite_index( - &mut self, - idx: core::ffi::c_uint, - partition: core::ffi::c_uint, - ) -> core::ffi::c_uint; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; fn get_m_time(&mut self) -> core::ffi::c_ulong; fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); } -pub trait VtkPath: VtkPointSet + VtkDataSet + VtkDataObject { +pub trait VtkPath { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; - fn insert_next_point( - &mut self, - pts: core::ffi::c_float, - code: core::ffi::c_int, - ) -> (); - fn insert_next_point( - &mut self, - pts: core::ffi::c_double, - code: core::ffi::c_int, - ) -> (); fn insert_next_point( &mut self, x: core::ffi::c_double, @@ -10174,358 +5033,112 @@ pub trait VtkPath: VtkPointSet + VtkDataSet + VtkDataObject { ) -> (); fn set_codes(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_codes(&mut self) -> *mut core::ffi::c_void; - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; - fn get_cell(&mut self, p0: core::ffi::c_uchar, p1: *mut core::ffi::c_void) -> (); + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_cell(&mut self, p0: core::ffi::c_longlong, p1: *mut core::ffi::c_void) -> (); fn get_cell_points( &mut self, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> (); fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> (); fn get_max_cell_size(&mut self) -> core::ffi::c_int; - fn allocate(&mut self, size: core::ffi::c_uchar, extSize: core::ffi::c_int) -> (); + fn allocate(&mut self, size: core::ffi::c_longlong, extSize: core::ffi::c_int) -> (); fn reset(&mut self) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } -pub trait VtkPentagonalPrism: VtkCell3D + VtkCell { +pub trait VtkPentagonalPrism { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( +} +pub trait VtkPeriodicDataArray { + fn initialize(&mut self) -> (); + fn get_tuples( &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, ) -> (); - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( + fn squeeze(&mut self) -> (); + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn clear_lookup(&mut self) -> (); + fn get_typed_tuple( &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, + idx: core::ffi::c_longlong, + t: *mut core::ffi::c_void, ) -> (); - fn interpolation_derivs( + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn allocate( &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); -} -pub trait VtkPeriodicDataArray { - fn initialize(&mut self) -> (); - fn get_tuples( - &mut self, - ptIds: *mut core::ffi::c_void, - output: *mut core::ffi::c_void, - ) -> (); - fn get_tuples( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - output: *mut core::ffi::c_void, - ) -> (); - fn squeeze(&mut self) -> (); - fn new_iterator(&mut self) -> *mut core::ffi::c_void; - fn lookup_value(&mut self, value: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn lookup_value( - &mut self, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> (); - fn get_variant_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn clear_lookup(&mut self) -> (); - fn get_tuple(&mut self, i: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_tuple(&mut self, i: core::ffi::c_uchar, tuple: core::ffi::c_double) -> (); - fn lookup_typed_value( - &mut self, - value: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn lookup_typed_value( - &mut self, - value: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ) -> (); - fn get_value(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_value_reference(&mut self, idx: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_typed_tuple( - &mut self, - idx: core::ffi::c_uchar, - t: *mut core::ffi::c_void, - ) -> (); - fn get_typed_component( - &mut self, - tupleIdx: core::ffi::c_uchar, - compIdx: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; - fn allocate( - &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; - fn resize(&mut self, numTuples: core::ffi::c_uchar) -> core::ffi::c_int; - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> (); + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); fn set_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> (); - fn set_tuple(&mut self, i: core::ffi::c_uchar, source: core::ffi::c_float) -> (); - fn set_tuple(&mut self, i: core::ffi::c_uchar, source: core::ffi::c_double) -> (); fn insert_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> (); - fn insert_tuple(&mut self, i: core::ffi::c_uchar, source: core::ffi::c_float) -> (); - fn insert_tuple(&mut self, i: core::ffi::c_uchar, source: core::ffi::c_double) -> (); fn insert_tuples( &mut self, dstIds: *mut core::ffi::c_void, srcIds: *mut core::ffi::c_void, source: *mut core::ffi::c_void, ) -> (); - fn insert_tuples( - &mut self, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - source: *mut core::ffi::c_void, - ) -> (); fn insert_next_tuple( &mut self, - j: core::ffi::c_uchar, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn insert_next_tuple(&mut self, source: core::ffi::c_float) -> core::ffi::c_uchar; - fn insert_next_tuple(&mut self, source: core::ffi::c_double) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); - fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - ptIndices: *mut core::ffi::c_void, - source: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_tuple( - &mut self, - i: core::ffi::c_uchar, - id1: core::ffi::c_uchar, - source1: *mut core::ffi::c_void, - id2: core::ffi::c_uchar, - source2: *mut core::ffi::c_void, - t: core::ffi::c_double, - ) -> (); - fn set_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_variant_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn remove_tuple(&mut self, id: core::ffi::c_uchar) -> (); + fn remove_tuple(&mut self, id: core::ffi::c_longlong) -> (); fn remove_first_tuple(&mut self) -> (); fn remove_last_tuple(&mut self) -> (); - fn set_typed_tuple(&mut self, i: core::ffi::c_uchar, t: Scalar) -> (); - fn set_typed_component( - &mut self, - t: core::ffi::c_uchar, - c: core::ffi::c_int, - v: *mut core::ffi::c_void, - ) -> (); - fn insert_typed_tuple(&mut self, i: core::ffi::c_uchar, t: Scalar) -> (); - fn insert_next_typed_tuple(&mut self, t: Scalar) -> core::ffi::c_uchar; - fn set_value( - &mut self, - idx: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn insert_next_value(&mut self, v: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn insert_value(&mut self, idx: core::ffi::c_uchar, v: *mut core::ffi::c_void) -> (); fn set_normalize(&mut self, _arg: bool) -> (); fn get_normalize(&mut self) -> bool; } -pub trait VtkPerlinNoise: VtkImplicitFunction { +pub trait VtkPerlinNoise { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); fn set_frequency( &mut self, _arg1: core::ffi::c_double, _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_frequency(&mut self, _arg: core::ffi::c_double) -> (); - fn get_frequency(&mut self) -> *mut core::ffi::c_double; - fn get_frequency(&mut self, data: core::ffi::c_double) -> (); fn set_phase( &mut self, _arg1: core::ffi::c_double, _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_phase(&mut self, _arg: core::ffi::c_double) -> (); - fn get_phase(&mut self) -> *mut core::ffi::c_double; - fn get_phase(&mut self, data: core::ffi::c_double) -> (); fn set_amplitude(&mut self, _arg: core::ffi::c_double) -> (); fn get_amplitude(&mut self) -> core::ffi::c_double; } -pub trait VtkPiecewiseFunction: VtkDataObject { +pub trait VtkPiecewiseFunction { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -10538,20 +5151,8 @@ pub trait VtkPiecewiseFunction: VtkDataObject { x: core::ffi::c_double, y: core::ffi::c_double, ) -> core::ffi::c_int; - fn add_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - midpoint: core::ffi::c_double, - sharpness: core::ffi::c_double, - ) -> core::ffi::c_int; fn remove_point_by_index(&mut self, id: usize) -> bool; fn remove_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; - fn remove_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> core::ffi::c_int; fn remove_all_points(&mut self) -> (); fn add_segment( &mut self, @@ -10561,56 +5162,6 @@ pub trait VtkPiecewiseFunction: VtkDataObject { y2: core::ffi::c_double, ) -> (); fn get_value(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn get_node_value( - &mut self, - index: core::ffi::c_int, - val: core::ffi::c_double, - ) -> core::ffi::c_int; - fn set_node_value( - &mut self, - index: core::ffi::c_int, - val: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_data_pointer(&mut self) -> *mut core::ffi::c_double; - fn fill_from_data_pointer( - &mut self, - p0: core::ffi::c_int, - p1: core::ffi::c_double, - ) -> (); - fn get_range(&mut self) -> *mut core::ffi::c_double; - fn get_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> (); - fn get_range(&mut self, _arg: core::ffi::c_double) -> (); - fn adjust_range(&mut self, range: core::ffi::c_double) -> core::ffi::c_int; - fn get_table( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - size: core::ffi::c_int, - table: core::ffi::c_float, - stride: core::ffi::c_int, - logIncrements: core::ffi::c_int, - ) -> (); - fn get_table( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - size: core::ffi::c_int, - table: core::ffi::c_double, - stride: core::ffi::c_int, - logIncrements: core::ffi::c_int, - ) -> (); - fn build_function_from_table( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - size: core::ffi::c_int, - table: core::ffi::c_double, - stride: core::ffi::c_int, - ) -> (); fn set_clamping(&mut self, _arg: core::ffi::c_int) -> (); fn get_clamping(&mut self) -> core::ffi::c_int; fn clamping_on(&mut self) -> (); @@ -10619,26 +5170,21 @@ pub trait VtkPiecewiseFunction: VtkDataObject { fn get_use_log_scale(&mut self) -> bool; fn use_log_scale_on(&mut self) -> (); fn use_log_scale_off(&mut self) -> (); - fn get_type(&mut self) -> *const core::ffi::c_char; + fn get_type(&mut self) -> &str; fn get_first_non_zero_value(&mut self) -> core::ffi::c_double; fn initialize(&mut self) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn set_allow_duplicate_scalars(&mut self, _arg: core::ffi::c_int) -> (); fn get_allow_duplicate_scalars(&mut self) -> core::ffi::c_int; fn allow_duplicate_scalars_on(&mut self) -> (); fn allow_duplicate_scalars_off(&mut self) -> (); fn estimate_min_number_of_samples( &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, + x1: &core::ffi::c_double, + x2: &core::ffi::c_double, ) -> core::ffi::c_int; } -pub trait VtkPixel: VtkCell { +pub trait VtkPixel { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -10648,12 +5194,6 @@ pub trait VtkPixel: VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -10665,7 +5205,7 @@ pub trait VtkPixel: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -10677,295 +5217,48 @@ pub trait VtkPixel: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; - fn compute_bounding_sphere( - &mut self, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn compute_normal(&mut self, n: core::ffi::c_double) -> core::ffi::c_int; } pub trait VtkPixelExtent { - fn set_data(&mut self, ext: vtkPixelExtent) -> (); fn clear(&mut self) -> (); - fn get_data(&mut self) -> *mut core::ffi::c_int; - fn get_data(&mut self) -> *const core::ffi::c_int; - fn get_data_u(&mut self) -> *mut core::ffi::c_uint; - fn get_data_u(&mut self) -> *const core::ffi::c_uint; - fn get_start_index(&mut self, first: core::ffi::c_int) -> (); - fn get_start_index( - &mut self, - first: core::ffi::c_int, - origin: core::ffi::c_int, - ) -> (); - fn get_end_index(&mut self, last: core::ffi::c_int) -> (); fn empty(&mut self) -> core::ffi::c_int; - fn contains(&mut self, other: vtkPixelExtent) -> core::ffi::c_int; - fn contains(&mut self, i: core::ffi::c_int, j: core::ffi::c_int) -> core::ffi::c_int; - fn disjoint(&mut self, other: *mut core::ffi::c_void) -> core::ffi::c_int; fn size(&mut self) -> usize; fn grow(&mut self, n: core::ffi::c_int) -> (); - fn grow(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); fn grow_low(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); fn grow_high(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); fn shrink(&mut self, n: core::ffi::c_int) -> (); - fn shrink(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); fn shift(&mut self) -> (); - fn shift(&mut self, ext: vtkPixelExtent) -> (); - fn shift(&mut self, n: core::ffi::c_int) -> (); - fn shift(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); - fn split(&mut self, dir: core::ffi::c_int) -> *mut core::ffi::c_void; fn cell_to_node(&mut self) -> (); fn node_to_cell(&mut self) -> (); - fn size(&mut self, ext: vtkPixelExtent) -> usize; - fn grow( - &mut self, - inputExt: vtkPixelExtent, - n: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn grow( - &mut self, - inputExt: vtkPixelExtent, - problemDomain: vtkPixelExtent, - n: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn grow_low( - &mut self, - ext: vtkPixelExtent, - q: core::ffi::c_int, - n: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn grow_high( - &mut self, - ext: vtkPixelExtent, - q: core::ffi::c_int, - n: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn shrink( - &mut self, - inputExt: vtkPixelExtent, - problemDomain: vtkPixelExtent, - n: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn shrink( - &mut self, - inputExt: vtkPixelExtent, - n: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn node_to_cell(&mut self, inputExt: vtkPixelExtent) -> *mut core::ffi::c_void; - fn cell_to_node(&mut self, inputExt: vtkPixelExtent) -> *mut core::ffi::c_void; - fn shift(&mut self, ij: core::ffi::c_int, n: core::ffi::c_int) -> (); - fn shift(&mut self, ij: core::ffi::c_int, n: core::ffi::c_int) -> (); -} -pub trait VtkPixelTransfer { - fn blit( - &mut self, - ext: vtkPixelExtent, - nComps: core::ffi::c_int, - srcType: core::ffi::c_int, - srcData: (), - destType: core::ffi::c_int, - destData: (), - ) -> core::ffi::c_int; - fn blit( - &mut self, - srcWhole: vtkPixelExtent, - srcSubset: vtkPixelExtent, - destWhole: vtkPixelExtent, - destSubset: vtkPixelExtent, - nSrcComps: core::ffi::c_int, - srcType: core::ffi::c_int, - srcData: (), - nDestComps: core::ffi::c_int, - destType: core::ffi::c_int, - destData: (), - ) -> core::ffi::c_int; } -pub trait VtkPlane: VtkImplicitFunction { +pub trait VtkPixelTransfer {} +pub trait VtkPlane { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); fn set_normal( &mut self, _arg1: core::ffi::c_double, _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_normal(&mut self, _arg: core::ffi::c_double) -> (); - fn get_normal(&mut self) -> *mut core::ffi::c_double; - fn get_normal(&mut self, data: core::ffi::c_double) -> (); fn set_origin( &mut self, _arg1: core::ffi::c_double, _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_origin(&mut self, _arg: core::ffi::c_double) -> (); - fn get_origin(&mut self) -> *mut core::ffi::c_double; - fn get_origin(&mut self, data: core::ffi::c_double) -> (); fn push(&mut self, distance: core::ffi::c_double) -> (); - fn project_point( - &mut self, - x: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - xproj: core::ffi::c_double, - ) -> (); - fn project_point( - &mut self, - x: core::ffi::c_double, - xproj: core::ffi::c_double, - ) -> (); - fn project_vector( - &mut self, - v: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - vproj: core::ffi::c_double, - ) -> (); - fn project_vector( - &mut self, - v: core::ffi::c_double, - vproj: core::ffi::c_double, - ) -> (); - fn generalized_project_point( - &mut self, - x: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - xproj: core::ffi::c_double, - ) -> (); - fn generalized_project_point( - &mut self, - x: core::ffi::c_double, - xproj: core::ffi::c_double, - ) -> (); - fn evaluate( - &mut self, - normal: core::ffi::c_double, - origin: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - fn distance_to_plane( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - p0: core::ffi::c_double, - ) -> core::ffi::c_double; - fn distance_to_plane(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - n: core::ffi::c_double, - p0: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersect_with_finite_plane( - &mut self, - n: core::ffi::c_double, - o: core::ffi::c_double, - pOrigin: core::ffi::c_double, - px: core::ffi::c_double, - py: core::ffi::c_double, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersect_with_finite_plane( - &mut self, - pOrigin: core::ffi::c_double, - px: core::ffi::c_double, - py: core::ffi::c_double, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - ) -> core::ffi::c_int; - fn compute_best_fitting_plane( - &mut self, - pts: *mut core::ffi::c_void, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - ) -> bool; } pub trait VtkPlaneCollection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -10974,25 +5267,16 @@ pub trait VtkPlaneCollection { fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_next_item(&mut self) -> *mut core::ffi::c_void; fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_next_plane(&mut self, cookie: ()) -> *mut core::ffi::c_void; fn get_number_of_items(&mut self) -> core::ffi::c_int; } -pub trait VtkPlanes: VtkImplicitFunction { +pub trait VtkPlanes { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); fn set_points(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_points(&mut self) -> *mut core::ffi::c_void; fn set_normals(&mut self, normals: *mut core::ffi::c_void) -> (); fn get_normals(&mut self) -> *mut core::ffi::c_void; - fn set_frustum_planes(&mut self, planes: core::ffi::c_double) -> (); - fn set_bounds(&mut self, bounds: core::ffi::c_double) -> (); fn set_bounds( &mut self, xmin: core::ffi::c_double, @@ -11004,44 +5288,28 @@ pub trait VtkPlanes: VtkImplicitFunction { ) -> (); fn get_number_of_planes(&mut self) -> core::ffi::c_int; fn get_plane(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_plane(&mut self, i: core::ffi::c_int, plane: *mut core::ffi::c_void) -> (); } -pub trait VtkPlanesIntersection: VtkPlanes + VtkImplicitFunction { +pub trait VtkPlanesIntersection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn set_region_vertices(&mut self, pts: *mut core::ffi::c_void) -> (); - fn set_region_vertices( - &mut self, - v: core::ffi::c_double, - nvertices: core::ffi::c_int, - ) -> (); fn get_number_of_region_vertices(&mut self) -> core::ffi::c_int; fn get_num_region_vertices(&mut self) -> core::ffi::c_int; - fn get_region_vertices( - &mut self, - v: core::ffi::c_double, - nvertices: core::ffi::c_int, - ) -> core::ffi::c_int; fn intersects_region(&mut self, R: *mut core::ffi::c_void) -> core::ffi::c_int; - fn polygon_intersects_b_box( - &mut self, - bounds: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn convert_3_d_cell( &mut self, cell: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } -pub trait VtkPointData: VtkDataSetAttributes + VtkFieldData { +pub trait VtkPointData { fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn null_point(&mut self, ptId: core::ffi::c_uchar) -> (); + fn null_point(&mut self, ptId: core::ffi::c_longlong) -> (); } -pub trait VtkPointLocator: VtkIncrementalPointLocator + VtkAbstractPointLocator + VtkLocator { +pub trait VtkPointLocator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -11051,69 +5319,16 @@ pub trait VtkPointLocator: VtkIncrementalPointLocator + VtkAbstractPointLocator _arg2: core::ffi::c_int, _arg3: core::ffi::c_int, ) -> (); - fn set_divisions(&mut self, _arg: core::ffi::c_int) -> (); - fn get_divisions(&mut self) -> *mut core::ffi::c_int; - fn get_divisions(&mut self, data: core::ffi::c_int) -> (); fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> (); fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int; fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int; fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int; - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - inputDataLength: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn init_point_insertion( - &mut self, - newPts: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - fn init_point_insertion( - &mut self, - newPts: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - estNumPts: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn insert_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> (); - fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; fn is_inserted_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn insert_unique_point( - &mut self, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn find_closest_inserted_point( - &mut self, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn find_distributed_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - M: core::ffi::c_int, - ) -> (); + ) -> core::ffi::c_longlong; fn find_distributed_points( &mut self, N: core::ffi::c_int, @@ -11123,17 +5338,6 @@ pub trait VtkPointLocator: VtkIncrementalPointLocator + VtkAbstractPointLocator result: *mut core::ffi::c_void, M: core::ffi::c_int, ) -> (); - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn get_points_in_bucket( - &mut self, - x: core::ffi::c_double, - ijk: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_points(&mut self) -> *mut core::ffi::c_void; fn initialize(&mut self) -> (); fn free_search_structure(&mut self) -> (); @@ -11144,7 +5348,7 @@ pub trait VtkPointLocator: VtkIncrementalPointLocator + VtkAbstractPointLocator pd: *mut core::ffi::c_void, ) -> (); } -pub trait VtkPointSet: VtkDataSet + VtkDataObject { +pub trait VtkPointSet { fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -11155,46 +5359,21 @@ pub trait VtkPointSet: VtkDataSet + VtkDataObject { fn editable_off(&mut self) -> (); fn initialize(&mut self) -> (); fn copy_structure(&mut self, pd: *mut core::ffi::c_void) -> (); - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; - fn get_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> (); - fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; fn get_max_cell_size(&mut self) -> core::ffi::c_int; - fn get_cell(&mut self, p0: core::ffi::c_uchar) -> *mut core::ffi::c_void; + fn get_cell(&mut self, p0: core::ffi::c_longlong) -> *mut core::ffi::c_void; fn get_cell_points( &mut self, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, idList: *mut core::ffi::c_void, ) -> (); fn get_point_cells( &mut self, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, idList: *mut core::ffi::c_void, ) -> (); - fn get_cell(&mut self, p0: core::ffi::c_uchar, cell: *mut core::ffi::c_void) -> (); - fn get_cell_type(&mut self, p0: core::ffi::c_uchar) -> core::ffi::c_int; - fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double; + fn get_cell_type(&mut self, p0: core::ffi::c_longlong) -> core::ffi::c_int; fn build_point_locator(&mut self) -> (); fn build_locator(&mut self) -> (); fn build_cell_locator(&mut self) -> (); @@ -11209,18 +5388,13 @@ pub trait VtkPointSet: VtkDataSet + VtkDataObject { fn get_points(&mut self) -> *mut core::ffi::c_void; fn register(&mut self, o: *mut core::ffi::c_void) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } -pub trait VtkPointSetCellIterator: VtkCellIterator { +pub trait VtkPointSetCellIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn is_done_with_traversal(&mut self) -> bool; - fn get_cell_id(&mut self) -> core::ffi::c_uchar; + fn get_cell_id(&mut self) -> core::ffi::c_longlong; } pub trait VtkPointsProjectedHull { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -11230,106 +5404,29 @@ pub trait VtkPointsProjectedHull { &mut self, R: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn rectangle_intersection_x( - &mut self, - ymin: core::ffi::c_float, - ymax: core::ffi::c_float, - zmin: core::ffi::c_float, - zmax: core::ffi::c_float, - ) -> core::ffi::c_int; - fn rectangle_intersection_x( - &mut self, - ymin: core::ffi::c_double, - ymax: core::ffi::c_double, - zmin: core::ffi::c_double, - zmax: core::ffi::c_double, - ) -> core::ffi::c_int; fn rectangle_intersection_y( &mut self, R: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn rectangle_intersection_y( - &mut self, - zmin: core::ffi::c_float, - zmax: core::ffi::c_float, - xmin: core::ffi::c_float, - xmax: core::ffi::c_float, - ) -> core::ffi::c_int; - fn rectangle_intersection_y( - &mut self, - zmin: core::ffi::c_double, - zmax: core::ffi::c_double, - xmin: core::ffi::c_double, - xmax: core::ffi::c_double, - ) -> core::ffi::c_int; fn rectangle_intersection_z( &mut self, R: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn rectangle_intersection_z( - &mut self, - xmin: core::ffi::c_float, - xmax: core::ffi::c_float, - ymin: core::ffi::c_float, - ymax: core::ffi::c_float, - ) -> core::ffi::c_int; - fn rectangle_intersection_z( - &mut self, - xmin: core::ffi::c_double, - xmax: core::ffi::c_double, - ymin: core::ffi::c_double, - ymax: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_ccw_hull_x( - &mut self, - pts: core::ffi::c_float, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_ccw_hull_x( - &mut self, - pts: core::ffi::c_double, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_ccw_hull_y( - &mut self, - pts: core::ffi::c_float, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_ccw_hull_y( - &mut self, - pts: core::ffi::c_double, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_ccw_hull_z( - &mut self, - pts: core::ffi::c_float, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_ccw_hull_z( - &mut self, - pts: core::ffi::c_double, - len: core::ffi::c_int, - ) -> core::ffi::c_int; fn get_size_ccw_hull_x(&mut self) -> core::ffi::c_int; fn get_size_ccw_hull_y(&mut self) -> core::ffi::c_int; fn get_size_ccw_hull_z(&mut self) -> core::ffi::c_int; fn update(&mut self) -> (); } -pub trait VtkPolyData: VtkPointSet + VtkDataSet + VtkDataObject { +pub trait VtkPolyData { fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> (); - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; fn copy_cells( &mut self, pd: *mut core::ffi::c_void, @@ -11338,22 +5435,21 @@ pub trait VtkPolyData: VtkPointSet + VtkDataSet + VtkDataObject { ) -> (); fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> (); fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> (); fn compute_cells_bounds(&mut self) -> (); - fn get_cells_bounds(&mut self, bounds: core::ffi::c_double) -> (); fn squeeze(&mut self) -> (); fn get_max_cell_size(&mut self) -> core::ffi::c_int; fn get_cell_id_relative_to_cell_array( &mut self, - cellId: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn set_verts(&mut self, v: *mut core::ffi::c_void) -> (); fn get_verts(&mut self) -> *mut core::ffi::c_void; fn set_lines(&mut self, l: *mut core::ffi::c_void) -> (); @@ -11362,41 +5458,19 @@ pub trait VtkPolyData: VtkPointSet + VtkDataSet + VtkDataObject { fn get_polys(&mut self) -> *mut core::ffi::c_void; fn set_strips(&mut self, s: *mut core::ffi::c_void) -> (); fn get_strips(&mut self) -> *mut core::ffi::c_void; - fn get_number_of_verts(&mut self) -> core::ffi::c_uchar; - fn get_number_of_lines(&mut self) -> core::ffi::c_uchar; - fn get_number_of_polys(&mut self) -> core::ffi::c_uchar; - fn get_number_of_strips(&mut self) -> core::ffi::c_uchar; + fn get_number_of_verts(&mut self) -> core::ffi::c_longlong; + fn get_number_of_lines(&mut self) -> core::ffi::c_longlong; + fn get_number_of_polys(&mut self) -> core::ffi::c_longlong; + fn get_number_of_strips(&mut self) -> core::ffi::c_longlong; fn allocate_estimate( &mut self, - numCells: core::ffi::c_uchar, - maxCellSize: core::ffi::c_uchar, - ) -> bool; - fn allocate_estimate( - &mut self, - numVerts: core::ffi::c_uchar, - maxVertSize: core::ffi::c_uchar, - numLines: core::ffi::c_uchar, - maxLineSize: core::ffi::c_uchar, - numPolys: core::ffi::c_uchar, - maxPolySize: core::ffi::c_uchar, - numStrips: core::ffi::c_uchar, - maxStripSize: core::ffi::c_uchar, - ) -> bool; - fn allocate_exact( - &mut self, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, ) -> bool; fn allocate_exact( &mut self, - numVerts: core::ffi::c_uchar, - vertConnSize: core::ffi::c_uchar, - numLines: core::ffi::c_uchar, - lineConnSize: core::ffi::c_uchar, - numPolys: core::ffi::c_uchar, - polyConnSize: core::ffi::c_uchar, - numStrips: core::ffi::c_uchar, - stripConnSize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool; fn allocate_copy(&mut self, pd: *mut core::ffi::c_void) -> bool; fn allocate_proportional( @@ -11406,57 +5480,27 @@ pub trait VtkPolyData: VtkPointSet + VtkDataSet + VtkDataObject { ) -> bool; fn allocate( &mut self, - numCells: core::ffi::c_uchar, - extSize: core::ffi::c_int, - ) -> (); - fn allocate( - &mut self, - inPolyData: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, extSize: core::ffi::c_int, ) -> (); - fn insert_next_cell( - &mut self, - type_: core::ffi::c_int, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; fn insert_next_cell( &mut self, type_: core::ffi::c_int, pts: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; fn reset(&mut self) -> (); fn build_cells(&mut self) -> (); fn need_to_build_cells(&mut self) -> bool; fn build_links(&mut self, initialSize: core::ffi::c_int) -> (); fn delete_cells(&mut self) -> (); fn delete_links(&mut self) -> (); - fn get_point_cells( - &mut self, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_uchar, - cells: core::ffi::c_uchar, - ) -> (); - fn get_point_cells( - &mut self, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_ushort, - cells: core::ffi::c_uchar, - ) -> (); fn get_cell_edge_neighbors( &mut self, - cellId: core::ffi::c_uchar, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> (); - fn get_cell_points( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; fn is_triangle( &mut self, v1: core::ffi::c_int, @@ -11465,71 +5509,48 @@ pub trait VtkPolyData: VtkPointSet + VtkDataSet + VtkDataObject { ) -> core::ffi::c_int; fn is_edge( &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, ) -> core::ffi::c_int; fn is_point_used_by_cell( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int; fn replace_cell( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ids: *mut core::ffi::c_void, ) -> (); - fn replace_cell( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> (); fn replace_cell_point( &mut self, - cellId: core::ffi::c_uchar, - oldPtId: core::ffi::c_uchar, - newPtId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + oldPtId: core::ffi::c_longlong, + newPtId: core::ffi::c_longlong, ) -> (); - fn reverse_cell(&mut self, cellId: core::ffi::c_uchar) -> (); - fn delete_point(&mut self, ptId: core::ffi::c_uchar) -> (); - fn delete_cell(&mut self, cellId: core::ffi::c_uchar) -> (); + fn reverse_cell(&mut self, cellId: core::ffi::c_longlong) -> (); + fn delete_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn delete_cell(&mut self, cellId: core::ffi::c_longlong) -> (); fn remove_deleted_cells(&mut self) -> (); fn insert_next_linked_point( &mut self, numLinks: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn insert_next_linked_point( - &mut self, - x: core::ffi::c_double, - numLinks: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn insert_next_linked_cell( - &mut self, - type_: core::ffi::c_int, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn replace_linked_cell( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> (); - fn remove_cell_reference(&mut self, cellId: core::ffi::c_uchar) -> (); - fn add_cell_reference(&mut self, cellId: core::ffi::c_uchar) -> (); + ) -> core::ffi::c_longlong; + fn remove_cell_reference(&mut self, cellId: core::ffi::c_longlong) -> (); + fn add_cell_reference(&mut self, cellId: core::ffi::c_longlong) -> (); fn remove_reference_to_cell( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> (); fn add_reference_to_cell( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> (); fn resize_cell_list( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, size: core::ffi::c_int, ) -> (); fn initialize(&mut self) -> (); @@ -11538,33 +5559,13 @@ pub trait VtkPolyData: VtkPointSet + VtkDataSet + VtkDataObject { fn get_ghost_level(&mut self) -> core::ffi::c_int; fn remove_ghost_cells(&mut self) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_scalar_field_critical_index( &mut self, - pointId: core::ffi::c_uchar, + pointId: core::ffi::c_longlong, scalarField: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn get_scalar_field_critical_index( - &mut self, - pointId: core::ffi::c_uchar, - fieldId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_scalar_field_critical_index( - &mut self, - pointId: core::ffi::c_uchar, - fieldName: core::ffi::c_char, - ) -> core::ffi::c_int; fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong; fn get_m_time(&mut self) -> core::ffi::c_ulong; - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; } pub trait VtkPolyDataCollection { fn new(&mut self) -> *mut core::ffi::c_void; @@ -11572,9 +5573,8 @@ pub trait VtkPolyDataCollection { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn add_item(&mut self, pd: *mut core::ffi::c_void) -> (); fn get_next_item(&mut self) -> *mut core::ffi::c_void; - fn get_next_poly_data(&mut self, cookie: ()) -> *mut core::ffi::c_void; } -pub trait VtkPolyLine: VtkCell { +pub trait VtkPolyLine { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -11584,25 +5584,12 @@ pub trait VtkPolyLine: VtkCell { p1: *mut core::ffi::c_void, p2: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn generate_sliding_normals( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - firstNormal: core::ffi::c_double, - ) -> core::ffi::c_int; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_cell_dimension(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -11614,7 +5601,7 @@ pub trait VtkPolyLine: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -11626,70 +5613,26 @@ pub trait VtkPolyLine: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; } -pub trait VtkPolyPlane: VtkImplicitFunction { +pub trait VtkPolyPlane { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); fn set_poly_line(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_poly_line(&mut self) -> *mut core::ffi::c_void; fn get_m_time(&mut self) -> core::ffi::c_ulong; } -pub trait VtkPolyVertex: VtkCell { +pub trait VtkPolyVertex { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -11699,12 +5642,6 @@ pub trait VtkPolyVertex: VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -11716,7 +5653,7 @@ pub trait VtkPolyVertex: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -11728,56 +5665,18 @@ pub trait VtkPolyVertex: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; } -pub trait VtkPolygon: VtkCell { +pub trait VtkPolygon { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -11787,12 +5686,6 @@ pub trait VtkPolygon: VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -11804,7 +5697,7 @@ pub trait VtkPolygon: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -11816,131 +5709,18 @@ pub trait VtkPolygon: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn compute_area(&mut self) -> core::ffi::c_double; - fn interpolate_functions( - &mut self, - x: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> (); - fn compute_normal( - &mut self, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - n: core::ffi::c_double, - ) -> (); - fn compute_normal( - &mut self, - p: *mut core::ffi::c_void, - n: core::ffi::c_double, - ) -> (); - fn compute_normal( - &mut self, - ids: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - n: core::ffi::c_double, - ) -> (); - fn compute_normal( - &mut self, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); fn is_convex(&mut self) -> bool; - fn is_convex( - &mut self, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> bool; - fn is_convex( - &mut self, - ids: *mut core::ffi::c_void, - p: *mut core::ffi::c_void, - ) -> bool; - fn is_convex(&mut self, p: *mut core::ffi::c_void) -> bool; - fn compute_centroid( - &mut self, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - fn compute_centroid( - &mut self, - ids: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - fn compute_area( - &mut self, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - normal: core::ffi::c_double, - ) -> core::ffi::c_double; - fn parameterize_polygon( - &mut self, - p0: core::ffi::c_double, - p10: core::ffi::c_double, - l10: core::ffi::c_double, - p20: core::ffi::c_double, - l20: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int; - fn point_in_polygon( - &mut self, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int; - fn triangulate(&mut self, outTris: *mut core::ffi::c_void) -> core::ffi::c_int; fn non_degenerate_triangulate( &mut self, outTris: *mut core::ffi::c_void, @@ -11950,33 +5730,6 @@ pub trait VtkPolygon: VtkCell { outTris: *mut core::ffi::c_void, tol: core::ffi::c_double, ) -> core::ffi::c_int; - fn distance_to_polygon( - &mut self, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - closest: core::ffi::c_double, - ) -> core::ffi::c_double; - fn intersect_polygon_with_polygon( - &mut self, - npts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - npts2: core::ffi::c_int, - pts2: core::ffi::c_double, - bounds2: core::ffi::c_double, - tol: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersect_convex_2_d_cells( - &mut self, - cell1: *mut core::ffi::c_void, - cell2: *mut core::ffi::c_void, - tol: core::ffi::c_double, - p0: core::ffi::c_double, - p1: core::ffi::c_double, - ) -> core::ffi::c_int; fn get_use_mvc_interpolation(&mut self) -> bool; fn set_use_mvc_interpolation(&mut self, _arg: bool) -> (); fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> (); @@ -11984,66 +5737,16 @@ pub trait VtkPolygon: VtkCell { fn get_tolerance_max_value(&mut self) -> core::ffi::c_double; fn get_tolerance(&mut self) -> core::ffi::c_double; fn ear_cut_triangulation(&mut self, measure: core::ffi::c_int) -> core::ffi::c_int; - fn ear_cut_triangulation( - &mut self, - outTris: *mut core::ffi::c_void, - measure: core::ffi::c_int, - ) -> core::ffi::c_int; - fn unbiased_ear_cut_triangulation( - &mut self, - seed: core::ffi::c_int, - measure: core::ffi::c_int, - ) -> core::ffi::c_int; fn unbiased_ear_cut_triangulation( &mut self, seed: core::ffi::c_int, - outTris: *mut core::ffi::c_void, measure: core::ffi::c_int, ) -> core::ffi::c_int; } -pub trait VtkPolyhedron: VtkCell3D + VtkCell { +pub trait VtkPolyhedron { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; - fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double; fn get_cell_type(&mut self) -> core::ffi::c_int; fn requires_initialization(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; @@ -12061,7 +5764,7 @@ pub trait VtkPolyhedron: VtkCell3D + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -12073,240 +5776,38 @@ pub trait VtkPolyhedron: VtkCell3D + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn triangulate( + fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; fn is_primary_cell(&mut self) -> core::ffi::c_int; - fn interpolate_functions( - &mut self, - x: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - x: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); fn requires_explicit_face_representation(&mut self) -> core::ffi::c_int; - fn is_inside( - &mut self, - x: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_int; fn is_convex(&mut self) -> bool; fn get_poly_data(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkPyramid: VtkCell3D + VtkCell { +pub trait VtkPyramid { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; } -pub trait VtkQuad: VtkCell { +pub trait VtkQuad { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -12316,12 +5817,6 @@ pub trait VtkQuad: VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -12333,53 +5828,15 @@ pub trait VtkQuad: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; fn clip( &mut self, value: core::ffi::c_double, @@ -12389,36 +5846,12 @@ pub trait VtkQuad: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; } -pub trait VtkQuadraticEdge: VtkNonLinearCell + VtkCell { +pub trait VtkQuadraticEdge { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -12428,12 +5861,6 @@ pub trait VtkQuadraticEdge: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -12445,39 +5872,15 @@ pub trait VtkQuadraticEdge: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -12487,46 +5890,12 @@ pub trait VtkQuadraticEdge: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkQuadraticHexahedron: VtkNonLinearCell + VtkCell { +pub trait VtkQuadraticHexahedron { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -12536,12 +5905,6 @@ pub trait VtkQuadraticHexahedron: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -12553,39 +5916,15 @@ pub trait VtkQuadraticHexahedron: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -12595,56 +5934,12 @@ pub trait VtkQuadraticHexahedron: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkQuadraticLinearQuad: VtkNonLinearCell + VtkCell { +pub trait VtkQuadraticLinearQuad { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -12654,12 +5949,6 @@ pub trait VtkQuadraticLinearQuad: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -12671,39 +5960,15 @@ pub trait VtkQuadraticLinearQuad: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -12713,47 +5978,12 @@ pub trait VtkQuadraticLinearQuad: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array(&mut self, edgeId: core::ffi::c_uchar) -> *mut core::ffi::c_int; } -pub trait VtkQuadraticLinearWedge: VtkNonLinearCell + VtkCell { +pub trait VtkQuadraticLinearWedge { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -12763,12 +5993,6 @@ pub trait VtkQuadraticLinearWedge: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -12780,39 +6004,15 @@ pub trait VtkQuadraticLinearWedge: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -12822,60 +6022,12 @@ pub trait VtkQuadraticLinearWedge: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkQuadraticPolygon: VtkNonLinearCell + VtkCell { +pub trait VtkQuadraticPolygon { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -12885,12 +6037,6 @@ pub trait VtkQuadraticPolygon: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -12902,7 +6048,7 @@ pub trait VtkQuadraticPolygon: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); fn clip( @@ -12914,114 +6060,19 @@ pub trait VtkQuadraticPolygon: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn interpolate_functions( - &mut self, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn compute_centroid( - &mut self, - ids: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> (); - fn parameterize_polygon( - &mut self, - p0: core::ffi::c_double, - p10: core::ffi::c_double, - l10: core::ffi::c_double, - p20: core::ffi::c_double, - l20: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int; - fn point_in_polygon( - &mut self, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int; fn triangulate(&mut self, outTris: *mut core::ffi::c_void) -> core::ffi::c_int; - fn triangulate( - &mut self, - index: core::ffi::c_int, - ptIds: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn non_degenerate_triangulate( &mut self, outTris: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn distance_to_polygon( - &mut self, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - closest: core::ffi::c_double, - ) -> core::ffi::c_double; - fn intersect_polygon_with_polygon( - &mut self, - npts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - npts2: core::ffi::c_int, - pts2: core::ffi::c_double, - bounds2: core::ffi::c_double, - tol: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersect_convex_2_d_cells( - &mut self, - cell1: *mut core::ffi::c_void, - cell2: *mut core::ffi::c_void, - tol: core::ffi::c_double, - p0: core::ffi::c_double, - p1: core::ffi::c_double, - ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn get_use_mvc_interpolation(&mut self) -> bool; fn set_use_mvc_interpolation(&mut self, _arg: bool) -> (); } -pub trait VtkQuadraticPyramid: VtkNonLinearCell + VtkCell { +pub trait VtkQuadraticPyramid { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -13031,12 +6082,6 @@ pub trait VtkQuadraticPyramid: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -13048,39 +6093,15 @@ pub trait VtkQuadraticPyramid: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -13090,60 +6111,12 @@ pub trait VtkQuadraticPyramid: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkQuadraticQuad: VtkNonLinearCell + VtkCell { +pub trait VtkQuadraticQuad { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -13153,12 +6126,6 @@ pub trait VtkQuadraticQuad: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -13170,39 +6137,15 @@ pub trait VtkQuadraticQuad: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -13212,46 +6155,12 @@ pub trait VtkQuadraticQuad: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkQuadraticTetra: VtkNonLinearCell + VtkCell { +pub trait VtkQuadraticTetra { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -13261,12 +6170,6 @@ pub trait VtkQuadraticTetra: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -13278,39 +6181,15 @@ pub trait VtkQuadraticTetra: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -13320,64 +6199,12 @@ pub trait VtkQuadraticTetra: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkQuadraticTriangle: VtkNonLinearCell + VtkCell { +pub trait VtkQuadraticTriangle { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -13387,12 +6214,6 @@ pub trait VtkQuadraticTriangle: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -13404,39 +6225,15 @@ pub trait VtkQuadraticTriangle: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -13446,50 +6243,12 @@ pub trait VtkQuadraticTriangle: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkQuadraticWedge: VtkNonLinearCell + VtkCell { +pub trait VtkQuadraticWedge { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -13499,12 +6258,6 @@ pub trait VtkQuadraticWedge: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -13516,39 +6269,15 @@ pub trait VtkQuadraticWedge: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -13558,58 +6287,10 @@ pub trait VtkQuadraticWedge: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } pub trait VtkQuadratureSchemeDefinition { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -13617,47 +6298,18 @@ pub trait VtkQuadratureSchemeDefinition { fn dictionary(&mut self) -> *mut core::ffi::c_void; fn quadrature_offset_array_name(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn deep_copy(&mut self, other: vtkQuadratureSchemeDefinition) -> core::ffi::c_int; fn save_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int; fn restore_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int; fn clear(&mut self) -> (); - fn initialize( - &mut self, - cellType: core::ffi::c_int, - numberOfNodes: core::ffi::c_int, - numberOfQuadraturePoints: core::ffi::c_int, - shapeFunctionWeights: core::ffi::c_double, - ) -> (); - fn initialize( - &mut self, - cellType: core::ffi::c_int, - numberOfNodes: core::ffi::c_int, - numberOfQuadraturePoints: core::ffi::c_int, - shapeFunctionWeights: core::ffi::c_double, - quadratureWeights: core::ffi::c_double, - ) -> (); fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_quadrature_key(&mut self) -> core::ffi::c_int; fn get_number_of_nodes(&mut self) -> core::ffi::c_int; fn get_number_of_quadrature_points(&mut self) -> core::ffi::c_int; - fn get_shape_function_weights(&mut self) -> *const core::ffi::c_double; - fn get_shape_function_weights( - &mut self, - quadraturePointId: core::ffi::c_int, - ) -> *const core::ffi::c_double; - fn get_quadrature_weights(&mut self) -> *const core::ffi::c_double; } -pub trait VtkQuadric: VtkImplicitFunction { +pub trait VtkQuadric { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); - fn set_coefficients(&mut self, a: core::ffi::c_double) -> (); fn set_coefficients( &mut self, a0: core::ffi::c_double, @@ -13671,110 +6323,81 @@ pub trait VtkQuadric: VtkImplicitFunction { a8: core::ffi::c_double, a9: core::ffi::c_double, ) -> (); - fn get_coefficients(&mut self) -> *mut core::ffi::c_double; - fn get_coefficients(&mut self, data: core::ffi::c_double) -> (); -} -pub trait VtkRect: VtkVector { - fn set(&mut self, x: T, y: T, width: T, height: T) -> (); - fn set_x(&mut self, x: T) -> (); - fn get_x(&mut self) -> T; - fn set_y(&mut self, y: T) -> (); - fn get_y(&mut self) -> T; - fn set_width(&mut self, width: T) -> (); - fn get_width(&mut self) -> T; - fn set_height(&mut self, height: T) -> (); - fn get_height(&mut self) -> T; - fn get_left(&mut self) -> T; - fn get_right(&mut self) -> *mut core::ffi::c_void; - fn get_top(&mut self) -> *mut core::ffi::c_void; - fn get_bottom(&mut self) -> T; - fn add_point(&mut self, point: T) -> (); - fn add_point(&mut self, x: *mut core::ffi::c_void, y: *mut core::ffi::c_void) -> (); - fn move_to(&mut self, x: *mut core::ffi::c_void, y: *mut core::ffi::c_void) -> (); - fn get_center(&mut self) -> *mut core::ffi::c_void; -} -pub trait VtkRectd: VtkRect + VtkVector { +} +pub trait VtkRect {} +pub trait VtkRectd { fn set( &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - width: core::ffi::c_double, - height: core::ffi::c_double, + x: &core::ffi::c_double, + y: &core::ffi::c_double, + width: &core::ffi::c_double, + height: &core::ffi::c_double, ) -> (); - fn set_x(&mut self, x: core::ffi::c_double) -> (); + fn set_x(&mut self, x: &core::ffi::c_double) -> (); fn get_x(&mut self) -> core::ffi::c_double; - fn set_y(&mut self, y: core::ffi::c_double) -> (); + fn set_y(&mut self, y: &core::ffi::c_double) -> (); fn get_y(&mut self) -> core::ffi::c_double; - fn set_width(&mut self, width: core::ffi::c_double) -> (); + fn set_width(&mut self, width: &core::ffi::c_double) -> (); fn get_width(&mut self) -> core::ffi::c_double; - fn set_height(&mut self, height: core::ffi::c_double) -> (); + fn set_height(&mut self, height: &core::ffi::c_double) -> (); fn get_height(&mut self) -> core::ffi::c_double; fn get_left(&mut self) -> core::ffi::c_double; fn get_right(&mut self) -> core::ffi::c_double; fn get_top(&mut self) -> core::ffi::c_double; fn get_bottom(&mut self) -> core::ffi::c_double; - fn add_point(&mut self, point: core::ffi::c_double) -> (); fn add_point(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); fn move_to(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); fn squared_norm(&mut self) -> core::ffi::c_double; - fn get_data(&mut self) -> *mut core::ffi::c_double; - fn get_data(&mut self) -> *const core::ffi::c_double; } -pub trait VtkRectf: VtkRect + VtkVector { +pub trait VtkRectf { fn set( &mut self, - x: core::ffi::c_float, - y: core::ffi::c_float, - width: core::ffi::c_float, - height: core::ffi::c_float, + x: &core::ffi::c_float, + y: &core::ffi::c_float, + width: &core::ffi::c_float, + height: &core::ffi::c_float, ) -> (); - fn set_x(&mut self, x: core::ffi::c_float) -> (); + fn set_x(&mut self, x: &core::ffi::c_float) -> (); fn get_x(&mut self) -> core::ffi::c_float; - fn set_y(&mut self, y: core::ffi::c_float) -> (); + fn set_y(&mut self, y: &core::ffi::c_float) -> (); fn get_y(&mut self) -> core::ffi::c_float; - fn set_width(&mut self, width: core::ffi::c_float) -> (); + fn set_width(&mut self, width: &core::ffi::c_float) -> (); fn get_width(&mut self) -> core::ffi::c_float; - fn set_height(&mut self, height: core::ffi::c_float) -> (); + fn set_height(&mut self, height: &core::ffi::c_float) -> (); fn get_height(&mut self) -> core::ffi::c_float; fn get_left(&mut self) -> core::ffi::c_float; fn get_right(&mut self) -> core::ffi::c_float; fn get_top(&mut self) -> core::ffi::c_float; fn get_bottom(&mut self) -> core::ffi::c_float; - fn add_point(&mut self, point: core::ffi::c_float) -> (); fn add_point(&mut self, x: core::ffi::c_float, y: core::ffi::c_float) -> (); fn move_to(&mut self, x: core::ffi::c_float, y: core::ffi::c_float) -> (); fn squared_norm(&mut self) -> core::ffi::c_float; - fn get_data(&mut self) -> *mut core::ffi::c_float; - fn get_data(&mut self) -> *const core::ffi::c_float; } -pub trait VtkRecti: VtkRect + VtkVector { +pub trait VtkRecti { fn set( &mut self, - x: core::ffi::c_int, - y: core::ffi::c_int, - width: core::ffi::c_int, - height: core::ffi::c_int, + x: &core::ffi::c_int, + y: &core::ffi::c_int, + width: &core::ffi::c_int, + height: &core::ffi::c_int, ) -> (); - fn set_x(&mut self, x: core::ffi::c_int) -> (); + fn set_x(&mut self, x: &core::ffi::c_int) -> (); fn get_x(&mut self) -> core::ffi::c_int; - fn set_y(&mut self, y: core::ffi::c_int) -> (); + fn set_y(&mut self, y: &core::ffi::c_int) -> (); fn get_y(&mut self) -> core::ffi::c_int; - fn set_width(&mut self, width: core::ffi::c_int) -> (); + fn set_width(&mut self, width: &core::ffi::c_int) -> (); fn get_width(&mut self) -> core::ffi::c_int; - fn set_height(&mut self, height: core::ffi::c_int) -> (); + fn set_height(&mut self, height: &core::ffi::c_int) -> (); fn get_height(&mut self) -> core::ffi::c_int; fn get_left(&mut self) -> core::ffi::c_int; fn get_right(&mut self) -> core::ffi::c_int; fn get_top(&mut self) -> core::ffi::c_int; fn get_bottom(&mut self) -> core::ffi::c_int; - fn add_point(&mut self, point: core::ffi::c_int) -> (); fn add_point(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); fn move_to(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); fn squared_norm(&mut self) -> core::ffi::c_int; - fn get_data(&mut self) -> *mut core::ffi::c_int; - fn get_data(&mut self) -> *const core::ffi::c_int; } -pub trait VtkRectilinearGrid: VtkDataSet + VtkDataObject { +pub trait VtkRectilinearGrid { fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -13782,61 +6405,25 @@ pub trait VtkRectilinearGrid: VtkDataSet + VtkDataObject { fn get_data_object_type(&mut self) -> core::ffi::c_int; fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); fn initialize(&mut self) -> (); - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar; - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; - fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double; - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> (); - fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> (); fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> (); fn get_max_cell_size(&mut self) -> core::ffi::c_int; - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - seedLoc: core::ffi::c_int, - ) -> (); - fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; fn has_any_blank_points(&mut self) -> bool; fn has_any_blank_cells(&mut self) -> bool; - fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> (); fn get_points(&mut self, pnts: *mut core::ffi::c_void) -> (); fn set_dimensions( &mut self, @@ -13844,32 +6431,13 @@ pub trait VtkRectilinearGrid: VtkDataSet + VtkDataObject { j: core::ffi::c_int, k: core::ffi::c_int, ) -> (); - fn set_dimensions(&mut self, dim: core::ffi::c_int) -> (); - fn get_dimensions(&mut self) -> *mut core::ffi::c_int; - fn get_dimensions(&mut self, data: core::ffi::c_int) -> (); fn get_data_dimension(&mut self) -> core::ffi::c_int; - fn compute_structured_coordinates( - &mut self, - x: core::ffi::c_double, - ijk: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn compute_point_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar; - fn compute_cell_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar; - fn get_point( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - p: core::ffi::c_double, - ) -> (); fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_x_coordinates(&mut self) -> *mut core::ffi::c_void; fn set_y_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_y_coordinates(&mut self) -> *mut core::ffi::c_void; fn set_z_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_z_coordinates(&mut self) -> *mut core::ffi::c_void; - fn set_extent(&mut self, extent: core::ffi::c_int) -> (); fn set_extent( &mut self, xMin: core::ffi::c_int, @@ -13879,25 +6447,8 @@ pub trait VtkRectilinearGrid: VtkDataSet + VtkDataObject { zMin: core::ffi::c_int, zMax: core::ffi::c_int, ) -> (); - fn get_extent(&mut self) -> *mut core::ffi::c_int; - fn get_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> (); - fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); fn get_extent_type(&mut self) -> core::ffi::c_int; - fn crop(&mut self, updateExtent: core::ffi::c_int) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn set_scalar_type( &mut self, p0: core::ffi::c_int, @@ -13905,8 +6456,7 @@ pub trait VtkRectilinearGrid: VtkDataSet + VtkDataObject { ) -> (); fn get_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> core::ffi::c_int; fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool; - fn get_scalar_type(&mut self) -> core::ffi::c_int; - fn get_scalar_type_as_string(&mut self) -> *const core::ffi::c_char; + fn get_scalar_type_as_string(&mut self) -> &str; fn set_number_of_scalar_components( &mut self, n: core::ffi::c_int, @@ -13920,9 +6470,8 @@ pub trait VtkRectilinearGrid: VtkDataSet + VtkDataObject { &mut self, meta_data: *mut core::ffi::c_void, ) -> bool; - fn get_number_of_scalar_components(&mut self) -> core::ffi::c_int; } -pub trait VtkReebGraph: VtkMutableDirectedGraph + VtkDirectedGraph + VtkGraph + VtkDataObject { +pub trait VtkReebGraph { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -13931,54 +6480,29 @@ pub trait VtkReebGraph: VtkMutableDirectedGraph + VtkDirectedGraph + VtkGraph + mesh: *mut core::ffi::c_void, scalarField: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn build( + fn stream_triangle( &mut self, - mesh: *mut core::ffi::c_void, - scalarField: *mut core::ffi::c_void, + vertex0Id: core::ffi::c_longlong, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_longlong, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_longlong, + scalar2: core::ffi::c_double, ) -> core::ffi::c_int; - fn build( + fn stream_tetrahedron( &mut self, - mesh: *mut core::ffi::c_void, - scalarFieldId: core::ffi::c_uchar, + vertex0Id: core::ffi::c_longlong, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_longlong, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_longlong, + scalar2: core::ffi::c_double, + vertex3Id: core::ffi::c_longlong, + scalar3: core::ffi::c_double, ) -> core::ffi::c_int; - fn build( - &mut self, - mesh: *mut core::ffi::c_void, - scalarFieldId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn build( - &mut self, - mesh: *mut core::ffi::c_void, - scalarFieldName: core::ffi::c_char, - ) -> core::ffi::c_int; - fn build( - &mut self, - mesh: *mut core::ffi::c_void, - scalarFieldName: core::ffi::c_char, - ) -> core::ffi::c_int; - fn stream_triangle( - &mut self, - vertex0Id: core::ffi::c_uchar, - scalar0: core::ffi::c_double, - vertex1Id: core::ffi::c_uchar, - scalar1: core::ffi::c_double, - vertex2Id: core::ffi::c_uchar, - scalar2: core::ffi::c_double, - ) -> core::ffi::c_int; - fn stream_tetrahedron( - &mut self, - vertex0Id: core::ffi::c_uchar, - scalar0: core::ffi::c_double, - vertex1Id: core::ffi::c_uchar, - scalar1: core::ffi::c_double, - vertex2Id: core::ffi::c_uchar, - scalar2: core::ffi::c_double, - vertex3Id: core::ffi::c_uchar, - scalar3: core::ffi::c_double, - ) -> core::ffi::c_int; - fn close_stream(&mut self) -> (); - fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); - fn simplify( + fn close_stream(&mut self) -> (); + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn simplify( &mut self, simplificationThreshold: core::ffi::c_double, simplificationMetric: *mut core::ffi::c_void, @@ -13997,42 +6521,29 @@ pub trait VtkReebGraphSimplificationMetric { &mut self, mesh: *mut core::ffi::c_void, field: *mut core::ffi::c_void, - startCriticalPoint: core::ffi::c_uchar, + startCriticalPoint: core::ffi::c_longlong, vertexList: *mut core::ffi::c_void, - endCriticalPoint: core::ffi::c_uchar, + endCriticalPoint: core::ffi::c_longlong, ) -> core::ffi::c_double; } -pub trait VtkSelection: VtkDataObject { +pub trait VtkSelection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; fn get_number_of_nodes(&mut self) -> core::ffi::c_uint; fn get_node(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; - fn get_node(&mut self, name: &str) -> *mut core::ffi::c_void; - fn add_node(&mut self, p0: *mut core::ffi::c_void) -> &str; fn set_node(&mut self, name: &str, p1: *mut core::ffi::c_void) -> (); - fn get_node_name_at_index(&mut self, idx: core::ffi::c_uint) -> &str; fn remove_node(&mut self, idx: core::ffi::c_uint) -> (); - fn remove_node(&mut self, name: &str) -> (); - fn remove_node(&mut self, p0: *mut core::ffi::c_void) -> (); fn remove_all_nodes(&mut self) -> (); fn set_expression(&mut self, _arg: &str) -> (); - fn get_expression(&mut self) -> &str; fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn union(&mut self, selection: *mut core::ffi::c_void) -> (); - fn union(&mut self, node: *mut core::ffi::c_void) -> (); fn subtract(&mut self, selection: *mut core::ffi::c_void) -> (); - fn subtract(&mut self, node: *mut core::ffi::c_void) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; fn dump(&mut self) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } pub trait VtkSelectionNode { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -14050,21 +6561,12 @@ pub trait VtkSelectionNode { fn content_type(&mut self) -> *mut core::ffi::c_void; fn set_content_type(&mut self, type_: core::ffi::c_int) -> (); fn get_content_type(&mut self) -> core::ffi::c_int; - fn get_content_type_as_string( - &mut self, - type_: core::ffi::c_int, - ) -> *const core::ffi::c_char; + fn get_content_type_as_string(&mut self, type_: core::ffi::c_int) -> &str; fn field_type(&mut self) -> *mut core::ffi::c_void; fn set_field_type(&mut self, type_: core::ffi::c_int) -> (); fn get_field_type(&mut self) -> core::ffi::c_int; - fn get_field_type_as_string( - &mut self, - type_: core::ffi::c_int, - ) -> *const core::ffi::c_char; - fn get_field_type_from_string( - &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_int; + fn get_field_type_as_string(&mut self, type_: core::ffi::c_int) -> &str; + fn get_field_type_from_string(&mut self, type_: &str) -> core::ffi::c_int; fn convert_selection_field_to_attribute_type( &mut self, val: core::ffi::c_int, @@ -14073,8 +6575,7 @@ pub trait VtkSelectionNode { &mut self, val: core::ffi::c_int, ) -> core::ffi::c_int; - fn set_query_string(&mut self, _arg: core::ffi::c_char) -> (); - fn get_query_string(&mut self) -> *mut core::ffi::c_char; + fn set_query_string(&mut self, _arg: &str) -> (); fn epsilon(&mut self) -> *mut core::ffi::c_void; fn zbuffer_value(&mut self) -> *mut core::ffi::c_void; fn containing_cells(&mut self) -> *mut core::ffi::c_void; @@ -14101,7 +6602,7 @@ pub trait VtkSelectionNode { fullcompare: bool, ) -> bool; } -pub trait VtkSimpleCellTessellator: VtkGenericCellTessellator { +pub trait VtkSimpleCellTessellator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -14110,7 +6611,7 @@ pub trait VtkSimpleCellTessellator: VtkGenericCellTessellator { &mut self, cell: *mut core::ffi::c_void, att: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, points: *mut core::ffi::c_void, cellArray: *mut core::ffi::c_void, internalPd: *mut core::ffi::c_void, @@ -14144,57 +6645,22 @@ pub trait VtkSimpleCellTessellator: VtkGenericCellTessellator { maxLevel: core::ffi::c_int, ) -> (); } -pub trait VtkSmoothErrorMetric: VtkGenericSubdivisionErrorMetric { +pub trait VtkSmoothErrorMetric { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_angle_tolerance(&mut self) -> core::ffi::c_double; fn set_angle_tolerance(&mut self, value: core::ffi::c_double) -> (); - fn requires_edge_subdivision( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_error( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_double; } pub trait VtkSortFieldData { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn sort( - &mut self, - fd: *mut core::ffi::c_void, - arrayName: core::ffi::c_char, - k: core::ffi::c_int, - returnIndices: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar; - fn sort( - &mut self, - fd: *mut core::ffi::c_void, - arrayName: core::ffi::c_char, - k: core::ffi::c_int, - returnIndices: core::ffi::c_int, - dir: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar; } -pub trait VtkSphere: VtkImplicitFunction { +pub trait VtkSphere { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); fn get_radius(&mut self) -> core::ffi::c_double; fn set_center( @@ -14203,61 +6669,17 @@ pub trait VtkSphere: VtkImplicitFunction { _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_center(&mut self, _arg: core::ffi::c_double) -> (); - fn get_center(&mut self) -> *mut core::ffi::c_double; - fn get_center(&mut self, data: core::ffi::c_double) -> (); - fn evaluate( - &mut self, - center: core::ffi::c_double, - R: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - fn compute_bounding_sphere( - &mut self, - pts: core::ffi::c_float, - numPts: core::ffi::c_uchar, - sphere: core::ffi::c_float, - hints: core::ffi::c_uchar, - ) -> (); - fn compute_bounding_sphere( - &mut self, - pts: core::ffi::c_double, - numPts: core::ffi::c_uchar, - sphere: core::ffi::c_double, - hints: core::ffi::c_uchar, - ) -> (); - fn compute_bounding_sphere( - &mut self, - spheres: core::ffi::c_float, - numSpheres: core::ffi::c_uchar, - sphere: core::ffi::c_float, - hints: core::ffi::c_uchar, - ) -> (); - fn compute_bounding_sphere( - &mut self, - spheres: core::ffi::c_double, - numSpheres: core::ffi::c_uchar, - sphere: core::ffi::c_double, - hints: core::ffi::c_uchar, - ) -> (); } -pub trait VtkSpheres: VtkImplicitFunction { +pub trait VtkSpheres { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); fn set_centers(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_centers(&mut self) -> *mut core::ffi::c_void; fn set_radii(&mut self, radii: *mut core::ffi::c_void) -> (); fn get_radii(&mut self) -> *mut core::ffi::c_void; fn get_number_of_spheres(&mut self) -> core::ffi::c_int; fn get_sphere(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_sphere(&mut self, i: core::ffi::c_int, sphere: *mut core::ffi::c_void) -> (); } pub trait VtkSpline { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -14267,8 +6689,6 @@ pub trait VtkSpline { tMin: core::ffi::c_double, tMax: core::ffi::c_double, ) -> (); - fn set_parametric_range(&mut self, tRange: core::ffi::c_double) -> (); - fn get_parametric_range(&mut self, tRange: core::ffi::c_double) -> (); fn set_clamp_value(&mut self, _arg: core::ffi::c_int) -> (); fn get_clamp_value(&mut self) -> core::ffi::c_int; fn clamp_value_on(&mut self) -> (); @@ -14298,19 +6718,16 @@ pub trait VtkSpline { fn get_m_time(&mut self) -> core::ffi::c_ulong; fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> (); } -pub trait VtkStaticCellLinks: VtkAbstractCellLinks { +pub trait VtkStaticCellLinks { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn build_links(&mut self, ds: *mut core::ffi::c_void) -> (); - fn get_number_of_cells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_ncells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_cells(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn select_cells( + fn get_number_of_cells( &mut self, - minMaxDegree: core::ffi::c_uchar, - cellSelection: core::ffi::c_uchar, - ) -> (); + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn get_ncells(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_longlong; fn initialize(&mut self) -> (); fn squeeze(&mut self) -> (); fn reset(&mut self) -> (); @@ -14320,49 +6737,26 @@ pub trait VtkStaticCellLinks: VtkAbstractCellLinks { pub trait VtkStaticCellLinksTemplate { fn initialize(&mut self) -> (); fn build_links(&mut self, ds: *mut core::ffi::c_void) -> (); - fn build_links(&mut self, pd: *mut core::ffi::c_void) -> (); - fn build_links(&mut self, ugrid: *mut core::ffi::c_void) -> (); - fn build_links(&mut self, esgrid: *mut core::ffi::c_void) -> (); fn serial_build_links( &mut self, - numPts: core::ffi::c_uchar, - numCells: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, + numCells: core::ffi::c_longlong, cellArray: *mut core::ffi::c_void, ) -> (); fn threaded_build_links( &mut self, - numPts: core::ffi::c_uchar, - numCells: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, + numCells: core::ffi::c_longlong, cellArray: *mut core::ffi::c_void, ) -> (); - fn get_number_of_cells( - &mut self, - ptId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn get_ncells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn matches_cell( - &mut self, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> bool; - fn get_cells(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_cells( - &mut self, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - cells: *mut core::ffi::c_void, - ) -> (); + fn get_ncells(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_cells(&mut self, ptId: core::ffi::c_longlong) -> *mut core::ffi::c_void; fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); - fn select_cells( - &mut self, - minMaxDegree: core::ffi::c_uchar, - cellSelection: core::ffi::c_uchar, - ) -> (); fn set_sequential_processing(&mut self, seq: core::ffi::c_int) -> (); fn get_sequential_processing(&mut self) -> core::ffi::c_int; } -pub trait VtkStaticCellLocator: VtkAbstractCellLocator + VtkLocator { +pub trait VtkStaticCellLocator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -14372,72 +6766,6 @@ pub trait VtkStaticCellLocator: VtkAbstractCellLocator + VtkLocator { _arg2: core::ffi::c_int, _arg3: core::ffi::c_int, ) -> (); - fn set_divisions(&mut self, _arg: core::ffi::c_int) -> (); - fn get_divisions(&mut self) -> *mut core::ffi::c_int; - fn get_divisions(&mut self, data: core::ffi::c_int) -> (); - fn find_cell( - &mut self, - pos: core::ffi::c_double, - tol2: core::ffi::c_double, - cell: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_cell(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_cells_along_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tolerance: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ) -> (); - fn find_cells_along_plane( - &mut self, - o: core::ffi::c_double, - n: core::ffi::c_double, - tolerance: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ) -> (); - fn intersect_with_line( - &mut self, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - points: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn generate_representation( &mut self, level: core::ffi::c_int, @@ -14445,25 +6773,18 @@ pub trait VtkStaticCellLocator: VtkAbstractCellLocator + VtkLocator { ) -> (); fn free_search_structure(&mut self) -> (); fn build_locator(&mut self) -> (); - fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar; - fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar; - fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar; + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong; fn get_large_ids(&mut self) -> bool; fn set_use_diagonal_length_tolerance(&mut self, _arg: bool) -> (); fn get_use_diagonal_length_tolerance(&mut self) -> bool; fn use_diagonal_length_tolerance_on(&mut self) -> (); fn use_diagonal_length_tolerance_off(&mut self) -> (); } -pub trait VtkStaticEdgeLocatorTemplate { - fn get_number_of_edges(&mut self) -> *mut core::ffi::c_void; - fn is_inserted_edge( - &mut self, - v0: *mut core::ffi::c_void, - v1: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; -} -pub trait VtkStaticPointLocator: VtkAbstractPointLocator + VtkLocator { +pub trait VtkStaticEdgeLocatorTemplate {} +pub trait VtkStaticPointLocator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -14477,54 +6798,9 @@ pub trait VtkStaticPointLocator: VtkAbstractPointLocator + VtkLocator { _arg2: core::ffi::c_int, _arg3: core::ffi::c_int, ) -> (); - fn set_divisions(&mut self, _arg: core::ffi::c_int) -> (); - fn get_divisions(&mut self) -> *mut core::ffi::c_int; - fn get_divisions(&mut self, data: core::ffi::c_int) -> (); - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - inputDataLength: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn intersect_with_line( - &mut self, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - lineX: core::ffi::c_double, - ptX: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn merge_points( - &mut self, - tol: core::ffi::c_double, - mergeMap: core::ffi::c_uchar, - ) -> (); fn initialize(&mut self) -> (); fn free_search_structure(&mut self) -> (); fn build_locator(&mut self) -> (); - fn build_locator(&mut self, inBounds: core::ffi::c_double) -> (); fn generate_representation( &mut self, level: core::ffi::c_int, @@ -14532,22 +6808,20 @@ pub trait VtkStaticPointLocator: VtkAbstractPointLocator + VtkLocator { ) -> (); fn get_number_of_points_in_bucket( &mut self, - bNum: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn get_bucket_ids( &mut self, - bNum: core::ffi::c_uchar, + bNum: core::ffi::c_longlong, bList: *mut core::ffi::c_void, ) -> (); - fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar; - fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar; - fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar; + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong; fn get_large_ids(&mut self) -> bool; - fn get_spacing(&mut self) -> *mut core::ffi::c_double; - fn get_spacing(&mut self, spacing: core::ffi::c_double) -> (); } -pub trait VtkStaticPointLocator2D: VtkAbstractPointLocator + VtkLocator { +pub trait VtkStaticPointLocator2D { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -14556,78 +6830,23 @@ pub trait VtkStaticPointLocator2D: VtkAbstractPointLocator + VtkLocator { fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int; fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int; fn set_divisions(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> (); - fn set_divisions(&mut self, _arg: core::ffi::c_int) -> (); - fn get_divisions(&mut self) -> *mut core::ffi::c_int; - fn get_divisions(&mut self, data: core::ffi::c_int) -> (); - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - inputDataLength: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> (); - fn intersect_with_line( - &mut self, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - lineX: core::ffi::c_double, - ptX: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn find_close_n_bounded_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - fn merge_points( - &mut self, - tol: core::ffi::c_double, - mergeMap: core::ffi::c_uchar, - ) -> (); fn initialize(&mut self) -> (); fn free_search_structure(&mut self) -> (); fn build_locator(&mut self) -> (); fn get_number_of_points_in_bucket( &mut self, - bNum: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn get_bucket_ids( &mut self, - bNum: core::ffi::c_uchar, + bNum: core::ffi::c_longlong, bList: *mut core::ffi::c_void, ) -> (); - fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar; - fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar; - fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar; + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong; fn get_large_ids(&mut self) -> bool; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_spacing(&mut self) -> *mut core::ffi::c_double; - fn get_spacing(&mut self, spacing: core::ffi::c_double) -> (); - fn get_bucket_indices(&mut self, x: core::ffi::c_double, ij: core::ffi::c_int) -> (); - fn get_bucket_index(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar; fn generate_representation( &mut self, level: core::ffi::c_int, @@ -14637,220 +6856,40 @@ pub trait VtkStaticPointLocator2D: VtkAbstractPointLocator + VtkLocator { pub trait VtkStructuredData { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set_dimensions( - &mut self, - inDim: core::ffi::c_int, - dim: core::ffi::c_int, - ) -> core::ffi::c_int; - fn set_extent( - &mut self, - inExt: core::ffi::c_int, - ext: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_data_description(&mut self, dims: core::ffi::c_int) -> core::ffi::c_int; - fn get_data_description_from_extent( - &mut self, - ext: core::ffi::c_int, - ) -> core::ffi::c_int; fn get_data_dimension( &mut self, dataDescription: core::ffi::c_int, ) -> core::ffi::c_int; - fn get_data_dimension(&mut self, ext: core::ffi::c_int) -> core::ffi::c_int; - fn get_number_of_points( - &mut self, - ext: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn get_number_of_cells( - &mut self, - ext: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn get_cell_extent_from_point_extent( - &mut self, - pntExtent: core::ffi::c_int, - cellExtent: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> (); - fn get_dimensions_from_extent( - &mut self, - ext: core::ffi::c_int, - dims: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> (); fn is_point_visible( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ghosts: *mut core::ffi::c_void, ) -> bool; - fn is_cell_visible( - &mut self, - cellId: core::ffi::c_uchar, - dimensions: core::ffi::c_int, - dataDescription: core::ffi::c_int, - cellGhostArray: *mut core::ffi::c_void, - pointGhostArray: *mut core::ffi::c_void, - ) -> bool; - fn get_cell_dimensions_from_extent( - &mut self, - ext: core::ffi::c_int, - celldims: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> (); - fn get_cell_dimensions_from_point_dimensions( - &mut self, - pntdims: core::ffi::c_int, - cellDims: core::ffi::c_int, - ) -> (); - fn get_local_structured_coordinates( - &mut self, - ijk: core::ffi::c_int, - ext: core::ffi::c_int, - lijk: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> (); - fn get_global_structured_coordinates( - &mut self, - lijk: core::ffi::c_int, - ext: core::ffi::c_int, - ijk: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> (); - fn get_cell_points( - &mut self, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - dataDescription: core::ffi::c_int, - dim: core::ffi::c_int, - ) -> (); - fn get_point_cells( - &mut self, - ptId: core::ffi::c_uchar, - cellIds: *mut core::ffi::c_void, - dim: core::ffi::c_int, - ) -> (); - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - dim: core::ffi::c_int, - ) -> (); - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - dim: core::ffi::c_int, - seedLoc: core::ffi::c_int, - ) -> (); - fn compute_point_id_for_extent( - &mut self, - extent: core::ffi::c_int, - ijk: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn compute_cell_id_for_extent( - &mut self, - extent: core::ffi::c_int, - ijk: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn compute_point_id( - &mut self, - dim: core::ffi::c_int, - ijk: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn compute_cell_id( - &mut self, - dim: core::ffi::c_int, - ijk: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> core::ffi::c_uchar; - fn compute_cell_structured_coords_for_extent( - &mut self, - cellIdx: core::ffi::c_uchar, - ext: core::ffi::c_int, - ijk: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> (); - fn compute_cell_structured_coords( - &mut self, - cellId: core::ffi::c_uchar, - dim: core::ffi::c_int, - ijk: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> (); - fn compute_point_structured_coords_for_extent( - &mut self, - ptId: core::ffi::c_uchar, - ext: core::ffi::c_int, - ijk: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> (); - fn compute_point_structured_coords( - &mut self, - ptId: core::ffi::c_uchar, - dim: core::ffi::c_int, - ijk: core::ffi::c_int, - dataDescription: core::ffi::c_int, - ) -> (); } pub trait VtkStructuredExtent { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn clamp(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> (); - fn strictly_smaller( - &mut self, - ext: core::ffi::c_int, - wholeExt: core::ffi::c_int, - ) -> bool; - fn smaller(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> bool; - fn grow(&mut self, ext: core::ffi::c_int, count: core::ffi::c_int) -> (); - fn grow( - &mut self, - ext: core::ffi::c_int, - count: core::ffi::c_int, - wholeExt: core::ffi::c_int, - ) -> (); - fn transform(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> (); - fn get_dimensions(&mut self, ext: core::ffi::c_int, dims: core::ffi::c_int) -> (); } -pub trait VtkStructuredGrid: VtkPointSet + VtkDataSet + VtkDataObject { +pub trait VtkStructuredGrid { fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); - fn get_number_of_points(&mut self) -> core::ffi::c_uchar; - fn get_point(&mut self, ptId: core::ffi::c_uchar, p: core::ffi::c_double) -> (); - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> (); - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> (); fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, - cellIds: *mut core::ffi::c_void, - ) -> (); - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, - seedLoc: core::ffi::c_int, ) -> (); fn set_dimensions( &mut self, @@ -14858,11 +6897,7 @@ pub trait VtkStructuredGrid: VtkPointSet + VtkDataSet + VtkDataObject { j: core::ffi::c_int, k: core::ffi::c_int, ) -> (); - fn set_dimensions(&mut self, dim: core::ffi::c_int) -> (); - fn get_dimensions(&mut self) -> *mut core::ffi::c_int; - fn get_dimensions(&mut self, dim: core::ffi::c_int) -> (); fn get_data_dimension(&mut self) -> core::ffi::c_int; - fn set_extent(&mut self, extent: core::ffi::c_int) -> (); fn set_extent( &mut self, xMin: core::ffi::c_int, @@ -14872,44 +6907,18 @@ pub trait VtkStructuredGrid: VtkPointSet + VtkDataSet + VtkDataObject { zMin: core::ffi::c_int, zMax: core::ffi::c_int, ) -> (); - fn get_extent(&mut self) -> *mut core::ffi::c_int; - fn get_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> (); - fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); fn get_extent_type(&mut self) -> core::ffi::c_int; - fn blank_point(&mut self, ptId: core::ffi::c_uchar) -> (); - fn un_blank_point(&mut self, ptId: core::ffi::c_uchar) -> (); - fn blank_cell(&mut self, ptId: core::ffi::c_uchar) -> (); - fn un_blank_cell(&mut self, ptId: core::ffi::c_uchar) -> (); - fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn blank_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn un_blank_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn blank_cell(&mut self, ptId: core::ffi::c_longlong) -> (); + fn un_blank_cell(&mut self, ptId: core::ffi::c_longlong) -> (); + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; fn has_any_blank_points(&mut self) -> bool; fn has_any_blank_cells(&mut self) -> bool; - fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> (); - fn crop(&mut self, updateExtent: core::ffi::c_int) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_point( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - p: core::ffi::c_double, - adjustForExtent: bool, - ) -> (); } -pub trait VtkStructuredPoints: VtkImageData + VtkDataSet + VtkDataObject { +pub trait VtkStructuredPoints { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -14921,36 +6930,23 @@ pub trait VtkStructuredPointsCollection { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); fn get_next_item(&mut self) -> *mut core::ffi::c_void; - fn get_next_structured_points(&mut self, cookie: ()) -> *mut core::ffi::c_void; } -pub trait VtkSuperquadric: VtkImplicitFunction { +pub trait VtkSuperquadric { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> (); fn set_center( &mut self, _arg1: core::ffi::c_double, _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_center(&mut self, _arg: core::ffi::c_double) -> (); - fn get_center(&mut self) -> *mut core::ffi::c_double; - fn get_center(&mut self, data: core::ffi::c_double) -> (); fn set_scale( &mut self, _arg1: core::ffi::c_double, _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_scale(&mut self, _arg: core::ffi::c_double) -> (); - fn get_scale(&mut self) -> *mut core::ffi::c_double; - fn get_scale(&mut self, data: core::ffi::c_double) -> (); fn get_thickness(&mut self) -> core::ffi::c_double; fn set_thickness(&mut self, _arg: core::ffi::c_double) -> (); fn get_thickness_min_value(&mut self) -> core::ffi::c_double; @@ -14966,7 +6962,7 @@ pub trait VtkSuperquadric: VtkImplicitFunction { fn get_toroidal(&mut self) -> core::ffi::c_int; fn set_toroidal(&mut self, _arg: core::ffi::c_int) -> (); } -pub trait VtkTable: VtkDataObject { +pub trait VtkTable { fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -14975,292 +6971,89 @@ pub trait VtkTable: VtkDataObject { fn get_data_object_type(&mut self) -> core::ffi::c_int; fn get_row_data(&mut self) -> *mut core::ffi::c_void; fn set_row_data(&mut self, data: *mut core::ffi::c_void) -> (); - fn get_number_of_rows(&mut self) -> core::ffi::c_uchar; - fn set_number_of_rows(&mut self, p0: core::ffi::c_uchar) -> (); - fn get_row(&mut self, row: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_row(&mut self, row: core::ffi::c_uchar, values: *mut core::ffi::c_void) -> (); - fn set_row(&mut self, row: core::ffi::c_uchar, values: *mut core::ffi::c_void) -> (); + fn get_number_of_rows(&mut self) -> core::ffi::c_longlong; + fn set_number_of_rows(&mut self, p0: core::ffi::c_longlong) -> (); + fn get_row(&mut self, row: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn set_row( + &mut self, + row: core::ffi::c_longlong, + values: *mut core::ffi::c_void, + ) -> (); fn insert_next_blank_row( &mut self, default_num_val: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn insert_next_row(&mut self, values: *mut core::ffi::c_void) -> core::ffi::c_uchar; - fn remove_row(&mut self, row: core::ffi::c_uchar) -> (); - fn get_number_of_columns(&mut self) -> core::ffi::c_uchar; - fn get_column_name(&mut self, col: core::ffi::c_uchar) -> *const core::ffi::c_char; - fn get_column_by_name(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void; - fn get_column(&mut self, col: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn add_column(&mut self, arr: *mut core::ffi::c_void) -> (); - fn remove_column_by_name(&mut self, name: core::ffi::c_char) -> (); - fn remove_column(&mut self, col: core::ffi::c_uchar) -> (); - fn get_value( - &mut self, - row: core::ffi::c_uchar, - col: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn get_value_by_name( - &mut self, - row: core::ffi::c_uchar, - col: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn set_value( - &mut self, - row: core::ffi::c_uchar, - col: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> (); - fn set_value_by_name( + ) -> core::ffi::c_longlong; + fn insert_next_row( &mut self, - row: core::ffi::c_uchar, - col: core::ffi::c_char, - value: *mut core::ffi::c_void, - ) -> (); + values: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn remove_row(&mut self, row: core::ffi::c_longlong) -> (); + fn get_number_of_columns(&mut self) -> core::ffi::c_longlong; + fn get_column_name(&mut self, col: core::ffi::c_longlong) -> &str; + fn get_column_by_name(&mut self, name: &str) -> *mut core::ffi::c_void; + fn get_column(&mut self, col: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn add_column(&mut self, arr: *mut core::ffi::c_void) -> (); + fn remove_column_by_name(&mut self, name: &str) -> (); + fn remove_column(&mut self, col: core::ffi::c_longlong) -> (); fn initialize(&mut self) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); - fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar; + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; } -pub trait VtkTetra: VtkCell3D + VtkCell { +pub trait VtkTetra { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - fn tetra_center( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - p4: core::ffi::c_double, - center: core::ffi::c_double, - ) -> (); - fn circumsphere( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - x4: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - fn insphere( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - p4: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - fn barycentric_coords( - &mut self, - x: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - x4: core::ffi::c_double, - bcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn compute_volume( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - p4: core::ffi::c_double, - ) -> core::ffi::c_double; - fn jacobian_inverse( - &mut self, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; } -pub trait VtkTree: VtkDirectedAcyclicGraph + VtkDirectedGraph + VtkGraph + VtkDataObject { +pub trait VtkTree { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_root(&mut self) -> core::ffi::c_uchar; - fn get_number_of_children(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn get_root(&mut self) -> core::ffi::c_longlong; + fn get_number_of_children( + &mut self, + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; fn get_child( &mut self, - v: core::ffi::c_uchar, - i: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_children(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> (); - fn get_parent(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_parent_edge(&mut self, v: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_level(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn is_leaf(&mut self, vertex: core::ffi::c_uchar) -> bool; - fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( + v: core::ffi::c_longlong, + i: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn get_children( &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ) -> (); + fn get_parent(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_level(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn is_leaf(&mut self, vertex: core::ffi::c_longlong) -> bool; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn reorder_children( &mut self, - parent: core::ffi::c_uchar, + parent: core::ffi::c_longlong, children: *mut core::ffi::c_void, ) -> (); } -pub trait VtkTreeBFSIterator: VtkTreeIterator { +pub trait VtkTreeBFSIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkTreeDFSIterator: VtkTreeIterator { +pub trait VtkTreeDFSIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -15272,13 +7065,13 @@ pub trait VtkTreeIterator { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn set_tree(&mut self, tree: *mut core::ffi::c_void) -> (); fn get_tree(&mut self) -> *mut core::ffi::c_void; - fn set_start_vertex(&mut self, vertex: core::ffi::c_uchar) -> (); - fn get_start_vertex(&mut self) -> core::ffi::c_uchar; - fn next(&mut self) -> core::ffi::c_uchar; + fn set_start_vertex(&mut self, vertex: core::ffi::c_longlong) -> (); + fn get_start_vertex(&mut self) -> core::ffi::c_longlong; + fn next(&mut self) -> core::ffi::c_longlong; fn has_next(&mut self) -> bool; fn restart(&mut self) -> (); } -pub trait VtkTriQuadraticHexahedron: VtkNonLinearCell + VtkCell { +pub trait VtkTriQuadraticHexahedron { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -15288,12 +7081,6 @@ pub trait VtkTriQuadraticHexahedron: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -15305,39 +7092,15 @@ pub trait VtkTriQuadraticHexahedron: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -15347,56 +7110,12 @@ pub trait VtkTriQuadraticHexahedron: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } -pub trait VtkTriQuadraticPyramid: VtkNonLinearCell + VtkCell { +pub trait VtkTriQuadraticPyramid { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -15406,12 +7125,6 @@ pub trait VtkTriQuadraticPyramid: VtkNonLinearCell + VtkCell { fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -15423,49 +7136,15 @@ pub trait VtkTriQuadraticPyramid: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn clip( &mut self, value: core::ffi::c_double, @@ -15475,54 +7154,12 @@ pub trait VtkTriQuadraticPyramid: VtkNonLinearCell + VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; } -pub trait VtkTriangle: VtkCell { +pub trait VtkTriangle { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -15532,12 +7169,6 @@ pub trait VtkTriangle: VtkCell { fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -15549,39 +7180,15 @@ pub trait VtkTriangle: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn compute_area(&mut self) -> core::ffi::c_double; fn clip( &mut self, @@ -15592,383 +7199,106 @@ pub trait VtkTriangle: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn interpolation_functions( +} +pub trait VtkTriangleStrip { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( &mut self, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, ) -> (); - fn interpolation_derivs( + fn clip( &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, ) -> (); - fn interpolate_functions( + fn triangulate( &mut self, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkUndirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_in_degree(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_in_edges( &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, ) -> (); - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - fn triangle_center( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - center: core::ffi::c_double, - ) -> (); - fn triangle_area( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - ) -> core::ffi::c_double; - fn circumcircle( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - fn barycentric_coords( - &mut self, - x: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - bcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn project_to_2_d( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - ) -> core::ffi::c_int; - fn compute_normal( - &mut self, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - n: core::ffi::c_double, - ) -> (); - fn compute_normal( - &mut self, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); - fn compute_normal_direction( - &mut self, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - n: core::ffi::c_double, - ) -> (); - fn triangles_intersect( - &mut self, - p1: core::ffi::c_double, - q1: core::ffi::c_double, - r1: core::ffi::c_double, - p2: core::ffi::c_double, - q2: core::ffi::c_double, - r2: core::ffi::c_double, - ) -> core::ffi::c_int; - fn point_in_triangle( - &mut self, - x: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - tol2: core::ffi::c_double, - ) -> core::ffi::c_int; - fn compute_quadric( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - quadric: core::ffi::c_double, - ) -> (); - fn compute_quadric( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - quadric: *mut core::ffi::c_void, - ) -> (); - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; -} -pub trait VtkTriangleStrip: VtkCell { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_cell_type(&mut self) -> core::ffi::c_int; - fn get_cell_dimension(&mut self) -> core::ffi::c_int; - fn get_number_of_edges(&mut self) -> core::ffi::c_int; - fn get_number_of_faces(&mut self) -> core::ffi::c_int; - fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn contour( - &mut self, - value: core::ffi::c_double, - cellScalars: *mut core::ffi::c_void, - locator: *mut core::ffi::c_void, - verts: *mut core::ffi::c_void, - lines: *mut core::ffi::c_void, - polys: *mut core::ffi::c_void, - inPd: *mut core::ffi::c_void, - outPd: *mut core::ffi::c_void, - inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - outCd: *mut core::ffi::c_void, - ) -> (); - fn clip( - &mut self, - value: core::ffi::c_double, - cellScalars: *mut core::ffi::c_void, - locator: *mut core::ffi::c_void, - polys: *mut core::ffi::c_void, - inPd: *mut core::ffi::c_void, - outPd: *mut core::ffi::c_void, - inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - outCd: *mut core::ffi::c_void, - insideOut: core::ffi::c_int, - ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - fn triangulate( - &mut self, - index: core::ffi::c_int, - ptIds: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn decompose_strip( - &mut self, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - tris: *mut core::ffi::c_void, - ) -> (); -} -pub trait VtkUndirectedGraph: VtkGraph + VtkDataObject { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_in_degree(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn get_in_edge( - &mut self, - v: core::ffi::c_uchar, - i: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - fn get_in_edge( - &mut self, - v: core::ffi::c_uchar, - i: core::ffi::c_uchar, - e: *mut core::ffi::c_void, - ) -> (); - fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_in_edges(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> (); - fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool; -} -pub trait VtkUniformGrid: VtkImageData + VtkDataSet + VtkDataObject { - fn new(&mut self) -> *mut core::ffi::c_void; - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_cell( + fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool; +} +pub trait VtkUniformGrid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell( &mut self, i: core::ffi::c_int, j: core::ffi::c_int, k: core::ffi::c_int, ) -> *mut core::ffi::c_void; fn get_grid_description(&mut self) -> core::ffi::c_int; - fn initialize( - &mut self, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - ) -> core::ffi::c_int; - fn initialize( - &mut self, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - nGhosts: core::ffi::c_int, - ) -> core::ffi::c_int; - fn initialize( - &mut self, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - nGhosts: core::ffi::c_int, - ) -> core::ffi::c_int; - fn initialize( - &mut self, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - nGhostsI: core::ffi::c_int, - nGhostsJ: core::ffi::c_int, - nGhostsK: core::ffi::c_int, - ) -> core::ffi::c_int; - fn blank_point(&mut self, ptId: core::ffi::c_uchar) -> (); - fn un_blank_point(&mut self, ptId: core::ffi::c_uchar) -> (); - fn blank_point( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> (); - fn un_blank_point( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> (); - fn blank_cell(&mut self, ptId: core::ffi::c_uchar) -> (); - fn un_blank_cell(&mut self, ptId: core::ffi::c_uchar) -> (); - fn blank_cell( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> (); - fn un_blank_cell( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> (); - fn is_point_visible(&mut self, pointId: core::ffi::c_uchar) -> core::ffi::c_uchar; - fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar; + fn blank_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn un_blank_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn blank_cell(&mut self, ptId: core::ffi::c_longlong) -> (); + fn un_blank_cell(&mut self, ptId: core::ffi::c_longlong) -> (); + fn is_point_visible(&mut self, pointId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; fn new_image_data_copy(&mut self) -> *mut core::ffi::c_void; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } -pub trait VtkUniformGridAMR: VtkCompositeDataSet + VtkDataObject { +pub trait VtkUniformGridAMR { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new_iterator(&mut self) -> *mut core::ffi::c_void; fn get_data_object_type(&mut self) -> core::ffi::c_int; fn initialize(&mut self) -> (); - fn initialize( - &mut self, - numLevels: core::ffi::c_int, - blocksPerLevel: core::ffi::c_int, - ) -> (); fn set_grid_description(&mut self, gridDescription: core::ffi::c_int) -> (); fn get_grid_description(&mut self) -> core::ffi::c_int; fn get_number_of_levels(&mut self) -> core::ffi::c_uint; fn get_total_number_of_blocks(&mut self) -> core::ffi::c_uint; fn get_number_of_data_sets(&mut self, level: core::ffi::c_uint) -> core::ffi::c_uint; - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> (); - fn get_bounds(&mut self) -> *const core::ffi::c_double; - fn get_min(&mut self, min: core::ffi::c_double) -> (); - fn get_max(&mut self, max: core::ffi::c_double) -> (); fn set_data_set( &mut self, iter: *mut core::ffi::c_void, dataObj: *mut core::ffi::c_void, ) -> (); - fn set_data_set( - &mut self, - level: core::ffi::c_uint, - idx: core::ffi::c_uint, - grid: *mut core::ffi::c_void, - ) -> (); fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data_set( - &mut self, - level: core::ffi::c_uint, - idx: core::ffi::c_uint, - ) -> *mut core::ffi::c_void; fn get_composite_index( &mut self, level: core::ffi::c_uint, @@ -15977,21 +7307,16 @@ pub trait VtkUniformGridAMR: VtkCompositeDataSet + VtkDataObject { fn get_level_and_index( &mut self, compositeIdx: core::ffi::c_uint, - level: core::ffi::c_uint, - idx: core::ffi::c_uint, + level: &mut core::ffi::c_uint, + idx: &mut core::ffi::c_uint, ) -> (); fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn copy_structure(&mut self, src: *mut core::ffi::c_void) -> (); fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } -pub trait VtkUniformGridAMRDataIterator: VtkCompositeDataIterator { +pub trait VtkUniformGridAMRDataIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -16005,7 +7330,7 @@ pub trait VtkUniformGridAMRDataIterator: VtkCompositeDataIterator { fn go_to_next_item(&mut self) -> (); fn is_done_with_traversal(&mut self) -> core::ffi::c_int; } -pub trait VtkUniformHyperTreeGrid: VtkHyperTreeGrid + VtkDataObject { +pub trait VtkUniformHyperTreeGrid { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -16016,42 +7341,18 @@ pub trait VtkUniformHyperTreeGrid: VtkHyperTreeGrid + VtkDataObject { _arg2: core::ffi::c_double, _arg3: core::ffi::c_double, ) -> (); - fn set_origin(&mut self, _arg: core::ffi::c_double) -> (); - fn get_origin(&mut self) -> *mut core::ffi::c_double; - fn get_origin( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_origin(&mut self, _arg: core::ffi::c_double) -> (); fn set_grid_scale( &mut self, p0: core::ffi::c_double, p1: core::ffi::c_double, p2: core::ffi::c_double, ) -> (); - fn set_grid_scale(&mut self, p0: core::ffi::c_double) -> (); - fn get_grid_scale(&mut self) -> *mut core::ffi::c_double; - fn get_grid_scale( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> (); - fn get_grid_scale(&mut self, _arg: core::ffi::c_double) -> (); - fn set_grid_scale(&mut self, p0: core::ffi::c_double) -> (); fn set_x_coordinates(&mut self, XCoordinates: *mut core::ffi::c_void) -> (); fn set_y_coordinates(&mut self, YCoordinates: *mut core::ffi::c_void) -> (); fn set_z_coordinates(&mut self, ZCoordinates: *mut core::ffi::c_void) -> (); - fn get_level_zero_origin_from_index( - &mut self, - p0: core::ffi::c_uchar, - p1: core::ffi::c_double, - ) -> (); fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong; } -pub trait VtkUnstructuredGrid: VtkUnstructuredGridBase + VtkPointSet + VtkDataSet + VtkDataObject { +pub trait VtkUnstructuredGrid { fn new(&mut self) -> *mut core::ffi::c_void; fn extended_new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -16059,57 +7360,34 @@ pub trait VtkUnstructuredGrid: VtkUnstructuredGridBase + VtkPointSet + VtkDataSe fn get_data_object_type(&mut self) -> core::ffi::c_int; fn allocate_estimate( &mut self, - numCells: core::ffi::c_uchar, - maxCellSize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, ) -> bool; fn allocate_exact( &mut self, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool; fn allocate( &mut self, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, extSize: core::ffi::c_int, ) -> (); fn reset(&mut self) -> (); fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void; - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> (); + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> (); fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> (); - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> (); - fn get_cell_points( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_point_cells( - &mut self, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_uchar, - cells: core::ffi::c_uchar, - ) -> (); - fn get_point_cells( - &mut self, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_ushort, - cells: core::ffi::c_uchar, - ) -> (); fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void; fn squeeze(&mut self) -> (); fn initialize(&mut self) -> (); @@ -16118,76 +7396,34 @@ pub trait VtkUnstructuredGrid: VtkUnstructuredGridBase + VtkPointSet + VtkDataSe fn get_cell_links(&mut self) -> *mut core::ffi::c_void; fn get_face_stream( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> (); - fn get_face_stream( - &mut self, - cellId: core::ffi::c_uchar, - nfaces: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - ) -> (); fn set_cells( &mut self, type_: core::ffi::c_int, cells: *mut core::ffi::c_void, ) -> (); - fn set_cells( - &mut self, - types: core::ffi::c_int, - cells: *mut core::ffi::c_void, - ) -> (); - fn set_cells( - &mut self, - cellTypes: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - ) -> (); - fn set_cells( - &mut self, - cellTypes: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - faceLocations: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ) -> (); fn get_cells(&mut self) -> *mut core::ffi::c_void; fn get_cell_neighbors( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellIds: *mut core::ffi::c_void, ) -> (); - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - cellIds: *mut core::ffi::c_void, - ) -> (); - fn is_cell_boundary( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - ) -> bool; - fn insert_next_linked_cell( - &mut self, - type_: core::ffi::c_int, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; fn remove_reference_to_cell( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> (); fn add_reference_to_cell( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> (); fn resize_cell_list( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, size: core::ffi::c_int, ) -> (); fn get_piece(&mut self) -> core::ffi::c_int; @@ -16201,104 +7437,36 @@ pub trait VtkUnstructuredGrid: VtkUnstructuredGridBase + VtkPointSet + VtkDataSe fn is_homogeneous(&mut self) -> core::ffi::c_int; fn remove_ghost_cells(&mut self) -> (); fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_faces(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar; - fn get_faces(&mut self) -> *mut core::ffi::c_void; fn get_face_locations(&mut self) -> *mut core::ffi::c_void; fn initialize_faces_representation( &mut self, - numPrevCells: core::ffi::c_uchar, + numPrevCells: core::ffi::c_longlong, ) -> core::ffi::c_int; fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong; fn decompose_a_polyhedron_cell( &mut self, polyhedronCellArray: *mut core::ffi::c_void, - nCellpts: core::ffi::c_uchar, - nCellfaces: core::ffi::c_uchar, - cellArray: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ) -> (); - fn decompose_a_polyhedron_cell( - &mut self, - polyhedronCellStream: core::ffi::c_uchar, - nCellpts: core::ffi::c_uchar, - nCellfaces: core::ffi::c_uchar, - cellArray: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ) -> (); - fn decompose_a_polyhedron_cell( - &mut self, - nCellFaces: core::ffi::c_uchar, - inFaceStream: core::ffi::c_uchar, - nCellpts: core::ffi::c_uchar, + nCellpts: &mut core::ffi::c_longlong, + nCellfaces: &mut core::ffi::c_longlong, cellArray: *mut core::ffi::c_void, faces: *mut core::ffi::c_void, ) -> (); - fn convert_face_stream_point_ids( - &mut self, - faceStream: *mut core::ffi::c_void, - idMap: core::ffi::c_uchar, - ) -> (); - fn convert_face_stream_point_ids( - &mut self, - nfaces: core::ffi::c_uchar, - faceStream: core::ffi::c_uchar, - idMap: core::ffi::c_uchar, - ) -> (); fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void; - fn set_cells( - &mut self, - cellTypes: *mut core::ffi::c_void, - cellLocations: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - ) -> (); - fn set_cells( - &mut self, - cellTypes: *mut core::ffi::c_void, - cellLocations: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - faceLocations: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ) -> (); } -pub trait VtkUnstructuredGridBase: VtkPointSet + VtkDataSet + VtkDataObject { +pub trait VtkUnstructuredGridBase { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn allocate( &mut self, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, extSize: core::ffi::c_int, ) -> (); fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); - fn insert_next_cell( - &mut self, - type_: core::ffi::c_int, - npts: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; fn insert_next_cell( &mut self, type_: core::ffi::c_int, ptIds: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - fn insert_next_cell( - &mut self, - type_: core::ffi::c_int, - npts: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - nfaces: core::ffi::c_uchar, - faces: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn replace_cell( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> (); + ) -> core::ffi::c_longlong; fn get_ids_of_cells_of_type( &mut self, type_: core::ffi::c_int, @@ -16306,188 +7474,128 @@ pub trait VtkUnstructuredGridBase: VtkPointSet + VtkDataSet + VtkDataObject { ) -> (); fn is_homogeneous(&mut self) -> core::ffi::c_int; fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; } -pub trait VtkUnstructuredGridCellIterator: VtkCellIterator { +pub trait VtkUnstructuredGridCellIterator { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn is_done_with_traversal(&mut self) -> bool; - fn get_cell_id(&mut self) -> core::ffi::c_uchar; - fn go_to_cell(&mut self, cellId: core::ffi::c_uchar) -> (); + fn get_cell_id(&mut self) -> core::ffi::c_longlong; + fn go_to_cell(&mut self, cellId: core::ffi::c_longlong) -> (); } pub trait VtkVector { - fn squared_norm(&mut self) -> *mut core::ffi::c_void; fn norm(&mut self) -> core::ffi::c_double; fn normalize(&mut self) -> core::ffi::c_double; } -pub trait VtkVector2: VtkVector { - fn set(&mut self, x: T, y: T) -> (); - fn set_x(&mut self, x: T) -> (); - fn get_x(&mut self) -> T; - fn set_y(&mut self, y: T) -> (); - fn get_y(&mut self) -> T; - fn get_data(&mut self) -> *const T; -} -pub trait VtkVector2d: VtkVector2 + VtkVector { - fn normalized(&mut self) -> *mut core::ffi::c_void; - fn set(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); - fn set_x(&mut self, x: core::ffi::c_double) -> (); +pub trait VtkVector2 {} +pub trait VtkVector2d { + fn set(&mut self, x: &core::ffi::c_double, y: &core::ffi::c_double) -> (); + fn set_x(&mut self, x: &core::ffi::c_double) -> (); fn get_x(&mut self) -> core::ffi::c_double; - fn set_y(&mut self, y: core::ffi::c_double) -> (); + fn set_y(&mut self, y: &core::ffi::c_double) -> (); fn get_y(&mut self) -> core::ffi::c_double; fn squared_norm(&mut self) -> core::ffi::c_double; - fn get_data(&mut self) -> *mut core::ffi::c_double; - fn get_data(&mut self) -> *const core::ffi::c_double; } -pub trait VtkVector2f: VtkVector2 + VtkVector { - fn normalized(&mut self) -> *mut core::ffi::c_void; - fn set(&mut self, x: core::ffi::c_float, y: core::ffi::c_float) -> (); - fn set_x(&mut self, x: core::ffi::c_float) -> (); +pub trait VtkVector2f { + fn set(&mut self, x: &core::ffi::c_float, y: &core::ffi::c_float) -> (); + fn set_x(&mut self, x: &core::ffi::c_float) -> (); fn get_x(&mut self) -> core::ffi::c_float; - fn set_y(&mut self, y: core::ffi::c_float) -> (); + fn set_y(&mut self, y: &core::ffi::c_float) -> (); fn get_y(&mut self) -> core::ffi::c_float; fn squared_norm(&mut self) -> core::ffi::c_float; - fn get_data(&mut self) -> *mut core::ffi::c_float; - fn get_data(&mut self) -> *const core::ffi::c_float; } -pub trait VtkVector2i: VtkVector2 + VtkVector { - fn normalized(&mut self) -> *mut core::ffi::c_void; - fn set(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); - fn set_x(&mut self, x: core::ffi::c_int) -> (); +pub trait VtkVector2i { + fn set(&mut self, x: &core::ffi::c_int, y: &core::ffi::c_int) -> (); + fn set_x(&mut self, x: &core::ffi::c_int) -> (); fn get_x(&mut self) -> core::ffi::c_int; - fn set_y(&mut self, y: core::ffi::c_int) -> (); + fn set_y(&mut self, y: &core::ffi::c_int) -> (); fn get_y(&mut self) -> core::ffi::c_int; fn squared_norm(&mut self) -> core::ffi::c_int; - fn get_data(&mut self) -> *mut core::ffi::c_int; - fn get_data(&mut self) -> *const core::ffi::c_int; -} -pub trait VtkVector3: VtkVector { - fn set(&mut self, x: T, y: T, z: T) -> (); - fn set_x(&mut self, x: T) -> (); - fn get_x(&mut self) -> T; - fn set_y(&mut self, y: T) -> (); - fn get_y(&mut self) -> T; - fn set_z(&mut self, z: T) -> (); - fn get_z(&mut self) -> T; - fn get_data(&mut self) -> *const T; -} -pub trait VtkVector3d: VtkVector3 + VtkVector { - fn normalized(&mut self) -> *mut core::ffi::c_void; - fn cross(&mut self, other: vtkVector3d) -> *mut core::ffi::c_void; +} +pub trait VtkVector3 {} +pub trait VtkVector3d { fn set( &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, + x: &core::ffi::c_double, + y: &core::ffi::c_double, + z: &core::ffi::c_double, ) -> (); - fn set_x(&mut self, x: core::ffi::c_double) -> (); + fn set_x(&mut self, x: &core::ffi::c_double) -> (); fn get_x(&mut self) -> core::ffi::c_double; - fn set_y(&mut self, y: core::ffi::c_double) -> (); + fn set_y(&mut self, y: &core::ffi::c_double) -> (); fn get_y(&mut self) -> core::ffi::c_double; - fn set_z(&mut self, z: core::ffi::c_double) -> (); + fn set_z(&mut self, z: &core::ffi::c_double) -> (); fn get_z(&mut self) -> core::ffi::c_double; fn squared_norm(&mut self) -> core::ffi::c_double; - fn get_data(&mut self) -> *mut core::ffi::c_double; - fn get_data(&mut self) -> *const core::ffi::c_double; } -pub trait VtkVector3f: VtkVector3 + VtkVector { - fn normalized(&mut self) -> *mut core::ffi::c_void; - fn cross(&mut self, other: vtkVector3f) -> *mut core::ffi::c_void; +pub trait VtkVector3f { fn set( &mut self, - x: core::ffi::c_float, - y: core::ffi::c_float, - z: core::ffi::c_float, + x: &core::ffi::c_float, + y: &core::ffi::c_float, + z: &core::ffi::c_float, ) -> (); - fn set_x(&mut self, x: core::ffi::c_float) -> (); + fn set_x(&mut self, x: &core::ffi::c_float) -> (); fn get_x(&mut self) -> core::ffi::c_float; - fn set_y(&mut self, y: core::ffi::c_float) -> (); + fn set_y(&mut self, y: &core::ffi::c_float) -> (); fn get_y(&mut self) -> core::ffi::c_float; - fn set_z(&mut self, z: core::ffi::c_float) -> (); + fn set_z(&mut self, z: &core::ffi::c_float) -> (); fn get_z(&mut self) -> core::ffi::c_float; fn squared_norm(&mut self) -> core::ffi::c_float; - fn get_data(&mut self) -> *mut core::ffi::c_float; - fn get_data(&mut self) -> *const core::ffi::c_float; } -pub trait VtkVector3i: VtkVector3 + VtkVector { - fn normalized(&mut self) -> *mut core::ffi::c_void; - fn cross(&mut self, other: vtkVector3i) -> *mut core::ffi::c_void; +pub trait VtkVector3i { fn set( &mut self, - x: core::ffi::c_int, - y: core::ffi::c_int, - z: core::ffi::c_int, + x: &core::ffi::c_int, + y: &core::ffi::c_int, + z: &core::ffi::c_int, ) -> (); - fn set_x(&mut self, x: core::ffi::c_int) -> (); + fn set_x(&mut self, x: &core::ffi::c_int) -> (); fn get_x(&mut self) -> core::ffi::c_int; - fn set_y(&mut self, y: core::ffi::c_int) -> (); + fn set_y(&mut self, y: &core::ffi::c_int) -> (); fn get_y(&mut self) -> core::ffi::c_int; - fn set_z(&mut self, z: core::ffi::c_int) -> (); + fn set_z(&mut self, z: &core::ffi::c_int) -> (); fn get_z(&mut self) -> core::ffi::c_int; fn squared_norm(&mut self) -> core::ffi::c_int; - fn get_data(&mut self) -> *mut core::ffi::c_int; - fn get_data(&mut self) -> *const core::ffi::c_int; -} -pub trait VtkVector4: VtkVector { - fn set(&mut self, x: T, y: T, z: T, w: T) -> (); - fn set_x(&mut self, x: T) -> (); - fn get_x(&mut self) -> T; - fn set_y(&mut self, y: T) -> (); - fn get_y(&mut self) -> T; - fn set_z(&mut self, z: T) -> (); - fn get_z(&mut self) -> T; - fn set_w(&mut self, w: T) -> (); - fn get_w(&mut self) -> T; - fn get_data(&mut self) -> *const T; -} -pub trait VtkVector4d: VtkVector4 + VtkVector { - fn normalized(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkVector4 {} +pub trait VtkVector4d { fn set( &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - w: core::ffi::c_double, + x: &core::ffi::c_double, + y: &core::ffi::c_double, + z: &core::ffi::c_double, + w: &core::ffi::c_double, ) -> (); - fn set_x(&mut self, x: core::ffi::c_double) -> (); + fn set_x(&mut self, x: &core::ffi::c_double) -> (); fn get_x(&mut self) -> core::ffi::c_double; - fn set_y(&mut self, y: core::ffi::c_double) -> (); + fn set_y(&mut self, y: &core::ffi::c_double) -> (); fn get_y(&mut self) -> core::ffi::c_double; - fn set_z(&mut self, z: core::ffi::c_double) -> (); + fn set_z(&mut self, z: &core::ffi::c_double) -> (); fn get_z(&mut self) -> core::ffi::c_double; - fn set_w(&mut self, w: core::ffi::c_double) -> (); + fn set_w(&mut self, w: &core::ffi::c_double) -> (); fn get_w(&mut self) -> core::ffi::c_double; fn squared_norm(&mut self) -> core::ffi::c_double; - fn get_data(&mut self) -> *mut core::ffi::c_double; - fn get_data(&mut self) -> *const core::ffi::c_double; } -pub trait VtkVector4i: VtkVector4 + VtkVector { - fn normalized(&mut self) -> *mut core::ffi::c_void; +pub trait VtkVector4i { fn set( &mut self, - x: core::ffi::c_int, - y: core::ffi::c_int, - z: core::ffi::c_int, - w: core::ffi::c_int, + x: &core::ffi::c_int, + y: &core::ffi::c_int, + z: &core::ffi::c_int, + w: &core::ffi::c_int, ) -> (); - fn set_x(&mut self, x: core::ffi::c_int) -> (); + fn set_x(&mut self, x: &core::ffi::c_int) -> (); fn get_x(&mut self) -> core::ffi::c_int; - fn set_y(&mut self, y: core::ffi::c_int) -> (); + fn set_y(&mut self, y: &core::ffi::c_int) -> (); fn get_y(&mut self) -> core::ffi::c_int; - fn set_z(&mut self, z: core::ffi::c_int) -> (); + fn set_z(&mut self, z: &core::ffi::c_int) -> (); fn get_z(&mut self) -> core::ffi::c_int; - fn set_w(&mut self, w: core::ffi::c_int) -> (); + fn set_w(&mut self, w: &core::ffi::c_int) -> (); fn get_w(&mut self) -> core::ffi::c_int; fn squared_norm(&mut self) -> core::ffi::c_int; - fn get_data(&mut self) -> *mut core::ffi::c_int; - fn get_data(&mut self) -> *const core::ffi::c_int; } -pub trait VtkVertex: VtkCell { +pub trait VtkVertex { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -16506,33 +7614,11 @@ pub trait VtkVertex: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> (); - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); fn inflate(&mut self, p0: core::ffi::c_double) -> core::ffi::c_int; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn contour( &mut self, value: core::ffi::c_double, @@ -16544,57 +7630,15 @@ pub trait VtkVertex: VtkCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> (); - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); } pub trait VtkVertexListIterator { fn new(&mut self) -> *mut core::ffi::c_void; @@ -16602,481 +7646,74 @@ pub trait VtkVertexListIterator { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn set_graph(&mut self, graph: *mut core::ffi::c_void) -> (); fn get_graph(&mut self) -> *mut core::ffi::c_void; - fn next(&mut self) -> core::ffi::c_uchar; + fn next(&mut self) -> core::ffi::c_longlong; fn has_next(&mut self) -> bool; } -pub trait VtkVoxel: VtkCell3D + VtkCell { +pub trait VtkVoxel { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faces: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edges: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faces: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; - fn compute_bounding_sphere( - &mut self, - center: core::ffi::c_double, - ) -> core::ffi::c_double; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int; - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; } -pub trait VtkWedge: VtkCell3D + VtkCell { +pub trait VtkWedge { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_edge_points(&mut self, edgeId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_face_points(&mut self, faceId: core::ffi::c_int, pts: core::ffi::c_int) -> (); - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> (); - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool; fn get_cell_type(&mut self) -> core::ffi::c_int; fn get_number_of_edges(&mut self) -> core::ffi::c_int; fn get_number_of_faces(&mut self) -> core::ffi::c_int; fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; fn triangulate( &mut self, index: core::ffi::c_int, ptIds: *mut core::ffi::c_void, pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> (); - fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int; - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> (); - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> (); - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; } pub trait VtkXMLDataElement { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn get_name(&mut self) -> *mut core::ffi::c_char; - fn set_name(&mut self, _arg: core::ffi::c_char) -> (); - fn get_id(&mut self) -> *mut core::ffi::c_char; - fn set_id(&mut self, _arg: core::ffi::c_char) -> (); - fn get_attribute(&mut self, name: core::ffi::c_char) -> *const core::ffi::c_char; - fn set_attribute(&mut self, name: core::ffi::c_char, value: core::ffi::c_char) -> (); - fn set_character_data( - &mut self, - data: core::ffi::c_char, - length: core::ffi::c_int, - ) -> (); - fn add_character_data(&mut self, c: core::ffi::c_char, length: usize) -> (); - fn get_character_data(&mut self) -> *mut core::ffi::c_char; - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_float, - ) -> core::ffi::c_int; + fn set_name(&mut self, _arg: &str) -> (); + fn set_id(&mut self, _arg: &str) -> (); + fn get_attribute(&mut self, name: &str) -> &str; + fn set_attribute(&mut self, name: &str, value: &str) -> (); + fn set_character_data(&mut self, data: &str, length: core::ffi::c_int) -> (); + fn add_character_data(&mut self, c: &str, length: usize) -> (); fn get_scalar_attribute( &mut self, - name: core::ffi::c_char, - value: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_long, - ) -> core::ffi::c_int; - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_ulong, + name: &str, + value: &mut core::ffi::c_int, ) -> core::ffi::c_int; - fn set_int_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_int, - ) -> (); - fn set_float_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_float, - ) -> (); - fn set_double_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_double, - ) -> (); + fn set_int_attribute(&mut self, name: &str, value: core::ffi::c_int) -> (); + fn set_float_attribute(&mut self, name: &str, value: core::ffi::c_float) -> (); + fn set_double_attribute(&mut self, name: &str, value: core::ffi::c_double) -> (); fn set_unsigned_long_attribute( &mut self, - name: core::ffi::c_char, + name: &str, value: core::ffi::c_ulong, ) -> (); - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_float, - ) -> core::ffi::c_int; - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_double, - ) -> core::ffi::c_int; - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_long, - ) -> core::ffi::c_int; - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulong, - ) -> core::ffi::c_int; - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_int, - ) -> (); - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_float, - ) -> (); - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_double, - ) -> (); - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulong, - ) -> (); - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_uchar, - ) -> core::ffi::c_int; - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_uchar, - ) -> (); - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_ulonglong, - ) -> core::ffi::c_int; - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulonglong, - ) -> core::ffi::c_int; - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulonglong, - ) -> (); fn get_word_type_attribute( &mut self, - name: core::ffi::c_char, - value: core::ffi::c_int, + name: &str, + value: &mut core::ffi::c_int, ) -> core::ffi::c_int; fn get_number_of_attributes(&mut self) -> core::ffi::c_int; - fn get_attribute_name(&mut self, idx: core::ffi::c_int) -> *const core::ffi::c_char; - fn get_attribute_value(&mut self, idx: core::ffi::c_int) -> *const core::ffi::c_char; - fn remove_attribute(&mut self, name: core::ffi::c_char) -> (); + fn get_attribute_name(&mut self, idx: core::ffi::c_int) -> &str; + fn get_attribute_value(&mut self, idx: core::ffi::c_int) -> &str; + fn remove_attribute(&mut self, name: &str) -> (); fn remove_all_attributes(&mut self) -> (); fn get_parent(&mut self) -> *mut core::ffi::c_void; fn set_parent(&mut self, parent: *mut core::ffi::c_void) -> (); @@ -17086,36 +7723,30 @@ pub trait VtkXMLDataElement { fn add_nested_element(&mut self, element: *mut core::ffi::c_void) -> (); fn remove_nested_element(&mut self, p0: *mut core::ffi::c_void) -> (); fn remove_all_nested_elements(&mut self) -> (); - fn find_nested_element(&mut self, id: core::ffi::c_char) -> *mut core::ffi::c_void; - fn find_nested_element_with_name( - &mut self, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; + fn find_nested_element(&mut self, id: &str) -> *mut core::ffi::c_void; + fn find_nested_element_with_name(&mut self, name: &str) -> *mut core::ffi::c_void; fn find_nested_element_with_name_and_id( &mut self, - name: core::ffi::c_char, - id: core::ffi::c_char, + name: &str, + id: &str, ) -> *mut core::ffi::c_void; fn find_nested_element_with_name_and_attribute( &mut self, - name: core::ffi::c_char, - att_name: core::ffi::c_char, - att_value: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - fn lookup_element_with_name( - &mut self, - name: core::ffi::c_char, + name: &str, + att_name: &str, + att_value: &str, ) -> *mut core::ffi::c_void; - fn lookup_element(&mut self, id: core::ffi::c_char) -> *mut core::ffi::c_void; - fn get_xml_byte_index(&mut self) -> core::ffi::c_uchar; - fn set_xml_byte_index(&mut self, _arg: core::ffi::c_uchar) -> (); + fn lookup_element_with_name(&mut self, name: &str) -> *mut core::ffi::c_void; + fn lookup_element(&mut self, id: &str) -> *mut core::ffi::c_void; + fn get_xml_byte_index(&mut self) -> core::ffi::c_longlong; + fn set_xml_byte_index(&mut self, _arg: core::ffi::c_longlong) -> (); fn is_equal_to(&mut self, elem: *mut core::ffi::c_void) -> core::ffi::c_int; fn deep_copy(&mut self, elem: *mut core::ffi::c_void) -> (); fn set_attribute_encoding(&mut self, _arg: core::ffi::c_int) -> (); fn get_attribute_encoding_min_value(&mut self) -> core::ffi::c_int; fn get_attribute_encoding_max_value(&mut self) -> core::ffi::c_int; fn get_attribute_encoding(&mut self) -> core::ffi::c_int; - fn print_xml(&mut self, fname: core::ffi::c_char) -> (); + fn print_xml(&mut self, fname: &str) -> (); fn get_character_data_width(&mut self) -> core::ffi::c_int; fn set_character_data_width(&mut self, _arg: core::ffi::c_int) -> (); } @@ -17205,23 +7836,6 @@ impl VtkAMRDataInternals for vtkAMRDataInternals { } unsafe { vtk_amr_data_internals_get_number_of_blocks(self.0) } } - fn get_block(&mut self, i: core::ffi::c_uint) -> Block { - unsafe extern "C" { - fn vtk_amr_data_internals_get_block( - sself: *mut core::ffi::c_void, - i: core::ffi::c_uint, - ) -> Block; - } - unsafe { vtk_amr_data_internals_get_block(self.0, i) } - } - fn get_all_blocks(&mut self) -> Vec { - unsafe extern "C" { - fn vtk_amr_data_internals_get_all_blocks( - sself: *mut core::ffi::c_void, - ) -> Vec; - } - unsafe { vtk_amr_data_internals_get_all_blocks(self.0) } - } } impl VtkAdjacentVertexIterator for vtkAdjacentVertexIterator { fn new(&mut self) -> *mut core::ffi::c_void { @@ -17249,12 +7863,12 @@ impl VtkAdjacentVertexIterator for vtkAdjacentVertexIterator { } unsafe { vtk_adjacent_vertex_iterator_new_instance(self.0) } } - fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> () { + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_adjacent_vertex_iterator_initialize( sself: *mut core::ffi::c_void, g: *mut core::ffi::c_void, - v: core::ffi::c_uchar, + v: core::ffi::c_longlong, ); } unsafe { vtk_adjacent_vertex_iterator_initialize(self.0, g, v) } @@ -17267,19 +7881,19 @@ impl VtkAdjacentVertexIterator for vtkAdjacentVertexIterator { } unsafe { vtk_adjacent_vertex_iterator_get_graph(self.0) } } - fn get_vertex(&mut self) -> core::ffi::c_uchar { + fn get_vertex(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_adjacent_vertex_iterator_get_vertex( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_adjacent_vertex_iterator_get_vertex(self.0) } } - fn next(&mut self) -> core::ffi::c_uchar { + fn next(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_adjacent_vertex_iterator_next( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_adjacent_vertex_iterator_next(self.0) } } @@ -17512,27 +8126,13 @@ impl VtkAnnotation for vtkAnnotation { } unsafe { vtk_annotation_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { + fn label(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_annotation_get_data( + fn vtk_annotation_label( sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, ) -> *mut core::ffi::c_void; } - unsafe { vtk_annotation_get_data(self.0, v, i) } - } - fn label(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_annotation_label( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_annotation_label(self.0) } + unsafe { vtk_annotation_label(self.0) } } fn color(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -17751,20 +8351,6 @@ impl VtkAnnotationLayers for vtkAnnotationLayers { } unsafe { vtk_annotation_layers_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_annotation_layers_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_annotation_layers_get_data(self.0, v, i) } - } fn get_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_annotation_layers_get_m_time( @@ -17809,20 +8395,6 @@ impl VtkArrayData for vtkArrayData { } unsafe { vtk_array_data_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_array_data_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_array_data_get_data(self.0, v, i) } - } fn add_array(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_array_data_add_array( @@ -17838,31 +8410,32 @@ impl VtkArrayData for vtkArrayData { } unsafe { vtk_array_data_clear_arrays(self.0) } } - fn get_number_of_arrays(&mut self) -> core::ffi::c_uchar { + fn get_number_of_arrays(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_array_data_get_number_of_arrays( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_array_data_get_number_of_arrays(self.0) } } - fn get_array(&mut self, index: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_array(&mut self, index: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_array_data_get_array( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_array_data_get_array(self.0, index) } } - fn get_array_by_name(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + fn get_array_by_name(&mut self, name: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_array_data_get_array_by_name( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } - unsafe { vtk_array_data_get_array_by_name(self.0, name) } + unsafe { vtk_array_data_get_array_by_name(self.0, c_name.as_ptr()) } } fn get_data_object_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { @@ -17953,58 +8526,6 @@ impl VtkAttributesErrorMetric for vtkAttributesErrorMetric { } unsafe { vtk_attributes_error_metric_set_attribute_tolerance(self.0, value) } } - fn requires_edge_subdivision( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_attributes_error_metric_requires_edge_subdivision( - sself: *mut core::ffi::c_void, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_attributes_error_metric_requires_edge_subdivision( - self.0, - leftPoint, - midPoint, - rightPoint, - alpha, - ) - } - } - fn get_error( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_attributes_error_metric_get_error( - sself: *mut core::ffi::c_void, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { - vtk_attributes_error_metric_get_error( - self.0, - leftPoint, - midPoint, - rightPoint, - alpha, - ) - } - } } impl VtkBSPCuts for vtkBSPCuts { fn new(&mut self) -> *mut core::ffi::c_void { @@ -18038,56 +8559,6 @@ impl VtkBSPCuts for vtkBSPCuts { } unsafe { vtk_bsp_cuts_get_data_object_type(self.0) } } - fn create_cuts( - &mut self, - bounds: core::ffi::c_double, - ncuts: core::ffi::c_int, - dim: core::ffi::c_int, - coord: core::ffi::c_double, - lower: core::ffi::c_int, - upper: core::ffi::c_int, - lowerDataCoord: core::ffi::c_double, - upperDataCoord: core::ffi::c_double, - npoints: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_bsp_cuts_create_cuts( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ncuts: core::ffi::c_int, - dim: core::ffi::c_int, - coord: core::ffi::c_double, - lower: core::ffi::c_int, - upper: core::ffi::c_int, - lowerDataCoord: core::ffi::c_double, - upperDataCoord: core::ffi::c_double, - npoints: core::ffi::c_int, - ); - } - unsafe { - vtk_bsp_cuts_create_cuts( - self.0, - bounds, - ncuts, - dim, - coord, - lower, - upper, - lowerDataCoord, - upperDataCoord, - npoints, - ) - } - } - fn create_cuts(&mut self, kd: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_bsp_cuts_create_cuts( - sself: *mut core::ffi::c_void, - kd: *mut core::ffi::c_void, - ); - } - unsafe { vtk_bsp_cuts_create_cuts(self.0, kd) } - } fn get_kd_node_tree(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_bsp_cuts_get_kd_node_tree( @@ -18104,44 +8575,6 @@ impl VtkBSPCuts for vtkBSPCuts { } unsafe { vtk_bsp_cuts_get_number_of_cuts(self.0) } } - fn get_arrays( - &mut self, - len: core::ffi::c_int, - dim: core::ffi::c_int, - coord: core::ffi::c_double, - lower: core::ffi::c_int, - upper: core::ffi::c_int, - lowerDataCoord: core::ffi::c_double, - upperDataCoord: core::ffi::c_double, - npoints: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bsp_cuts_get_arrays( - sself: *mut core::ffi::c_void, - len: core::ffi::c_int, - dim: core::ffi::c_int, - coord: core::ffi::c_double, - lower: core::ffi::c_int, - upper: core::ffi::c_int, - lowerDataCoord: core::ffi::c_double, - upperDataCoord: core::ffi::c_double, - npoints: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bsp_cuts_get_arrays( - self.0, - len, - dim, - coord, - lower, - upper, - lowerDataCoord, - upperDataCoord, - npoints, - ) - } - } fn equals( &mut self, other: *mut core::ffi::c_void, @@ -18177,20 +8610,6 @@ impl VtkBSPCuts for vtkBSPCuts { } unsafe { vtk_bsp_cuts_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bsp_cuts_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bsp_cuts_get_data(self.0, v, i) } - } fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_bsp_cuts_shallow_copy( @@ -18244,15 +8663,6 @@ impl VtkBSPIntersections for vtkBSPIntersections { } unsafe { vtk_bsp_intersections_get_cuts(self.0) } } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bsp_intersections_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_bsp_intersections_get_bounds(self.0, bounds) } - } fn get_number_of_regions(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_bsp_intersections_get_number_of_regions( @@ -18261,137 +8671,6 @@ impl VtkBSPIntersections for vtkBSPIntersections { } unsafe { vtk_bsp_intersections_get_number_of_regions(self.0) } } - fn get_region_bounds( - &mut self, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bsp_intersections_get_region_bounds( - sself: *mut core::ffi::c_void, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_bsp_intersections_get_region_bounds(self.0, regionID, bounds) } - } - fn get_region_data_bounds( - &mut self, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bsp_intersections_get_region_data_bounds( - sself: *mut core::ffi::c_void, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_bsp_intersections_get_region_data_bounds(self.0, regionID, bounds) } - } - fn intersects_box( - &mut self, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bsp_intersections_intersects_box( - sself: *mut core::ffi::c_void, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_bsp_intersections_intersects_box(self.0, regionId, x) } - } - fn intersects_box( - &mut self, - regionId: core::ffi::c_int, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - y0: core::ffi::c_double, - y1: core::ffi::c_double, - z0: core::ffi::c_double, - z1: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bsp_intersections_intersects_box( - sself: *mut core::ffi::c_void, - regionId: core::ffi::c_int, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - y0: core::ffi::c_double, - y1: core::ffi::c_double, - z0: core::ffi::c_double, - z1: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bsp_intersections_intersects_box( - self.0, - regionId, - x0, - x1, - y0, - y1, - z0, - z1, - ) - } - } - fn intersects_box( - &mut self, - ids: core::ffi::c_int, - len: core::ffi::c_int, - x: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bsp_intersections_intersects_box( - sself: *mut core::ffi::c_void, - ids: core::ffi::c_int, - len: core::ffi::c_int, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_bsp_intersections_intersects_box(self.0, ids, len, x) } - } - fn intersects_box( - &mut self, - ids: core::ffi::c_int, - len: core::ffi::c_int, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - y0: core::ffi::c_double, - y1: core::ffi::c_double, - z0: core::ffi::c_double, - z1: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bsp_intersections_intersects_box( - sself: *mut core::ffi::c_void, - ids: core::ffi::c_int, - len: core::ffi::c_int, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - y0: core::ffi::c_double, - y1: core::ffi::c_double, - z0: core::ffi::c_double, - z1: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bsp_intersections_intersects_box( - self.0, - ids, - len, - x0, - x1, - y0, - y1, - z0, - z1, - ) - } - } fn intersects_sphere_2( &mut self, regionId: core::ffi::c_int, @@ -18421,38 +8700,6 @@ impl VtkBSPIntersections for vtkBSPIntersections { ) } } - fn intersects_sphere_2( - &mut self, - ids: core::ffi::c_int, - len: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - rSquared: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bsp_intersections_intersects_sphere_2( - sself: *mut core::ffi::c_void, - ids: core::ffi::c_int, - len: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - rSquared: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bsp_intersections_intersects_sphere_2( - self.0, - ids, - len, - x, - y, - z, - rSquared, - ) - } - } fn intersects_cell( &mut self, regionId: core::ffi::c_int, @@ -18471,26 +8718,6 @@ impl VtkBSPIntersections for vtkBSPIntersections { vtk_bsp_intersections_intersects_cell(self.0, regionId, cell, cellRegion) } } - fn intersects_cell( - &mut self, - ids: core::ffi::c_int, - len: core::ffi::c_int, - cell: *mut core::ffi::c_void, - cellRegion: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bsp_intersections_intersects_cell( - sself: *mut core::ffi::c_void, - ids: core::ffi::c_int, - len: core::ffi::c_int, - cell: *mut core::ffi::c_void, - cellRegion: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bsp_intersections_intersects_cell(self.0, ids, len, cell, cellRegion) - } - } fn get_compute_intersections_using_data_bounds(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_bsp_intersections_get_compute_intersections_using_data_bounds( @@ -18570,42 +8797,16 @@ impl VtkBezierCurve for vtkBezierCurve { } unsafe { vtk_bezier_curve_get_cell_type(self.0) } } - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_curve_evaluate_location_projected_node( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_curve_evaluate_location_projected_node( - self.0, - subId, - point_id, - x, - weights, - ) - } - } fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_bezier_curve_set_rational_weights_from_point_data( sself: *mut core::ffi::c_void, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ); } unsafe { @@ -18616,20 +8817,6 @@ impl VtkBezierCurve for vtkBezierCurve { ) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_curve_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_bezier_curve_interpolate_functions(self.0, pcoords, weights) } - } fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_bezier_curve_get_rational_weights( @@ -18691,56 +8878,16 @@ impl VtkBezierHexahedron for vtkBezierHexahedron { } unsafe { vtk_bezier_hexahedron_get_face(self.0, faceId) } } - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_hexahedron_evaluate_location_projected_node( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_hexahedron_evaluate_location_projected_node( - self.0, - subId, - point_id, - x, - weights, - ) - } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_hexahedron_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_bezier_hexahedron_interpolate_functions(self.0, pcoords, weights) } - } fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_bezier_hexahedron_set_rational_weights_from_point_data( sself: *mut core::ffi::c_void, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ); } unsafe { @@ -18810,509 +8957,6 @@ impl VtkBezierInterpolation for vtkBezierInterpolation { } unsafe { vtk_bezier_interpolation_new_instance(self.0) } } - fn flatten_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - coord: vtkVector3i, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bezier_interpolation_flatten_simplex( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - coord: vtkVector3i, - ) -> core::ffi::c_int; - } - unsafe { vtk_bezier_interpolation_flatten_simplex(self.0, dim, deg, coord) } - } - fn flatten_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - coord: vtkVector3i, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bezier_interpolation_flatten_simplex( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - coord: vtkVector3i, - ) -> core::ffi::c_int; - } - unsafe { vtk_bezier_interpolation_flatten_simplex(self.0, dim, deg, coord) } - } - fn unflatten_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - flat: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bezier_interpolation_unflatten_simplex( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - flat: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bezier_interpolation_unflatten_simplex(self.0, dim, deg, flat) } - } - fn un_flatten_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - flat: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bezier_interpolation_un_flatten_simplex( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - flat: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bezier_interpolation_un_flatten_simplex(self.0, dim, deg, flat) } - } - fn de_casteljau_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_de_casteljau_simplex( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_de_casteljau_simplex( - self.0, - dim, - deg, - pcoords, - weights, - ) - } - } - fn de_casteljau_simplex( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_de_casteljau_simplex( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_de_casteljau_simplex( - self.0, - dim, - deg, - pcoords, - weights, - ) - } - } - fn de_casteljau_simplex_deriv( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_de_casteljau_simplex_deriv( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_de_casteljau_simplex_deriv( - self.0, - dim, - deg, - pcoords, - weights, - ) - } - } - fn de_casteljau_simplex_deriv( - &mut self, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_de_casteljau_simplex_deriv( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - deg: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_de_casteljau_simplex_deriv( - self.0, - dim, - deg, - pcoords, - weights, - ) - } - } - fn evaluate_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_evaluate_shape_functions( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_evaluate_shape_functions( - self.0, - order, - pcoord, - shape, - ) - } - } - fn evaluate_shape_and_gradient( - &mut self, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - grad: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_evaluate_shape_and_gradient( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - grad: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_evaluate_shape_and_gradient( - self.0, - order, - pcoord, - shape, - grad, - ) - } - } - fn tensor_1_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bezier_interpolation_tensor_1_shape_functions( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bezier_interpolation_tensor_1_shape_functions( - self.0, - order, - pcoords, - shape, - ) - } - } - fn tensor_1_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bezier_interpolation_tensor_1_shape_derivatives( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bezier_interpolation_tensor_1_shape_derivatives( - self.0, - order, - pcoords, - derivs, - ) - } - } - fn tensor_2_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bezier_interpolation_tensor_2_shape_functions( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bezier_interpolation_tensor_2_shape_functions( - self.0, - order, - pcoords, - shape, - ) - } - } - fn tensor_2_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bezier_interpolation_tensor_2_shape_derivatives( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bezier_interpolation_tensor_2_shape_derivatives( - self.0, - order, - pcoords, - derivs, - ) - } - } - fn tensor_3_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bezier_interpolation_tensor_3_shape_functions( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bezier_interpolation_tensor_3_shape_functions( - self.0, - order, - pcoords, - shape, - ) - } - } - fn tensor_3_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bezier_interpolation_tensor_3_shape_derivatives( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bezier_interpolation_tensor_3_shape_derivatives( - self.0, - order, - pcoords, - derivs, - ) - } - } - fn tensor_3_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_tensor_3_evaluate_derivative( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_tensor_3_evaluate_derivative( - self.0, - order, - pcoords, - points, - fieldVals, - fieldDim, - fieldDerivs, - ) - } - } - fn wedge_shape_functions( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_wedge_shape_functions( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_wedge_shape_functions( - self.0, - order, - numberOfPoints, - pcoords, - shape, - ) - } - } - fn wedge_shape_derivatives( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_wedge_shape_derivatives( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_wedge_shape_derivatives( - self.0, - order, - numberOfPoints, - pcoords, - derivs, - ) - } - } - fn wedge_evaluate( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldAtPCoords: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_wedge_evaluate( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldAtPCoords: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_wedge_evaluate( - self.0, - order, - numberOfPoints, - pcoords, - fieldVals, - fieldDim, - fieldAtPCoords, - ) - } - } - fn wedge_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_interpolation_wedge_evaluate_derivative( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_interpolation_wedge_evaluate_derivative( - self.0, - order, - pcoords, - points, - fieldVals, - fieldDim, - fieldDerivs, - ) - } - } } impl VtkBezierQuadrilateral for vtkBezierQuadrilateral { fn new(&mut self) -> *mut core::ffi::c_void { @@ -19357,58 +9001,16 @@ impl VtkBezierQuadrilateral for vtkBezierQuadrilateral { } unsafe { vtk_bezier_quadrilateral_get_edge(self.0, edgeId) } } - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_quadrilateral_evaluate_location_projected_node( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_quadrilateral_evaluate_location_projected_node( - self.0, - subId, - point_id, - x, - weights, - ) - } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_quadrilateral_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_quadrilateral_interpolate_functions(self.0, pcoords, weights) - } - } fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_bezier_quadrilateral_set_rational_weights_from_point_data( sself: *mut core::ffi::c_void, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ); } unsafe { @@ -19488,42 +9090,16 @@ impl VtkBezierTetra for vtkBezierTetra { } unsafe { vtk_bezier_tetra_get_face(self.0, faceId) } } - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_tetra_evaluate_location_projected_node( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_tetra_evaluate_location_projected_node( - self.0, - subId, - point_id, - x, - weights, - ) - } - } fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_bezier_tetra_set_rational_weights_from_point_data( sself: *mut core::ffi::c_void, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ); } unsafe { @@ -19534,20 +9110,6 @@ impl VtkBezierTetra for vtkBezierTetra { ) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_tetra_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_bezier_tetra_interpolate_functions(self.0, pcoords, weights) } - } fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_bezier_tetra_get_edge_cell( @@ -19616,42 +9178,16 @@ impl VtkBezierTriangle for vtkBezierTriangle { } unsafe { vtk_bezier_triangle_get_edge(self.0, edgeId) } } - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_triangle_evaluate_location_projected_node( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_triangle_evaluate_location_projected_node( - self.0, - subId, - point_id, - x, - weights, - ) - } - } fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_bezier_triangle_set_rational_weights_from_point_data( sself: *mut core::ffi::c_void, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ); } unsafe { @@ -19662,20 +9198,6 @@ impl VtkBezierTriangle for vtkBezierTriangle { ) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_triangle_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_bezier_triangle_interpolate_functions(self.0, pcoords, weights) } - } fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_bezier_triangle_get_edge_cell( @@ -19745,56 +9267,16 @@ impl VtkBezierWedge for vtkBezierWedge { } unsafe { vtk_bezier_wedge_get_face(self.0, faceId) } } - fn evaluate_location_projected_node( - &mut self, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_wedge_evaluate_location_projected_node( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - point_id: core::ffi::c_uchar, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bezier_wedge_evaluate_location_projected_node( - self.0, - subId, - point_id, - x, - weights, - ) - } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bezier_wedge_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_bezier_wedge_interpolate_functions(self.0, pcoords, weights) } - } fn set_rational_weights_from_point_data( &mut self, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_bezier_wedge_set_rational_weights_from_point_data( sself: *mut core::ffi::c_void, point_data: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, + numPts: core::ffi::c_longlong, ); } unsafe { @@ -19922,74 +9404,6 @@ impl VtkBiQuadraticQuad for vtkBiQuadraticQuad { } unsafe { vtk_bi_quadratic_quad_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_quad_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_bi_quadratic_quad_cell_boundary(self.0, subId, pcoords, pts) } - } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_quad_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_quad_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quad_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quad_evaluate_location(self.0, subId, pcoords, x, weights) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -20006,35 +9420,6 @@ impl VtkBiQuadraticQuad for vtkBiQuadraticQuad { } unsafe { vtk_bi_quadratic_quad_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quad_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quad_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn contour( &mut self, value: core::ffi::c_double, @@ -20046,7 +9431,7 @@ impl VtkBiQuadraticQuad for vtkBiQuadraticQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -20061,7 +9446,7 @@ impl VtkBiQuadraticQuad for vtkBiQuadraticQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -20091,7 +9476,7 @@ impl VtkBiQuadraticQuad for vtkBiQuadraticQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -20105,7 +9490,7 @@ impl VtkBiQuadraticQuad for vtkBiQuadraticQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -20126,81 +9511,6 @@ impl VtkBiQuadraticQuad for vtkBiQuadraticQuad { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_quad_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_quad_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_quad_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_bi_quadratic_quad_get_parametric_center(self.0, pcoords) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quad_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_bi_quadratic_quad_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quad_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_bi_quadratic_quad_interpolate_derivs(self.0, pcoords, derivs) } - } } impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { fn new(&mut self) -> *mut core::ffi::c_void { @@ -20278,29 +9588,6 @@ impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { } unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_quadratic_hexahedron_cell_boundary( - self.0, - subId, - pcoords, - pts, - ) - } - } fn contour( &mut self, value: core::ffi::c_double, @@ -20312,7 +9599,7 @@ impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -20327,7 +9614,7 @@ impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -20348,64 +9635,6 @@ impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_quadratic_hexahedron_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_hexahedron_evaluate_location( - self.0, - subId, - pcoords, - x, - weights, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -20424,35 +9653,6 @@ impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { vtk_bi_quadratic_quadratic_hexahedron_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_hexahedron_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -20462,7 +9662,7 @@ impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -20476,7 +9676,7 @@ impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -20497,184 +9697,22 @@ impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { +} +impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_intersect_with_line( + fn vtk_bi_quadratic_quadratic_wedge_new( sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_quadratic_hexahedron_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) + ) -> *mut core::ffi::c_void; } + unsafe { vtk_bi_quadratic_quadratic_wedge_new(self.0) } } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_interpolation_functions( + fn vtk_bi_quadratic_quadratic_wedge_safe_down_cast( sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_hexahedron_interpolation_functions( - self.0, - pcoords, - weights, - ) - } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_hexahedron_interpolation_derivs( - self.0, - pcoords, - derivs, - ) - } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_hexahedron_interpolate_functions( - self.0, - pcoords, - weights, - ) - } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_hexahedron_interpolate_derivs( - self.0, - pcoords, - derivs, - ) - } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_face_array(self.0, faceId) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_hexahedron_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_hexahedron_jacobian_inverse( - self.0, - pcoords, - inverse, - derivs, - ) - } - } -} -impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_bi_quadratic_quadratic_wedge_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } unsafe { vtk_bi_quadratic_quadratic_wedge_safe_down_cast(self.0, o) } } @@ -20736,24 +9774,6 @@ impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { } unsafe { vtk_bi_quadratic_quadratic_wedge_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_cell_boundary(self.0, subId, pcoords, pts) - } - } fn contour( &mut self, value: core::ffi::c_double, @@ -20765,7 +9785,7 @@ impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -20780,7 +9800,7 @@ impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -20801,64 +9821,6 @@ impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_evaluate_location( - self.0, - subId, - pcoords, - x, - weights, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -20877,35 +9839,6 @@ impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { vtk_bi_quadratic_quadratic_wedge_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -20915,7 +9848,7 @@ impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -20929,7 +9862,7 @@ impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -20950,178 +9883,6 @@ impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_get_parametric_center(self.0, pcoords) - } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_interpolation_functions( - self.0, - pcoords, - weights, - ) - } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_interpolation_derivs( - self.0, - pcoords, - derivs, - ) - } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_interpolate_functions( - self.0, - pcoords, - weights, - ) - } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_interpolate_derivs(self.0, pcoords, derivs) - } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_bi_quadratic_quadratic_wedge_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_bi_quadratic_quadratic_wedge_get_face_array(self.0, faceId) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_quadratic_wedge_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_quadratic_wedge_jacobian_inverse( - self.0, - pcoords, - inverse, - derivs, - ) - } - } } impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { fn new(&mut self) -> *mut core::ffi::c_void { @@ -21199,22 +9960,6 @@ impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { } unsafe { vtk_bi_quadratic_triangle_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_bi_quadratic_triangle_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -21226,7 +9971,7 @@ impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -21241,7 +9986,7 @@ impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -21262,64 +10007,6 @@ impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_triangle_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_triangle_evaluate_location( - self.0, - subId, - pcoords, - x, - weights, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -21336,35 +10023,6 @@ impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { } unsafe { vtk_bi_quadratic_triangle_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_triangle_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -21374,7 +10032,7 @@ impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -21388,7 +10046,7 @@ impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -21409,127 +10067,6 @@ impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_bi_quadratic_triangle_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_bi_quadratic_triangle_get_parametric_center(self.0, pcoords) } - } - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_get_parametric_distance( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_bi_quadratic_triangle_get_parametric_distance(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_triangle_interpolation_functions(self.0, pcoords, weights) - } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_triangle_interpolation_derivs(self.0, pcoords, derivs) - } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_bi_quadratic_triangle_interpolate_functions(self.0, pcoords, weights) - } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_bi_quadratic_triangle_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_bi_quadratic_triangle_interpolate_derivs(self.0, pcoords, derivs) } - } } impl VtkBox for vtkBox { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -21555,35 +10092,6 @@ impl VtkBox for vtkBox { } unsafe { vtk_box_new(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_box_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_box_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_box_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_box_evaluate_gradient(self.0, x, n) } - } - fn set_x_min(&mut self, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_box_set_x_min(sself: *mut core::ffi::c_void, p: core::ffi::c_double); - } - unsafe { vtk_box_set_x_min(self.0, p) } - } fn set_x_min( &mut self, x: core::ffi::c_double, @@ -21600,34 +10108,22 @@ impl VtkBox for vtkBox { } unsafe { vtk_box_set_x_min(self.0, x, y, z) } } - fn get_x_min(&mut self, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_box_get_x_min(sself: *mut core::ffi::c_void, p: core::ffi::c_double); - } - unsafe { vtk_box_get_x_min(self.0, p) } - } fn get_x_min( &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, ) -> () { unsafe extern "C" { fn vtk_box_get_x_min( sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, ); } unsafe { vtk_box_get_x_min(self.0, x, y, z) } } - fn set_x_max(&mut self, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_box_set_x_max(sself: *mut core::ffi::c_void, p: core::ffi::c_double); - } - unsafe { vtk_box_set_x_max(self.0, p) } - } fn set_x_max( &mut self, x: core::ffi::c_double, @@ -21644,24 +10140,18 @@ impl VtkBox for vtkBox { } unsafe { vtk_box_set_x_max(self.0, x, y, z) } } - fn get_x_max(&mut self, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_box_get_x_max(sself: *mut core::ffi::c_void, p: core::ffi::c_double); - } - unsafe { vtk_box_get_x_max(self.0, p) } - } fn get_x_max( &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, ) -> () { unsafe extern "C" { fn vtk_box_get_x_max( sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, ); } unsafe { vtk_box_get_x_max(self.0, x, y, z) } @@ -21688,217 +10178,28 @@ impl VtkBox for vtkBox { } unsafe { vtk_box_set_bounds(self.0, xMin, xMax, yMin, yMax, zMin, zMax) } } - fn set_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_box_set_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_box_set_bounds(self.0, bounds) } - } fn get_bounds( &mut self, - xMin: core::ffi::c_double, - xMax: core::ffi::c_double, - yMin: core::ffi::c_double, - yMax: core::ffi::c_double, - zMin: core::ffi::c_double, - zMax: core::ffi::c_double, + xMin: &mut core::ffi::c_double, + xMax: &mut core::ffi::c_double, + yMin: &mut core::ffi::c_double, + yMax: &mut core::ffi::c_double, + zMin: &mut core::ffi::c_double, + zMax: &mut core::ffi::c_double, ) -> () { unsafe extern "C" { fn vtk_box_get_bounds( sself: *mut core::ffi::c_void, - xMin: core::ffi::c_double, - xMax: core::ffi::c_double, - yMin: core::ffi::c_double, - yMax: core::ffi::c_double, - zMin: core::ffi::c_double, - zMax: core::ffi::c_double, + xMin: &mut core::ffi::c_double, + xMax: &mut core::ffi::c_double, + yMin: &mut core::ffi::c_double, + yMax: &mut core::ffi::c_double, + zMin: &mut core::ffi::c_double, + zMax: &mut core::ffi::c_double, ); } unsafe { vtk_box_get_bounds(self.0, xMin, xMax, yMin, yMax, zMin, zMax) } } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_box_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_box_get_bounds(self.0, bounds) } - } - fn get_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_box_get_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_box_get_bounds(self.0) } - } - fn add_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_box_add_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_box_add_bounds(self.0, bounds) } - } - fn intersect_box( - &mut self, - bounds: core::ffi::c_double, - origin: core::ffi::c_double, - dir: core::ffi::c_double, - coord: core::ffi::c_double, - t: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_char { - unsafe extern "C" { - fn vtk_box_intersect_box( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - origin: core::ffi::c_double, - dir: core::ffi::c_double, - coord: core::ffi::c_double, - t: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_char; - } - unsafe { - vtk_box_intersect_box(self.0, bounds, origin, dir, coord, t, tolerance) - } - } - fn intersect_with_line( - &mut self, - bounds: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - plane1: core::ffi::c_int, - plane2: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_box_intersect_with_line( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - plane1: core::ffi::c_int, - plane2: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_box_intersect_with_line( - self.0, - bounds, - p1, - p2, - t1, - t2, - x1, - x2, - plane1, - plane2, - ) - } - } - fn intersect_with_infinite_line( - &mut self, - bounds: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - plane1: core::ffi::c_int, - plane2: core::ffi::c_int, - ) -> bool { - unsafe extern "C" { - fn vtk_box_intersect_with_infinite_line( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - plane1: core::ffi::c_int, - plane2: core::ffi::c_int, - ) -> bool; - } - unsafe { - vtk_box_intersect_with_infinite_line( - self.0, - bounds, - p1, - p2, - t1, - t2, - x1, - x2, - plane1, - plane2, - ) - } - } - fn intersect_with_plane( - &mut self, - bounds: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_box_intersect_with_plane( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_box_intersect_with_plane(self.0, bounds, origin, normal) } - } - fn intersect_with_plane( - &mut self, - bounds: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - xout: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_box_intersect_with_plane( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - xout: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_box_intersect_with_plane(self.0, bounds, origin, normal, xout) } - } - fn is_box_in_frustum( - &mut self, - planes: core::ffi::c_double, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_box_is_box_in_frustum( - sself: *mut core::ffi::c_void, - planes: core::ffi::c_double, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_box_is_box_in_frustum(self.0, planes, bounds) } - } } impl VtkCellArray for vtkCellArray { fn new(&mut self) -> *mut core::ffi::c_void { @@ -21928,42 +10229,42 @@ impl VtkCellArray for vtkCellArray { } fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_cell_array_allocate( sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_cell_array_allocate(self.0, sz, ext) } } fn allocate_estimate( &mut self, - numCells: core::ffi::c_uchar, - maxCellSize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, ) -> bool { unsafe extern "C" { fn vtk_cell_array_allocate_estimate( sself: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, - maxCellSize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_cell_array_allocate_estimate(self.0, numCells, maxCellSize) } } fn allocate_exact( &mut self, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool { unsafe extern "C" { fn vtk_cell_array_allocate_exact( sself: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_cell_array_allocate_exact(self.0, numCells, connectivitySize) } @@ -21979,14 +10280,14 @@ impl VtkCellArray for vtkCellArray { } fn resize_exact( &mut self, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool { unsafe extern "C" { fn vtk_cell_array_resize_exact( sself: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_cell_array_resize_exact(self.0, numCells, connectivitySize) } @@ -22015,27 +10316,27 @@ impl VtkCellArray for vtkCellArray { } unsafe { vtk_cell_array_is_valid(self.0) } } - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_get_number_of_cells( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_get_number_of_cells(self.0) } } - fn get_number_of_offsets(&mut self) -> core::ffi::c_uchar { + fn get_number_of_offsets(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_get_number_of_offsets( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_get_number_of_offsets(self.0) } } - fn get_number_of_connectivity_ids(&mut self) -> core::ffi::c_uchar { + fn get_number_of_connectivity_ids(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_get_number_of_connectivity_ids( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_get_number_of_connectivity_ids(self.0) } } @@ -22061,20 +10362,6 @@ impl VtkCellArray for vtkCellArray { } unsafe { vtk_cell_array_set_data(self.0, offsets, connectivity) } } - fn set_data( - &mut self, - cellSize: core::ffi::c_uchar, - connectivity: *mut core::ffi::c_void, - ) -> bool { - unsafe extern "C" { - fn vtk_cell_array_set_data( - sself: *mut core::ffi::c_void, - cellSize: core::ffi::c_uchar, - connectivity: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_cell_array_set_data(self.0, cellSize, connectivity) } - } fn is_storage_64_bit(&mut self) -> bool { unsafe extern "C" { fn vtk_cell_array_is_storage_64_bit(sself: *mut core::ffi::c_void) -> bool; @@ -22211,11 +10498,11 @@ impl VtkCellArray for vtkCellArray { } unsafe { vtk_cell_array_get_connectivity_array_64(self.0) } } - fn is_homogeneous(&mut self) -> core::ffi::c_uchar { + fn is_homogeneous(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_is_homogeneous( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_is_homogeneous(self.0) } } @@ -22225,126 +10512,32 @@ impl VtkCellArray for vtkCellArray { } unsafe { vtk_cell_array_init_traversal(self.0) } } - fn get_next_cell( - &mut self, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_int { + fn get_cell_size(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_cell_array_get_next_cell( + fn vtk_cell_array_get_cell_size( sself: *mut core::ffi::c_void, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_int; + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } - unsafe { vtk_cell_array_get_next_cell(self.0, npts, pts) } - } - fn get_next_cell(&mut self, pts: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_cell_array_get_next_cell( - sself: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_cell_array_get_next_cell(self.0, pts) } - } - fn get_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - cellSize: core::ffi::c_uchar, - cellPoints: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_get_cell_at_id( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - cellSize: core::ffi::c_uchar, - cellPoints: core::ffi::c_uchar, - ); - } - unsafe { vtk_cell_array_get_cell_at_id(self.0, cellId, cellSize, cellPoints) } - } - fn get_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - pts: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_get_cell_at_id( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - pts: *mut core::ffi::c_void, - ); - } - unsafe { vtk_cell_array_get_cell_at_id(self.0, cellId, pts) } - } - fn get_cell_size(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_cell_array_get_cell_size( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_cell_array_get_cell_size(self.0, cellId) } - } - fn insert_next_cell(&mut self, cell: *mut core::ffi::c_void) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_cell_array_insert_next_cell( - sself: *mut core::ffi::c_void, - cell: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_cell_array_insert_next_cell(self.0, cell) } + unsafe { vtk_cell_array_get_cell_size(self.0, cellId) } } fn insert_next_cell( &mut self, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_cell_array_insert_next_cell( - sself: *mut core::ffi::c_void, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_cell_array_insert_next_cell(self.0, npts, pts) } - } - fn insert_next_cell(&mut self, pts: *mut core::ffi::c_void) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_cell_array_insert_next_cell( - sself: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_cell_array_insert_next_cell(self.0, pts) } - } - fn insert_next_cell( - &mut self, - cell: std::collections::LinkedList, - ) -> core::ffi::c_uchar { + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_insert_next_cell( sself: *mut core::ffi::c_void, - cell: std::collections::LinkedList, - ) -> core::ffi::c_uchar; + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_insert_next_cell(self.0, cell) } } - fn insert_next_cell(&mut self, npts: core::ffi::c_int) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_cell_array_insert_next_cell( - sself: *mut core::ffi::c_void, - npts: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_cell_array_insert_next_cell(self.0, npts) } - } - fn insert_cell_point(&mut self, id: core::ffi::c_uchar) -> () { + fn insert_cell_point(&mut self, id: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_cell_array_insert_cell_point( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ); } unsafe { vtk_cell_array_insert_cell_point(self.0, id) } @@ -22358,78 +10551,46 @@ impl VtkCellArray for vtkCellArray { } unsafe { vtk_cell_array_update_cell_count(self.0, npts) } } - fn get_traversal_cell_id(&mut self) -> core::ffi::c_uchar { + fn get_traversal_cell_id(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_get_traversal_cell_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_get_traversal_cell_id(self.0) } } - fn set_traversal_cell_id(&mut self, cellId: core::ffi::c_uchar) -> () { + fn set_traversal_cell_id(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_cell_array_set_traversal_cell_id( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_cell_array_set_traversal_cell_id(self.0, cellId) } } - fn reverse_cell_at_id(&mut self, cellId: core::ffi::c_uchar) -> () { + fn reverse_cell_at_id(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_cell_array_reverse_cell_at_id( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_cell_array_reverse_cell_at_id(self.0, cellId) } } fn replace_cell_at_id( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, list: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_cell_array_replace_cell_at_id( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, list: *mut core::ffi::c_void, ); } unsafe { vtk_cell_array_replace_cell_at_id(self.0, cellId, list) } } - fn replace_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - cellSize: core::ffi::c_uchar, - cellPoints: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_replace_cell_at_id( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - cellSize: core::ffi::c_uchar, - cellPoints: core::ffi::c_uchar, - ); - } - unsafe { - vtk_cell_array_replace_cell_at_id(self.0, cellId, cellSize, cellPoints) - } - } - fn replace_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - cell: std::collections::LinkedList, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_replace_cell_at_id( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - cell: std::collections::LinkedList, - ); - } - unsafe { vtk_cell_array_replace_cell_at_id(self.0, cellId, cell) } - } fn get_max_cell_size(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_cell_array_get_max_cell_size( @@ -22459,13 +10620,13 @@ impl VtkCellArray for vtkCellArray { fn append( &mut self, src: *mut core::ffi::c_void, - pointOffset: core::ffi::c_uchar, + pointOffset: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_cell_array_append( sself: *mut core::ffi::c_void, src: *mut core::ffi::c_void, - pointOffset: core::ffi::c_uchar, + pointOffset: core::ffi::c_longlong, ); } unsafe { vtk_cell_array_append(self.0, src, pointOffset) } @@ -22488,50 +10649,20 @@ impl VtkCellArray for vtkCellArray { } unsafe { vtk_cell_array_import_legacy_format(self.0, data) } } - fn import_legacy_format( - &mut self, - data: core::ffi::c_uchar, - len: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_import_legacy_format( - sself: *mut core::ffi::c_void, - data: core::ffi::c_uchar, - len: core::ffi::c_uchar, - ); - } - unsafe { vtk_cell_array_import_legacy_format(self.0, data, len) } - } fn append_legacy_format( &mut self, data: *mut core::ffi::c_void, - ptOffset: core::ffi::c_uchar, + ptOffset: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_cell_array_append_legacy_format( sself: *mut core::ffi::c_void, data: *mut core::ffi::c_void, - ptOffset: core::ffi::c_uchar, + ptOffset: core::ffi::c_longlong, ); } unsafe { vtk_cell_array_append_legacy_format(self.0, data, ptOffset) } } - fn append_legacy_format( - &mut self, - data: core::ffi::c_uchar, - len: core::ffi::c_uchar, - ptOffset: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_append_legacy_format( - sself: *mut core::ffi::c_void, - data: core::ffi::c_uchar, - len: core::ffi::c_uchar, - ptOffset: core::ffi::c_uchar, - ); - } - unsafe { vtk_cell_array_append_legacy_format(self.0, data, len, ptOffset) } - } fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_cell_array_get_actual_memory_size( @@ -22540,143 +10671,89 @@ impl VtkCellArray for vtkCellArray { } unsafe { vtk_cell_array_get_actual_memory_size(self.0) } } - fn set_number_of_cells(&mut self, p0: core::ffi::c_uchar) -> () { + fn set_number_of_cells(&mut self, p0: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_cell_array_set_number_of_cells( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, ); } unsafe { vtk_cell_array_set_number_of_cells(self.0, p0) } } fn estimate_size( &mut self, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, maxPtsPerCell: core::ffi::c_int, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_estimate_size( sself: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, maxPtsPerCell: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_estimate_size(self.0, numCells, maxPtsPerCell) } } - fn get_size(&mut self) -> core::ffi::c_uchar { + fn get_size(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_get_size( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_get_size(self.0) } } - fn get_number_of_connectivity_entries(&mut self) -> core::ffi::c_uchar { + fn get_number_of_connectivity_entries(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_get_number_of_connectivity_entries( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_get_number_of_connectivity_entries(self.0) } } - fn get_cell( - &mut self, - loc: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_get_cell( - sself: *mut core::ffi::c_void, - loc: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_cell_array_get_cell(self.0, loc, npts, pts) } - } - fn get_cell(&mut self, loc: core::ffi::c_uchar, pts: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_cell_array_get_cell( - sself: *mut core::ffi::c_void, - loc: core::ffi::c_uchar, - pts: *mut core::ffi::c_void, - ); - } - unsafe { vtk_cell_array_get_cell(self.0, loc, pts) } - } - fn get_insert_location(&mut self, npts: core::ffi::c_int) -> core::ffi::c_uchar { + fn get_insert_location(&mut self, npts: core::ffi::c_int) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_get_insert_location( sself: *mut core::ffi::c_void, npts: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_get_insert_location(self.0, npts) } } - fn get_traversal_location(&mut self) -> core::ffi::c_uchar { + fn get_traversal_location(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_get_traversal_location( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_get_traversal_location(self.0) } } - fn get_traversal_location( - &mut self, - npts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_cell_array_get_traversal_location( - sself: *mut core::ffi::c_void, - npts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_cell_array_get_traversal_location(self.0, npts) } - } - fn set_traversal_location(&mut self, loc: core::ffi::c_uchar) -> () { + fn set_traversal_location(&mut self, loc: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_cell_array_set_traversal_location( sself: *mut core::ffi::c_void, - loc: core::ffi::c_uchar, + loc: core::ffi::c_longlong, ); } unsafe { vtk_cell_array_set_traversal_location(self.0, loc) } } - fn reverse_cell(&mut self, loc: core::ffi::c_uchar) -> () { + fn reverse_cell(&mut self, loc: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_cell_array_reverse_cell( sself: *mut core::ffi::c_void, - loc: core::ffi::c_uchar, + loc: core::ffi::c_longlong, ); } unsafe { vtk_cell_array_reverse_cell(self.0, loc) } } - fn replace_cell( - &mut self, - loc: core::ffi::c_uchar, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_replace_cell( - sself: *mut core::ffi::c_void, - loc: core::ffi::c_uchar, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_cell_array_replace_cell(self.0, loc, npts, pts) } - } fn set_cells( &mut self, - ncells: core::ffi::c_uchar, + ncells: core::ffi::c_longlong, cells: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_cell_array_set_cells( sself: *mut core::ffi::c_void, - ncells: core::ffi::c_uchar, + ncells: core::ffi::c_longlong, cells: *mut core::ffi::c_void, ); } @@ -22725,56 +10802,15 @@ impl VtkCellArrayIterator for vtkCellArrayIterator { } unsafe { vtk_cell_array_iterator_get_cell_array(self.0) } } - fn go_to_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + fn go_to_cell(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_cell_array_iterator_go_to_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_cell_array_iterator_go_to_cell(self.0, cellId) } } - fn get_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - numCellPts: core::ffi::c_uchar, - cellPts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_iterator_get_cell_at_id( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - numCellPts: core::ffi::c_uchar, - cellPts: core::ffi::c_uchar, - ); - } - unsafe { - vtk_cell_array_iterator_get_cell_at_id(self.0, cellId, numCellPts, cellPts) - } - } - fn get_cell_at_id( - &mut self, - cellId: core::ffi::c_uchar, - cellIds: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_iterator_get_cell_at_id( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - cellIds: *mut core::ffi::c_void, - ); - } - unsafe { vtk_cell_array_iterator_get_cell_at_id(self.0, cellId, cellIds) } - } - fn get_cell_at_id(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_cell_array_iterator_get_cell_at_id( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_cell_array_iterator_get_cell_at_id(self.0, cellId) } - } fn go_to_first_cell(&mut self) -> () { unsafe extern "C" { fn vtk_cell_array_iterator_go_to_first_cell(sself: *mut core::ffi::c_void); @@ -22795,45 +10831,14 @@ impl VtkCellArrayIterator for vtkCellArrayIterator { } unsafe { vtk_cell_array_iterator_is_done_with_traversal(self.0) } } - fn get_current_cell_id(&mut self) -> core::ffi::c_uchar { + fn get_current_cell_id(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_array_iterator_get_current_cell_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_array_iterator_get_current_cell_id(self.0) } } - fn get_current_cell( - &mut self, - cellSize: core::ffi::c_uchar, - cellPoints: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_iterator_get_current_cell( - sself: *mut core::ffi::c_void, - cellSize: core::ffi::c_uchar, - cellPoints: core::ffi::c_uchar, - ); - } - unsafe { vtk_cell_array_iterator_get_current_cell(self.0, cellSize, cellPoints) } - } - fn get_current_cell(&mut self, ids: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_cell_array_iterator_get_current_cell( - sself: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - ); - } - unsafe { vtk_cell_array_iterator_get_current_cell(self.0, ids) } - } - fn get_current_cell(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_cell_array_iterator_get_current_cell( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_cell_array_iterator_get_current_cell(self.0) } - } fn replace_current_cell(&mut self, list: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_cell_array_iterator_replace_current_cell( @@ -22843,20 +10848,6 @@ impl VtkCellArrayIterator for vtkCellArrayIterator { } unsafe { vtk_cell_array_iterator_replace_current_cell(self.0, list) } } - fn replace_current_cell( - &mut self, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_cell_array_iterator_replace_current_cell( - sself: *mut core::ffi::c_void, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_cell_array_iterator_replace_current_cell(self.0, npts, pts) } - } fn reverse_current_cell(&mut self) -> () { unsafe extern "C" { fn vtk_cell_array_iterator_reverse_current_cell( @@ -22936,12 +10927,16 @@ impl VtkCellLinks for vtkCellLinks { } unsafe { vtk_cell_links_build_links(self.0, data) } } - fn allocate(&mut self, numLinks: core::ffi::c_uchar, ext: core::ffi::c_uchar) -> () { + fn allocate( + &mut self, + numLinks: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> () { unsafe extern "C" { fn vtk_cell_links_allocate( sself: *mut core::ffi::c_void, - numLinks: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + numLinks: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ); } unsafe { vtk_cell_links_allocate(self.0, numLinks, ext) } @@ -22952,116 +10947,87 @@ impl VtkCellLinks for vtkCellLinks { } unsafe { vtk_cell_links_initialize(self.0) } } - fn get_link(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_cell_links_get_link( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_cell_links_get_link(self.0, ptId) } - } - fn get_ncells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn get_ncells(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_links_get_ncells( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_links_get_ncells(self.0, ptId) } } - fn get_cells(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_cell_links_get_cells( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_cell_links_get_cells(self.0, ptId) } - } - fn select_cells( + fn insert_next_point( &mut self, - minMaxDegree: core::ffi::c_uchar, - cellSelection: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_cell_links_select_cells( - sself: *mut core::ffi::c_void, - minMaxDegree: core::ffi::c_uchar, - cellSelection: core::ffi::c_uchar, - ); - } - unsafe { vtk_cell_links_select_cells(self.0, minMaxDegree, cellSelection) } - } - fn insert_next_point(&mut self, numLinks: core::ffi::c_int) -> core::ffi::c_uchar { + numLinks: core::ffi::c_int, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_links_insert_next_point( sself: *mut core::ffi::c_void, numLinks: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_links_insert_next_point(self.0, numLinks) } } fn insert_next_cell_reference( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_cell_links_insert_next_cell_reference( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_cell_links_insert_next_cell_reference(self.0, ptId, cellId) } } - fn delete_point(&mut self, ptId: core::ffi::c_uchar) -> () { + fn delete_point(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_cell_links_delete_point( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_cell_links_delete_point(self.0, ptId) } } fn remove_cell_reference( &mut self, - cellId: core::ffi::c_uchar, - ptId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_cell_links_remove_cell_reference( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ptId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_cell_links_remove_cell_reference(self.0, cellId, ptId) } } fn add_cell_reference( &mut self, - cellId: core::ffi::c_uchar, - ptId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_cell_links_add_cell_reference( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ptId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_cell_links_add_cell_reference(self.0, cellId, ptId) } } fn resize_cell_list( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, size: core::ffi::c_int, ) -> () { unsafe extern "C" { fn vtk_cell_links_resize_cell_list( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, size: core::ffi::c_int, ); } @@ -23140,117 +11106,6 @@ impl VtkCellLocator for vtkCellLocator { } unsafe { vtk_cell_locator_get_number_of_cells_per_bucket(self.0) } } - fn intersect_with_line( - &mut self, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_cell_locator_intersect_with_line( - sself: *mut core::ffi::c_void, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_cell_locator_intersect_with_line( - self.0, - a0, - a1, - tol, - t, - x, - pcoords, - subId, - cellId, - cell, - ) - } - } - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cell_locator_find_closest_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - ); - } - unsafe { - vtk_cell_locator_find_closest_point( - self.0, - x, - closestPoint, - cell, - cellId, - subId, - dist2, - ) - } - } - fn find_closest_point_within_radius( - &mut self, - x: core::ffi::c_double, - radius: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - inside: core::ffi::c_int, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_cell_locator_find_closest_point_within_radius( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - radius: core::ffi::c_double, - closestPoint: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - subId: core::ffi::c_int, - dist2: core::ffi::c_double, - inside: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_cell_locator_find_closest_point_within_radius( - self.0, - x, - radius, - closestPoint, - cell, - cellId, - subId, - dist2, - inside, - ) - } - } fn get_cells(&mut self, bucket: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_cell_locator_get_cells( @@ -23268,26 +11123,6 @@ impl VtkCellLocator for vtkCellLocator { } unsafe { vtk_cell_locator_get_number_of_buckets(self.0) } } - fn find_cells_along_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tolerance: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_cell_locator_find_cells_along_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tolerance: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_cell_locator_find_cells_along_line(self.0, p1, p2, tolerance, cells) - } - } fn free_search_structure(&mut self) -> () { unsafe extern "C" { fn vtk_cell_locator_free_search_structure(sself: *mut core::ffi::c_void); @@ -23368,44 +11203,6 @@ impl VtkCellLocatorStrategy for vtkCellLocatorStrategy { } unsafe { vtk_cell_locator_strategy_initialize(self.0, ps) } } - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_cell_locator_strategy_find_cell( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_cell_locator_strategy_find_cell( - self.0, - x, - cell, - gencell, - cellId, - tol2, - subId, - pcoords, - weights, - ) - } - } fn set_cell_locator(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_cell_locator_strategy_set_cell_locator( @@ -23452,30 +11249,30 @@ impl VtkCellTypes for vtkCellTypes { } fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_cell_types_allocate( sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_cell_types_allocate(self.0, sz, ext) } } fn insert_cell( &mut self, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, type_: core::ffi::c_uchar, - loc: core::ffi::c_uchar, + loc: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_cell_types_insert_cell( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, type_: core::ffi::c_uchar, - loc: core::ffi::c_uchar, + loc: core::ffi::c_longlong, ); } unsafe { vtk_cell_types_insert_cell(self.0, id, type_, loc) } @@ -23483,27 +11280,27 @@ impl VtkCellTypes for vtkCellTypes { fn insert_next_cell( &mut self, type_: core::ffi::c_uchar, - loc: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + loc: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_types_insert_next_cell( sself: *mut core::ffi::c_void, type_: core::ffi::c_uchar, - loc: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + loc: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_types_insert_next_cell(self.0, type_, loc) } } fn set_cell_types( &mut self, - ncells: core::ffi::c_uchar, + ncells: core::ffi::c_longlong, cellTypes: *mut core::ffi::c_void, cellLocations: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_cell_types_set_cell_types( sself: *mut core::ffi::c_void, - ncells: core::ffi::c_uchar, + ncells: core::ffi::c_longlong, cellTypes: *mut core::ffi::c_void, cellLocations: *mut core::ffi::c_void, ); @@ -23512,47 +11309,32 @@ impl VtkCellTypes for vtkCellTypes { vtk_cell_types_set_cell_types(self.0, ncells, cellTypes, cellLocations) } } - fn set_cell_types( + fn get_cell_location( &mut self, - ncells: core::ffi::c_uchar, - cellTypes: *mut core::ffi::c_void, - cellLocations: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_cell_types_set_cell_types( - sself: *mut core::ffi::c_void, - ncells: core::ffi::c_uchar, - cellTypes: *mut core::ffi::c_void, - cellLocations: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_cell_types_set_cell_types(self.0, ncells, cellTypes, cellLocations) - } - } - fn get_cell_location(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_types_get_cell_location( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_types_get_cell_location(self.0, cellId) } } - fn delete_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + fn delete_cell(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_cell_types_delete_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_cell_types_delete_cell(self.0, cellId) } } - fn get_number_of_types(&mut self) -> core::ffi::c_uchar { + fn get_number_of_types(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_types_get_number_of_types( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_types_get_number_of_types(self.0) } } @@ -23565,20 +11347,20 @@ impl VtkCellTypes for vtkCellTypes { } unsafe { vtk_cell_types_is_type(self.0, type_) } } - fn insert_next_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn insert_next_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_cell_types_insert_next_type( sself: *mut core::ffi::c_void, type_: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_cell_types_insert_next_type(self.0, type_) } } - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_cell_types_get_cell_type( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_cell_types_get_cell_type(self.0, cellId) } @@ -23612,29 +11394,31 @@ impl VtkCellTypes for vtkCellTypes { } unsafe { vtk_cell_types_deep_copy(self.0, src) } } - fn get_class_name_from_type_id( - &mut self, - typeId: core::ffi::c_int, - ) -> *const core::ffi::c_char { + fn get_class_name_from_type_id(&mut self, typeId: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_cell_types_get_class_name_from_type_id( sself: *mut core::ffi::c_void, typeId: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_cell_types_get_class_name_from_type_id(self.0, typeId) } + let ptr = unsafe { vtk_cell_types_get_class_name_from_type_id(self.0, typeId) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn get_type_id_from_class_name( - &mut self, - classname: core::ffi::c_char, - ) -> core::ffi::c_int { + fn get_type_id_from_class_name(&mut self, classname: &str) -> core::ffi::c_int { + let c_classname = std::ffi::CString::new(classname) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_cell_types_get_type_id_from_class_name( sself: *mut core::ffi::c_void, - classname: core::ffi::c_char, + classname: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_cell_types_get_type_id_from_class_name(self.0, classname) } + unsafe { + vtk_cell_types_get_type_id_from_class_name(self.0, c_classname.as_ptr()) + } } fn is_linear(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int { unsafe extern "C" { @@ -23688,44 +11472,6 @@ impl VtkClosestNPointsStrategy for vtkClosestNPointsStrategy { } unsafe { vtk_closest_n_points_strategy_new_instance(self.0) } } - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_closest_n_points_strategy_find_cell( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_closest_n_points_strategy_find_cell( - self.0, - x, - cell, - gencell, - cellId, - tol2, - subId, - pcoords, - weights, - ) - } - } fn set_closest_n_points(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_closest_n_points_strategy_set_closest_n_points( @@ -23795,44 +11541,6 @@ impl VtkClosestPointStrategy for vtkClosestPointStrategy { } unsafe { vtk_closest_point_strategy_initialize(self.0, ps) } } - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_closest_point_strategy_find_cell( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_closest_point_strategy_find_cell( - self.0, - x, - cell, - gencell, - cellId, - tol2, - subId, - pcoords, - weights, - ) - } - } fn set_point_locator(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_closest_point_strategy_set_point_locator( @@ -23853,7 +11561,7 @@ impl VtkClosestPointStrategy for vtkClosestPointStrategy { fn select_cell( &mut self, self_: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, cell: *mut core::ffi::c_void, gencell: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void { @@ -23861,7 +11569,7 @@ impl VtkClosestPointStrategy for vtkClosestPointStrategy { fn vtk_closest_point_strategy_select_cell( sself: *mut core::ffi::c_void, self_: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, cell: *mut core::ffi::c_void, gencell: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; @@ -23895,29 +11603,6 @@ impl VtkCone for vtkCone { } unsafe { vtk_cone_new_instance(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_cone_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_cone_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cone_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - g: core::ffi::c_double, - ); - } - unsafe { vtk_cone_evaluate_gradient(self.0, x, g) } - } fn set_angle(&mut self, _arg: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_cone_set_angle( @@ -23984,157 +11669,6 @@ impl VtkConvexPointSet for vtkConvexPointSet { } unsafe { vtk_convex_point_set_has_fixed_topology(self.0) } } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_convex_point_set_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_convex_point_set_get_edge_points(self.0, edgeId, pts) } - } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_convex_point_set_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_convex_point_set_get_edge_points(self.0, edgeId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_convex_point_set_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_convex_point_set_get_face_points(self.0, faceId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_convex_point_set_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_convex_point_set_get_face_points(self.0, faceId, pts) } - } - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_convex_point_set_get_edge_to_adjacent_faces( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_convex_point_set_get_edge_to_adjacent_faces(self.0, edgeId, pts) } - } - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_convex_point_set_get_face_to_adjacent_faces( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_convex_point_set_get_face_to_adjacent_faces(self.0, faceId, faceIds) - } - } - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_convex_point_set_get_point_to_incident_edges( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_convex_point_set_get_point_to_incident_edges(self.0, pointId, edgeIds) - } - } - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_convex_point_set_get_point_to_incident_faces( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_convex_point_set_get_point_to_incident_faces(self.0, pointId, faceIds) - } - } - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_convex_point_set_get_point_to_one_ring_points( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_convex_point_set_get_point_to_one_ring_points(self.0, pointId, pts) - } - } - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { - unsafe extern "C" { - fn vtk_convex_point_set_get_centroid( - sself: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_convex_point_set_get_centroid(self.0, centroid) } - } - fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_convex_point_set_get_parametric_coords( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_convex_point_set_get_parametric_coords(self.0) } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_convex_point_set_get_cell_type( @@ -24196,7 +11730,7 @@ impl VtkConvexPointSet for vtkConvexPointSet { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -24211,7 +11745,7 @@ impl VtkConvexPointSet for vtkConvexPointSet { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -24241,7 +11775,7 @@ impl VtkConvexPointSet for vtkConvexPointSet { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -24255,7 +11789,7 @@ impl VtkConvexPointSet for vtkConvexPointSet { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -24276,93 +11810,6 @@ impl VtkConvexPointSet for vtkConvexPointSet { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_convex_point_set_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_convex_point_set_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_convex_point_set_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_convex_point_set_evaluate_location(self.0, subId, pcoords, x, weights) - } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_convex_point_set_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_convex_point_set_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -24379,56 +11826,6 @@ impl VtkConvexPointSet for vtkConvexPointSet { } unsafe { vtk_convex_point_set_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_convex_point_set_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_convex_point_set_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_convex_point_set_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_convex_point_set_cell_boundary(self.0, subId, pcoords, pts) } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_convex_point_set_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_convex_point_set_get_parametric_center(self.0, pcoords) } - } fn is_primary_cell(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_convex_point_set_is_primary_cell( @@ -24437,20 +11834,6 @@ impl VtkConvexPointSet for vtkConvexPointSet { } unsafe { vtk_convex_point_set_is_primary_cell(self.0) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_convex_point_set_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ); - } - unsafe { vtk_convex_point_set_interpolate_functions(self.0, pcoords, sf) } - } } impl VtkCubicLine for vtkCubicLine { fn new(&mut self) -> *mut core::ffi::c_void { @@ -24528,22 +11911,6 @@ impl VtkCubicLine for vtkCubicLine { } unsafe { vtk_cubic_line_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_cubic_line_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_cubic_line_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -24555,7 +11922,7 @@ impl VtkCubicLine for vtkCubicLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -24570,7 +11937,7 @@ impl VtkCubicLine for vtkCubicLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -24591,56 +11958,6 @@ impl VtkCubicLine for vtkCubicLine { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_cubic_line_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_cubic_line_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cubic_line_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_cubic_line_evaluate_location(self.0, subId, pcoords, x, weights) } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -24657,40 +11974,6 @@ impl VtkCubicLine for vtkCubicLine { } unsafe { vtk_cubic_line_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cubic_line_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_cubic_line_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_cubic_line_get_parametric_distance( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_cubic_line_get_parametric_distance(self.0, pcoords) } - } fn clip( &mut self, value: core::ffi::c_double, @@ -24700,7 +11983,7 @@ impl VtkCubicLine for vtkCubicLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -24714,7 +11997,7 @@ impl VtkCubicLine for vtkCubicLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -24735,100 +12018,6 @@ impl VtkCubicLine for vtkCubicLine { ) } } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_cubic_line_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_cubic_line_get_parametric_center(self.0, pcoords) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_cubic_line_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_cubic_line_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cubic_line_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_cubic_line_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cubic_line_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_cubic_line_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cubic_line_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_cubic_line_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cubic_line_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_cubic_line_interpolate_derivs(self.0, pcoords, derivs) } - } } impl VtkCylinder for vtkCylinder { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -24854,29 +12043,6 @@ impl VtkCylinder for vtkCylinder { } unsafe { vtk_cylinder_new(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_cylinder_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_cylinder_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cylinder_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - g: core::ffi::c_double, - ); - } - unsafe { vtk_cylinder_evaluate_gradient(self.0, x, g) } - } fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_cylinder_set_radius( @@ -24910,48 +12076,6 @@ impl VtkCylinder for vtkCylinder { } unsafe { vtk_cylinder_set_center(self.0, _arg1, _arg2, _arg3) } } - fn set_center(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_cylinder_set_center( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_cylinder_set_center(self.0, _arg) } - } - fn get_center(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_cylinder_get_center( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_cylinder_get_center(self.0) } - } - fn get_center( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cylinder_get_center( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { vtk_cylinder_get_center(self.0, _arg1, _arg2, _arg3) } - } - fn get_center(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_cylinder_get_center( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_cylinder_get_center(self.0, _arg) } - } fn set_axis( &mut self, ax: core::ffi::c_double, @@ -24968,48 +12092,6 @@ impl VtkCylinder for vtkCylinder { } unsafe { vtk_cylinder_set_axis(self.0, ax, ay, az) } } - fn set_axis(&mut self, a: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_cylinder_set_axis( - sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - ); - } - unsafe { vtk_cylinder_set_axis(self.0, a) } - } - fn get_axis(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_cylinder_get_axis( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_cylinder_get_axis(self.0) } - } - fn get_axis( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_cylinder_get_axis( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { vtk_cylinder_get_axis(self.0, _arg1, _arg2, _arg3) } - } - fn get_axis(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_cylinder_get_axis( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_cylinder_get_axis(self.0, _arg) } - } } impl VtkDataAssembly for vtkDataAssembly { fn new(&mut self) -> *mut core::ffi::c_void { @@ -25043,27 +12125,16 @@ impl VtkDataAssembly for vtkDataAssembly { } unsafe { vtk_data_assembly_initialize(self.0) } } - fn initialize_from_xml(&mut self, xmlcontents: core::ffi::c_char) -> bool { + fn initialize_from_xml(&mut self, xmlcontents: &str) -> bool { + let c_xmlcontents = std::ffi::CString::new(xmlcontents) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_initialize_from_xml( sself: *mut core::ffi::c_void, - xmlcontents: core::ffi::c_char, + xmlcontents: *const core::ffi::c_char, ) -> bool; } - unsafe { vtk_data_assembly_initialize_from_xml(self.0, xmlcontents) } - } - fn serialize_to_xml(&mut self, indent: *mut core::ffi::c_void) -> &str { - unsafe extern "C" { - fn vtk_data_assembly_serialize_to_xml( - sself: *mut core::ffi::c_void, - indent: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { vtk_data_assembly_serialize_to_xml(self.0, indent) }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + unsafe { vtk_data_assembly_initialize_from_xml(self.0, c_xmlcontents.as_ptr()) } } fn get_root_node(&mut self) -> core::ffi::c_int { unsafe extern "C" { @@ -25073,50 +12144,38 @@ impl VtkDataAssembly for vtkDataAssembly { } unsafe { vtk_data_assembly_get_root_node(self.0) } } - fn set_root_node_name(&mut self, name: core::ffi::c_char) -> () { + fn set_root_node_name(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_set_root_node_name( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ); } - unsafe { vtk_data_assembly_set_root_node_name(self.0, name) } + unsafe { vtk_data_assembly_set_root_node_name(self.0, c_name.as_ptr()) } } - fn get_root_node_name(&mut self) -> *const core::ffi::c_char { + fn get_root_node_name(&mut self) -> &str { unsafe extern "C" { fn vtk_data_assembly_get_root_node_name( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_data_assembly_get_root_node_name(self.0) } + let ptr = unsafe { vtk_data_assembly_get_root_node_name(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn add_node( - &mut self, - name: core::ffi::c_char, - parent: core::ffi::c_int, - ) -> core::ffi::c_int { + fn add_node(&mut self, name: &str, parent: core::ffi::c_int) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_add_node( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, parent: core::ffi::c_int, ) -> core::ffi::c_int; } - unsafe { vtk_data_assembly_add_node(self.0, name, parent) } - } - fn add_nodes( - &mut self, - names: Vec, - parent: core::ffi::c_int, - ) -> Vec { - unsafe extern "C" { - fn vtk_data_assembly_add_nodes( - sself: *mut core::ffi::c_void, - names: Vec, - parent: core::ffi::c_int, - ) -> Vec; - } - unsafe { vtk_data_assembly_add_nodes(self.0, names, parent) } + unsafe { vtk_data_assembly_add_node(self.0, c_name.as_ptr(), parent) } } fn add_subtree( &mut self, @@ -25143,46 +12202,39 @@ impl VtkDataAssembly for vtkDataAssembly { } unsafe { vtk_data_assembly_remove_node(self.0, id) } } - fn set_node_name(&mut self, id: core::ffi::c_int, name: core::ffi::c_char) -> () { + fn set_node_name(&mut self, id: core::ffi::c_int, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_set_node_name( sself: *mut core::ffi::c_void, id: core::ffi::c_int, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ); } - unsafe { vtk_data_assembly_set_node_name(self.0, id, name) } + unsafe { vtk_data_assembly_set_node_name(self.0, id, c_name.as_ptr()) } } - fn get_node_name(&mut self, id: core::ffi::c_int) -> *const core::ffi::c_char { + fn get_node_name(&mut self, id: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_data_assembly_get_node_name( sself: *mut core::ffi::c_void, id: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_data_assembly_get_node_name(self.0, id) } - } - fn get_node_path(&mut self, id: core::ffi::c_int) -> &str { - unsafe extern "C" { - fn vtk_data_assembly_get_node_path( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { vtk_data_assembly_get_node_path(self.0, id) }; + let ptr = unsafe { vtk_data_assembly_get_node_name(self.0, id) }; if ptr.is_null() { return ""; } unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn get_first_node_by_path(&mut self, path: core::ffi::c_char) -> core::ffi::c_int { + fn get_first_node_by_path(&mut self, path: &str) -> core::ffi::c_int { + let c_path = std::ffi::CString::new(path).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_get_first_node_by_path( sself: *mut core::ffi::c_void, - path: core::ffi::c_char, + path: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_assembly_get_first_node_by_path(self.0, path) } + unsafe { vtk_data_assembly_get_first_node_by_path(self.0, c_path.as_ptr()) } } fn add_data_set_index( &mut self, @@ -25198,20 +12250,6 @@ impl VtkDataAssembly for vtkDataAssembly { } unsafe { vtk_data_assembly_add_data_set_index(self.0, id, dataset_index) } } - fn add_data_set_indices( - &mut self, - id: core::ffi::c_int, - dataset_indices: Vec, - ) -> bool { - unsafe extern "C" { - fn vtk_data_assembly_add_data_set_indices( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - dataset_indices: Vec, - ) -> bool; - } - unsafe { vtk_data_assembly_add_data_set_indices(self.0, id, dataset_indices) } - } fn add_data_set_index_range( &mut self, id: core::ffi::c_int, @@ -25262,53 +12300,21 @@ impl VtkDataAssembly for vtkDataAssembly { } fn find_first_node_with_name( &mut self, - name: core::ffi::c_char, + name: &str, traversal_order: core::ffi::c_int, ) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_find_first_node_with_name( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, traversal_order: core::ffi::c_int, ) -> core::ffi::c_int; } unsafe { - vtk_data_assembly_find_first_node_with_name(self.0, name, traversal_order) - } - } - fn find_nodes_with_name( - &mut self, - name: core::ffi::c_char, - sort_order: core::ffi::c_int, - ) -> Vec { - unsafe extern "C" { - fn vtk_data_assembly_find_nodes_with_name( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - sort_order: core::ffi::c_int, - ) -> Vec; - } - unsafe { vtk_data_assembly_find_nodes_with_name(self.0, name, sort_order) } - } - fn get_child_nodes( - &mut self, - parent: core::ffi::c_int, - traverse_subtree: bool, - traversal_order: core::ffi::c_int, - ) -> Vec { - unsafe extern "C" { - fn vtk_data_assembly_get_child_nodes( - sself: *mut core::ffi::c_void, - parent: core::ffi::c_int, - traverse_subtree: bool, - traversal_order: core::ffi::c_int, - ) -> Vec; - } - unsafe { - vtk_data_assembly_get_child_nodes( + vtk_data_assembly_find_first_node_with_name( self.0, - parent, - traverse_subtree, + c_name.as_ptr(), traversal_order, ) } @@ -25359,215 +12365,86 @@ impl VtkDataAssembly for vtkDataAssembly { } unsafe { vtk_data_assembly_get_parent(self.0, id) } } - fn has_attribute(&mut self, id: core::ffi::c_int, name: core::ffi::c_char) -> bool { + fn has_attribute(&mut self, id: core::ffi::c_int, name: &str) -> bool { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_has_attribute( sself: *mut core::ffi::c_void, id: core::ffi::c_int, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> bool; } - unsafe { vtk_data_assembly_has_attribute(self.0, id, name) } - } - fn set_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_char, - ) -> () { - unsafe extern "C" { - fn vtk_data_assembly_set_attribute( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_char, - ); - } - unsafe { vtk_data_assembly_set_attribute(self.0, id, name, value) } - } - fn set_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_data_assembly_set_attribute( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_int, - ); - } - unsafe { vtk_data_assembly_set_attribute(self.0, id, name, value) } - } - fn set_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uint, - ) -> () { - unsafe extern "C" { - fn vtk_data_assembly_set_attribute( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uint, - ); - } - unsafe { vtk_data_assembly_set_attribute(self.0, id, name, value) } + unsafe { vtk_data_assembly_has_attribute(self.0, id, c_name.as_ptr()) } } - fn set_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uchar, - ) -> () { + fn set_attribute(&mut self, id: core::ffi::c_int, name: &str, value: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_value = std::ffi::CString::new(value).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_set_attribute( sself: *mut core::ffi::c_void, id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uchar, + name: *const core::ffi::c_char, + value: *const core::ffi::c_char, ); } - unsafe { vtk_data_assembly_set_attribute(self.0, id, name, value) } - } - fn get_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_char, - ) -> bool { - unsafe extern "C" { - fn vtk_data_assembly_get_attribute( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_char, - ) -> bool; - } - unsafe { vtk_data_assembly_get_attribute(self.0, id, name, value) } - } - fn get_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_int, - ) -> bool { - unsafe extern "C" { - fn vtk_data_assembly_get_attribute( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_int, - ) -> bool; - } - unsafe { vtk_data_assembly_get_attribute(self.0, id, name, value) } - } - fn get_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uint, - ) -> bool { - unsafe extern "C" { - fn vtk_data_assembly_get_attribute( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uint, - ) -> bool; + unsafe { + vtk_data_assembly_set_attribute( + self.0, + id, + c_name.as_ptr(), + c_value.as_ptr(), + ) } - unsafe { vtk_data_assembly_get_attribute(self.0, id, name, value) } } - fn get_attribute( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uchar, - ) -> bool { + fn get_attribute(&mut self, id: core::ffi::c_int, name: &str, value: &str) -> bool { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_value = std::ffi::CString::new(value).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_get_attribute( sself: *mut core::ffi::c_void, id: core::ffi::c_int, - name: core::ffi::c_char, - value: core::ffi::c_uchar, + name: *const core::ffi::c_char, + value: *const core::ffi::c_char, ) -> bool; } - unsafe { vtk_data_assembly_get_attribute(self.0, id, name, value) } - } - fn get_attribute_or_default( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_char, - ) -> *const core::ffi::c_char { - unsafe extern "C" { - fn vtk_data_assembly_get_attribute_or_default( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_char, - ) -> *const core::ffi::c_char; - } - unsafe { - vtk_data_assembly_get_attribute_or_default(self.0, id, name, default_value) - } - } - fn get_attribute_or_default( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_assembly_get_attribute_or_default( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_int, - ) -> core::ffi::c_int; - } unsafe { - vtk_data_assembly_get_attribute_or_default(self.0, id, name, default_value) - } - } - fn get_attribute_or_default( - &mut self, - id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_uint, - ) -> core::ffi::c_uint { - unsafe extern "C" { - fn vtk_data_assembly_get_attribute_or_default( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_uint, - ) -> core::ffi::c_uint; - } - unsafe { - vtk_data_assembly_get_attribute_or_default(self.0, id, name, default_value) + vtk_data_assembly_get_attribute( + self.0, + id, + c_name.as_ptr(), + c_value.as_ptr(), + ) } } fn get_attribute_or_default( &mut self, id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + name: &str, + default_value: &str, + ) -> &str { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_default_value = std::ffi::CString::new(default_value) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_get_attribute_or_default( sself: *mut core::ffi::c_void, id: core::ffi::c_int, - name: core::ffi::c_char, - default_value: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + name: *const core::ffi::c_char, + default_value: *const core::ffi::c_char, + ) -> *const core::ffi::c_char; } - unsafe { - vtk_data_assembly_get_attribute_or_default(self.0, id, name, default_value) + let ptr = unsafe { + vtk_data_assembly_get_attribute_or_default( + self.0, + id, + c_name.as_ptr(), + c_default_value.as_ptr(), + ) + }; + if ptr.is_null() { + return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn visit( &mut self, @@ -25583,112 +12460,6 @@ impl VtkDataAssembly for vtkDataAssembly { } unsafe { vtk_data_assembly_visit(self.0, visitor, traversal_order) } } - fn visit( - &mut self, - id: core::ffi::c_int, - visitor: *mut core::ffi::c_void, - traversal_order: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_data_assembly_visit( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - visitor: *mut core::ffi::c_void, - traversal_order: core::ffi::c_int, - ); - } - unsafe { vtk_data_assembly_visit(self.0, id, visitor, traversal_order) } - } - fn get_data_set_indices( - &mut self, - id: core::ffi::c_int, - traverse_subtree: bool, - traversal_order: core::ffi::c_int, - ) -> Vec { - unsafe extern "C" { - fn vtk_data_assembly_get_data_set_indices( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - traverse_subtree: bool, - traversal_order: core::ffi::c_int, - ) -> Vec; - } - unsafe { - vtk_data_assembly_get_data_set_indices( - self.0, - id, - traverse_subtree, - traversal_order, - ) - } - } - fn get_data_set_indices( - &mut self, - ids: Vec, - traverse_subtree: bool, - traversal_order: core::ffi::c_int, - ) -> Vec { - unsafe extern "C" { - fn vtk_data_assembly_get_data_set_indices( - sself: *mut core::ffi::c_void, - ids: Vec, - traverse_subtree: bool, - traversal_order: core::ffi::c_int, - ) -> Vec; - } - unsafe { - vtk_data_assembly_get_data_set_indices( - self.0, - ids, - traverse_subtree, - traversal_order, - ) - } - } - fn select_nodes( - &mut self, - path_queries: Vec, - traversal_order: core::ffi::c_int, - ) -> Vec { - unsafe extern "C" { - fn vtk_data_assembly_select_nodes( - sself: *mut core::ffi::c_void, - path_queries: Vec, - traversal_order: core::ffi::c_int, - ) -> Vec; - } - unsafe { vtk_data_assembly_select_nodes(self.0, path_queries, traversal_order) } - } - fn remap_data_set_indices( - &mut self, - mapping: std::collections::HashMap, - remove_unmapped: bool, - ) -> bool { - unsafe extern "C" { - fn vtk_data_assembly_remap_data_set_indices( - sself: *mut core::ffi::c_void, - mapping: std::collections::HashMap, - remove_unmapped: bool, - ) -> bool; - } - unsafe { - vtk_data_assembly_remap_data_set_indices(self.0, mapping, remove_unmapped) - } - } - fn subset_copy( - &mut self, - other: *mut core::ffi::c_void, - selected_branches: Vec, - ) -> () { - unsafe extern "C" { - fn vtk_data_assembly_subset_copy( - sself: *mut core::ffi::c_void, - other: *mut core::ffi::c_void, - selected_branches: Vec, - ); - } - unsafe { vtk_data_assembly_subset_copy(self.0, other, selected_branches) } - } fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_data_assembly_deep_copy( @@ -25698,36 +12469,25 @@ impl VtkDataAssembly for vtkDataAssembly { } unsafe { vtk_data_assembly_deep_copy(self.0, other) } } - fn is_node_name_valid(&mut self, name: core::ffi::c_char) -> bool { + fn is_node_name_valid(&mut self, name: &str) -> bool { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_is_node_name_valid( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> bool; } - unsafe { vtk_data_assembly_is_node_name_valid(self.0, name) } - } - fn make_valid_node_name(&mut self, name: core::ffi::c_char) -> &str { - unsafe extern "C" { - fn vtk_data_assembly_make_valid_node_name( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { vtk_data_assembly_make_valid_node_name(self.0, name) }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + unsafe { vtk_data_assembly_is_node_name_valid(self.0, c_name.as_ptr()) } } - fn is_node_name_reserved(&mut self, name: core::ffi::c_char) -> bool { + fn is_node_name_reserved(&mut self, name: &str) -> bool { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_assembly_is_node_name_reserved( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> bool; } - unsafe { vtk_data_assembly_is_node_name_reserved(self.0, name) } + unsafe { vtk_data_assembly_is_node_name_reserved(self.0, c_name.as_ptr()) } } } impl VtkDataAssemblyUtilities for vtkDataAssemblyUtilities { @@ -25756,13 +12516,17 @@ impl VtkDataAssemblyUtilities for vtkDataAssemblyUtilities { } unsafe { vtk_data_assembly_utilities_new_instance(self.0) } } - fn hierarchy_name(&mut self) -> *const core::ffi::c_char { + fn hierarchy_name(&mut self) -> &str { unsafe extern "C" { fn vtk_data_assembly_utilities_hierarchy_name( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_data_assembly_utilities_hierarchy_name(self.0) } + let ptr = unsafe { vtk_data_assembly_utilities_hierarchy_name(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn generate_hierarchy( &mut self, @@ -25787,100 +12551,30 @@ impl VtkDataAssemblyUtilities for vtkDataAssemblyUtilities { ) } } - fn get_selected_composite_ids( - &mut self, - selectors: Vec, - hierarchyOrAssembly: *mut core::ffi::c_void, - data: *mut core::ffi::c_void, - leaf_nodes_only: bool, - ) -> Vec { +} +impl VtkDataObject for vtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_data_assembly_utilities_get_selected_composite_ids( + fn vtk_data_object_new( sself: *mut core::ffi::c_void, - selectors: Vec, - hierarchyOrAssembly: *mut core::ffi::c_void, - data: *mut core::ffi::c_void, - leaf_nodes_only: bool, - ) -> Vec; - } - unsafe { - vtk_data_assembly_utilities_get_selected_composite_ids( - self.0, - selectors, - hierarchyOrAssembly, - data, - leaf_nodes_only, - ) + ) -> *mut core::ffi::c_void; } + unsafe { vtk_data_object_new(self.0) } } - fn get_selector_for_composite_id( - &mut self, - id: core::ffi::c_uint, - hierarchy: *mut core::ffi::c_void, - ) -> &str { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_data_assembly_utilities_get_selector_for_composite_id( + fn vtk_data_object_safe_down_cast( sself: *mut core::ffi::c_void, - id: core::ffi::c_uint, - hierarchy: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { - vtk_data_assembly_utilities_get_selector_for_composite_id( - self.0, - id, - hierarchy, - ) - }; - if ptr.is_null() { - return ""; + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + unsafe { vtk_data_object_safe_down_cast(self.0, o) } } - fn get_selectors_for_composite_ids( - &mut self, - ids: Vec, - hierarchy: *mut core::ffi::c_void, - ) -> Vec { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_data_assembly_utilities_get_selectors_for_composite_ids( + fn vtk_data_object_new_instance( sself: *mut core::ffi::c_void, - ids: Vec, - hierarchy: *mut core::ffi::c_void, - ) -> Vec; - } - unsafe { - vtk_data_assembly_utilities_get_selectors_for_composite_ids( - self.0, - ids, - hierarchy, - ) - } - } -} -impl VtkDataObject for vtkDataObject { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_object_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_object_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_object_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_object_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_object_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + ) -> *mut core::ffi::c_void; } unsafe { vtk_data_object_new_instance(self.0) } } @@ -26048,14 +12742,15 @@ impl VtkDataObject for vtkDataObject { &mut self, info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, - name: core::ffi::c_char, + name: &str, ) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_object_get_named_field_information( sself: *mut core::ffi::c_void, info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } unsafe { @@ -26063,7 +12758,7 @@ impl VtkDataObject for vtkDataObject { self.0, info, fieldAssociation, - name, + c_name.as_ptr(), ) } } @@ -26071,14 +12766,15 @@ impl VtkDataObject for vtkDataObject { &mut self, info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, - name: core::ffi::c_char, + name: &str, ) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_object_remove_named_field_information( sself: *mut core::ffi::c_void, info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ); } unsafe { @@ -26086,7 +12782,7 @@ impl VtkDataObject for vtkDataObject { self.0, info, fieldAssociation, - name, + c_name.as_ptr(), ) } } @@ -26094,15 +12790,17 @@ impl VtkDataObject for vtkDataObject { &mut self, info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, - attributeName: core::ffi::c_char, + attributeName: &str, attributeType: core::ffi::c_int, ) -> *mut core::ffi::c_void { + let c_attributeName = std::ffi::CString::new(attributeName) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_data_object_set_active_attribute( sself: *mut core::ffi::c_void, info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, - attributeName: core::ffi::c_char, + attributeName: *const core::ffi::c_char, attributeType: core::ffi::c_int, ) -> *mut core::ffi::c_void; } @@ -26111,7 +12809,7 @@ impl VtkDataObject for vtkDataObject { self.0, info, fieldAssociation, - attributeName, + c_attributeName.as_ptr(), attributeType, ) } @@ -26121,18 +12819,19 @@ impl VtkDataObject for vtkDataObject { info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, attributeType: core::ffi::c_int, - name: core::ffi::c_char, + name: &str, arrayType: core::ffi::c_int, numComponents: core::ffi::c_int, numTuples: core::ffi::c_int, ) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_object_set_active_attribute_info( sself: *mut core::ffi::c_void, info: *mut core::ffi::c_void, fieldAssociation: core::ffi::c_int, attributeType: core::ffi::c_int, - name: core::ffi::c_char, + name: *const core::ffi::c_char, arrayType: core::ffi::c_int, numComponents: core::ffi::c_int, numTuples: core::ffi::c_int, @@ -26144,7 +12843,7 @@ impl VtkDataObject for vtkDataObject { info, fieldAssociation, attributeType, - name, + c_name.as_ptr(), arrayType, numComponents, numTuples, @@ -26212,15 +12911,6 @@ impl VtkDataObject for vtkDataObject { } unsafe { vtk_data_object_get_extent_type(self.0) } } - fn crop(&mut self, updateExtent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_data_object_crop( - sself: *mut core::ffi::c_void, - updateExtent: core::ffi::c_int, - ); - } - unsafe { vtk_data_object_crop(self.0, updateExtent) } - } fn get_attributes(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_data_object_get_attributes( @@ -26263,41 +12953,53 @@ impl VtkDataObject for vtkDataObject { } unsafe { vtk_data_object_get_attribute_type_for_array(self.0, arr) } } - fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar { + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_data_object_get_number_of_elements( sself: *mut core::ffi::c_void, type_: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_data_object_get_number_of_elements(self.0, type_) } } fn get_association_type_as_string( &mut self, associationType: core::ffi::c_int, - ) -> *const core::ffi::c_char { + ) -> &str { unsafe extern "C" { fn vtk_data_object_get_association_type_as_string( sself: *mut core::ffi::c_void, associationType: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { + let ptr = unsafe { vtk_data_object_get_association_type_as_string(self.0, associationType) + }; + if ptr.is_null() { + return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn get_association_type_from_string( &mut self, - associationName: core::ffi::c_char, + associationName: &str, ) -> core::ffi::c_int { + let c_associationName = std::ffi::CString::new(associationName) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_data_object_get_association_type_from_string( sself: *mut core::ffi::c_void, - associationName: core::ffi::c_char, + associationName: *const core::ffi::c_char, ) -> core::ffi::c_int; } unsafe { - vtk_data_object_get_association_type_from_string(self.0, associationName) + vtk_data_object_get_association_type_from_string( + self.0, + c_associationName.as_ptr(), + ) } } fn data_type_name(&mut self) -> *mut core::ffi::c_void { @@ -26533,20 +13235,6 @@ impl VtkDataObject for vtkDataObject { } unsafe { vtk_data_object_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_object_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_object_get_data(self.0, v, i) } - } } impl VtkDataObjectCollection for vtkDataObjectCollection { fn new(&mut self) -> *mut core::ffi::c_void { @@ -26600,15 +13288,6 @@ impl VtkDataObjectCollection for vtkDataObjectCollection { } unsafe { vtk_data_object_collection_get_item(self.0, i) } } - fn get_next_data_object(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_object_collection_get_next_data_object( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_object_collection_get_next_data_object(self.0, cookie) } - } fn get_number_of_items(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_data_object_collection_get_number_of_items( @@ -26793,50 +13472,47 @@ impl VtkDataObjectTypes for vtkDataObjectTypes { } unsafe { vtk_data_object_types_new_instance(self.0) } } - fn get_class_name_from_type_id( - &mut self, - typeId: core::ffi::c_int, - ) -> *const core::ffi::c_char { + fn get_class_name_from_type_id(&mut self, typeId: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_data_object_types_get_class_name_from_type_id( sself: *mut core::ffi::c_void, typeId: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_data_object_types_get_class_name_from_type_id(self.0, typeId) } + let ptr = unsafe { + vtk_data_object_types_get_class_name_from_type_id(self.0, typeId) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn get_type_id_from_class_name( - &mut self, - classname: core::ffi::c_char, - ) -> core::ffi::c_int { + fn get_type_id_from_class_name(&mut self, classname: &str) -> core::ffi::c_int { + let c_classname = std::ffi::CString::new(classname) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_data_object_types_get_type_id_from_class_name( sself: *mut core::ffi::c_void, - classname: core::ffi::c_char, + classname: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_object_types_get_type_id_from_class_name(self.0, classname) } - } - fn new_data_object( - &mut self, - classname: core::ffi::c_char, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_object_types_new_data_object( - sself: *mut core::ffi::c_void, - classname: core::ffi::c_char, - ) -> *mut core::ffi::c_void; + unsafe { + vtk_data_object_types_get_type_id_from_class_name( + self.0, + c_classname.as_ptr(), + ) } - unsafe { vtk_data_object_types_new_data_object(self.0, classname) } } - fn new_data_object(&mut self, typeId: core::ffi::c_int) -> *mut core::ffi::c_void { + fn new_data_object(&mut self, classname: &str) -> *mut core::ffi::c_void { + let c_classname = std::ffi::CString::new(classname) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_data_object_types_new_data_object( sself: *mut core::ffi::c_void, - typeId: core::ffi::c_int, + classname: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } - unsafe { vtk_data_object_types_new_data_object(self.0, typeId) } + unsafe { vtk_data_object_types_new_data_object(self.0, c_classname.as_ptr()) } } fn type_id_is_a( &mut self, @@ -26931,13 +13607,17 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_shallow_copy(self.0, pd) } } - fn ghost_array_name(&mut self) -> *const core::ffi::c_char { + fn ghost_array_name(&mut self) -> &str { unsafe extern "C" { fn vtk_data_set_attributes_ghost_array_name( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_data_set_attributes_ghost_array_name(self.0) } + let ptr = unsafe { vtk_data_set_attributes_ghost_array_name(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn set_scalars(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { unsafe extern "C" { @@ -26948,14 +13628,15 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_set_scalars(self.0, da) } } - fn set_active_scalars(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn set_active_scalars(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_scalars( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_set_attributes_set_active_scalars(self.0, name) } + unsafe { vtk_data_set_attributes_set_active_scalars(self.0, c_name.as_ptr()) } } fn get_scalars(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -26974,14 +13655,15 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_set_vectors(self.0, da) } } - fn set_active_vectors(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn set_active_vectors(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_vectors( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_set_attributes_set_active_vectors(self.0, name) } + unsafe { vtk_data_set_attributes_set_active_vectors(self.0, c_name.as_ptr()) } } fn get_vectors(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -27000,14 +13682,15 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_set_normals(self.0, da) } } - fn set_active_normals(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn set_active_normals(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_normals( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_set_attributes_set_active_normals(self.0, name) } + unsafe { vtk_data_set_attributes_set_active_normals(self.0, c_name.as_ptr()) } } fn get_normals(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -27026,14 +13709,15 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_set_tangents(self.0, da) } } - fn set_active_tangents(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn set_active_tangents(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_tangents( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_set_attributes_set_active_tangents(self.0, name) } + unsafe { vtk_data_set_attributes_set_active_tangents(self.0, c_name.as_ptr()) } } fn get_tangents(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -27052,14 +13736,15 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_set_t_coords(self.0, da) } } - fn set_active_t_coords(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn set_active_t_coords(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_t_coords( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_set_attributes_set_active_t_coords(self.0, name) } + unsafe { vtk_data_set_attributes_set_active_t_coords(self.0, c_name.as_ptr()) } } fn get_t_coords(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -27078,14 +13763,15 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_set_tensors(self.0, da) } } - fn set_active_tensors(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn set_active_tensors(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_tensors( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_set_attributes_set_active_tensors(self.0, name) } + unsafe { vtk_data_set_attributes_set_active_tensors(self.0, c_name.as_ptr()) } } fn get_tensors(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -27104,14 +13790,15 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_set_global_ids(self.0, da) } } - fn set_active_global_ids(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn set_active_global_ids(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_global_ids( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_set_attributes_set_active_global_ids(self.0, name) } + unsafe { vtk_data_set_attributes_set_active_global_ids(self.0, c_name.as_ptr()) } } fn get_global_ids(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -27130,14 +13817,17 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_set_pedigree_ids(self.0, da) } } - fn set_active_pedigree_ids(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn set_active_pedigree_ids(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_pedigree_ids( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_set_attributes_set_active_pedigree_ids(self.0, name) } + unsafe { + vtk_data_set_attributes_set_active_pedigree_ids(self.0, c_name.as_ptr()) + } } fn get_pedigree_ids(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -27156,17 +13846,17 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_set_rational_weights(self.0, da) } } - fn set_active_rational_weights( - &mut self, - name: core::ffi::c_char, - ) -> core::ffi::c_int { + fn set_active_rational_weights(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_rational_weights( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_set_attributes_set_active_rational_weights(self.0, name) } + unsafe { + vtk_data_set_attributes_set_active_rational_weights(self.0, c_name.as_ptr()) + } } fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -27188,17 +13878,20 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_set_higher_order_degrees(self.0, da) } } - fn set_active_higher_order_degrees( - &mut self, - name: core::ffi::c_char, - ) -> core::ffi::c_int { + fn set_active_higher_order_degrees(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_higher_order_degrees( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_data_set_attributes_set_active_higher_order_degrees(self.0, name) } + unsafe { + vtk_data_set_attributes_set_active_higher_order_degrees( + self.0, + c_name.as_ptr(), + ) + } } fn get_higher_order_degrees(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -27208,142 +13901,26 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_get_higher_order_degrees(self.0) } } - fn get_scalars(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_attributes_get_scalars( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_attributes_get_scalars(self.0, name) } - } - fn get_vectors(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_attributes_get_vectors( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_attributes_get_vectors(self.0, name) } - } - fn get_normals(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_attributes_get_normals( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_attributes_get_normals(self.0, name) } - } - fn get_tangents(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_attributes_get_tangents( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_attributes_get_tangents(self.0, name) } - } - fn get_t_coords(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_attributes_get_t_coords( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_attributes_get_t_coords(self.0, name) } - } - fn get_tensors(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_attributes_get_tensors( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_attributes_get_tensors(self.0, name) } - } - fn get_global_ids(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_attributes_get_global_ids( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_attributes_get_global_ids(self.0, name) } - } - fn get_pedigree_ids(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_attributes_get_pedigree_ids( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_attributes_get_pedigree_ids(self.0, name) } - } - fn get_rational_weights( - &mut self, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_attributes_get_rational_weights( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_attributes_get_rational_weights(self.0, name) } - } - fn get_higher_order_degrees( - &mut self, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_attributes_get_higher_order_degrees( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_attributes_get_higher_order_degrees(self.0, name) } - } fn set_active_attribute( &mut self, - name: core::ffi::c_char, - attributeType: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_set_attributes_set_active_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - attributeType: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_data_set_attributes_set_active_attribute(self.0, name, attributeType) - } - } - fn set_active_attribute( - &mut self, - index: core::ffi::c_int, + name: &str, attributeType: core::ffi::c_int, ) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_data_set_attributes_set_active_attribute( sself: *mut core::ffi::c_void, - index: core::ffi::c_int, + name: *const core::ffi::c_char, attributeType: core::ffi::c_int, ) -> core::ffi::c_int; } unsafe { - vtk_data_set_attributes_set_active_attribute(self.0, index, attributeType) - } - } - fn get_attribute_indices(&mut self, indexArray: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_get_attribute_indices( - sself: *mut core::ffi::c_void, - indexArray: core::ffi::c_int, - ); + vtk_data_set_attributes_set_active_attribute( + self.0, + c_name.as_ptr(), + attributeType, + ) } - unsafe { vtk_data_set_attributes_get_attribute_indices(self.0, indexArray) } } fn is_array_an_attribute(&mut self, idx: core::ffi::c_int) -> core::ffi::c_int { unsafe extern "C" { @@ -27392,36 +13969,41 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_get_abstract_attribute(self.0, attributeType) } } - fn get_attribute_type_as_string( - &mut self, - attributeType: core::ffi::c_int, - ) -> *const core::ffi::c_char { + fn get_attribute_type_as_string(&mut self, attributeType: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_data_set_attributes_get_attribute_type_as_string( sself: *mut core::ffi::c_void, attributeType: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { + let ptr = unsafe { vtk_data_set_attributes_get_attribute_type_as_string(self.0, attributeType) + }; + if ptr.is_null() { + return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn get_long_attribute_type_as_string( &mut self, attributeType: core::ffi::c_int, - ) -> *const core::ffi::c_char { + ) -> &str { unsafe extern "C" { fn vtk_data_set_attributes_get_long_attribute_type_as_string( sself: *mut core::ffi::c_void, attributeType: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { + let ptr = unsafe { vtk_data_set_attributes_get_long_attribute_type_as_string( self.0, attributeType, ) + }; + if ptr.is_null() { + return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn set_copy_attribute( &mut self, @@ -27833,45 +14415,19 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { fn copy_allocate( &mut self, pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_data_set_attributes_copy_allocate( sself: *mut core::ffi::c_void, pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ); } unsafe { vtk_data_set_attributes_copy_allocate(self.0, pd, sze, ext) } } - fn copy_allocate( - &mut self, - pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - shallowCopyArrays: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_copy_allocate( - sself: *mut core::ffi::c_void, - pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - shallowCopyArrays: core::ffi::c_int, - ); - } - unsafe { - vtk_data_set_attributes_copy_allocate( - self.0, - pd, - sze, - ext, - shallowCopyArrays, - ) - } - } fn setup_for_copy(&mut self, pd: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_data_set_attributes_setup_for_copy( @@ -27881,98 +14437,36 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { } unsafe { vtk_data_set_attributes_setup_for_copy(self.0, pd) } } - fn copy_structured_data( - &mut self, - inDsa: *mut core::ffi::c_void, - inExt: core::ffi::c_int, - outExt: core::ffi::c_int, - setSize: bool, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_copy_structured_data( - sself: *mut core::ffi::c_void, - inDsa: *mut core::ffi::c_void, - inExt: core::ffi::c_int, - outExt: core::ffi::c_int, - setSize: bool, - ); - } - unsafe { - vtk_data_set_attributes_copy_structured_data( - self.0, - inDsa, - inExt, - outExt, - setSize, - ) - } - } fn copy_data( &mut self, fromPd: *mut core::ffi::c_void, - fromId: core::ffi::c_uchar, - toId: core::ffi::c_uchar, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_data_set_attributes_copy_data( sself: *mut core::ffi::c_void, fromPd: *mut core::ffi::c_void, - fromId: core::ffi::c_uchar, - toId: core::ffi::c_uchar, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, ); } unsafe { vtk_data_set_attributes_copy_data(self.0, fromPd, fromId, toId) } } - fn copy_data( - &mut self, - fromPd: *mut core::ffi::c_void, - fromIds: *mut core::ffi::c_void, - toIds: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_copy_data( - sself: *mut core::ffi::c_void, - fromPd: *mut core::ffi::c_void, - fromIds: *mut core::ffi::c_void, - toIds: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_set_attributes_copy_data(self.0, fromPd, fromIds, toIds) } - } - fn copy_data( - &mut self, - fromPd: *mut core::ffi::c_void, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_copy_data( - sself: *mut core::ffi::c_void, - fromPd: *mut core::ffi::c_void, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - ); - } - unsafe { - vtk_data_set_attributes_copy_data(self.0, fromPd, dstStart, n, srcStart) - } - } fn copy_tuple( &mut self, fromData: *mut core::ffi::c_void, toData: *mut core::ffi::c_void, - fromId: core::ffi::c_uchar, - toId: core::ffi::c_uchar, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_data_set_attributes_copy_tuple( sself: *mut core::ffi::c_void, fromData: *mut core::ffi::c_void, toData: *mut core::ffi::c_void, - fromId: core::ffi::c_uchar, - toId: core::ffi::c_uchar, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, ); } unsafe { @@ -27999,112 +14493,37 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { vtk_data_set_attributes_copy_tuples(self.0, fromData, toData, fromIds, toIds) } } - fn copy_tuples( - &mut self, - fromData: *mut core::ffi::c_void, - toData: *mut core::ffi::c_void, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_copy_tuples( - sself: *mut core::ffi::c_void, - fromData: *mut core::ffi::c_void, - toData: *mut core::ffi::c_void, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - ); - } - unsafe { - vtk_data_set_attributes_copy_tuples( - self.0, - fromData, - toData, - dstStart, - n, - srcStart, - ) - } - } fn interpolate_allocate( &mut self, pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_data_set_attributes_interpolate_allocate( sself: *mut core::ffi::c_void, pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ); } unsafe { vtk_data_set_attributes_interpolate_allocate(self.0, pd, sze, ext) } } - fn interpolate_allocate( - &mut self, - pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - shallowCopyArrays: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_interpolate_allocate( - sself: *mut core::ffi::c_void, - pd: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - shallowCopyArrays: core::ffi::c_int, - ); - } - unsafe { - vtk_data_set_attributes_interpolate_allocate( - self.0, - pd, - sze, - ext, - shallowCopyArrays, - ) - } - } - fn interpolate_point( - &mut self, - fromPd: *mut core::ffi::c_void, - toId: core::ffi::c_uchar, - ids: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_interpolate_point( - sself: *mut core::ffi::c_void, - fromPd: *mut core::ffi::c_void, - toId: core::ffi::c_uchar, - ids: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_data_set_attributes_interpolate_point(self.0, fromPd, toId, ids, weights) - } - } fn interpolate_edge( &mut self, fromPd: *mut core::ffi::c_void, - toId: core::ffi::c_uchar, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, + toId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, t: core::ffi::c_double, ) -> () { unsafe extern "C" { fn vtk_data_set_attributes_interpolate_edge( sself: *mut core::ffi::c_void, fromPd: *mut core::ffi::c_void, - toId: core::ffi::c_uchar, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, + toId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, t: core::ffi::c_double, ); } @@ -28116,7 +14535,7 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { &mut self, from1: *mut core::ffi::c_void, from2: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, t: core::ffi::c_double, ) -> () { unsafe extern "C" { @@ -28124,130 +14543,12 @@ impl VtkDataSetAttributes for vtkDataSetAttributes { sself: *mut core::ffi::c_void, from1: *mut core::ffi::c_void, from2: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, t: core::ffi::c_double, ); } unsafe { vtk_data_set_attributes_interpolate_time(self.0, from1, from2, id, t) } } - fn copy_allocate( - &mut self, - list: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_copy_allocate( - sself: *mut core::ffi::c_void, - list: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ); - } - unsafe { vtk_data_set_attributes_copy_allocate(self.0, list, sze, ext) } - } - fn copy_data( - &mut self, - list: *mut core::ffi::c_void, - dsa: *mut core::ffi::c_void, - idx: core::ffi::c_int, - fromId: core::ffi::c_uchar, - toId: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_copy_data( - sself: *mut core::ffi::c_void, - list: *mut core::ffi::c_void, - dsa: *mut core::ffi::c_void, - idx: core::ffi::c_int, - fromId: core::ffi::c_uchar, - toId: core::ffi::c_uchar, - ); - } - unsafe { - vtk_data_set_attributes_copy_data(self.0, list, dsa, idx, fromId, toId) - } - } - fn copy_data( - &mut self, - list: *mut core::ffi::c_void, - dsa: *mut core::ffi::c_void, - idx: core::ffi::c_int, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_copy_data( - sself: *mut core::ffi::c_void, - list: *mut core::ffi::c_void, - dsa: *mut core::ffi::c_void, - idx: core::ffi::c_int, - dstStart: core::ffi::c_uchar, - n: core::ffi::c_uchar, - srcStart: core::ffi::c_uchar, - ); - } - unsafe { - vtk_data_set_attributes_copy_data( - self.0, - list, - dsa, - idx, - dstStart, - n, - srcStart, - ) - } - } - fn interpolate_allocate( - &mut self, - list: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_interpolate_allocate( - sself: *mut core::ffi::c_void, - list: *mut core::ffi::c_void, - sze: core::ffi::c_uchar, - ext: core::ffi::c_uchar, - ); - } - unsafe { vtk_data_set_attributes_interpolate_allocate(self.0, list, sze, ext) } - } - fn interpolate_point( - &mut self, - list: *mut core::ffi::c_void, - fromPd: *mut core::ffi::c_void, - idx: core::ffi::c_int, - toId: core::ffi::c_uchar, - ids: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_attributes_interpolate_point( - sself: *mut core::ffi::c_void, - list: *mut core::ffi::c_void, - fromPd: *mut core::ffi::c_void, - idx: core::ffi::c_int, - toId: core::ffi::c_uchar, - ids: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_data_set_attributes_interpolate_point( - self.0, - list, - fromPd, - idx, - toId, - ids, - weights, - ) - } - } } impl VtkDataSetCellIterator for vtkDataSetCellIterator { fn new(&mut self) -> *mut core::ffi::c_void { @@ -28283,11 +14584,11 @@ impl VtkDataSetCellIterator for vtkDataSetCellIterator { } unsafe { vtk_data_set_cell_iterator_is_done_with_traversal(self.0) } } - fn get_cell_id(&mut self) -> core::ffi::c_uchar { + fn get_cell_id(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_data_set_cell_iterator_get_cell_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_data_set_cell_iterator_get_cell_id(self.0) } } @@ -28361,15 +14662,6 @@ impl VtkDataSetCollection for vtkDataSetCollection { } unsafe { vtk_data_set_collection_get_data_set(self.0, i) } } - fn get_next_data_set(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_collection_get_next_data_set( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_collection_get_next_data_set(self.0, cookie) } - } fn get_number_of_items(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_data_set_collection_get_number_of_items( @@ -28414,20 +14706,6 @@ impl VtkDirectedAcyclicGraph for vtkDirectedAcyclicGraph { } unsafe { vtk_directed_acyclic_graph_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_directed_acyclic_graph_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_directed_acyclic_graph_get_data(self.0, v, i) } - } } impl VtkDirectedGraph for vtkDirectedGraph { fn new(&mut self) -> *mut core::ffi::c_void { @@ -28464,20 +14742,6 @@ impl VtkDirectedGraph for vtkDirectedGraph { } unsafe { vtk_directed_graph_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_directed_graph_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_directed_graph_get_data(self.0, v, i) } - } fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool { unsafe extern "C" { fn vtk_directed_graph_is_structure_valid( @@ -28531,14 +14795,6 @@ impl VtkEdgeListIterator for vtkEdgeListIterator { } unsafe { vtk_edge_list_iterator_set_graph(self.0, graph) } } - fn next(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_edge_list_iterator_next( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_edge_list_iterator_next(self.0) } - } fn next_graph_edge(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_edge_list_iterator_next_graph_edge( @@ -28588,13 +14844,13 @@ impl VtkEdgeTable for vtkEdgeTable { } fn init_edge_insertion( &mut self, - numPoints: core::ffi::c_uchar, + numPoints: core::ffi::c_longlong, storeAttributes: core::ffi::c_int, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_edge_table_init_edge_insertion( sself: *mut core::ffi::c_void, - numPoints: core::ffi::c_uchar, + numPoints: core::ffi::c_longlong, storeAttributes: core::ffi::c_int, ) -> core::ffi::c_int; } @@ -28602,117 +14858,51 @@ impl VtkEdgeTable for vtkEdgeTable { } fn insert_edge( &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_edge_table_insert_edge( sself: *mut core::ffi::c_void, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_edge_table_insert_edge(self.0, p1, p2) } } - fn insert_edge( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - attributeId: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_edge_table_insert_edge( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - attributeId: core::ffi::c_uchar, - ); - } - unsafe { vtk_edge_table_insert_edge(self.0, p1, p2, attributeId) } - } - fn insert_edge( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ptr: (), - ) -> () { - unsafe extern "C" { - fn vtk_edge_table_insert_edge( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ptr: (), - ); - } - unsafe { vtk_edge_table_insert_edge(self.0, p1, p2, ptr) } - } fn is_edge( &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_edge_table_is_edge( sself: *mut core::ffi::c_void, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_edge_table_is_edge(self.0, p1, p2) } } - fn is_edge( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ptr: (), - ) -> () { - unsafe extern "C" { - fn vtk_edge_table_is_edge( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ptr: (), - ); - } - unsafe { vtk_edge_table_is_edge(self.0, p1, p2, ptr) } - } fn init_point_insertion( &mut self, newPts: *mut core::ffi::c_void, - estSize: core::ffi::c_uchar, + estSize: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_edge_table_init_point_insertion( sself: *mut core::ffi::c_void, newPts: *mut core::ffi::c_void, - estSize: core::ffi::c_uchar, + estSize: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_edge_table_init_point_insertion(self.0, newPts, estSize) } } - fn insert_unique_point( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_edge_table_insert_unique_point( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_edge_table_insert_unique_point(self.0, p1, p2, x, ptId) } - } - fn get_number_of_edges(&mut self) -> core::ffi::c_uchar { + fn get_number_of_edges(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_edge_table_get_number_of_edges( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_edge_table_get_number_of_edges(self.0) } } @@ -28724,34 +14914,18 @@ impl VtkEdgeTable for vtkEdgeTable { } fn get_next_edge( &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + p1: &mut core::ffi::c_longlong, + p2: &mut core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_edge_table_get_next_edge( sself: *mut core::ffi::c_void, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + p1: &mut core::ffi::c_longlong, + p2: &mut core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_edge_table_get_next_edge(self.0, p1, p2) } } - fn get_next_edge( - &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ptr: (), - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_edge_table_get_next_edge( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, - ptr: (), - ) -> core::ffi::c_int; - } - unsafe { vtk_edge_table_get_next_edge(self.0, p1, p2, ptr) } - } fn reset(&mut self) -> () { unsafe extern "C" { fn vtk_edge_table_reset(sself: *mut core::ffi::c_void); @@ -28835,22 +15009,6 @@ impl VtkEmptyCell for vtkEmptyCell { } unsafe { vtk_empty_cell_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_empty_cell_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_empty_cell_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -28862,7 +15020,7 @@ impl VtkEmptyCell for vtkEmptyCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -28877,7 +15035,7 @@ impl VtkEmptyCell for vtkEmptyCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -28907,7 +15065,7 @@ impl VtkEmptyCell for vtkEmptyCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -28921,7 +15079,7 @@ impl VtkEmptyCell for vtkEmptyCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -28942,82 +15100,6 @@ impl VtkEmptyCell for vtkEmptyCell { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_empty_cell_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_empty_cell_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_empty_cell_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_empty_cell_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_empty_cell_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_empty_cell_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -29034,28 +15116,6 @@ impl VtkEmptyCell for vtkEmptyCell { } unsafe { vtk_empty_cell_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_empty_cell_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_empty_cell_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } } impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { fn new(&mut self) -> *mut core::ffi::c_void { @@ -29097,47 +15157,33 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { } unsafe { vtk_explicit_structured_grid_initialize(self.0) } } - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_explicit_structured_grid_get_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_explicit_structured_grid_get_cell(self.0, cellId) } } - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_cell( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ); - } - unsafe { vtk_explicit_structured_grid_get_cell(self.0, cellId, cell) } - } - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_explicit_structured_grid_get_cell_type( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_explicit_structured_grid_get_cell_type(self.0, cellId) } } fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_explicit_structured_grid_get_cell_points( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ); } @@ -29145,13 +15191,13 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { } fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_explicit_structured_grid_get_point_cells( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ); } @@ -29190,33 +15236,6 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { } unsafe { vtk_explicit_structured_grid_set_dimensions(self.0, i, j, k) } } - fn set_dimensions(&mut self, dim: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_set_dimensions( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - ); - } - unsafe { vtk_explicit_structured_grid_set_dimensions(self.0, dim) } - } - fn get_dimensions(&mut self, dim: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_dimensions( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - ); - } - unsafe { vtk_explicit_structured_grid_get_dimensions(self.0, dim) } - } - fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_cell_dims( - sself: *mut core::ffi::c_void, - cellDims: core::ffi::c_int, - ); - } - unsafe { vtk_explicit_structured_grid_get_cell_dims(self.0, cellDims) } - } fn get_extent_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_explicit_structured_grid_get_extent_type( @@ -29249,64 +15268,6 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { vtk_explicit_structured_grid_set_extent(self.0, x0, x1, y0, y1, z0, z1) } } - fn set_extent(&mut self, extent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_set_extent( - sself: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_explicit_structured_grid_set_extent(self.0, extent) } - } - fn get_extent(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_extent( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_explicit_structured_grid_get_extent(self.0) } - } - fn get_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_extent( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ); - } - unsafe { - vtk_explicit_structured_grid_get_extent( - self.0, - _arg1, - _arg2, - _arg3, - _arg4, - _arg5, - _arg6, - ) - } - } - fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_extent( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_explicit_structured_grid_get_extent(self.0, _arg) } - } fn set_cells(&mut self, cells: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_explicit_structured_grid_set_cells( @@ -29338,74 +15299,21 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { } unsafe { vtk_explicit_structured_grid_get_links(self.0) } } - fn get_cell_points( - &mut self, - cellId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_cell_points( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_explicit_structured_grid_get_cell_points(self.0, cellId) } - } - fn get_cell_points( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_cell_points( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { - vtk_explicit_structured_grid_get_cell_points(self.0, cellId, npts, pts) - } - } - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - neighbors: core::ffi::c_uchar, - wholeExtent: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_cell_neighbors( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - neighbors: core::ffi::c_uchar, - wholeExtent: core::ffi::c_int, - ); - } - unsafe { - vtk_explicit_structured_grid_get_cell_neighbors( - self.0, - cellId, - neighbors, - wholeExtent, - ) - } - } fn compute_cell_structured_coords( &mut self, - cellId: core::ffi::c_uchar, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, + cellId: core::ffi::c_longlong, + i: &mut core::ffi::c_int, + j: &mut core::ffi::c_int, + k: &mut core::ffi::c_int, adjustForExtent: bool, ) -> () { unsafe extern "C" { fn vtk_explicit_structured_grid_compute_cell_structured_coords( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, + cellId: core::ffi::c_longlong, + i: &mut core::ffi::c_int, + j: &mut core::ffi::c_int, + k: &mut core::ffi::c_int, adjustForExtent: bool, ); } @@ -29426,7 +15334,7 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { j: core::ffi::c_int, k: core::ffi::c_int, adjustForExtent: bool, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_explicit_structured_grid_compute_cell_id( sself: *mut core::ffi::c_void, @@ -29434,7 +15342,7 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { j: core::ffi::c_int, k: core::ffi::c_int, adjustForExtent: bool, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_explicit_structured_grid_compute_cell_id( @@ -29456,47 +15364,35 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(self.0) } } - fn set_faces_connectivity_flags_array_name( - &mut self, - _arg: core::ffi::c_char, - ) -> () { + fn set_faces_connectivity_flags_array_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { fn vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, + _arg: *const core::ffi::c_char, ); } unsafe { vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name( self.0, - _arg, + c__arg.as_ptr(), ) } } - fn get_faces_connectivity_flags_array_name(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_faces_connectivity_flags_array_name( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { - vtk_explicit_structured_grid_get_faces_connectivity_flags_array_name(self.0) - } - } - fn blank_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + fn blank_cell(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_explicit_structured_grid_blank_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_explicit_structured_grid_blank_cell(self.0, cellId) } } - fn un_blank_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + fn un_blank_cell(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_explicit_structured_grid_un_blank_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_explicit_structured_grid_un_blank_cell(self.0, cellId) } @@ -29509,20 +15405,20 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { } unsafe { vtk_explicit_structured_grid_has_any_blank_cells(self.0) } } - fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_explicit_structured_grid_is_cell_visible( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_explicit_structured_grid_is_cell_visible(self.0, cellId) } } - fn is_cell_ghost(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn is_cell_ghost(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_explicit_structured_grid_is_cell_ghost( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_explicit_structured_grid_is_cell_ghost(self.0, cellId) } @@ -29535,38 +15431,6 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { } unsafe { vtk_explicit_structured_grid_has_any_ghost_cells(self.0) } } - fn crop(&mut self, updateExtent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_crop( - sself: *mut core::ffi::c_void, - updateExtent: core::ffi::c_int, - ); - } - unsafe { vtk_explicit_structured_grid_crop(self.0, updateExtent) } - } - fn crop( - &mut self, - input: *mut core::ffi::c_void, - updateExtent: core::ffi::c_int, - generateOriginalCellIds: bool, - ) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_crop( - sself: *mut core::ffi::c_void, - input: *mut core::ffi::c_void, - updateExtent: core::ffi::c_int, - generateOriginalCellIds: bool, - ); - } - unsafe { - vtk_explicit_structured_grid_crop( - self.0, - input, - updateExtent, - generateOriginalCellIds, - ) - } - } fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_explicit_structured_grid_get_data( @@ -29576,20 +15440,6 @@ impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { } unsafe { vtk_explicit_structured_grid_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_explicit_structured_grid_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_explicit_structured_grid_get_data(self.0, v, i) } - } fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_explicit_structured_grid_get_actual_memory_size( @@ -29633,83 +15483,6 @@ impl VtkExtractStructuredGridHelper for vtkExtractStructuredGridHelper { } unsafe { vtk_extract_structured_grid_helper_new_instance(self.0) } } - fn get_output_whole_extent(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_extract_structured_grid_helper_get_output_whole_extent( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_extract_structured_grid_helper_get_output_whole_extent(self.0) } - } - fn get_output_whole_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_extract_structured_grid_helper_get_output_whole_extent( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ); - } - unsafe { - vtk_extract_structured_grid_helper_get_output_whole_extent( - self.0, - _arg1, - _arg2, - _arg3, - _arg4, - _arg5, - _arg6, - ) - } - } - fn get_output_whole_extent(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_extract_structured_grid_helper_get_output_whole_extent( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { - vtk_extract_structured_grid_helper_get_output_whole_extent(self.0, _arg) - } - } - fn initialize( - &mut self, - voi: core::ffi::c_int, - wholeExt: core::ffi::c_int, - sampleRate: core::ffi::c_int, - includeBoundary: bool, - ) -> () { - unsafe extern "C" { - fn vtk_extract_structured_grid_helper_initialize( - sself: *mut core::ffi::c_void, - voi: core::ffi::c_int, - wholeExt: core::ffi::c_int, - sampleRate: core::ffi::c_int, - includeBoundary: bool, - ); - } - unsafe { - vtk_extract_structured_grid_helper_initialize( - self.0, - voi, - wholeExt, - sampleRate, - includeBoundary, - ) - } - } fn is_valid(&mut self) -> bool { unsafe extern "C" { fn vtk_extract_structured_grid_helper_is_valid( @@ -29803,151 +15576,6 @@ impl VtkExtractStructuredGridHelper for vtkExtractStructuredGridHelper { ) } } - fn compute_begin_and_end( - &mut self, - inExt: core::ffi::c_int, - voi: core::ffi::c_int, - begin: core::ffi::c_int, - end: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_extract_structured_grid_helper_compute_begin_and_end( - sself: *mut core::ffi::c_void, - inExt: core::ffi::c_int, - voi: core::ffi::c_int, - begin: core::ffi::c_int, - end: core::ffi::c_int, - ); - } - unsafe { - vtk_extract_structured_grid_helper_compute_begin_and_end( - self.0, - inExt, - voi, - begin, - end, - ) - } - } - fn copy_points_and_point_data( - &mut self, - inExt: core::ffi::c_int, - outExt: core::ffi::c_int, - pd: *mut core::ffi::c_void, - inpnts: *mut core::ffi::c_void, - outPD: *mut core::ffi::c_void, - outpnts: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_extract_structured_grid_helper_copy_points_and_point_data( - sself: *mut core::ffi::c_void, - inExt: core::ffi::c_int, - outExt: core::ffi::c_int, - pd: *mut core::ffi::c_void, - inpnts: *mut core::ffi::c_void, - outPD: *mut core::ffi::c_void, - outpnts: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_extract_structured_grid_helper_copy_points_and_point_data( - self.0, - inExt, - outExt, - pd, - inpnts, - outPD, - outpnts, - ) - } - } - fn copy_cell_data( - &mut self, - inExt: core::ffi::c_int, - outExt: core::ffi::c_int, - cd: *mut core::ffi::c_void, - outCD: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_extract_structured_grid_helper_copy_cell_data( - sself: *mut core::ffi::c_void, - inExt: core::ffi::c_int, - outExt: core::ffi::c_int, - cd: *mut core::ffi::c_void, - outCD: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_extract_structured_grid_helper_copy_cell_data( - self.0, - inExt, - outExt, - cd, - outCD, - ) - } - } - fn get_partitioned_voi( - &mut self, - globalVOI: core::ffi::c_int, - partitionedExtent: core::ffi::c_int, - sampleRate: core::ffi::c_int, - includeBoundary: bool, - partitionedVOI: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_extract_structured_grid_helper_get_partitioned_voi( - sself: *mut core::ffi::c_void, - globalVOI: core::ffi::c_int, - partitionedExtent: core::ffi::c_int, - sampleRate: core::ffi::c_int, - includeBoundary: bool, - partitionedVOI: core::ffi::c_int, - ); - } - unsafe { - vtk_extract_structured_grid_helper_get_partitioned_voi( - self.0, - globalVOI, - partitionedExtent, - sampleRate, - includeBoundary, - partitionedVOI, - ) - } - } - fn get_partitioned_output_extent( - &mut self, - globalVOI: core::ffi::c_int, - partitionedVOI: core::ffi::c_int, - outputWholeExtent: core::ffi::c_int, - sampleRate: core::ffi::c_int, - includeBoundary: bool, - partitionedOutputExtent: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_extract_structured_grid_helper_get_partitioned_output_extent( - sself: *mut core::ffi::c_void, - globalVOI: core::ffi::c_int, - partitionedVOI: core::ffi::c_int, - outputWholeExtent: core::ffi::c_int, - sampleRate: core::ffi::c_int, - includeBoundary: bool, - partitionedOutputExtent: core::ffi::c_int, - ); - } - unsafe { - vtk_extract_structured_grid_helper_get_partitioned_output_extent( - self.0, - globalVOI, - partitionedVOI, - outputWholeExtent, - sampleRate, - includeBoundary, - partitionedOutputExtent, - ) - } - } } impl VtkFieldData for vtkFieldData { fn new(&mut self) -> *mut core::ffi::c_void { @@ -29991,14 +15619,14 @@ impl VtkFieldData for vtkFieldData { } fn allocate( &mut self, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_field_data_allocate( sself: *mut core::ffi::c_void, - sz: core::ffi::c_uchar, - ext: core::ffi::c_uchar, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_field_data_allocate(self.0, sz, ext) } @@ -30038,32 +15666,24 @@ impl VtkFieldData for vtkFieldData { } unsafe { vtk_field_data_add_array(self.0, array) } } - fn null_data(&mut self, id: core::ffi::c_uchar) -> () { + fn null_data(&mut self, id: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_field_data_null_data( sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, + id: core::ffi::c_longlong, ); } unsafe { vtk_field_data_null_data(self.0, id) } } - fn remove_array(&mut self, name: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_field_data_remove_array( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ); - } - unsafe { vtk_field_data_remove_array(self.0, name) } - } - fn remove_array(&mut self, index: core::ffi::c_int) -> () { + fn remove_array(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_field_data_remove_array( sself: *mut core::ffi::c_void, - index: core::ffi::c_int, + name: *const core::ffi::c_char, ); } - unsafe { vtk_field_data_remove_array(self.0, index) } + unsafe { vtk_field_data_remove_array(self.0, c_name.as_ptr()) } } fn get_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -30074,29 +15694,6 @@ impl VtkFieldData for vtkFieldData { } unsafe { vtk_field_data_get_array(self.0, i) } } - fn get_array( - &mut self, - arrayName: core::ffi::c_char, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_field_data_get_array( - sself: *mut core::ffi::c_void, - arrayName: core::ffi::c_char, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_field_data_get_array(self.0, arrayName, index) } - } - fn get_array(&mut self, arrayName: core::ffi::c_char) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_field_data_get_array( - sself: *mut core::ffi::c_void, - arrayName: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_field_data_get_array(self.0, arrayName) } - } fn get_abstract_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_field_data_get_abstract_array( @@ -30106,49 +15703,28 @@ impl VtkFieldData for vtkFieldData { } unsafe { vtk_field_data_get_abstract_array(self.0, i) } } - fn get_abstract_array( - &mut self, - arrayName: core::ffi::c_char, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_field_data_get_abstract_array( - sself: *mut core::ffi::c_void, - arrayName: core::ffi::c_char, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_field_data_get_abstract_array(self.0, arrayName, index) } - } - fn get_abstract_array( - &mut self, - arrayName: core::ffi::c_char, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_field_data_get_abstract_array( - sself: *mut core::ffi::c_void, - arrayName: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_field_data_get_abstract_array(self.0, arrayName) } - } - fn has_array(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn has_array(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_field_data_has_array( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_field_data_has_array(self.0, name) } + unsafe { vtk_field_data_has_array(self.0, c_name.as_ptr()) } } - fn get_array_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char { + fn get_array_name(&mut self, i: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_field_data_get_array_name( sself: *mut core::ffi::c_void, i: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_field_data_get_array_name(self.0, i) } + let ptr = unsafe { vtk_field_data_get_array_name(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn pass_data(&mut self, fd: *mut core::ffi::c_void) -> () { unsafe extern "C" { @@ -30159,23 +15735,25 @@ impl VtkFieldData for vtkFieldData { } unsafe { vtk_field_data_pass_data(self.0, fd) } } - fn copy_field_on(&mut self, name: core::ffi::c_char) -> () { + fn copy_field_on(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_field_data_copy_field_on( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ); } - unsafe { vtk_field_data_copy_field_on(self.0, name) } + unsafe { vtk_field_data_copy_field_on(self.0, c_name.as_ptr()) } } - fn copy_field_off(&mut self, name: core::ffi::c_char) -> () { + fn copy_field_off(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_field_data_copy_field_off( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ); } - unsafe { vtk_field_data_copy_field_off(self.0, name) } + unsafe { vtk_field_data_copy_field_off(self.0, c_name.as_ptr()) } } fn copy_all_on(&mut self, unused: core::ffi::c_int) -> () { unsafe extern "C" { @@ -30258,13 +15836,13 @@ impl VtkFieldData for vtkFieldData { fn get_array_containing_component( &mut self, i: core::ffi::c_int, - arrayComp: core::ffi::c_int, + arrayComp: &mut core::ffi::c_int, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_field_data_get_array_containing_component( sself: *mut core::ffi::c_void, i: core::ffi::c_int, - arrayComp: core::ffi::c_int, + arrayComp: &mut core::ffi::c_int, ) -> core::ffi::c_int; } unsafe { vtk_field_data_get_array_containing_component(self.0, i, arrayComp) } @@ -30277,34 +15855,34 @@ impl VtkFieldData for vtkFieldData { } unsafe { vtk_field_data_get_number_of_components(self.0) } } - fn get_number_of_tuples(&mut self) -> core::ffi::c_uchar { + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_field_data_get_number_of_tuples( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_field_data_get_number_of_tuples(self.0) } } - fn set_number_of_tuples(&mut self, number: core::ffi::c_uchar) -> () { + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_field_data_set_number_of_tuples( sself: *mut core::ffi::c_void, - number: core::ffi::c_uchar, + number: core::ffi::c_longlong, ); } unsafe { vtk_field_data_set_number_of_tuples(self.0, number) } } fn set_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_field_data_set_tuple( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ); } @@ -30312,15 +15890,15 @@ impl VtkFieldData for vtkFieldData { } fn insert_tuple( &mut self, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_field_data_insert_tuple( sself: *mut core::ffi::c_void, - i: core::ffi::c_uchar, - j: core::ffi::c_uchar, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, ); } @@ -30328,15 +15906,15 @@ impl VtkFieldData for vtkFieldData { } fn insert_next_tuple( &mut self, - j: core::ffi::c_uchar, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_field_data_insert_next_tuple( sself: *mut core::ffi::c_void, - j: core::ffi::c_uchar, + j: core::ffi::c_longlong, source: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_field_data_insert_next_tuple(self.0, j, source) } } @@ -30428,14 +16006,17 @@ impl VtkGenericAttributeCollection for vtkGenericAttributeCollection { } unsafe { vtk_generic_attribute_collection_get_attribute(self.0, i) } } - fn find_attribute(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn find_attribute(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_generic_attribute_collection_find_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_generic_attribute_collection_find_attribute(self.0, name) } + unsafe { + vtk_generic_attribute_collection_find_attribute(self.0, c_name.as_ptr()) + } } fn get_attribute_index(&mut self, i: core::ffi::c_int) -> core::ffi::c_int { unsafe extern "C" { @@ -30558,57 +16139,6 @@ impl VtkGenericAttributeCollection for vtkGenericAttributeCollection { ) } } - fn get_attributes_to_interpolate(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_generic_attribute_collection_get_attributes_to_interpolate( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_generic_attribute_collection_get_attributes_to_interpolate(self.0) } - } - fn has_attribute( - &mut self, - size: core::ffi::c_int, - attributes: core::ffi::c_int, - attribute: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_generic_attribute_collection_has_attribute( - sself: *mut core::ffi::c_void, - size: core::ffi::c_int, - attributes: core::ffi::c_int, - attribute: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_generic_attribute_collection_has_attribute( - self.0, - size, - attributes, - attribute, - ) - } - } - fn set_attributes_to_interpolate( - &mut self, - size: core::ffi::c_int, - attributes: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_generic_attribute_collection_set_attributes_to_interpolate( - sself: *mut core::ffi::c_void, - size: core::ffi::c_int, - attributes: core::ffi::c_int, - ); - } - unsafe { - vtk_generic_attribute_collection_set_attributes_to_interpolate( - self.0, - size, - attributes, - ) - } - } fn set_attributes_to_interpolate_to_all(&mut self) -> () { unsafe extern "C" { fn vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all( @@ -30723,72 +16253,6 @@ impl VtkGenericCell for vtkGenericCell { } unsafe { vtk_generic_cell_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_generic_cell_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_generic_cell_cell_boundary(self.0, subId, pcoords, pts) } - } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_generic_cell_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_generic_cell_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_generic_cell_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_generic_cell_evaluate_location(self.0, subId, pcoords, x, weights) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -30800,7 +16264,7 @@ impl VtkGenericCell for vtkGenericCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -30815,7 +16279,7 @@ impl VtkGenericCell for vtkGenericCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -30845,7 +16309,7 @@ impl VtkGenericCell for vtkGenericCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -30859,7 +16323,7 @@ impl VtkGenericCell for vtkGenericCell { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -30880,41 +16344,6 @@ impl VtkGenericCell for vtkGenericCell { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_generic_cell_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_generic_cell_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -30931,42 +16360,6 @@ impl VtkGenericCell for vtkGenericCell { } unsafe { vtk_generic_cell_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_generic_cell_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_generic_cell_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_generic_cell_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_generic_cell_interpolate_functions(self.0, pcoords, weights) } - } fn set_cell_type(&mut self, cellType: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_generic_cell_set_cell_type( @@ -31391,84 +16784,66 @@ impl VtkGenericEdgeTable for vtkGenericEdgeTable { } fn insert_edge( &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ref_: core::ffi::c_int, - ptId: core::ffi::c_uchar, + ptId: &mut core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_generic_edge_table_insert_edge( sself: *mut core::ffi::c_void, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ref_: core::ffi::c_int, - ptId: core::ffi::c_uchar, + ptId: &mut core::ffi::c_longlong, ); } unsafe { vtk_generic_edge_table_insert_edge(self.0, e1, e2, cellId, ref_, ptId) } } - fn insert_edge( - &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, - ref_: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_generic_edge_table_insert_edge( - sself: *mut core::ffi::c_void, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, - ref_: core::ffi::c_int, - ); - } - unsafe { vtk_generic_edge_table_insert_edge(self.0, e1, e2, cellId, ref_) } - } fn remove_edge( &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_generic_edge_table_remove_edge( sself: *mut core::ffi::c_void, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_generic_edge_table_remove_edge(self.0, e1, e2) } } fn check_edge( &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - ptId: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ptId: &mut core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_generic_edge_table_check_edge( sself: *mut core::ffi::c_void, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - ptId: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ptId: &mut core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_generic_edge_table_check_edge(self.0, e1, e2, ptId) } } fn increment_edge_reference_count( &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_generic_edge_table_increment_edge_reference_count( sself: *mut core::ffi::c_void, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { @@ -31477,23 +16852,23 @@ impl VtkGenericEdgeTable for vtkGenericEdgeTable { } fn check_edge_reference_count( &mut self, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_generic_edge_table_check_edge_reference_count( sself: *mut core::ffi::c_void, - e1: core::ffi::c_uchar, - e2: core::ffi::c_uchar, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_generic_edge_table_check_edge_reference_count(self.0, e1, e2) } } - fn initialize(&mut self, start: core::ffi::c_uchar) -> () { + fn initialize(&mut self, start: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_generic_edge_table_initialize( sself: *mut core::ffi::c_void, - start: core::ffi::c_uchar, + start: core::ffi::c_longlong, ); } unsafe { vtk_generic_edge_table_initialize(self.0, start) } @@ -31515,75 +16890,29 @@ impl VtkGenericEdgeTable for vtkGenericEdgeTable { } unsafe { vtk_generic_edge_table_set_number_of_components(self.0, count) } } - fn check_point(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_int { + fn check_point(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_generic_edge_table_check_point( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_generic_edge_table_check_point(self.0, ptId) } } - fn check_point( - &mut self, - ptId: core::ffi::c_uchar, - point: core::ffi::c_double, - scalar: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_generic_edge_table_check_point( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - point: core::ffi::c_double, - scalar: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_generic_edge_table_check_point(self.0, ptId, point, scalar) } - } - fn insert_point( - &mut self, - ptId: core::ffi::c_uchar, - point: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_generic_edge_table_insert_point( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - point: core::ffi::c_double, - ); - } - unsafe { vtk_generic_edge_table_insert_point(self.0, ptId, point) } - } - fn insert_point_and_scalar( - &mut self, - ptId: core::ffi::c_uchar, - pt: core::ffi::c_double, - s: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_generic_edge_table_insert_point_and_scalar( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - pt: core::ffi::c_double, - s: core::ffi::c_double, - ); - } - unsafe { vtk_generic_edge_table_insert_point_and_scalar(self.0, ptId, pt, s) } - } - fn remove_point(&mut self, ptId: core::ffi::c_uchar) -> () { + fn remove_point(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_generic_edge_table_remove_point( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_generic_edge_table_remove_point(self.0, ptId) } } - fn increment_point_reference_count(&mut self, ptId: core::ffi::c_uchar) -> () { + fn increment_point_reference_count(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_generic_edge_table_increment_point_reference_count( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_generic_edge_table_increment_point_reference_count(self.0, ptId) } @@ -31627,20 +16956,6 @@ impl VtkGenericInterpolatedVelocityField for vtkGenericInterpolatedVelocityField } unsafe { vtk_generic_interpolated_velocity_field_new(self.0) } } - fn function_values( - &mut self, - x: core::ffi::c_double, - f: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_generic_interpolated_velocity_field_function_values( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - f: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_generic_interpolated_velocity_field_function_values(self.0, x, f) } - } fn add_data_set(&mut self, dataset: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_generic_interpolated_velocity_field_add_data_set( @@ -31666,23 +16981,6 @@ impl VtkGenericInterpolatedVelocityField for vtkGenericInterpolatedVelocityField } unsafe { vtk_generic_interpolated_velocity_field_get_last_cell(self.0) } } - fn get_last_local_coordinates( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_generic_interpolated_velocity_field_get_last_local_coordinates( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_generic_interpolated_velocity_field_get_last_local_coordinates( - self.0, - pcoords, - ) - } - } fn get_caching(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_generic_interpolated_velocity_field_get_caching( @@ -31732,23 +17030,20 @@ impl VtkGenericInterpolatedVelocityField for vtkGenericInterpolatedVelocityField } unsafe { vtk_generic_interpolated_velocity_field_get_cache_miss(self.0) } } - fn get_vectors_selection(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_generic_interpolated_velocity_field_get_vectors_selection( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_generic_interpolated_velocity_field_get_vectors_selection(self.0) } - } - fn select_vectors(&mut self, fieldName: core::ffi::c_char) -> () { + fn select_vectors(&mut self, fieldName: &str) -> () { + let c_fieldName = std::ffi::CString::new(fieldName) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_generic_interpolated_velocity_field_select_vectors( sself: *mut core::ffi::c_void, - fieldName: core::ffi::c_char, + fieldName: *const core::ffi::c_char, ); } unsafe { - vtk_generic_interpolated_velocity_field_select_vectors(self.0, fieldName) + vtk_generic_interpolated_velocity_field_select_vectors( + self.0, + c_fieldName.as_ptr(), + ) } } fn get_last_data_set(&mut self) -> *mut core::ffi::c_void { @@ -31834,58 +17129,6 @@ impl VtkGeometricErrorMetric for vtkGeometricErrorMetric { ) } } - fn requires_edge_subdivision( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_geometric_error_metric_requires_edge_subdivision( - sself: *mut core::ffi::c_void, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_geometric_error_metric_requires_edge_subdivision( - self.0, - leftPoint, - midPoint, - rightPoint, - alpha, - ) - } - } - fn get_error( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_geometric_error_metric_get_error( - sself: *mut core::ffi::c_void, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { - vtk_geometric_error_metric_get_error( - self.0, - leftPoint, - midPoint, - rightPoint, - alpha, - ) - } - } fn get_relative(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_geometric_error_metric_get_relative( @@ -31921,54 +17164,54 @@ impl VtkGraphEdge for vtkGraphEdge { } unsafe { vtk_graph_edge_new_instance(self.0) } } - fn set_source(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_source(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_graph_edge_set_source( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_graph_edge_set_source(self.0, _arg) } } - fn get_source(&mut self) -> core::ffi::c_uchar { + fn get_source(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_graph_edge_get_source( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_graph_edge_get_source(self.0) } } - fn set_target(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_target(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_graph_edge_set_target( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_graph_edge_set_target(self.0, _arg) } } - fn get_target(&mut self) -> core::ffi::c_uchar { + fn get_target(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_graph_edge_get_target( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_graph_edge_get_target(self.0) } } - fn set_id(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_id(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_graph_edge_set_id( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_graph_edge_set_id(self.0, _arg) } } - fn get_id(&mut self) -> core::ffi::c_uchar { + fn get_id(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_graph_edge_get_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_graph_edge_get_id(self.0) } } @@ -31999,70 +17242,6 @@ impl VtkGraphInternals for vtkGraphInternals { } unsafe { vtk_graph_internals_new_instance(self.0) } } - fn remove_edge_from_out_list( - &mut self, - e: core::ffi::c_uchar, - outEdges: Vec, - ) -> () { - unsafe extern "C" { - fn vtk_graph_internals_remove_edge_from_out_list( - sself: *mut core::ffi::c_void, - e: core::ffi::c_uchar, - outEdges: Vec, - ); - } - unsafe { vtk_graph_internals_remove_edge_from_out_list(self.0, e, outEdges) } - } - fn remove_edge_from_in_list( - &mut self, - e: core::ffi::c_uchar, - inEdges: Vec, - ) -> () { - unsafe extern "C" { - fn vtk_graph_internals_remove_edge_from_in_list( - sself: *mut core::ffi::c_void, - e: core::ffi::c_uchar, - inEdges: Vec, - ); - } - unsafe { vtk_graph_internals_remove_edge_from_in_list(self.0, e, inEdges) } - } - fn replace_edge_from_out_list( - &mut self, - from: core::ffi::c_uchar, - to: core::ffi::c_uchar, - outEdges: Vec, - ) -> () { - unsafe extern "C" { - fn vtk_graph_internals_replace_edge_from_out_list( - sself: *mut core::ffi::c_void, - from: core::ffi::c_uchar, - to: core::ffi::c_uchar, - outEdges: Vec, - ); - } - unsafe { - vtk_graph_internals_replace_edge_from_out_list(self.0, from, to, outEdges) - } - } - fn replace_edge_from_in_list( - &mut self, - from: core::ffi::c_uchar, - to: core::ffi::c_uchar, - inEdges: Vec, - ) -> () { - unsafe extern "C" { - fn vtk_graph_internals_replace_edge_from_in_list( - sself: *mut core::ffi::c_void, - from: core::ffi::c_uchar, - to: core::ffi::c_uchar, - inEdges: Vec, - ); - } - unsafe { - vtk_graph_internals_replace_edge_from_in_list(self.0, from, to, inEdges) - } - } } impl VtkHexagonalPrism for vtkHexagonalPrism { fn new(&mut self) -> *mut core::ffi::c_void { @@ -32090,147 +17269,6 @@ impl VtkHexagonalPrism for vtkHexagonalPrism { } unsafe { vtk_hexagonal_prism_new_instance(self.0) } } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_hexagonal_prism_get_edge_points(self.0, edgeId, pts) } - } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_hexagonal_prism_get_edge_points(self.0, edgeId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_hexagonal_prism_get_face_points(self.0, faceId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_hexagonal_prism_get_face_points(self.0, faceId, pts) } - } - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_edge_to_adjacent_faces( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_hexagonal_prism_get_edge_to_adjacent_faces(self.0, edgeId, pts) } - } - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_face_to_adjacent_faces( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_hexagonal_prism_get_face_to_adjacent_faces(self.0, faceId, faceIds) - } - } - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_point_to_incident_edges( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_hexagonal_prism_get_point_to_incident_edges(self.0, pointId, edgeIds) - } - } - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_point_to_incident_faces( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_hexagonal_prism_get_point_to_incident_faces(self.0, pointId, faceIds) - } - } - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_point_to_one_ring_points( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_hexagonal_prism_get_point_to_one_ring_points(self.0, pointId, pts) } - } - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_centroid( - sself: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_hexagonal_prism_get_centroid(self.0, centroid) } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_hexagonal_prism_get_cell_type( @@ -32273,109 +17311,6 @@ impl VtkHexagonalPrism for vtkHexagonalPrism { } unsafe { vtk_hexagonal_prism_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_hexagonal_prism_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_hexagonal_prism_cell_boundary(self.0, subId, pcoords, pts) } - } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_hexagonal_prism_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_hexagonal_prism_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_hexagonal_prism_evaluate_location(self.0, subId, pcoords, x, weights) - } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_hexagonal_prism_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_hexagonal_prism_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -32392,216 +17327,6 @@ impl VtkHexagonalPrism for vtkHexagonalPrism { } unsafe { vtk_hexagonal_prism_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_hexagonal_prism_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_hexagonal_prism_get_parametric_center(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_hexagonal_prism_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_hexagonal_prism_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_hexagonal_prism_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_hexagonal_prism_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexagonal_prism_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexagonal_prism_get_face_array(self.0, faceId) } - } - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_edge_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexagonal_prism_get_edge_to_adjacent_faces_array(self.0, edgeId) } - } - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_face_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexagonal_prism_get_face_to_adjacent_faces_array(self.0, faceId) } - } - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_point_to_incident_edges_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexagonal_prism_get_point_to_incident_edges_array(self.0, pointId) } - } - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_point_to_incident_faces_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexagonal_prism_get_point_to_incident_faces_array(self.0, pointId) } - } - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexagonal_prism_get_point_to_one_ring_points_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { - vtk_hexagonal_prism_get_point_to_one_ring_points_array(self.0, pointId) - } - } - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_hexagonal_prism_compute_centroid( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { - vtk_hexagonal_prism_compute_centroid(self.0, points, pointIds, centroid) - } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexagonal_prism_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_hexagonal_prism_jacobian_inverse(self.0, pcoords, inverse, derivs) } - } } impl VtkHexahedron for vtkHexahedron { fn new(&mut self) -> *mut core::ffi::c_void { @@ -32629,141 +17354,6 @@ impl VtkHexahedron for vtkHexahedron { } unsafe { vtk_hexahedron_new_instance(self.0) } } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_hexahedron_get_edge_points(self.0, edgeId, pts) } - } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_hexahedron_get_edge_points(self.0, edgeId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_face_points(self.0, faceId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_hexahedron_get_face_points(self.0, faceId, pts) } - } - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_get_edge_to_adjacent_faces( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_hexahedron_get_edge_to_adjacent_faces(self.0, edgeId, pts) } - } - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_face_to_adjacent_faces( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_face_to_adjacent_faces(self.0, faceId, faceIds) } - } - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_point_to_incident_edges( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_point_to_incident_edges(self.0, pointId, edgeIds) } - } - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_point_to_incident_faces( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_point_to_incident_faces(self.0, pointId, faceIds) } - } - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_point_to_one_ring_points( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_point_to_one_ring_points(self.0, pointId, pts) } - } - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { - unsafe extern "C" { - fn vtk_hexahedron_get_centroid( - sself: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_hexahedron_get_centroid(self.0, centroid) } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_hexahedron_get_cell_type( @@ -32806,98 +17396,6 @@ impl VtkHexahedron for vtkHexahedron { } unsafe { vtk_hexahedron_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_hexahedron_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_hexahedron_cell_boundary(self.0, subId, pcoords, pts) } - } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_hexahedron_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_hexahedron_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_hexahedron_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_hexahedron_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_hexahedron_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -32914,209 +17412,6 @@ impl VtkHexahedron for vtkHexahedron { } unsafe { vtk_hexahedron_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_hexahedron_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } - fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_hexahedron_get_triangle_cases( - sself: *mut core::ffi::c_void, - caseId: core::ffi::c_int, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_hexahedron_get_triangle_cases(self.0, caseId) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_hexahedron_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_hexahedron_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_hexahedron_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_hexahedron_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_face_array(self.0, faceId) } - } - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_edge_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_edge_to_adjacent_faces_array(self.0, edgeId) } - } - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_face_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_face_to_adjacent_faces_array(self.0, faceId) } - } - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_point_to_incident_edges_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_point_to_incident_edges_array(self.0, pointId) } - } - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_point_to_incident_faces_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_point_to_incident_faces_array(self.0, pointId) } - } - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_hexahedron_get_point_to_one_ring_points_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_hexahedron_get_point_to_one_ring_points_array(self.0, pointId) } - } - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_hexahedron_compute_centroid( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_hexahedron_compute_centroid(self.0, points, pointIds, centroid) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hexahedron_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_hexahedron_jacobian_inverse(self.0, pcoords, inverse, derivs) } - } } impl VtkHierarchicalBoxDataIterator for vtkHierarchicalBoxDataIterator { fn new(&mut self) -> *mut core::ffi::c_void { @@ -33188,20 +17483,6 @@ impl VtkHierarchicalBoxDataSet for vtkHierarchicalBoxDataSet { } unsafe { vtk_hierarchical_box_data_set_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_hierarchical_box_data_set_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_hierarchical_box_data_set_get_data(self.0, v, i) } - } } impl VtkHyperTreeGrid for vtkHyperTreeGrid { fn levels(&mut self) -> *mut core::ffi::c_void { @@ -33261,22 +17542,15 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_new_instance(self.0) } } - fn set_mode_squeeze(&mut self, _arg: core::ffi::c_char) -> () { + fn set_mode_squeeze(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { fn vtk_hyper_tree_grid_set_mode_squeeze( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, + _arg: *const core::ffi::c_char, ); } - unsafe { vtk_hyper_tree_grid_set_mode_squeeze(self.0, _arg) } - } - fn get_mode_squeeze(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_mode_squeeze( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_hyper_tree_grid_get_mode_squeeze(self.0) } + unsafe { vtk_hyper_tree_grid_set_mode_squeeze(self.0, c__arg.as_ptr()) } } fn squeeze(&mut self) -> () { unsafe extern "C" { @@ -33310,24 +17584,6 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_copy_empty_structure(self.0, p0) } } - fn set_dimensions(&mut self, dims: core::ffi::c_uint) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_set_dimensions( - sself: *mut core::ffi::c_void, - dims: core::ffi::c_uint, - ); - } - unsafe { vtk_hyper_tree_grid_set_dimensions(self.0, dims) } - } - fn set_dimensions(&mut self, dims: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_set_dimensions( - sself: *mut core::ffi::c_void, - dims: core::ffi::c_int, - ); - } - unsafe { vtk_hyper_tree_grid_set_dimensions(self.0, dims) } - } fn set_dimensions( &mut self, i: core::ffi::c_uint, @@ -33344,57 +17600,6 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_set_dimensions(self.0, i, j, k) } } - fn set_dimensions( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_set_dimensions( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ); - } - unsafe { vtk_hyper_tree_grid_set_dimensions(self.0, i, j, k) } - } - fn get_dimensions(&mut self) -> *const core::ffi::c_uint { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_dimensions( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_uint; - } - unsafe { vtk_hyper_tree_grid_get_dimensions(self.0) } - } - fn get_dimensions(&mut self, dim: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_dimensions( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - ); - } - unsafe { vtk_hyper_tree_grid_get_dimensions(self.0, dim) } - } - fn get_dimensions(&mut self, dim: core::ffi::c_uint) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_dimensions( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_uint, - ); - } - unsafe { vtk_hyper_tree_grid_get_dimensions(self.0, dim) } - } - fn set_extent(&mut self, extent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_set_extent( - sself: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_hyper_tree_grid_set_extent(self.0, extent) } - } fn set_extent( &mut self, x1: core::ffi::c_int, @@ -33417,81 +17622,6 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_set_extent(self.0, x1, x2, y1, y2, z1, z2) } } - fn get_extent(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_extent( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_hyper_tree_grid_get_extent(self.0) } - } - fn get_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_extent( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ); - } - unsafe { - vtk_hyper_tree_grid_get_extent( - self.0, - _arg1, - _arg2, - _arg3, - _arg4, - _arg5, - _arg6, - ) - } - } - fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_extent( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_hyper_tree_grid_get_extent(self.0, _arg) } - } - fn get_cell_dims(&mut self) -> *const core::ffi::c_uint { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_cell_dims( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_uint; - } - unsafe { vtk_hyper_tree_grid_get_cell_dims(self.0) } - } - fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_cell_dims( - sself: *mut core::ffi::c_void, - cellDims: core::ffi::c_int, - ); - } - unsafe { vtk_hyper_tree_grid_get_cell_dims(self.0, cellDims) } - } - fn get_cell_dims(&mut self, cellDims: core::ffi::c_uint) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_cell_dims( - sself: *mut core::ffi::c_void, - cellDims: core::ffi::c_uint, - ); - } - unsafe { vtk_hyper_tree_grid_get_cell_dims(self.0, cellDims) } - } fn get_dimension(&mut self) -> core::ffi::c_uint { unsafe extern "C" { fn vtk_hyper_tree_grid_get_dimension( @@ -33500,37 +17630,29 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_get_dimension(self.0) } } - fn get_1_d_axis(&mut self, axis: core::ffi::c_uint) -> () { + fn get_1_d_axis(&mut self, axis: &mut core::ffi::c_uint) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_get_1_d_axis( sself: *mut core::ffi::c_void, - axis: core::ffi::c_uint, + axis: &mut core::ffi::c_uint, ); } unsafe { vtk_hyper_tree_grid_get_1_d_axis(self.0, axis) } } fn get_2_d_axes( &mut self, - axis1: core::ffi::c_uint, - axis2: core::ffi::c_uint, + axis1: &mut core::ffi::c_uint, + axis2: &mut core::ffi::c_uint, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_get_2_d_axes( sself: *mut core::ffi::c_void, - axis1: core::ffi::c_uint, - axis2: core::ffi::c_uint, + axis1: &mut core::ffi::c_uint, + axis2: &mut core::ffi::c_uint, ); } unsafe { vtk_hyper_tree_grid_get_2_d_axes(self.0, axis1, axis2) } } - fn get_axes(&mut self) -> *const core::ffi::c_uint { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_axes( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_uint; - } - unsafe { vtk_hyper_tree_grid_get_axes(self.0) } - } fn get_number_of_children(&mut self) -> core::ffi::c_uint { unsafe extern "C" { fn vtk_hyper_tree_grid_get_number_of_children( @@ -33605,55 +17727,47 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_get_branch_factor(self.0) } } - fn get_max_number_of_trees(&mut self) -> core::ffi::c_uchar { + fn get_max_number_of_trees(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_get_max_number_of_trees( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_get_max_number_of_trees(self.0) } } - fn get_number_of_vertices(&mut self) -> core::ffi::c_uchar { + fn get_number_of_vertices(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_get_number_of_vertices( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_get_number_of_vertices(self.0) } } - fn get_number_of_non_empty_trees(&mut self) -> core::ffi::c_uchar { + fn get_number_of_non_empty_trees(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_get_number_of_non_empty_trees( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_get_number_of_non_empty_trees(self.0) } } - fn get_number_of_leaves(&mut self) -> core::ffi::c_uchar { + fn get_number_of_leaves(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_get_number_of_leaves( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_get_number_of_leaves(self.0) } } - fn get_number_of_levels(&mut self, p0: core::ffi::c_uchar) -> core::ffi::c_uint { + fn get_number_of_levels(&mut self, p0: core::ffi::c_longlong) -> core::ffi::c_uint { unsafe extern "C" { fn vtk_hyper_tree_grid_get_number_of_levels( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, ) -> core::ffi::c_uint; } unsafe { vtk_hyper_tree_grid_get_number_of_levels(self.0, p0) } } - fn get_number_of_levels(&mut self) -> core::ffi::c_uint { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_number_of_levels( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uint; - } - unsafe { vtk_hyper_tree_grid_get_number_of_levels(self.0) } - } fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_set_x_coordinates( @@ -33705,15 +17819,6 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_get_z_coordinates(self.0) } } - fn copy_coordinates(&mut self, output: vtkHyperTreeGrid) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_copy_coordinates( - sself: *mut core::ffi::c_void, - output: vtkHyperTreeGrid, - ); - } - unsafe { vtk_hyper_tree_grid_copy_coordinates(self.0, output) } - } fn set_fixed_coordinates( &mut self, axis: core::ffi::c_uint, @@ -33780,39 +17885,29 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_has_interface_off(self.0) } } - fn set_interface_normals_name(&mut self, _arg: core::ffi::c_char) -> () { + fn set_interface_normals_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { fn vtk_hyper_tree_grid_set_interface_normals_name( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, + _arg: *const core::ffi::c_char, ); } - unsafe { vtk_hyper_tree_grid_set_interface_normals_name(self.0, _arg) } - } - fn get_interface_normals_name(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_interface_normals_name( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; + unsafe { + vtk_hyper_tree_grid_set_interface_normals_name(self.0, c__arg.as_ptr()) } - unsafe { vtk_hyper_tree_grid_get_interface_normals_name(self.0) } } - fn set_interface_intercepts_name(&mut self, _arg: core::ffi::c_char) -> () { + fn set_interface_intercepts_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { fn vtk_hyper_tree_grid_set_interface_intercepts_name( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, + _arg: *const core::ffi::c_char, ); } - unsafe { vtk_hyper_tree_grid_set_interface_intercepts_name(self.0, _arg) } - } - fn get_interface_intercepts_name(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_interface_intercepts_name( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; + unsafe { + vtk_hyper_tree_grid_set_interface_intercepts_name(self.0, c__arg.as_ptr()) } - unsafe { vtk_hyper_tree_grid_get_interface_intercepts_name(self.0) } } fn set_depth_limiter(&mut self, _arg: core::ffi::c_uint) -> () { unsafe extern "C" { @@ -33834,14 +17929,14 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { fn initialize_oriented_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_initialize_oriented_cursor( sself: *mut core::ffi::c_void, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ); } @@ -33851,13 +17946,13 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn new_oriented_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_new_oriented_cursor( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; } @@ -33866,14 +17961,14 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { fn initialize_oriented_geometry_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_initialize_oriented_geometry_cursor( sself: *mut core::ffi::c_void, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ); } @@ -33888,13 +17983,13 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn new_oriented_geometry_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_new_oriented_geometry_cursor( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; } @@ -33905,14 +18000,14 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { fn initialize_non_oriented_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_initialize_non_oriented_cursor( sself: *mut core::ffi::c_void, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ); } @@ -33927,13 +18022,13 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn new_non_oriented_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_new_non_oriented_cursor( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; } @@ -33942,14 +18037,14 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { fn initialize_non_oriented_geometry_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_initialize_non_oriented_geometry_cursor( sself: *mut core::ffi::c_void, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ); } @@ -33964,13 +18059,13 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn new_non_oriented_geometry_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_new_non_oriented_geometry_cursor( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; } @@ -33978,18 +18073,6 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { vtk_hyper_tree_grid_new_non_oriented_geometry_cursor(self.0, index, create) } } - fn find_non_oriented_geometry_cursor( - &mut self, - x: core::ffi::c_double, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_hyper_tree_grid_find_non_oriented_geometry_cursor( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_hyper_tree_grid_find_non_oriented_geometry_cursor(self.0, x) } - } fn find_dichotomic_x(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint { unsafe extern "C" { fn vtk_hyper_tree_grid_find_dichotomic_x( @@ -34020,14 +18103,14 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { fn initialize_non_oriented_von_neumann_super_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_initialize_non_oriented_von_neumann_super_cursor( sself: *mut core::ffi::c_void, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ); } @@ -34042,13 +18125,13 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn new_non_oriented_von_neumann_super_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_new_non_oriented_von_neumann_super_cursor( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; } @@ -34063,14 +18146,14 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { fn initialize_non_oriented_von_neumann_super_cursor_light( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_initialize_non_oriented_von_neumann_super_cursor_light( sself: *mut core::ffi::c_void, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ); } @@ -34085,13 +18168,13 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn new_non_oriented_von_neumann_super_cursor_light( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_new_non_oriented_von_neumann_super_cursor_light( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; } @@ -34106,14 +18189,14 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { fn initialize_non_oriented_moore_super_cursor( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_initialize_non_oriented_moore_super_cursor( sself: *mut core::ffi::c_void, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ); } @@ -34128,13 +18211,13 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn new_non_oriented_moore_super_cursor( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_new_non_oriented_moore_super_cursor( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; } @@ -34149,14 +18232,14 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { fn initialize_non_oriented_moore_super_cursor_light( &mut self, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_initialize_non_oriented_moore_super_cursor_light( sself: *mut core::ffi::c_void, cursor: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ); } @@ -34171,13 +18254,13 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn new_non_oriented_moore_super_cursor_light( &mut self, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_new_non_oriented_moore_super_cursor_light( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; } @@ -34197,23 +18280,23 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn get_tree( &mut self, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_get_tree( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, create: bool, ) -> *mut core::ffi::c_void; } unsafe { vtk_hyper_tree_grid_get_tree(self.0, p0, create) } } - fn set_tree(&mut self, p0: core::ffi::c_uchar, p1: *mut core::ffi::c_void) -> () { + fn set_tree(&mut self, p0: core::ffi::c_longlong, p1: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_set_tree( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, p1: *mut core::ffi::c_void, ); } @@ -34296,7 +18379,7 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn get_index_from_level_zero_coordinates( &mut self, - p0: core::ffi::c_uchar, + p0: &mut core::ffi::c_longlong, p1: core::ffi::c_uint, p2: core::ffi::c_uint, p3: core::ffi::c_uint, @@ -34304,7 +18387,7 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { unsafe extern "C" { fn vtk_hyper_tree_grid_get_index_from_level_zero_coordinates( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: &mut core::ffi::c_longlong, p1: core::ffi::c_uint, p2: core::ffi::c_uint, p3: core::ffi::c_uint, @@ -34322,19 +18405,19 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn get_shifted_level_zero_index( &mut self, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, p1: core::ffi::c_uint, p2: core::ffi::c_uint, p3: core::ffi::c_uint, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_get_shifted_level_zero_index( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, p1: core::ffi::c_uint, p2: core::ffi::c_uint, p3: core::ffi::c_uint, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_get_shifted_level_zero_index(self.0, p0, p1, p2, p3) @@ -34342,18 +18425,18 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } fn get_level_zero_coordinates_from_index( &mut self, - p0: core::ffi::c_uchar, - p1: core::ffi::c_uint, - p2: core::ffi::c_uint, - p3: core::ffi::c_uint, + p0: core::ffi::c_longlong, + p1: &mut core::ffi::c_uint, + p2: &mut core::ffi::c_uint, + p3: &mut core::ffi::c_uint, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_get_level_zero_coordinates_from_index( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, - p1: core::ffi::c_uint, - p2: core::ffi::c_uint, - p3: core::ffi::c_uint, + p0: core::ffi::c_longlong, + p1: &mut core::ffi::c_uint, + p2: &mut core::ffi::c_uint, + p3: &mut core::ffi::c_uint, ); } unsafe { @@ -34366,48 +18449,11 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { ) } } - fn get_level_zero_origin_and_size_from_index( - &mut self, - p0: core::ffi::c_uchar, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_level_zero_origin_and_size_from_index( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - ); - } - unsafe { - vtk_hyper_tree_grid_get_level_zero_origin_and_size_from_index( - self.0, - p0, - p1, - p2, - ) - } - } - fn get_level_zero_origin_from_index( - &mut self, - p0: core::ffi::c_uchar, - p1: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_level_zero_origin_from_index( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, - p1: core::ffi::c_double, - ); - } - unsafe { vtk_hyper_tree_grid_get_level_zero_origin_from_index(self.0, p0, p1) } - } - fn get_global_node_index_max(&mut self) -> core::ffi::c_uchar { + fn get_global_node_index_max(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_get_global_node_index_max( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_get_global_node_index_max(self.0) } } @@ -34451,15 +18497,6 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_allocate_tree_ghost_array(self.0) } } - fn initialize_tree_iterator(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_initialize_tree_iterator( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_hyper_tree_grid_initialize_tree_iterator(self.0, p0) } - } fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_get_data( @@ -34469,54 +18506,6 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_hyper_tree_grid_get_data(self.0, v, i) } - } - fn get_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_hyper_tree_grid_get_bounds(self.0) } - } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_hyper_tree_grid_get_bounds(self.0, bounds) } - } - fn get_center(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_center( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_hyper_tree_grid_get_center(self.0) } - } - fn get_center(&mut self, center: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_get_center( - sself: *mut core::ffi::c_void, - center: core::ffi::c_double, - ); - } - unsafe { vtk_hyper_tree_grid_get_center(self.0, center) } - } fn get_cell_data(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_get_cell_data( @@ -34537,12 +18526,15 @@ impl VtkHyperTreeGrid for vtkHyperTreeGrid { } unsafe { vtk_hyper_tree_grid_get_attributes_as_field_data(self.0, type_) } } - fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar { + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_get_number_of_elements( sself: *mut core::ffi::c_void, type_: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_get_number_of_elements(self.0, type_) } } @@ -34584,14 +18576,14 @@ impl VtkHyperTreeGridNonOrientedCursor for vtkHyperTreeGridNonOrientedCursor { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_cursor_initialize( sself: *mut core::ffi::c_void, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ); } @@ -34604,58 +18596,6 @@ impl VtkHyperTreeGridNonOrientedCursor for vtkHyperTreeGridNonOrientedCursor { ) } } - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_non_oriented_cursor_initialize( - sself: *mut core::ffi::c_void, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_hyper_tree_grid_non_oriented_cursor_initialize( - self.0, - grid, - tree, - level, - entry, - ) - } - } - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_non_oriented_cursor_initialize( - sself: *mut core::ffi::c_void, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - ); - } - unsafe { - vtk_hyper_tree_grid_non_oriented_cursor_initialize( - self.0, - grid, - tree, - level, - index, - ) - } - } fn get_grid(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_cursor_get_grid( @@ -34680,19 +18620,19 @@ impl VtkHyperTreeGridNonOrientedCursor for vtkHyperTreeGridNonOrientedCursor { } unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_tree(self.0) } } - fn get_vertex_id(&mut self) -> core::ffi::c_uchar { + fn get_vertex_id(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(self.0) } } - fn get_global_node_index(&mut self) -> core::ffi::c_uchar { + fn get_global_node_index(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(self.0) } } @@ -34712,22 +18652,22 @@ impl VtkHyperTreeGridNonOrientedCursor for vtkHyperTreeGridNonOrientedCursor { } unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(self.0) } } - fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> () { + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, ); } unsafe { vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(self.0, index) } } - fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> () { + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, ); } unsafe { @@ -34852,14 +18792,14 @@ for vtkHyperTreeGridNonOrientedGeometryCursor { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( sself: *mut core::ffi::c_void, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ); } @@ -34872,72 +18812,6 @@ for vtkHyperTreeGridNonOrientedGeometryCursor { ) } } - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( - sself: *mut core::ffi::c_void, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( - self.0, - grid, - tree, - level, - entry, - ) - } - } - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - origin: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( - sself: *mut core::ffi::c_void, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - origin: core::ffi::c_double, - ); - } - unsafe { - vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( - self.0, - grid, - tree, - level, - index, - origin, - ) - } - } - fn initialize(&mut self, cursor: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( - sself: *mut core::ffi::c_void, - cursor: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize(self.0, cursor) - } - } fn has_tree(&mut self) -> bool { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree( @@ -34954,19 +18828,19 @@ for vtkHyperTreeGridNonOrientedGeometryCursor { } unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_tree(self.0) } } - fn get_vertex_id(&mut self) -> core::ffi::c_uchar { + fn get_vertex_id(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(self.0) } } - fn get_global_node_index(&mut self) -> core::ffi::c_uchar { + fn get_global_node_index(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index( @@ -34994,11 +18868,11 @@ for vtkHyperTreeGridNonOrientedGeometryCursor { ) } } - fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> () { + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, ); } unsafe { @@ -35008,11 +18882,11 @@ for vtkHyperTreeGridNonOrientedGeometryCursor { ) } } - fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> () { + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, ); } unsafe { @@ -35022,44 +18896,6 @@ for vtkHyperTreeGridNonOrientedGeometryCursor { ) } } - fn get_origin(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_origin( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_origin(self.0) } - } - fn get_size(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_size( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_size(self.0) } - } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { - vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_bounds(self.0, bounds) - } - } - fn get_point(&mut self, point: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_point( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - ); - } - unsafe { - vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_point(self.0, point) - } - } fn set_mask(&mut self, state: bool) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask( @@ -35175,14 +19011,14 @@ for vtkHyperTreeGridNonOrientedMooreSuperCursor { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_initialize( sself: *mut core::ffi::c_void, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ); } @@ -35258,14 +19094,14 @@ for vtkHyperTreeGridNonOrientedMooreSuperCursorLight { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_initialize( sself: *mut core::ffi::c_void, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ); } @@ -35341,14 +19177,14 @@ for vtkHyperTreeGridNonOrientedVonNeumannSuperCursor { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_initialize( sself: *mut core::ffi::c_void, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ); } @@ -35403,14 +19239,14 @@ for vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_initialize( sself: *mut core::ffi::c_void, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ); } @@ -35461,14 +19297,14 @@ impl VtkHyperTreeGridOrientedCursor for vtkHyperTreeGridOrientedCursor { fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_cursor_initialize( sself: *mut core::ffi::c_void, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ); } @@ -35481,58 +19317,6 @@ impl VtkHyperTreeGridOrientedCursor for vtkHyperTreeGridOrientedCursor { ) } } - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_oriented_cursor_initialize( - sself: *mut core::ffi::c_void, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - ); - } - unsafe { - vtk_hyper_tree_grid_oriented_cursor_initialize( - self.0, - grid, - tree, - level, - index, - ) - } - } - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_oriented_cursor_initialize( - sself: *mut core::ffi::c_void, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_hyper_tree_grid_oriented_cursor_initialize( - self.0, - grid, - tree, - level, - entry, - ) - } - } fn get_grid(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_cursor_get_grid( @@ -35557,19 +19341,19 @@ impl VtkHyperTreeGridOrientedCursor for vtkHyperTreeGridOrientedCursor { } unsafe { vtk_hyper_tree_grid_oriented_cursor_get_tree(self.0) } } - fn get_vertex_id(&mut self) -> core::ffi::c_uchar { + fn get_vertex_id(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_cursor_get_vertex_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(self.0) } } - fn get_global_node_index(&mut self) -> core::ffi::c_uchar { + fn get_global_node_index(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_cursor_get_global_node_index( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(self.0) } } @@ -35589,22 +19373,22 @@ impl VtkHyperTreeGridOrientedCursor for vtkHyperTreeGridOrientedCursor { } unsafe { vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(self.0) } } - fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> () { + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_cursor_set_global_index_start( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, ); } unsafe { vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(self.0, index) } } - fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> () { + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, ); } unsafe { @@ -35710,14 +19494,14 @@ impl VtkHyperTreeGridOrientedGeometryCursor for vtkHyperTreeGridOrientedGeometry fn initialize( &mut self, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( sself: *mut core::ffi::c_void, grid: *mut core::ffi::c_void, - treeIndex: core::ffi::c_uchar, + treeIndex: core::ffi::c_longlong, create: bool, ); } @@ -35730,72 +19514,6 @@ impl VtkHyperTreeGridOrientedGeometryCursor for vtkHyperTreeGridOrientedGeometry ) } } - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( - sself: *mut core::ffi::c_void, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - entry: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( - self.0, - grid, - tree, - level, - entry, - ) - } - } - fn initialize( - &mut self, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - origin: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( - sself: *mut core::ffi::c_void, - grid: *mut core::ffi::c_void, - tree: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uchar, - origin: core::ffi::c_double, - ); - } - unsafe { - vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( - self.0, - grid, - tree, - level, - index, - origin, - ) - } - } - fn initialize(&mut self, cursor: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( - sself: *mut core::ffi::c_void, - cursor: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_hyper_tree_grid_oriented_geometry_cursor_initialize(self.0, cursor) - } - } fn has_tree(&mut self) -> bool { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree( @@ -35812,19 +19530,19 @@ impl VtkHyperTreeGridOrientedGeometryCursor for vtkHyperTreeGridOrientedGeometry } unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_tree(self.0) } } - fn get_vertex_id(&mut self) -> core::ffi::c_uchar { + fn get_vertex_id(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(self.0) } } - fn get_global_node_index(&mut self) -> core::ffi::c_uchar { + fn get_global_node_index(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(self.0) @@ -35848,11 +19566,11 @@ impl VtkHyperTreeGridOrientedGeometryCursor for vtkHyperTreeGridOrientedGeometry vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(self.0) } } - fn set_global_index_start(&mut self, index: core::ffi::c_uchar) -> () { + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, ); } unsafe { @@ -35862,11 +19580,11 @@ impl VtkHyperTreeGridOrientedGeometryCursor for vtkHyperTreeGridOrientedGeometry ) } } - fn set_global_index_from_local(&mut self, index: core::ffi::c_uchar) -> () { + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, ); } unsafe { @@ -35876,42 +19594,6 @@ impl VtkHyperTreeGridOrientedGeometryCursor for vtkHyperTreeGridOrientedGeometry ) } } - fn get_origin(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_origin( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_origin(self.0) } - } - fn get_size(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_size( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_size(self.0) } - } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { - vtk_hyper_tree_grid_oriented_geometry_cursor_get_bounds(self.0, bounds) - } - } - fn get_point(&mut self, point: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_point( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - ); - } - unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_point(self.0, point) } - } fn set_mask(&mut self, state: bool) -> () { unsafe extern "C" { fn vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask( @@ -36022,170 +19704,65 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_get_data_object_type(self.0) } } - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_image_data_get_number_of_cells( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_image_data_get_number_of_cells(self.0) } } - fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_image_data_get_number_of_points( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_image_data_get_number_of_points(self.0) } } - fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_image_data_get_point( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_image_data_get_point(self.0, ptId) } - } - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_image_data_get_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_image_data_get_cell(self.0, cellId) } } - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_cell( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ); - } - unsafe { vtk_image_data_get_cell(self.0, cellId, cell) } - } fn find_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_image_data_find_point( sself: *mut core::ffi::c_void, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_image_data_find_point(self.0, x, y, z) } } - fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_image_data_find_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_image_data_find_point(self.0, x) } - } - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_image_data_find_cell( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_image_data_find_cell( - self.0, - x, - cell, - cellId, - tol2, - subId, - pcoords, - weights, - ) - } - } - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_image_data_find_cell( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_image_data_find_cell( - self.0, - x, - cell, - gencell, - cellId, - tol2, - subId, - pcoords, - weights, - ) - } - } - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_image_data_get_cell_type( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_image_data_get_cell_type(self.0, cellId) } } fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_image_data_get_cell_points( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ); } @@ -36193,13 +19770,13 @@ impl VtkImageData for vtkImageData { } fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_image_data_get_point_cells( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ); } @@ -36213,46 +19790,26 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_get_max_cell_size(self.0) } } - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - seedLoc: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_cell_neighbors( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - seedLoc: core::ffi::c_int, - ); - } - unsafe { - vtk_image_data_get_cell_neighbors(self.0, cellId, ptIds, cellIds, seedLoc) - } - } fn initialize(&mut self) -> () { unsafe extern "C" { fn vtk_image_data_initialize(sself: *mut core::ffi::c_void); } unsafe { vtk_image_data_initialize(self.0) } } - fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_image_data_is_point_visible( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_image_data_is_point_visible(self.0, ptId) } } - fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_image_data_is_cell_visible( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_image_data_is_cell_visible(self.0, cellId) } @@ -36271,15 +19828,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_has_any_blank_cells(self.0) } } - fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_image_data_get_cell_dims( - sself: *mut core::ffi::c_void, - cellDims: core::ffi::c_int, - ); - } - unsafe { vtk_image_data_get_cell_dims(self.0, cellDims) } - } fn set_dimensions( &mut self, i: core::ffi::c_int, @@ -36296,57 +19844,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_set_dimensions(self.0, i, j, k) } } - fn set_dimensions(&mut self, dims: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_image_data_set_dimensions( - sself: *mut core::ffi::c_void, - dims: core::ffi::c_int, - ); - } - unsafe { vtk_image_data_set_dimensions(self.0, dims) } - } - fn get_dimensions(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_image_data_get_dimensions( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_image_data_get_dimensions(self.0) } - } - fn get_dimensions(&mut self, dims: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_image_data_get_dimensions( - sself: *mut core::ffi::c_void, - dims: core::ffi::c_int, - ); - } - unsafe { vtk_image_data_get_dimensions(self.0, dims) } - } - fn get_dimensions(&mut self, dims: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_image_data_get_dimensions( - sself: *mut core::ffi::c_void, - dims: core::ffi::c_uchar, - ); - } - unsafe { vtk_image_data_get_dimensions(self.0, dims) } - } - fn compute_structured_coordinates( - &mut self, - x: core::ffi::c_double, - ijk: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_image_data_compute_structured_coordinates( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ijk: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_image_data_compute_structured_coordinates(self.0, x, ijk, pcoords) } - } fn get_voxel_gradient( &mut self, i: core::ffi::c_int, @@ -36367,26 +19864,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_get_voxel_gradient(self.0, i, j, k, s, g) } } - fn get_point_gradient( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - s: *mut core::ffi::c_void, - g: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_point_gradient( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - s: *mut core::ffi::c_void, - g: core::ffi::c_double, - ); - } - unsafe { vtk_image_data_get_point_gradient(self.0, i, j, k, s, g) } - } fn get_data_dimension(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_image_data_get_data_dimension( @@ -36395,82 +19872,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_get_data_dimension(self.0) } } - fn compute_point_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_image_data_compute_point_id( - sself: *mut core::ffi::c_void, - ijk: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_image_data_compute_point_id(self.0, ijk) } - } - fn compute_cell_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_image_data_compute_cell_id( - sself: *mut core::ffi::c_void, - ijk: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_image_data_compute_cell_id(self.0, ijk) } - } - fn set_axis_update_extent( - &mut self, - axis: core::ffi::c_int, - min: core::ffi::c_int, - max: core::ffi::c_int, - updateExtent: core::ffi::c_int, - axisUpdateExtent: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_set_axis_update_extent( - sself: *mut core::ffi::c_void, - axis: core::ffi::c_int, - min: core::ffi::c_int, - max: core::ffi::c_int, - updateExtent: core::ffi::c_int, - axisUpdateExtent: core::ffi::c_int, - ); - } - unsafe { - vtk_image_data_set_axis_update_extent( - self.0, - axis, - min, - max, - updateExtent, - axisUpdateExtent, - ) - } - } - fn get_axis_update_extent( - &mut self, - axis: core::ffi::c_int, - min: core::ffi::c_int, - max: core::ffi::c_int, - updateExtent: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_axis_update_extent( - sself: *mut core::ffi::c_void, - axis: core::ffi::c_int, - min: core::ffi::c_int, - max: core::ffi::c_int, - updateExtent: core::ffi::c_int, - ); - } - unsafe { - vtk_image_data_get_axis_update_extent(self.0, axis, min, max, updateExtent) - } - } - fn set_extent(&mut self, extent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_image_data_set_extent( - sself: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_image_data_set_extent(self.0, extent) } - } fn set_extent( &mut self, x1: core::ffi::c_int, @@ -36493,47 +19894,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_set_extent(self.0, x1, x2, y1, y2, z1, z2) } } - fn get_extent(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_image_data_get_extent( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_image_data_get_extent(self.0) } - } - fn get_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_extent( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ); - } - unsafe { - vtk_image_data_get_extent(self.0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6) - } - } - fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_image_data_get_extent( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_image_data_get_extent(self.0, _arg) } - } fn get_scalar_type_min( &mut self, meta_data: *mut core::ffi::c_void, @@ -36546,14 +19906,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_get_scalar_type_min(self.0, meta_data) } } - fn get_scalar_type_min(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_image_data_get_scalar_type_min( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_image_data_get_scalar_type_min(self.0) } - } fn get_scalar_type_max( &mut self, meta_data: *mut core::ffi::c_void, @@ -36566,14 +19918,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_get_scalar_type_max(self.0, meta_data) } } - fn get_scalar_type_max(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_image_data_get_scalar_type_max( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_image_data_get_scalar_type_max(self.0) } - } fn get_scalar_size( &mut self, meta_data: *mut core::ffi::c_void, @@ -36586,216 +19930,19 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_get_scalar_size(self.0, meta_data) } } - fn get_scalar_size(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_image_data_get_scalar_size( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_image_data_get_scalar_size(self.0) } - } - fn get_increments(&mut self) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_image_data_get_increments( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_image_data_get_increments(self.0) } - } - fn get_increments( - &mut self, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_increments( - sself: *mut core::ffi::c_void, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ); - } - unsafe { vtk_image_data_get_increments(self.0, incX, incY, incZ) } - } - fn get_increments(&mut self, inc: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_image_data_get_increments( - sself: *mut core::ffi::c_void, - inc: core::ffi::c_uchar, - ); - } - unsafe { vtk_image_data_get_increments(self.0, inc) } - } - fn get_increments( - &mut self, - scalars: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_image_data_get_increments( - sself: *mut core::ffi::c_void, - scalars: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_image_data_get_increments(self.0, scalars) } - } - fn get_increments( - &mut self, - scalars: *mut core::ffi::c_void, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_increments( - sself: *mut core::ffi::c_void, - scalars: *mut core::ffi::c_void, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ); - } - unsafe { vtk_image_data_get_increments(self.0, scalars, incX, incY, incZ) } - } - fn get_increments( - &mut self, - scalars: *mut core::ffi::c_void, - inc: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_increments( - sself: *mut core::ffi::c_void, - scalars: *mut core::ffi::c_void, - inc: core::ffi::c_uchar, - ); - } - unsafe { vtk_image_data_get_increments(self.0, scalars, inc) } - } - fn get_continuous_increments( - &mut self, - extent: core::ffi::c_int, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_continuous_increments( - sself: *mut core::ffi::c_void, - extent: core::ffi::c_int, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ); - } - unsafe { - vtk_image_data_get_continuous_increments(self.0, extent, incX, incY, incZ) - } - } - fn get_continuous_increments( - &mut self, - scalars: *mut core::ffi::c_void, - extent: core::ffi::c_int, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_continuous_increments( - sself: *mut core::ffi::c_void, - scalars: *mut core::ffi::c_void, - extent: core::ffi::c_int, - incX: core::ffi::c_uchar, - incY: core::ffi::c_uchar, - incZ: core::ffi::c_uchar, - ); - } - unsafe { - vtk_image_data_get_continuous_increments( - self.0, - scalars, - extent, - incX, - incY, - incZ, - ) - } - } - fn get_scalar_pointer_for_extent(&mut self, extent: core::ffi::c_int) -> *mut () { - unsafe extern "C" { - fn vtk_image_data_get_scalar_pointer_for_extent( - sself: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> *mut (); - } - unsafe { vtk_image_data_get_scalar_pointer_for_extent(self.0, extent) } - } - fn get_scalar_pointer(&mut self, coordinates: core::ffi::c_int) -> *mut () { - unsafe extern "C" { - fn vtk_image_data_get_scalar_pointer( - sself: *mut core::ffi::c_void, - coordinates: core::ffi::c_int, - ) -> *mut (); - } - unsafe { vtk_image_data_get_scalar_pointer(self.0, coordinates) } - } - fn get_scalar_pointer( - &mut self, - x: core::ffi::c_int, - y: core::ffi::c_int, - z: core::ffi::c_int, - ) -> *mut () { - unsafe extern "C" { - fn vtk_image_data_get_scalar_pointer( - sself: *mut core::ffi::c_void, - x: core::ffi::c_int, - y: core::ffi::c_int, - z: core::ffi::c_int, - ) -> *mut (); - } - unsafe { vtk_image_data_get_scalar_pointer(self.0, x, y, z) } - } - fn get_scalar_pointer(&mut self) -> *mut () { - unsafe extern "C" { - fn vtk_image_data_get_scalar_pointer( - sself: *mut core::ffi::c_void, - ) -> *mut (); - } - unsafe { vtk_image_data_get_scalar_pointer(self.0) } - } - fn get_scalar_index_for_extent( - &mut self, - extent: core::ffi::c_int, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_image_data_get_scalar_index_for_extent( - sself: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_image_data_get_scalar_index_for_extent(self.0, extent) } - } - fn get_scalar_index(&mut self, coordinates: core::ffi::c_int) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_image_data_get_scalar_index( - sself: *mut core::ffi::c_void, - coordinates: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_image_data_get_scalar_index(self.0, coordinates) } - } fn get_scalar_index( &mut self, x: core::ffi::c_int, y: core::ffi::c_int, z: core::ffi::c_int, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_image_data_get_scalar_index( sself: *mut core::ffi::c_void, x: core::ffi::c_int, y: core::ffi::c_int, z: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_image_data_get_scalar_index(self.0, x, y, z) } } @@ -36904,29 +20051,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_allocate_scalars(self.0, dataType, numComponents) } } - fn allocate_scalars(&mut self, pipeline_info: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_image_data_allocate_scalars( - sself: *mut core::ffi::c_void, - pipeline_info: *mut core::ffi::c_void, - ); - } - unsafe { vtk_image_data_allocate_scalars(self.0, pipeline_info) } - } - fn copy_and_cast_from( - &mut self, - inData: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_copy_and_cast_from( - sself: *mut core::ffi::c_void, - inData: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_image_data_copy_and_cast_from(self.0, inData, extent) } - } fn copy_and_cast_from( &mut self, inData: *mut core::ffi::c_void, @@ -36953,48 +20077,6 @@ impl VtkImageData for vtkImageData { vtk_image_data_copy_and_cast_from(self.0, inData, x0, x1, y0, y1, z0, z1) } } - fn crop(&mut self, updateExtent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_image_data_crop( - sself: *mut core::ffi::c_void, - updateExtent: core::ffi::c_int, - ); - } - unsafe { vtk_image_data_crop(self.0, updateExtent) } - } - fn get_spacing(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_image_data_get_spacing( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_image_data_get_spacing(self.0) } - } - fn get_spacing( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_spacing( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { vtk_image_data_get_spacing(self.0, _arg1, _arg2, _arg3) } - } - fn get_spacing(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_image_data_get_spacing( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_image_data_get_spacing(self.0, _arg) } - } fn set_spacing( &mut self, i: core::ffi::c_double, @@ -37011,48 +20093,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_set_spacing(self.0, i, j, k) } } - fn set_spacing(&mut self, ijk: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_image_data_set_spacing( - sself: *mut core::ffi::c_void, - ijk: core::ffi::c_double, - ); - } - unsafe { vtk_image_data_set_spacing(self.0, ijk) } - } - fn get_origin(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_image_data_get_origin( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_image_data_get_origin(self.0) } - } - fn get_origin( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_origin( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { vtk_image_data_get_origin(self.0, _arg1, _arg2, _arg3) } - } - fn get_origin(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_image_data_get_origin( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_image_data_get_origin(self.0, _arg) } - } fn set_origin( &mut self, i: core::ffi::c_double, @@ -37069,15 +20109,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_set_origin(self.0, i, j, k) } } - fn set_origin(&mut self, ijk: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_image_data_set_origin( - sself: *mut core::ffi::c_void, - ijk: core::ffi::c_double, - ); - } - unsafe { vtk_image_data_set_origin(self.0, ijk) } - } fn get_direction_matrix(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_image_data_get_direction_matrix( @@ -37095,392 +20126,113 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_set_direction_matrix(self.0, m) } } - fn set_direction_matrix(&mut self, elements: core::ffi::c_double) -> () { + fn get_index_to_physical_matrix(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_image_data_set_direction_matrix( + fn vtk_image_data_get_index_to_physical_matrix( sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_index_to_physical_matrix(self.0) } + } + fn get_physical_to_index_matrix(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_physical_to_index_matrix( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_image_data_set_direction_matrix(self.0, elements) } + unsafe { vtk_image_data_get_physical_to_index_matrix(self.0) } } - fn set_direction_matrix( + fn set_scalar_type( &mut self, - e00: core::ffi::c_double, - e01: core::ffi::c_double, - e02: core::ffi::c_double, - e10: core::ffi::c_double, - e11: core::ffi::c_double, - e12: core::ffi::c_double, - e20: core::ffi::c_double, - e21: core::ffi::c_double, - e22: core::ffi::c_double, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { - fn vtk_image_data_set_direction_matrix( + fn vtk_image_data_set_scalar_type( sself: *mut core::ffi::c_void, - e00: core::ffi::c_double, - e01: core::ffi::c_double, - e02: core::ffi::c_double, - e10: core::ffi::c_double, - e11: core::ffi::c_double, - e12: core::ffi::c_double, - e20: core::ffi::c_double, - e21: core::ffi::c_double, - e22: core::ffi::c_double, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, ); } - unsafe { - vtk_image_data_set_direction_matrix( - self.0, - e00, - e01, - e02, - e10, - e11, - e12, - e20, - e21, - e22, - ) + unsafe { vtk_image_data_set_scalar_type(self.0, p0, meta_data) } + } + fn get_scalar_type( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; } + unsafe { vtk_image_data_get_scalar_type(self.0, meta_data) } } - fn get_index_to_physical_matrix(&mut self) -> *mut core::ffi::c_void { + fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool { unsafe extern "C" { - fn vtk_image_data_get_index_to_physical_matrix( + fn vtk_image_data_has_scalar_type( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + meta_data: *mut core::ffi::c_void, + ) -> bool; } - unsafe { vtk_image_data_get_index_to_physical_matrix(self.0) } + unsafe { vtk_image_data_has_scalar_type(self.0, meta_data) } } - fn transform_continuous_index_to_physical_point( - &mut self, - i: core::ffi::c_double, - j: core::ffi::c_double, - k: core::ffi::c_double, - xyz: core::ffi::c_double, - ) -> () { + fn get_scalar_type_as_string(&mut self) -> &str { unsafe extern "C" { - fn vtk_image_data_transform_continuous_index_to_physical_point( + fn vtk_image_data_get_scalar_type_as_string( sself: *mut core::ffi::c_void, - i: core::ffi::c_double, - j: core::ffi::c_double, - k: core::ffi::c_double, - xyz: core::ffi::c_double, - ); + ) -> *const core::ffi::c_char; } - unsafe { - vtk_image_data_transform_continuous_index_to_physical_point( - self.0, - i, - j, - k, - xyz, - ) + let ptr = unsafe { vtk_image_data_get_scalar_type_as_string(self.0) }; + if ptr.is_null() { + return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn transform_continuous_index_to_physical_point( + fn set_number_of_scalar_components( &mut self, - ijk: core::ffi::c_double, - xyz: core::ffi::c_double, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { - fn vtk_image_data_transform_continuous_index_to_physical_point( + fn vtk_image_data_set_number_of_scalar_components( sself: *mut core::ffi::c_void, - ijk: core::ffi::c_double, - xyz: core::ffi::c_double, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, ); } - unsafe { - vtk_image_data_transform_continuous_index_to_physical_point(self.0, ijk, xyz) - } + unsafe { vtk_image_data_set_number_of_scalar_components(self.0, n, meta_data) } } - fn transform_index_to_physical_point( + fn get_number_of_scalar_components( &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - xyz: core::ffi::c_double, - ) -> () { + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_image_data_transform_index_to_physical_point( + fn vtk_image_data_get_number_of_scalar_components( sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - xyz: core::ffi::c_double, - ); + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; } - unsafe { vtk_image_data_transform_index_to_physical_point(self.0, i, j, k, xyz) } + unsafe { vtk_image_data_get_number_of_scalar_components(self.0, meta_data) } } - fn transform_index_to_physical_point( + fn has_number_of_scalar_components( &mut self, - ijk: core::ffi::c_int, - xyz: core::ffi::c_double, - ) -> () { + meta_data: *mut core::ffi::c_void, + ) -> bool { unsafe extern "C" { - fn vtk_image_data_transform_index_to_physical_point( + fn vtk_image_data_has_number_of_scalar_components( sself: *mut core::ffi::c_void, - ijk: core::ffi::c_int, - xyz: core::ffi::c_double, - ); + meta_data: *mut core::ffi::c_void, + ) -> bool; } - unsafe { vtk_image_data_transform_index_to_physical_point(self.0, ijk, xyz) } + unsafe { vtk_image_data_has_number_of_scalar_components(self.0, meta_data) } } - fn transform_continuous_index_to_physical_point( + fn copy_information_from_pipeline( &mut self, - i: core::ffi::c_double, - j: core::ffi::c_double, - k: core::ffi::c_double, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - direction: core::ffi::c_double, - xyz: core::ffi::c_double, + information: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { - fn vtk_image_data_transform_continuous_index_to_physical_point( - sself: *mut core::ffi::c_void, - i: core::ffi::c_double, - j: core::ffi::c_double, - k: core::ffi::c_double, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - direction: core::ffi::c_double, - xyz: core::ffi::c_double, - ); - } - unsafe { - vtk_image_data_transform_continuous_index_to_physical_point( - self.0, - i, - j, - k, - origin, - spacing, - direction, - xyz, - ) - } - } - fn get_physical_to_index_matrix(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_image_data_get_physical_to_index_matrix( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_image_data_get_physical_to_index_matrix(self.0) } - } - fn transform_physical_point_to_continuous_index( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ijk: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_transform_physical_point_to_continuous_index( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ijk: core::ffi::c_double, - ); - } - unsafe { - vtk_image_data_transform_physical_point_to_continuous_index( - self.0, - x, - y, - z, - ijk, - ) - } - } - fn transform_physical_point_to_continuous_index( - &mut self, - xyz: core::ffi::c_double, - ijk: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_transform_physical_point_to_continuous_index( - sself: *mut core::ffi::c_void, - xyz: core::ffi::c_double, - ijk: core::ffi::c_double, - ); - } - unsafe { - vtk_image_data_transform_physical_point_to_continuous_index(self.0, xyz, ijk) - } - } - fn compute_index_to_physical_matrix( - &mut self, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - direction: core::ffi::c_double, - result: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_compute_index_to_physical_matrix( - sself: *mut core::ffi::c_void, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - direction: core::ffi::c_double, - result: core::ffi::c_double, - ); - } - unsafe { - vtk_image_data_compute_index_to_physical_matrix( - self.0, - origin, - spacing, - direction, - result, - ) - } - } - fn transform_physical_normal_to_continuous_index( - &mut self, - xyz: core::ffi::c_double, - ijk: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_transform_physical_normal_to_continuous_index( - sself: *mut core::ffi::c_void, - xyz: core::ffi::c_double, - ijk: core::ffi::c_double, - ); - } - unsafe { - vtk_image_data_transform_physical_normal_to_continuous_index( - self.0, - xyz, - ijk, - ) - } - } - fn transform_physical_plane_to_continuous_index( - &mut self, - pplane: core::ffi::c_double, - iplane: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_transform_physical_plane_to_continuous_index( - sself: *mut core::ffi::c_void, - pplane: core::ffi::c_double, - iplane: core::ffi::c_double, - ); - } - unsafe { - vtk_image_data_transform_physical_plane_to_continuous_index( - self.0, - pplane, - iplane, - ) - } - } - fn set_scalar_type( - &mut self, - p0: core::ffi::c_int, - meta_data: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_set_scalar_type( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - meta_data: *mut core::ffi::c_void, - ); - } - unsafe { vtk_image_data_set_scalar_type(self.0, p0, meta_data) } - } - fn get_scalar_type( - &mut self, - meta_data: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_image_data_get_scalar_type( - sself: *mut core::ffi::c_void, - meta_data: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_image_data_get_scalar_type(self.0, meta_data) } - } - fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool { - unsafe extern "C" { - fn vtk_image_data_has_scalar_type( - sself: *mut core::ffi::c_void, - meta_data: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_image_data_has_scalar_type(self.0, meta_data) } - } - fn get_scalar_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_image_data_get_scalar_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_image_data_get_scalar_type(self.0) } - } - fn get_scalar_type_as_string(&mut self) -> *const core::ffi::c_char { - unsafe extern "C" { - fn vtk_image_data_get_scalar_type_as_string( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - unsafe { vtk_image_data_get_scalar_type_as_string(self.0) } - } - fn set_number_of_scalar_components( - &mut self, - n: core::ffi::c_int, - meta_data: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_set_number_of_scalar_components( - sself: *mut core::ffi::c_void, - n: core::ffi::c_int, - meta_data: *mut core::ffi::c_void, - ); - } - unsafe { vtk_image_data_set_number_of_scalar_components(self.0, n, meta_data) } - } - fn get_number_of_scalar_components( - &mut self, - meta_data: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_image_data_get_number_of_scalar_components( - sself: *mut core::ffi::c_void, - meta_data: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_image_data_get_number_of_scalar_components(self.0, meta_data) } - } - fn has_number_of_scalar_components( - &mut self, - meta_data: *mut core::ffi::c_void, - ) -> bool { - unsafe extern "C" { - fn vtk_image_data_has_number_of_scalar_components( - sself: *mut core::ffi::c_void, - meta_data: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_image_data_has_number_of_scalar_components(self.0, meta_data) } - } - fn get_number_of_scalar_components(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_image_data_get_number_of_scalar_components( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_image_data_get_number_of_scalar_components(self.0) } - } - fn copy_information_from_pipeline( - &mut self, - information: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_copy_information_from_pipeline( + fn vtk_image_data_copy_information_from_pipeline( sself: *mut core::ffi::c_void, information: *mut core::ffi::c_void, ); @@ -37505,78 +20257,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_prepare_for_new_data(self.0) } } - fn get_array_pointer_for_extent( - &mut self, - array: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> *mut () { - unsafe extern "C" { - fn vtk_image_data_get_array_pointer_for_extent( - sself: *mut core::ffi::c_void, - array: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> *mut (); - } - unsafe { vtk_image_data_get_array_pointer_for_extent(self.0, array, extent) } - } - fn get_array_pointer( - &mut self, - array: *mut core::ffi::c_void, - coordinates: core::ffi::c_int, - ) -> *mut () { - unsafe extern "C" { - fn vtk_image_data_get_array_pointer( - sself: *mut core::ffi::c_void, - array: *mut core::ffi::c_void, - coordinates: core::ffi::c_int, - ) -> *mut (); - } - unsafe { vtk_image_data_get_array_pointer(self.0, array, coordinates) } - } - fn get_tuple_index( - &mut self, - array: *mut core::ffi::c_void, - coordinates: core::ffi::c_int, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_image_data_get_tuple_index( - sself: *mut core::ffi::c_void, - array: *mut core::ffi::c_void, - coordinates: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_image_data_get_tuple_index(self.0, array, coordinates) } - } - fn get_array_increments( - &mut self, - array: *mut core::ffi::c_void, - increments: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_get_array_increments( - sself: *mut core::ffi::c_void, - array: *mut core::ffi::c_void, - increments: core::ffi::c_uchar, - ); - } - unsafe { vtk_image_data_get_array_increments(self.0, array, increments) } - } - fn compute_internal_extent( - &mut self, - intExt: core::ffi::c_int, - tgtExt: core::ffi::c_int, - bnds: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_image_data_compute_internal_extent( - sself: *mut core::ffi::c_void, - intExt: core::ffi::c_int, - tgtExt: core::ffi::c_int, - bnds: core::ffi::c_int, - ); - } - unsafe { vtk_image_data_compute_internal_extent(self.0, intExt, tgtExt, bnds) } - } fn get_extent_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_image_data_get_extent_type( @@ -37594,20 +20274,6 @@ impl VtkImageData for vtkImageData { } unsafe { vtk_image_data_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_image_data_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_image_data_get_data(self.0, v, i) } - } } impl VtkImageTransform for vtkImageTransform { fn new(&mut self) -> *mut core::ffi::c_void { @@ -37649,46 +20315,6 @@ impl VtkImageTransform for vtkImageTransform { } unsafe { vtk_image_transform_transform_point_set(self.0, im, ps) } } - fn transform_point_set( - &mut self, - im: *mut core::ffi::c_void, - ps: *mut core::ffi::c_void, - transNormals: bool, - transVectors: bool, - ) -> () { - unsafe extern "C" { - fn vtk_image_transform_transform_point_set( - sself: *mut core::ffi::c_void, - im: *mut core::ffi::c_void, - ps: *mut core::ffi::c_void, - transNormals: bool, - transVectors: bool, - ); - } - unsafe { - vtk_image_transform_transform_point_set( - self.0, - im, - ps, - transNormals, - transVectors, - ) - } - } - fn translate_points( - &mut self, - t: core::ffi::c_double, - da: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_image_transform_translate_points( - sself: *mut core::ffi::c_void, - t: core::ffi::c_double, - da: *mut core::ffi::c_void, - ); - } - unsafe { vtk_image_transform_translate_points(self.0, t, da) } - } fn transform_points( &mut self, m4: *mut core::ffi::c_void, @@ -37703,38 +20329,6 @@ impl VtkImageTransform for vtkImageTransform { } unsafe { vtk_image_transform_transform_points(self.0, m4, da) } } - fn transform_normals( - &mut self, - m3: *mut core::ffi::c_void, - spacing: core::ffi::c_double, - da: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_image_transform_transform_normals( - sself: *mut core::ffi::c_void, - m3: *mut core::ffi::c_void, - spacing: core::ffi::c_double, - da: *mut core::ffi::c_void, - ); - } - unsafe { vtk_image_transform_transform_normals(self.0, m3, spacing, da) } - } - fn transform_vectors( - &mut self, - m3: *mut core::ffi::c_void, - spacing: core::ffi::c_double, - da: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_image_transform_transform_vectors( - sself: *mut core::ffi::c_void, - m3: *mut core::ffi::c_void, - spacing: core::ffi::c_double, - da: *mut core::ffi::c_void, - ); - } - unsafe { vtk_image_transform_transform_vectors(self.0, m3, spacing, da) } - } } impl VtkImplicitBoolean for vtkImplicitBoolean { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -37762,29 +20356,6 @@ impl VtkImplicitBoolean for vtkImplicitBoolean { } unsafe { vtk_implicit_boolean_new(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_boolean_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_implicit_boolean_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_implicit_boolean_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - g: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_boolean_evaluate_gradient(self.0, x, g) } - } fn get_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_implicit_boolean_get_m_time( @@ -37884,13 +20455,17 @@ impl VtkImplicitBoolean for vtkImplicitBoolean { } unsafe { vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(self.0) } } - fn get_operation_type_as_string(&mut self) -> *const core::ffi::c_char { + fn get_operation_type_as_string(&mut self) -> &str { unsafe extern "C" { fn vtk_implicit_boolean_get_operation_type_as_string( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_implicit_boolean_get_operation_type_as_string(self.0) } + let ptr = unsafe { vtk_implicit_boolean_get_operation_type_as_string(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } } impl VtkImplicitDataSet for vtkImplicitDataSet { @@ -37927,29 +20502,6 @@ impl VtkImplicitDataSet for vtkImplicitDataSet { } unsafe { vtk_implicit_data_set_get_m_time(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_data_set_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_implicit_data_set_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_implicit_data_set_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_data_set_evaluate_gradient(self.0, x, n) } - } fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_implicit_data_set_set_data_set( @@ -38000,48 +20552,6 @@ impl VtkImplicitDataSet for vtkImplicitDataSet { } unsafe { vtk_implicit_data_set_set_out_gradient(self.0, _arg1, _arg2, _arg3) } } - fn set_out_gradient(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_data_set_set_out_gradient( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_data_set_set_out_gradient(self.0, _arg) } - } - fn get_out_gradient(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_data_set_get_out_gradient( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_implicit_data_set_get_out_gradient(self.0) } - } - fn get_out_gradient( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_implicit_data_set_get_out_gradient( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_data_set_get_out_gradient(self.0, _arg1, _arg2, _arg3) } - } - fn get_out_gradient(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_data_set_get_out_gradient( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_data_set_get_out_gradient(self.0, _arg) } - } } impl VtkImplicitFunctionCollection for vtkImplicitFunctionCollection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -38086,17 +20596,6 @@ impl VtkImplicitFunctionCollection for vtkImplicitFunctionCollection { } unsafe { vtk_implicit_function_collection_get_next_item(self.0) } } - fn get_next_implicit_function(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_implicit_function_collection_get_next_implicit_function( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { - vtk_implicit_function_collection_get_next_implicit_function(self.0, cookie) - } - } } impl VtkImplicitHalo for vtkImplicitHalo { fn new(&mut self) -> *mut core::ffi::c_void { @@ -38124,29 +20623,6 @@ impl VtkImplicitHalo for vtkImplicitHalo { } unsafe { vtk_implicit_halo_new_instance(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_halo_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_implicit_halo_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_implicit_halo_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - g: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_halo_evaluate_gradient(self.0, x, g) } - } fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_implicit_halo_set_radius( @@ -38180,48 +20656,6 @@ impl VtkImplicitHalo for vtkImplicitHalo { } unsafe { vtk_implicit_halo_set_center(self.0, _arg1, _arg2, _arg3) } } - fn set_center(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_halo_set_center( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_halo_set_center(self.0, _arg) } - } - fn get_center(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_halo_get_center( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_implicit_halo_get_center(self.0) } - } - fn get_center( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_implicit_halo_get_center( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_halo_get_center(self.0, _arg1, _arg2, _arg3) } - } - fn get_center(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_halo_get_center( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_halo_get_center(self.0, _arg) } - } fn set_fade_out(&mut self, _arg: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_implicit_halo_set_fade_out( @@ -38266,29 +20700,6 @@ impl VtkImplicitSelectionLoop for vtkImplicitSelectionLoop { } unsafe { vtk_implicit_selection_loop_new(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_selection_loop_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_implicit_selection_loop_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_implicit_selection_loop_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_selection_loop_evaluate_gradient(self.0, x, n) } - } fn set_loop(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_implicit_selection_loop_set_loop( @@ -38357,32 +20768,6 @@ impl VtkImplicitSelectionLoop for vtkImplicitSelectionLoop { } unsafe { vtk_implicit_selection_loop_set_normal(self.0, _arg1, _arg2, _arg3) } } - fn set_normal(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_selection_loop_set_normal( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_selection_loop_set_normal(self.0, _arg) } - } - fn get_normal(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_selection_loop_get_normal( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_implicit_selection_loop_get_normal(self.0) } - } - fn get_normal(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_selection_loop_get_normal( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_selection_loop_get_normal(self.0, data) } - } fn get_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_implicit_selection_loop_get_m_time( @@ -38418,29 +20803,6 @@ impl VtkImplicitSum for vtkImplicitSum { } unsafe { vtk_implicit_sum_new_instance(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_sum_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_implicit_sum_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_implicit_sum_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - g: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_sum_evaluate_gradient(self.0, x, g) } - } fn get_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_implicit_sum_get_m_time( @@ -38463,15 +20825,6 @@ impl VtkImplicitSum for vtkImplicitSum { } unsafe { vtk_implicit_sum_add_function(self.0, in_, weight) } } - fn add_function(&mut self, in_: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_implicit_sum_add_function( - sself: *mut core::ffi::c_void, - in_: *mut core::ffi::c_void, - ); - } - unsafe { vtk_implicit_sum_add_function(self.0, in_) } - } fn remove_all_functions(&mut self) -> () { unsafe extern "C" { fn vtk_implicit_sum_remove_all_functions(sself: *mut core::ffi::c_void); @@ -38556,29 +20909,6 @@ impl VtkImplicitVolume for vtkImplicitVolume { } unsafe { vtk_implicit_volume_get_m_time(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_volume_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_implicit_volume_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_implicit_volume_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_volume_evaluate_gradient(self.0, x, n) } - } fn set_volume(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_implicit_volume_set_volume( @@ -38629,48 +20959,6 @@ impl VtkImplicitVolume for vtkImplicitVolume { } unsafe { vtk_implicit_volume_set_out_gradient(self.0, _arg1, _arg2, _arg3) } } - fn set_out_gradient(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_volume_set_out_gradient( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_volume_set_out_gradient(self.0, _arg) } - } - fn get_out_gradient(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_volume_get_out_gradient( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_implicit_volume_get_out_gradient(self.0) } - } - fn get_out_gradient( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_implicit_volume_get_out_gradient( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_volume_get_out_gradient(self.0, _arg1, _arg2, _arg3) } - } - fn get_out_gradient(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_volume_get_out_gradient( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_volume_get_out_gradient(self.0, _arg) } - } } impl VtkImplicitWindowFunction for vtkImplicitWindowFunction { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -38698,29 +20986,6 @@ impl VtkImplicitWindowFunction for vtkImplicitWindowFunction { } unsafe { vtk_implicit_window_function_new(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_window_function_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_implicit_window_function_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_implicit_window_function_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_window_function_evaluate_gradient(self.0, x, n) } - } fn set_implicit_function(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_implicit_window_function_set_implicit_function( @@ -38752,37 +21017,11 @@ impl VtkImplicitWindowFunction for vtkImplicitWindowFunction { } unsafe { vtk_implicit_window_function_set_window_range(self.0, _arg1, _arg2) } } - fn set_window_range(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_window_function_set_window_range( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_window_function_set_window_range(self.0, _arg) } - } - fn get_window_range(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_window_function_get_window_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_implicit_window_function_get_window_range(self.0) } - } - fn get_window_range(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_window_function_get_window_range( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_window_function_get_window_range(self.0, data) } - } - fn set_window_values( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> () { + fn set_window_values( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { unsafe extern "C" { fn vtk_implicit_window_function_set_window_values( sself: *mut core::ffi::c_void, @@ -38792,32 +21031,6 @@ impl VtkImplicitWindowFunction for vtkImplicitWindowFunction { } unsafe { vtk_implicit_window_function_set_window_values(self.0, _arg1, _arg2) } } - fn set_window_values(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_window_function_set_window_values( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_window_function_set_window_values(self.0, _arg) } - } - fn get_window_values(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_implicit_window_function_get_window_values( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_implicit_window_function_get_window_values(self.0) } - } - fn get_window_values(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_implicit_window_function_get_window_values( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_implicit_window_function_get_window_values(self.0, data) } - } fn get_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_implicit_window_function_get_m_time( @@ -38862,12 +21075,12 @@ impl VtkInEdgeIterator for vtkInEdgeIterator { } unsafe { vtk_in_edge_iterator_new_instance(self.0) } } - fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> () { + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_in_edge_iterator_initialize( sself: *mut core::ffi::c_void, g: *mut core::ffi::c_void, - v: core::ffi::c_uchar, + v: core::ffi::c_longlong, ); } unsafe { vtk_in_edge_iterator_initialize(self.0, g, v) } @@ -38880,22 +21093,14 @@ impl VtkInEdgeIterator for vtkInEdgeIterator { } unsafe { vtk_in_edge_iterator_get_graph(self.0) } } - fn get_vertex(&mut self) -> core::ffi::c_uchar { + fn get_vertex(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_in_edge_iterator_get_vertex( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_in_edge_iterator_get_vertex(self.0) } } - fn next(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_in_edge_iterator_next( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_in_edge_iterator_next(self.0) } - } fn next_graph_edge(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_in_edge_iterator_next_graph_edge( @@ -38983,101 +21188,6 @@ impl VtkIncrementalOctreeNode for vtkIncrementalOctreeNode { } unsafe { vtk_incremental_octree_node_set_bounds(self.0, x1, x2, y1, y2, z1, z2) } } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_incremental_octree_node_get_bounds(self.0, bounds) } - } - fn get_min_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_min_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_incremental_octree_node_get_min_bounds(self.0) } - } - fn get_min_bounds( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_min_bounds( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { - vtk_incremental_octree_node_get_min_bounds(self.0, _arg1, _arg2, _arg3) - } - } - fn get_min_bounds(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_min_bounds( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_incremental_octree_node_get_min_bounds(self.0, _arg) } - } - fn get_max_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_max_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_incremental_octree_node_get_max_bounds(self.0) } - } - fn get_max_bounds( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_max_bounds( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { - vtk_incremental_octree_node_get_max_bounds(self.0, _arg1, _arg2, _arg3) - } - } - fn get_max_bounds(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_max_bounds( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_incremental_octree_node_get_max_bounds(self.0, _arg) } - } - fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_min_data_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_incremental_octree_node_get_min_data_bounds(self.0) } - } - fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_max_data_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_incremental_octree_node_get_max_data_bounds(self.0) } - } fn is_leaf(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_incremental_octree_node_is_leaf( @@ -39086,15 +21196,6 @@ impl VtkIncrementalOctreeNode for vtkIncrementalOctreeNode { } unsafe { vtk_incremental_octree_node_is_leaf(self.0) } } - fn get_child_index(&mut self, point: core::ffi::c_double) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_child_index( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_incremental_octree_node_get_child_index(self.0, point) } - } fn get_child(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_incremental_octree_node_get_child( @@ -39104,154 +21205,6 @@ impl VtkIncrementalOctreeNode for vtkIncrementalOctreeNode { } unsafe { vtk_incremental_octree_node_get_child(self.0, i) } } - fn contains_point(&mut self, pnt: core::ffi::c_double) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_incremental_octree_node_contains_point( - sself: *mut core::ffi::c_void, - pnt: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_incremental_octree_node_contains_point(self.0, pnt) } - } - fn contains_point_by_data(&mut self, pnt: core::ffi::c_double) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_incremental_octree_node_contains_point_by_data( - sself: *mut core::ffi::c_void, - pnt: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_incremental_octree_node_contains_point_by_data(self.0, pnt) } - } - fn insert_point( - &mut self, - points: *mut core::ffi::c_void, - newPnt: core::ffi::c_double, - maxPts: core::ffi::c_int, - pntId: core::ffi::c_uchar, - ptMode: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_incremental_octree_node_insert_point( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - newPnt: core::ffi::c_double, - maxPts: core::ffi::c_int, - pntId: core::ffi::c_uchar, - ptMode: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_incremental_octree_node_insert_point( - self.0, - points, - newPnt, - maxPts, - pntId, - ptMode, - ) - } - } - fn insert_point( - &mut self, - points: *mut core::ffi::c_void, - newPnt: core::ffi::c_double, - maxPts: core::ffi::c_int, - pntId: core::ffi::c_uchar, - ptMode: core::ffi::c_int, - numberOfNodes: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_incremental_octree_node_insert_point( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - newPnt: core::ffi::c_double, - maxPts: core::ffi::c_int, - pntId: core::ffi::c_uchar, - ptMode: core::ffi::c_int, - numberOfNodes: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_incremental_octree_node_insert_point( - self.0, - points, - newPnt, - maxPts, - pntId, - ptMode, - numberOfNodes, - ) - } - } - fn get_distance_2_to_inner_boundary( - &mut self, - point: core::ffi::c_double, - rootNode: *mut core::ffi::c_void, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_distance_2_to_inner_boundary( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - rootNode: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { - vtk_incremental_octree_node_get_distance_2_to_inner_boundary( - self.0, - point, - rootNode, - ) - } - } - fn get_distance_2_to_boundary( - &mut self, - point: core::ffi::c_double, - rootNode: *mut core::ffi::c_void, - checkData: core::ffi::c_int, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_distance_2_to_boundary( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - rootNode: *mut core::ffi::c_void, - checkData: core::ffi::c_int, - ) -> core::ffi::c_double; - } - unsafe { - vtk_incremental_octree_node_get_distance_2_to_boundary( - self.0, - point, - rootNode, - checkData, - ) - } - } - fn get_distance_2_to_boundary( - &mut self, - point: core::ffi::c_double, - closest: core::ffi::c_double, - rootNode: *mut core::ffi::c_void, - checkData: core::ffi::c_int, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_incremental_octree_node_get_distance_2_to_boundary( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - closest: core::ffi::c_double, - rootNode: *mut core::ffi::c_void, - checkData: core::ffi::c_int, - ) -> core::ffi::c_double; - } - unsafe { - vtk_incremental_octree_node_get_distance_2_to_boundary( - self.0, - point, - closest, - rootNode, - checkData, - ) - } - } fn export_all_point_ids_by_insertion( &mut self, idList: *mut core::ffi::c_void, @@ -39266,26 +21219,6 @@ impl VtkIncrementalOctreeNode for vtkIncrementalOctreeNode { vtk_incremental_octree_node_export_all_point_ids_by_insertion(self.0, idList) } } - fn export_all_point_ids_by_direct_set( - &mut self, - pntIdx: core::ffi::c_uchar, - idList: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_node_export_all_point_ids_by_direct_set( - sself: *mut core::ffi::c_void, - pntIdx: core::ffi::c_uchar, - idList: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_incremental_octree_node_export_all_point_ids_by_direct_set( - self.0, - pntIdx, - idList, - ) - } - } fn get_number_of_levels(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_incremental_octree_node_get_number_of_levels( @@ -39439,23 +21372,6 @@ impl VtkIncrementalOctreePointLocator for vtkIncrementalOctreePointLocator { } unsafe { vtk_incremental_octree_point_locator_free_search_structure(self.0) } } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_incremental_octree_point_locator_get_bounds(self.0, bounds) } - } - fn get_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_get_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_incremental_octree_point_locator_get_bounds(self.0) } - } fn get_number_of_points(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_incremental_octree_point_locator_get_number_of_points( @@ -39472,54 +21388,16 @@ impl VtkIncrementalOctreePointLocator for vtkIncrementalOctreePointLocator { } unsafe { vtk_incremental_octree_point_locator_get_number_of_nodes(self.0) } } - fn find_closest_inserted_point( - &mut self, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_find_closest_inserted_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_incremental_octree_point_locator_find_closest_inserted_point(self.0, x) - } - } - fn generate_representation( - &mut self, - level: core::ffi::c_int, - polysData: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_generate_representation( - sself: *mut core::ffi::c_void, - level: core::ffi::c_int, - polysData: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_incremental_octree_point_locator_generate_representation( - self.0, - level, - polysData, - ) - } - } fn generate_representation( &mut self, level: core::ffi::c_int, polysData: *mut core::ffi::c_void, - UserGetBounds: *mut core::ffi::c_void, - data: (), ) -> () { unsafe extern "C" { fn vtk_incremental_octree_point_locator_generate_representation( sself: *mut core::ffi::c_void, level: core::ffi::c_int, polysData: *mut core::ffi::c_void, - UserGetBounds: *mut core::ffi::c_void, - data: (), ); } unsafe { @@ -39527,8 +21405,6 @@ impl VtkIncrementalOctreePointLocator for vtkIncrementalOctreePointLocator { self.0, level, polysData, - UserGetBounds, - data, ) } } @@ -39540,322 +21416,42 @@ impl VtkIncrementalOctreePointLocator for vtkIncrementalOctreePointLocator { } unsafe { vtk_incremental_octree_point_locator_build_locator(self.0) } } - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_find_closest_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_incremental_octree_point_locator_find_closest_point(self.0, x) } - } fn find_closest_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_incremental_octree_point_locator_find_closest_point( sself: *mut core::ffi::c_void, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_incremental_octree_point_locator_find_closest_point(self.0, x, y, z) } } - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - miniDist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_find_closest_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - miniDist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_incremental_octree_point_locator_find_closest_point(self.0, x, miniDist2) - } - } - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - miniDist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_find_closest_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - miniDist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_incremental_octree_point_locator_find_closest_point( - self.0, - x, - y, - z, - miniDist2, - ) - } - } - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_find_closest_point_within_radius( - sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_incremental_octree_point_locator_find_closest_point_within_radius( - self.0, - radius, - x, - dist2, - ) - } - } - fn find_closest_point_within_squared_radius( - &mut self, - radius2: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_find_closest_point_within_squared_radius( - sself: *mut core::ffi::c_void, - radius2: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_incremental_octree_point_locator_find_closest_point_within_squared_radius( - self.0, - radius2, - x, - dist2, - ) - } - } - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_find_points_within_radius( - sself: *mut core::ffi::c_void, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_incremental_octree_point_locator_find_points_within_radius( - self.0, - R, - x, - result, - ) - } - } - fn find_points_within_squared_radius( - &mut self, - R2: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_find_points_within_squared_radius( - sself: *mut core::ffi::c_void, - R2: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_incremental_octree_point_locator_find_points_within_squared_radius( - self.0, - R2, - x, - result, - ) - } - } - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_find_closest_n_points( - sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_incremental_octree_point_locator_find_closest_n_points( - self.0, - N, - x, - result, - ) - } - } - fn init_point_insertion( - &mut self, - points: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_init_point_insertion( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_incremental_octree_point_locator_init_point_insertion( - self.0, - points, - bounds, - ) - } - } - fn init_point_insertion( - &mut self, - points: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - estSize: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_init_point_insertion( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - estSize: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { - vtk_incremental_octree_point_locator_init_point_insertion( - self.0, - points, - bounds, - estSize, - ) - } - } - fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_is_inserted_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_incremental_octree_point_locator_is_inserted_point(self.0, x) } - } fn is_inserted_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_incremental_octree_point_locator_is_inserted_point( sself: *mut core::ffi::c_void, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_incremental_octree_point_locator_is_inserted_point(self.0, x, y, z) } } - fn insert_unique_point( - &mut self, - point: core::ffi::c_double, - pntId: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_insert_unique_point( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - pntId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { - vtk_incremental_octree_point_locator_insert_unique_point( - self.0, - point, - pntId, - ) - } - } - fn insert_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_insert_point( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - x: core::ffi::c_double, - ); - } - unsafe { vtk_incremental_octree_point_locator_insert_point(self.0, ptId, x) } - } - fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_insert_next_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_incremental_octree_point_locator_insert_next_point(self.0, x) } - } - fn insert_point_without_checking( - &mut self, - point: core::ffi::c_double, - pntId: core::ffi::c_uchar, - insert: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_incremental_octree_point_locator_insert_point_without_checking( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - pntId: core::ffi::c_uchar, - insert: core::ffi::c_int, - ); - } - unsafe { - vtk_incremental_octree_point_locator_insert_point_without_checking( - self.0, - point, - pntId, - insert, - ) - } - } fn get_root(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_incremental_octree_point_locator_get_root( @@ -40084,17 +21680,21 @@ impl VtkIterativeClosestPointTransform for vtkIterativeClosestPointTransform { ) } } - fn get_mean_distance_mode_as_string(&mut self) -> *const core::ffi::c_char { + fn get_mean_distance_mode_as_string(&mut self) -> &str { unsafe extern "C" { fn vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { + let ptr = unsafe { vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string( self.0, ) + }; + if ptr.is_null() { + return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn set_maximum_mean_distance(&mut self, _arg: core::ffi::c_double) -> () { unsafe extern "C" { @@ -40304,24 +21904,6 @@ impl VtkKdNode for vtkKdNode { } unsafe { vtk_kd_node_set_bounds(self.0, x1, x2, y1, y2, z1, z2) } } - fn set_bounds(&mut self, b: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_kd_node_set_bounds( - sself: *mut core::ffi::c_void, - b: core::ffi::c_double, - ); - } - unsafe { vtk_kd_node_set_bounds(self.0, b) } - } - fn get_bounds(&mut self, b: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_kd_node_get_bounds( - sself: *mut core::ffi::c_void, - b: core::ffi::c_double, - ); - } - unsafe { vtk_kd_node_get_bounds(self.0, b) } - } fn set_data_bounds( &mut self, x1: core::ffi::c_double, @@ -40344,92 +21926,6 @@ impl VtkKdNode for vtkKdNode { } unsafe { vtk_kd_node_set_data_bounds(self.0, x1, x2, y1, y2, z1, z2) } } - fn get_data_bounds(&mut self, b: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_kd_node_get_data_bounds( - sself: *mut core::ffi::c_void, - b: core::ffi::c_double, - ); - } - unsafe { vtk_kd_node_get_data_bounds(self.0, b) } - } - fn set_data_bounds(&mut self, v: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_kd_node_set_data_bounds( - sself: *mut core::ffi::c_void, - v: core::ffi::c_float, - ); - } - unsafe { vtk_kd_node_set_data_bounds(self.0, v) } - } - fn get_min_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_kd_node_get_min_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_kd_node_get_min_bounds(self.0) } - } - fn get_max_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_kd_node_get_max_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_kd_node_get_max_bounds(self.0) } - } - fn set_min_bounds(&mut self, mb: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_kd_node_set_min_bounds( - sself: *mut core::ffi::c_void, - mb: core::ffi::c_double, - ); - } - unsafe { vtk_kd_node_set_min_bounds(self.0, mb) } - } - fn set_max_bounds(&mut self, mb: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_kd_node_set_max_bounds( - sself: *mut core::ffi::c_void, - mb: core::ffi::c_double, - ); - } - unsafe { vtk_kd_node_set_max_bounds(self.0, mb) } - } - fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_kd_node_get_min_data_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_kd_node_get_min_data_bounds(self.0) } - } - fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_kd_node_get_max_data_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_kd_node_get_max_data_bounds(self.0) } - } - fn set_min_data_bounds(&mut self, mb: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_kd_node_set_min_data_bounds( - sself: *mut core::ffi::c_void, - mb: core::ffi::c_double, - ); - } - unsafe { vtk_kd_node_set_min_data_bounds(self.0, mb) } - } - fn set_max_data_bounds(&mut self, mb: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_kd_node_set_max_data_bounds( - sself: *mut core::ffi::c_void, - mb: core::ffi::c_double, - ); - } - unsafe { vtk_kd_node_set_max_data_bounds(self.0, mb) } - } fn set_id(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_kd_node_set_id(sself: *mut core::ffi::c_void, _arg: core::ffi::c_int); @@ -40605,32 +22101,6 @@ impl VtkKdNode for vtkKdNode { } unsafe { vtk_kd_node_intersects_region(self.0, pi, useDataBounds) } } - fn intersects_cell( - &mut self, - cell: *mut core::ffi::c_void, - useDataBounds: core::ffi::c_int, - cellRegion: core::ffi::c_int, - cellBounds: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_kd_node_intersects_cell( - sself: *mut core::ffi::c_void, - cell: *mut core::ffi::c_void, - useDataBounds: core::ffi::c_int, - cellRegion: core::ffi::c_int, - cellBounds: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_kd_node_intersects_cell( - self.0, - cell, - useDataBounds, - cellRegion, - cellBounds, - ) - } - } fn contains_box( &mut self, x1: core::ffi::c_double, @@ -40693,35 +22163,6 @@ impl VtkKdNode for vtkKdNode { } unsafe { vtk_kd_node_get_distance_2_to_boundary(self.0, x, y, z, useDataBounds) } } - fn get_distance_2_to_boundary( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - boundaryPt: core::ffi::c_double, - useDataBounds: core::ffi::c_int, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_kd_node_get_distance_2_to_boundary( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - boundaryPt: core::ffi::c_double, - useDataBounds: core::ffi::c_int, - ) -> core::ffi::c_double; - } - unsafe { - vtk_kd_node_get_distance_2_to_boundary( - self.0, - x, - y, - z, - boundaryPt, - useDataBounds, - ) - } - } fn get_distance_2_to_inner_boundary( &mut self, x: core::ffi::c_double, @@ -40962,15 +22403,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_remove_data_set(self.0, index) } } - fn remove_data_set(&mut self, set: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_kd_tree_remove_data_set( - sself: *mut core::ffi::c_void, - set: *mut core::ffi::c_void, - ); - } - unsafe { vtk_kd_tree_remove_data_set(self.0, set) } - } fn remove_all_data_sets(&mut self) -> () { unsafe extern "C" { fn vtk_kd_tree_remove_all_data_sets(sself: *mut core::ffi::c_void); @@ -40994,14 +22426,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_get_data_set(self.0, n) } } - fn get_data_set(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_kd_tree_get_data_set( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_kd_tree_get_data_set(self.0) } - } fn get_data_sets(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_kd_tree_get_data_sets( @@ -41019,24 +22443,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_get_data_set_index(self.0, set) } } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_kd_tree_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_kd_tree_get_bounds(self.0, bounds) } - } - fn set_new_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_kd_tree_set_new_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_kd_tree_set_new_bounds(self.0, bounds) } - } fn get_number_of_regions(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_kd_tree_get_number_of_regions( @@ -41045,34 +22451,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_get_number_of_regions(self.0) } } - fn get_region_bounds( - &mut self, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_get_region_bounds( - sself: *mut core::ffi::c_void, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_kd_tree_get_region_bounds(self.0, regionID, bounds) } - } - fn get_region_data_bounds( - &mut self, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_get_region_data_bounds( - sself: *mut core::ffi::c_void, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_kd_tree_get_region_data_bounds(self.0, regionID, bounds) } - } fn print_tree(&mut self) -> () { unsafe extern "C" { fn vtk_kd_tree_print_tree(sself: *mut core::ffi::c_void); @@ -41094,65 +22472,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_print_region(self.0, id) } } - fn create_cell_lists( - &mut self, - dataSetIndex: core::ffi::c_int, - regionReqList: core::ffi::c_int, - reqListSize: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_create_cell_lists( - sself: *mut core::ffi::c_void, - dataSetIndex: core::ffi::c_int, - regionReqList: core::ffi::c_int, - reqListSize: core::ffi::c_int, - ); - } - unsafe { - vtk_kd_tree_create_cell_lists( - self.0, - dataSetIndex, - regionReqList, - reqListSize, - ) - } - } - fn create_cell_lists( - &mut self, - set: *mut core::ffi::c_void, - regionReqList: core::ffi::c_int, - reqListSize: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_create_cell_lists( - sself: *mut core::ffi::c_void, - set: *mut core::ffi::c_void, - regionReqList: core::ffi::c_int, - reqListSize: core::ffi::c_int, - ); - } - unsafe { vtk_kd_tree_create_cell_lists(self.0, set, regionReqList, reqListSize) } - } - fn create_cell_lists( - &mut self, - regionReqList: core::ffi::c_int, - listSize: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_create_cell_lists( - sself: *mut core::ffi::c_void, - regionReqList: core::ffi::c_int, - listSize: core::ffi::c_int, - ); - } - unsafe { vtk_kd_tree_create_cell_lists(self.0, regionReqList, listSize) } - } - fn create_cell_lists(&mut self) -> () { - unsafe extern "C" { - fn vtk_kd_tree_create_cell_lists(sself: *mut core::ffi::c_void); - } - unsafe { vtk_kd_tree_create_cell_lists(self.0) } - } fn set_include_region_boundary_cells(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_kd_tree_set_include_region_boundary_cells( @@ -41219,7 +22538,7 @@ impl VtkKdTree for vtkKdTree { set: core::ffi::c_int, inRegionCells: *mut core::ffi::c_void, onBoundaryCells: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_kd_tree_get_cell_lists( sself: *mut core::ffi::c_void, @@ -41227,33 +22546,7 @@ impl VtkKdTree for vtkKdTree { set: core::ffi::c_int, inRegionCells: *mut core::ffi::c_void, onBoundaryCells: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_kd_tree_get_cell_lists( - self.0, - regions, - set, - inRegionCells, - onBoundaryCells, - ) - } - } - fn get_cell_lists( - &mut self, - regions: *mut core::ffi::c_void, - set: *mut core::ffi::c_void, - inRegionCells: *mut core::ffi::c_void, - onBoundaryCells: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_get_cell_lists( - sself: *mut core::ffi::c_void, - regions: *mut core::ffi::c_void, - set: *mut core::ffi::c_void, - inRegionCells: *mut core::ffi::c_void, - onBoundaryCells: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_kd_tree_get_cell_lists( @@ -41265,72 +22558,20 @@ impl VtkKdTree for vtkKdTree { ) } } - fn get_cell_lists( - &mut self, - regions: *mut core::ffi::c_void, - inRegionCells: *mut core::ffi::c_void, - onBoundaryCells: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_get_cell_lists( - sself: *mut core::ffi::c_void, - regions: *mut core::ffi::c_void, - inRegionCells: *mut core::ffi::c_void, - onBoundaryCells: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_kd_tree_get_cell_lists(self.0, regions, inRegionCells, onBoundaryCells) - } - } fn get_region_containing_cell( &mut self, set: *mut core::ffi::c_void, - cellID: core::ffi::c_uchar, + cellID: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_kd_tree_get_region_containing_cell( sself: *mut core::ffi::c_void, set: *mut core::ffi::c_void, - cellID: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_kd_tree_get_region_containing_cell(self.0, set, cellID) } - } - fn get_region_containing_cell( - &mut self, - set: core::ffi::c_int, - cellID: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_kd_tree_get_region_containing_cell( - sself: *mut core::ffi::c_void, - set: core::ffi::c_int, - cellID: core::ffi::c_uchar, + cellID: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_kd_tree_get_region_containing_cell(self.0, set, cellID) } } - fn get_region_containing_cell( - &mut self, - cellID: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_kd_tree_get_region_containing_cell( - sself: *mut core::ffi::c_void, - cellID: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_kd_tree_get_region_containing_cell(self.0, cellID) } - } - fn all_get_region_containing_cell(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_kd_tree_all_get_region_containing_cell( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_kd_tree_all_get_region_containing_cell(self.0) } - } fn get_region_containing_point( &mut self, x: core::ffi::c_double, @@ -41353,112 +22594,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_build_locator(self.0) } } - fn minimal_number_of_convex_sub_regions( - &mut self, - regionIdList: *mut core::ffi::c_void, - convexRegionBounds: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_kd_tree_minimal_number_of_convex_sub_regions( - sself: *mut core::ffi::c_void, - regionIdList: *mut core::ffi::c_void, - convexRegionBounds: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_kd_tree_minimal_number_of_convex_sub_regions( - self.0, - regionIdList, - convexRegionBounds, - ) - } - } - fn view_order_all_regions_in_direction( - &mut self, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_kd_tree_view_order_all_regions_in_direction( - sself: *mut core::ffi::c_void, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_kd_tree_view_order_all_regions_in_direction( - self.0, - directionOfProjection, - orderedList, - ) - } - } - fn view_order_regions_in_direction( - &mut self, - regionIds: *mut core::ffi::c_void, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_kd_tree_view_order_regions_in_direction( - sself: *mut core::ffi::c_void, - regionIds: *mut core::ffi::c_void, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_kd_tree_view_order_regions_in_direction( - self.0, - regionIds, - directionOfProjection, - orderedList, - ) - } - } - fn view_order_all_regions_from_position( - &mut self, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_kd_tree_view_order_all_regions_from_position( - sself: *mut core::ffi::c_void, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_kd_tree_view_order_all_regions_from_position( - self.0, - directionOfProjection, - orderedList, - ) - } - } - fn view_order_regions_from_position( - &mut self, - regionIds: *mut core::ffi::c_void, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_kd_tree_view_order_regions_from_position( - sself: *mut core::ffi::c_void, - regionIds: *mut core::ffi::c_void, - directionOfProjection: core::ffi::c_double, - orderedList: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_kd_tree_view_order_regions_from_position( - self.0, - regionIds, - directionOfProjection, - orderedList, - ) - } - } fn build_locator_from_points(&mut self, pointset: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_kd_tree_build_locator_from_points( @@ -41468,29 +22603,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_build_locator_from_points(self.0, pointset) } } - fn build_locator_from_points(&mut self, ptArray: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_kd_tree_build_locator_from_points( - sself: *mut core::ffi::c_void, - ptArray: *mut core::ffi::c_void, - ); - } - unsafe { vtk_kd_tree_build_locator_from_points(self.0, ptArray) } - } - fn build_locator_from_points( - &mut self, - ptArray: *mut core::ffi::c_void, - numPtArrays: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_build_locator_from_points( - sself: *mut core::ffi::c_void, - ptArray: *mut core::ffi::c_void, - numPtArrays: core::ffi::c_int, - ); - } - unsafe { vtk_kd_tree_build_locator_from_points(self.0, ptArray, numPtArrays) } - } fn build_map_for_duplicate_points( &mut self, tolerance: core::ffi::c_float, @@ -41503,149 +22615,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_build_map_for_duplicate_points(self.0, tolerance) } } - fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_find_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_kd_tree_find_point(self.0, x) } - } - fn find_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_find_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_kd_tree_find_point(self.0, x, y, z) } - } - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_find_closest_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_kd_tree_find_closest_point(self.0, x, dist2) } - } - fn find_closest_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_find_closest_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_kd_tree_find_closest_point(self.0, x, y, z, dist2) } - } - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_find_closest_point_within_radius( - sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_kd_tree_find_closest_point_within_radius(self.0, radius, x, dist2) } - } - fn find_closest_point_in_region( - &mut self, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_find_closest_point_in_region( - sself: *mut core::ffi::c_void, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_kd_tree_find_closest_point_in_region(self.0, regionId, x, dist2) } - } - fn find_closest_point_in_region( - &mut self, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_find_closest_point_in_region( - sself: *mut core::ffi::c_void, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_kd_tree_find_closest_point_in_region(self.0, regionId, x, y, z, dist2) - } - } - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_find_points_within_radius( - sself: *mut core::ffi::c_void, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { vtk_kd_tree_find_points_within_radius(self.0, R, x, result) } - } - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_find_closest_n_points( - sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { vtk_kd_tree_find_closest_n_points(self.0, N, x, result) } - } fn get_points_in_region( &mut self, regionId: core::ffi::c_int, @@ -41678,22 +22647,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_generate_representation(self.0, level, pd) } } - fn generate_representation( - &mut self, - regionList: core::ffi::c_int, - len: core::ffi::c_int, - pd: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_generate_representation( - sself: *mut core::ffi::c_void, - regionList: core::ffi::c_int, - len: core::ffi::c_int, - pd: *mut core::ffi::c_void, - ); - } - unsafe { vtk_kd_tree_generate_representation(self.0, regionList, len, pd) } - } fn generate_representation_using_data_bounds_on(&mut self) -> () { unsafe extern "C" { fn vtk_kd_tree_generate_representation_using_data_bounds_on( @@ -41740,20 +22693,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_new_geometry(self.0) } } - fn new_geometry( - &mut self, - sets: *mut core::ffi::c_void, - numDataSets: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_kd_tree_new_geometry( - sself: *mut core::ffi::c_void, - sets: *mut core::ffi::c_void, - numDataSets: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_kd_tree_new_geometry(self.0, sets, numDataSets) } - } fn invalidate_geometry(&mut self) -> () { unsafe extern "C" { fn vtk_kd_tree_invalidate_geometry(sself: *mut core::ffi::c_void); @@ -41769,22 +22708,6 @@ impl VtkKdTree for vtkKdTree { } unsafe { vtk_kd_tree_copy_tree(self.0, kd) } } - fn find_points_in_area( - &mut self, - area: core::ffi::c_double, - ids: *mut core::ffi::c_void, - clearArray: bool, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_find_points_in_area( - sself: *mut core::ffi::c_void, - area: core::ffi::c_double, - ids: *mut core::ffi::c_void, - clearArray: bool, - ); - } - unsafe { vtk_kd_tree_find_points_in_area(self.0, area, ids, clearArray) } - } } impl VtkKdTreePointLocator for vtkKdTreePointLocator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -41812,72 +22735,6 @@ impl VtkKdTreePointLocator for vtkKdTreePointLocator { } unsafe { vtk_kd_tree_point_locator_new(self.0) } } - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_point_locator_find_closest_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_kd_tree_point_locator_find_closest_point(self.0, x) } - } - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_kd_tree_point_locator_find_closest_point_within_radius( - sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_kd_tree_point_locator_find_closest_point_within_radius( - self.0, - radius, - x, - dist2, - ) - } - } - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_point_locator_find_closest_n_points( - sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { vtk_kd_tree_point_locator_find_closest_n_points(self.0, N, x, result) } - } - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_kd_tree_point_locator_find_points_within_radius( - sself: *mut core::ffi::c_void, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_kd_tree_point_locator_find_points_within_radius(self.0, R, x, result) - } - } fn free_search_structure(&mut self) -> () { unsafe extern "C" { fn vtk_kd_tree_point_locator_free_search_structure( @@ -41941,20 +22798,6 @@ impl VtkLagrangeCurve for vtkLagrangeCurve { } unsafe { vtk_lagrange_curve_get_cell_type(self.0) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_curve_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_lagrange_curve_interpolate_functions(self.0, pcoords, weights) } - } } impl VtkLagrangeHexahedron for vtkLagrangeHexahedron { fn new(&mut self) -> *mut core::ffi::c_void { @@ -42008,22 +22851,6 @@ impl VtkLagrangeHexahedron for vtkLagrangeHexahedron { } unsafe { vtk_lagrange_hexahedron_get_face(self.0, faceId) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_hexahedron_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_lagrange_hexahedron_interpolate_functions(self.0, pcoords, weights) - } - } fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_lagrange_hexahedron_get_edge_cell( @@ -42075,401 +22902,50 @@ impl VtkLagrangeInterpolation for vtkLagrangeInterpolation { } unsafe { vtk_lagrange_interpolation_new_instance(self.0) } } - fn evaluate_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> () { +} +impl VtkLagrangeQuadrilateral for vtkLagrangeQuadrilateral { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lagrange_interpolation_evaluate_shape_functions( + fn vtk_lagrange_quadrilateral_new( sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - ); - } - unsafe { - vtk_lagrange_interpolation_evaluate_shape_functions( - self.0, - order, - pcoord, - shape, - ) + ) -> *mut core::ffi::c_void; } + unsafe { vtk_lagrange_quadrilateral_new(self.0) } } - fn evaluate_shape_and_gradient( - &mut self, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - grad: core::ffi::c_double, - ) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lagrange_interpolation_evaluate_shape_and_gradient( + fn vtk_lagrange_quadrilateral_safe_down_cast( sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoord: core::ffi::c_double, - shape: core::ffi::c_double, - grad: core::ffi::c_double, - ); - } - unsafe { - vtk_lagrange_interpolation_evaluate_shape_and_gradient( - self.0, - order, - pcoord, - shape, - grad, - ) + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } + unsafe { vtk_lagrange_quadrilateral_safe_down_cast(self.0, o) } } - fn tensor_1_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lagrange_interpolation_tensor_1_shape_functions( + fn vtk_lagrange_quadrilateral_new_instance( sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_lagrange_interpolation_tensor_1_shape_functions( - self.0, - order, - pcoords, - shape, - ) + ) -> *mut core::ffi::c_void; } + unsafe { vtk_lagrange_quadrilateral_new_instance(self.0) } } - fn tensor_1_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int { + fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_lagrange_interpolation_tensor_1_shape_derivatives( + fn vtk_lagrange_quadrilateral_get_cell_type( sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, ) -> core::ffi::c_int; } - unsafe { - vtk_lagrange_interpolation_tensor_1_shape_derivatives( - self.0, - order, - pcoords, - derivs, - ) - } + unsafe { vtk_lagrange_quadrilateral_get_cell_type(self.0) } } - fn tensor_2_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int { + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_lagrange_interpolation_tensor_2_shape_functions( + fn vtk_lagrange_quadrilateral_get_edge( sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_lagrange_interpolation_tensor_2_shape_functions( - self.0, - order, - pcoords, - shape, - ) - } - } - fn tensor_2_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_lagrange_interpolation_tensor_2_shape_derivatives( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_lagrange_interpolation_tensor_2_shape_derivatives( - self.0, - order, - pcoords, - derivs, - ) - } - } - fn tensor_3_shape_functions( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_lagrange_interpolation_tensor_3_shape_functions( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_lagrange_interpolation_tensor_3_shape_functions( - self.0, - order, - pcoords, - shape, - ) - } - } - fn tensor_3_shape_derivatives( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_lagrange_interpolation_tensor_3_shape_derivatives( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_lagrange_interpolation_tensor_3_shape_derivatives( - self.0, - order, - pcoords, - derivs, - ) - } - } - fn tensor_3_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_interpolation_tensor_3_evaluate_derivative( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ); - } - unsafe { - vtk_lagrange_interpolation_tensor_3_evaluate_derivative( - self.0, - order, - pcoords, - points, - fieldVals, - fieldDim, - fieldDerivs, - ) - } - } - fn wedge_shape_functions( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_interpolation_wedge_shape_functions( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - shape: core::ffi::c_double, - ); - } - unsafe { - vtk_lagrange_interpolation_wedge_shape_functions( - self.0, - order, - numberOfPoints, - pcoords, - shape, - ) - } - } - fn wedge_shape_derivatives( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_interpolation_wedge_shape_derivatives( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_lagrange_interpolation_wedge_shape_derivatives( - self.0, - order, - numberOfPoints, - pcoords, - derivs, - ) - } - } - fn wedge_evaluate( - &mut self, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldAtPCoords: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_interpolation_wedge_evaluate( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - numberOfPoints: core::ffi::c_uchar, - pcoords: core::ffi::c_double, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldAtPCoords: core::ffi::c_double, - ); - } - unsafe { - vtk_lagrange_interpolation_wedge_evaluate( - self.0, - order, - numberOfPoints, - pcoords, - fieldVals, - fieldDim, - fieldAtPCoords, - ) - } - } - fn wedge_evaluate_derivative( - &mut self, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_interpolation_wedge_evaluate_derivative( - sself: *mut core::ffi::c_void, - order: core::ffi::c_int, - pcoords: core::ffi::c_double, - points: *mut core::ffi::c_void, - fieldVals: core::ffi::c_double, - fieldDim: core::ffi::c_int, - fieldDerivs: core::ffi::c_double, - ); - } - unsafe { - vtk_lagrange_interpolation_wedge_evaluate_derivative( - self.0, - order, - pcoords, - points, - fieldVals, - fieldDim, - fieldDerivs, - ) - } - } -} -impl VtkLagrangeQuadrilateral for vtkLagrangeQuadrilateral { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_lagrange_quadrilateral_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_lagrange_quadrilateral_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_lagrange_quadrilateral_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_lagrange_quadrilateral_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_lagrange_quadrilateral_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_lagrange_quadrilateral_new_instance(self.0) } - } - fn get_cell_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_lagrange_quadrilateral_get_cell_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_lagrange_quadrilateral_get_cell_type(self.0) } - } - fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_lagrange_quadrilateral_get_edge( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_int, - ) -> *mut core::ffi::c_void; + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; } unsafe { vtk_lagrange_quadrilateral_get_edge(self.0, edgeId) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_quadrilateral_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_lagrange_quadrilateral_interpolate_functions(self.0, pcoords, weights) - } - } fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_lagrange_quadrilateral_get_edge_cell( @@ -42531,20 +23007,6 @@ impl VtkLagrangeTetra for vtkLagrangeTetra { } unsafe { vtk_lagrange_tetra_get_face(self.0, faceId) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_tetra_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_lagrange_tetra_interpolate_functions(self.0, pcoords, weights) } - } fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_lagrange_tetra_get_edge_cell( @@ -42605,20 +23067,6 @@ impl VtkLagrangeTriangle for vtkLagrangeTriangle { } unsafe { vtk_lagrange_triangle_get_edge(self.0, edgeId) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_triangle_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_lagrange_triangle_interpolate_functions(self.0, pcoords, weights) } - } fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_lagrange_triangle_get_edge_cell( @@ -42680,20 +23128,6 @@ impl VtkLagrangeWedge for vtkLagrangeWedge { } unsafe { vtk_lagrange_wedge_get_face(self.0, faceId) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_lagrange_wedge_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_lagrange_wedge_interpolate_functions(self.0, pcoords, weights) } - } fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_lagrange_wedge_get_boundary_quad( @@ -42799,22 +23233,6 @@ impl VtkLine for vtkLine { } unsafe { vtk_line_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_line_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_line_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -42826,7 +23244,7 @@ impl VtkLine for vtkLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -42841,7 +23259,7 @@ impl VtkLine for vtkLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -42862,56 +23280,6 @@ impl VtkLine for vtkLine { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_line_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_line_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_line_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_line_evaluate_location(self.0, subId, pcoords, x, weights) } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -42928,26 +23296,6 @@ impl VtkLine for vtkLine { } unsafe { vtk_line_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_line_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_line_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int { unsafe extern "C" { fn vtk_line_inflate( @@ -42966,7 +23314,7 @@ impl VtkLine for vtkLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -42980,7 +23328,7 @@ impl VtkLine for vtkLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -43001,264 +23349,6 @@ impl VtkLine for vtkLine { ) } } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_line_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_line_get_parametric_center(self.0, pcoords) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_line_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_line_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } - fn intersection( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - u: core::ffi::c_double, - v: core::ffi::c_double, - tolerance: core::ffi::c_double, - toleranceType: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_line_intersection( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - u: core::ffi::c_double, - v: core::ffi::c_double, - tolerance: core::ffi::c_double, - toleranceType: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_line_intersection(self.0, p1, p2, x1, x2, u, v, tolerance, toleranceType) - } - } - fn intersection_3_d( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - u: core::ffi::c_double, - v: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_line_intersection_3_d( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - u: core::ffi::c_double, - v: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_line_intersection_3_d(self.0, p1, p2, x1, x2, u, v, tolerance) } - } - fn distance_to_line( - &mut self, - x: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t: core::ffi::c_double, - closestPoint: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_line_distance_to_line( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t: core::ffi::c_double, - closestPoint: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_line_distance_to_line(self.0, x, p1, p2, t, closestPoint) } - } - fn distance_to_line( - &mut self, - x: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_line_distance_to_line( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_line_distance_to_line(self.0, x, p1, p2) } - } - fn distance_between_lines( - &mut self, - l0: core::ffi::c_double, - l1: core::ffi::c_double, - m0: core::ffi::c_double, - m1: core::ffi::c_double, - closestPt1: core::ffi::c_double, - closestPt2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_line_distance_between_lines( - sself: *mut core::ffi::c_void, - l0: core::ffi::c_double, - l1: core::ffi::c_double, - m0: core::ffi::c_double, - m1: core::ffi::c_double, - closestPt1: core::ffi::c_double, - closestPt2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { - vtk_line_distance_between_lines( - self.0, - l0, - l1, - m0, - m1, - closestPt1, - closestPt2, - t1, - t2, - ) - } - } - fn distance_between_line_segments( - &mut self, - l0: core::ffi::c_double, - l1: core::ffi::c_double, - m0: core::ffi::c_double, - m1: core::ffi::c_double, - closestPt1: core::ffi::c_double, - closestPt2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_line_distance_between_line_segments( - sself: *mut core::ffi::c_void, - l0: core::ffi::c_double, - l1: core::ffi::c_double, - m0: core::ffi::c_double, - m1: core::ffi::c_double, - closestPt1: core::ffi::c_double, - closestPt2: core::ffi::c_double, - t1: core::ffi::c_double, - t2: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { - vtk_line_distance_between_line_segments( - self.0, - l0, - l1, - m0, - m1, - closestPt1, - closestPt2, - t1, - t2, - ) - } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_line_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_line_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_line_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_line_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_line_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_line_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_line_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_line_interpolate_derivs(self.0, pcoords, derivs) } - } } impl VtkMeanValueCoordinatesInterpolator for vtkMeanValueCoordinatesInterpolator { fn new(&mut self) -> *mut core::ffi::c_void { @@ -43286,58 +23376,6 @@ impl VtkMeanValueCoordinatesInterpolator for vtkMeanValueCoordinatesInterpolator } unsafe { vtk_mean_value_coordinates_interpolator_new_instance(self.0) } } - fn compute_interpolation_weights( - &mut self, - x: core::ffi::c_double, - pts: *mut core::ffi::c_void, - tris: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_mean_value_coordinates_interpolator_compute_interpolation_weights( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - pts: *mut core::ffi::c_void, - tris: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_mean_value_coordinates_interpolator_compute_interpolation_weights( - self.0, - x, - pts, - tris, - weights, - ) - } - } - fn compute_interpolation_weights( - &mut self, - x: core::ffi::c_double, - pts: *mut core::ffi::c_void, - tris: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_mean_value_coordinates_interpolator_compute_interpolation_weights( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - pts: *mut core::ffi::c_void, - tris: *mut core::ffi::c_void, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_mean_value_coordinates_interpolator_compute_interpolation_weights( - self.0, - x, - pts, - tris, - weights, - ) - } - } } impl VtkMergePoints for vtkMergePoints { fn new(&mut self) -> *mut core::ffi::c_void { @@ -43365,29 +23403,6 @@ impl VtkMergePoints for vtkMergePoints { } unsafe { vtk_merge_points_new_instance(self.0) } } - fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_merge_points_is_inserted_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_merge_points_is_inserted_point(self.0, x) } - } - fn insert_unique_point( - &mut self, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_merge_points_insert_unique_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_merge_points_insert_unique_point(self.0, x, ptId) } - } } impl VtkMolecule for vtkMolecule { fn new(&mut self) -> *mut core::ffi::c_void { @@ -43413,319 +23428,133 @@ impl VtkMolecule for vtkMolecule { } unsafe { vtk_molecule_new_instance(self.0) } } - fn append_atom(&mut self) -> *mut core::ffi::c_void { + fn get_number_of_atoms(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_molecule_append_atom( + fn vtk_molecule_get_number_of_atoms( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + ) -> core::ffi::c_longlong; } - unsafe { vtk_molecule_append_atom(self.0) } + unsafe { vtk_molecule_get_number_of_atoms(self.0) } } - fn append_atom( - &mut self, - atomicNumber: core::ffi::c_ushort, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> *mut core::ffi::c_void { + fn get_number_of_bonds(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_molecule_append_atom( + fn vtk_molecule_get_number_of_bonds( sself: *mut core::ffi::c_void, - atomicNumber: core::ffi::c_ushort, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> *mut core::ffi::c_void; + ) -> core::ffi::c_longlong; } - unsafe { vtk_molecule_append_atom(self.0, atomicNumber, x, y, z) } + unsafe { vtk_molecule_get_number_of_bonds(self.0) } } - fn append_atom( + fn get_atom_atomic_number( &mut self, - atomicNumber: core::ffi::c_ushort, - pos: vtkVector3f, - ) -> *mut core::ffi::c_void { + atomId: core::ffi::c_longlong, + ) -> core::ffi::c_ushort { unsafe extern "C" { - fn vtk_molecule_append_atom( + fn vtk_molecule_get_atom_atomic_number( sself: *mut core::ffi::c_void, - atomicNumber: core::ffi::c_ushort, - pos: vtkVector3f, - ) -> *mut core::ffi::c_void; + atomId: core::ffi::c_longlong, + ) -> core::ffi::c_ushort; } - unsafe { vtk_molecule_append_atom(self.0, atomicNumber, pos) } + unsafe { vtk_molecule_get_atom_atomic_number(self.0, atomId) } } - fn append_atom( + fn set_atom_atomic_number( &mut self, - atomicNumber: core::ffi::c_ushort, - pos: core::ffi::c_double, - ) -> *mut core::ffi::c_void { + atomId: core::ffi::c_longlong, + atomicNum: core::ffi::c_ushort, + ) -> () { unsafe extern "C" { - fn vtk_molecule_append_atom( + fn vtk_molecule_set_atom_atomic_number( sself: *mut core::ffi::c_void, - atomicNumber: core::ffi::c_ushort, - pos: core::ffi::c_double, - ) -> *mut core::ffi::c_void; + atomId: core::ffi::c_longlong, + atomicNum: core::ffi::c_ushort, + ); } - unsafe { vtk_molecule_append_atom(self.0, atomicNumber, pos) } + unsafe { vtk_molecule_set_atom_atomic_number(self.0, atomId, atomicNum) } } - fn get_atom(&mut self, atomId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn set_bond_order( + &mut self, + bondId: core::ffi::c_longlong, + order: core::ffi::c_ushort, + ) -> () { unsafe extern "C" { - fn vtk_molecule_get_atom( + fn vtk_molecule_set_bond_order( sself: *mut core::ffi::c_void, - atomId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; + bondId: core::ffi::c_longlong, + order: core::ffi::c_ushort, + ); } - unsafe { vtk_molecule_get_atom(self.0, atomId) } + unsafe { vtk_molecule_set_bond_order(self.0, bondId, order) } } - fn get_number_of_atoms(&mut self) -> core::ffi::c_uchar { + fn get_bond_order(&mut self, bondId: core::ffi::c_longlong) -> core::ffi::c_ushort { unsafe extern "C" { - fn vtk_molecule_get_number_of_atoms( + fn vtk_molecule_get_bond_order( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + bondId: core::ffi::c_longlong, + ) -> core::ffi::c_ushort; } - unsafe { vtk_molecule_get_number_of_atoms(self.0) } + unsafe { vtk_molecule_get_bond_order(self.0, bondId) } } - fn append_bond( - &mut self, - atom1: core::ffi::c_uchar, - atom2: core::ffi::c_uchar, - order: core::ffi::c_ushort, - ) -> *mut core::ffi::c_void { + fn get_bond_length(&mut self, bondId: core::ffi::c_longlong) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_molecule_append_bond( + fn vtk_molecule_get_bond_length( sself: *mut core::ffi::c_void, - atom1: core::ffi::c_uchar, - atom2: core::ffi::c_uchar, - order: core::ffi::c_ushort, - ) -> *mut core::ffi::c_void; + bondId: core::ffi::c_longlong, + ) -> core::ffi::c_double; } - unsafe { vtk_molecule_append_bond(self.0, atom1, atom2, order) } + unsafe { vtk_molecule_get_bond_length(self.0, bondId) } } - fn append_bond( - &mut self, - atom1: vtkAtom, - atom2: vtkAtom, - order: core::ffi::c_ushort, - ) -> *mut core::ffi::c_void { + fn get_atomic_position_array(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_molecule_append_bond( + fn vtk_molecule_get_atomic_position_array( sself: *mut core::ffi::c_void, - atom1: vtkAtom, - atom2: vtkAtom, - order: core::ffi::c_ushort, ) -> *mut core::ffi::c_void; } - unsafe { vtk_molecule_append_bond(self.0, atom1, atom2, order) } + unsafe { vtk_molecule_get_atomic_position_array(self.0) } } - fn get_bond(&mut self, bondId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_atomic_number_array(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_molecule_get_bond( + fn vtk_molecule_get_atomic_number_array( sself: *mut core::ffi::c_void, - bondId: core::ffi::c_uchar, ) -> *mut core::ffi::c_void; } - unsafe { vtk_molecule_get_bond(self.0, bondId) } + unsafe { vtk_molecule_get_atomic_number_array(self.0) } } - fn get_number_of_bonds(&mut self) -> core::ffi::c_uchar { + fn get_bond_orders_array(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_molecule_get_number_of_bonds( + fn vtk_molecule_get_bond_orders_array( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_molecule_get_number_of_bonds(self.0) } + unsafe { vtk_molecule_get_bond_orders_array(self.0) } } - fn get_atom_atomic_number( - &mut self, - atomId: core::ffi::c_uchar, - ) -> core::ffi::c_ushort { + fn get_electronic_data(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_molecule_get_atom_atomic_number( + fn vtk_molecule_get_electronic_data( sself: *mut core::ffi::c_void, - atomId: core::ffi::c_uchar, - ) -> core::ffi::c_ushort; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_molecule_get_atom_atomic_number(self.0, atomId) } + unsafe { vtk_molecule_get_electronic_data(self.0) } } - fn set_atom_atomic_number( - &mut self, - atomId: core::ffi::c_uchar, - atomicNum: core::ffi::c_ushort, - ) -> () { + fn set_electronic_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_molecule_set_atom_atomic_number( + fn vtk_molecule_set_electronic_data( sself: *mut core::ffi::c_void, - atomId: core::ffi::c_uchar, - atomicNum: core::ffi::c_ushort, + p0: *mut core::ffi::c_void, ); } - unsafe { vtk_molecule_set_atom_atomic_number(self.0, atomId, atomicNum) } + unsafe { vtk_molecule_set_electronic_data(self.0, p0) } } - fn set_atom_position(&mut self, atomId: core::ffi::c_uchar, pos: vtkVector3f) -> () { + fn shallow_copy(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_molecule_set_atom_position( + fn vtk_molecule_shallow_copy( sself: *mut core::ffi::c_void, - atomId: core::ffi::c_uchar, - pos: vtkVector3f, + obj: *mut core::ffi::c_void, ); } - unsafe { vtk_molecule_set_atom_position(self.0, atomId, pos) } + unsafe { vtk_molecule_shallow_copy(self.0, obj) } } - fn set_atom_position( - &mut self, - atomId: core::ffi::c_uchar, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> () { + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_molecule_set_atom_position( - sself: *mut core::ffi::c_void, - atomId: core::ffi::c_uchar, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ); - } - unsafe { vtk_molecule_set_atom_position(self.0, atomId, x, y, z) } - } - fn set_atom_position( - &mut self, - atomId: core::ffi::c_uchar, - pos: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_molecule_set_atom_position( - sself: *mut core::ffi::c_void, - atomId: core::ffi::c_uchar, - pos: core::ffi::c_double, - ); - } - unsafe { vtk_molecule_set_atom_position(self.0, atomId, pos) } - } - fn get_atom_position( - &mut self, - atomId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_molecule_get_atom_position( - sself: *mut core::ffi::c_void, - atomId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_molecule_get_atom_position(self.0, atomId) } - } - fn get_atom_position( - &mut self, - atomId: core::ffi::c_uchar, - pos: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_molecule_get_atom_position( - sself: *mut core::ffi::c_void, - atomId: core::ffi::c_uchar, - pos: core::ffi::c_float, - ); - } - unsafe { vtk_molecule_get_atom_position(self.0, atomId, pos) } - } - fn get_atom_position( - &mut self, - atomId: core::ffi::c_uchar, - pos: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_molecule_get_atom_position( - sself: *mut core::ffi::c_void, - atomId: core::ffi::c_uchar, - pos: core::ffi::c_double, - ); - } - unsafe { vtk_molecule_get_atom_position(self.0, atomId, pos) } - } - fn set_bond_order( - &mut self, - bondId: core::ffi::c_uchar, - order: core::ffi::c_ushort, - ) -> () { - unsafe extern "C" { - fn vtk_molecule_set_bond_order( - sself: *mut core::ffi::c_void, - bondId: core::ffi::c_uchar, - order: core::ffi::c_ushort, - ); - } - unsafe { vtk_molecule_set_bond_order(self.0, bondId, order) } - } - fn get_bond_order(&mut self, bondId: core::ffi::c_uchar) -> core::ffi::c_ushort { - unsafe extern "C" { - fn vtk_molecule_get_bond_order( - sself: *mut core::ffi::c_void, - bondId: core::ffi::c_uchar, - ) -> core::ffi::c_ushort; - } - unsafe { vtk_molecule_get_bond_order(self.0, bondId) } - } - fn get_bond_length(&mut self, bondId: core::ffi::c_uchar) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_molecule_get_bond_length( - sself: *mut core::ffi::c_void, - bondId: core::ffi::c_uchar, - ) -> core::ffi::c_double; - } - unsafe { vtk_molecule_get_bond_length(self.0, bondId) } - } - fn get_atomic_position_array(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_molecule_get_atomic_position_array( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_molecule_get_atomic_position_array(self.0) } - } - fn get_atomic_number_array(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_molecule_get_atomic_number_array( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_molecule_get_atomic_number_array(self.0) } - } - fn get_bond_orders_array(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_molecule_get_bond_orders_array( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_molecule_get_bond_orders_array(self.0) } - } - fn get_electronic_data(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_molecule_get_electronic_data( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_molecule_get_electronic_data(self.0) } - } - fn set_electronic_data(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_molecule_set_electronic_data( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_molecule_set_electronic_data(self.0, p0) } - } - fn shallow_copy(&mut self, obj: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_molecule_shallow_copy( - sself: *mut core::ffi::c_void, - obj: *mut core::ffi::c_void, - ); - } - unsafe { vtk_molecule_shallow_copy(self.0, obj) } - } - fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_molecule_deep_copy( + fn vtk_molecule_deep_copy( sself: *mut core::ffi::c_void, obj: *mut core::ffi::c_void, ); @@ -43768,40 +23597,6 @@ impl VtkMolecule for vtkMolecule { } unsafe { vtk_molecule_deep_copy_attributes(self.0, m) } } - fn get_plane_from_bond( - &mut self, - bond: vtkBond, - normal: vtkVector3f, - plane: *mut core::ffi::c_void, - ) -> bool { - unsafe extern "C" { - fn vtk_molecule_get_plane_from_bond( - sself: *mut core::ffi::c_void, - bond: vtkBond, - normal: vtkVector3f, - plane: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_molecule_get_plane_from_bond(self.0, bond, normal, plane) } - } - fn get_plane_from_bond( - &mut self, - atom1: vtkAtom, - atom2: vtkAtom, - normal: vtkVector3f, - plane: *mut core::ffi::c_void, - ) -> bool { - unsafe extern "C" { - fn vtk_molecule_get_plane_from_bond( - sself: *mut core::ffi::c_void, - atom1: vtkAtom, - atom2: vtkAtom, - normal: vtkVector3f, - plane: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_molecule_get_plane_from_bond(self.0, atom1, atom2, normal, plane) } - } fn has_lattice(&mut self) -> bool { unsafe extern "C" { fn vtk_molecule_has_lattice(sself: *mut core::ffi::c_void) -> bool; @@ -43823,17 +23618,6 @@ impl VtkMolecule for vtkMolecule { } unsafe { vtk_molecule_set_lattice(self.0, matrix) } } - fn set_lattice(&mut self, a: vtkVector3d, b: vtkVector3d, c: vtkVector3d) -> () { - unsafe extern "C" { - fn vtk_molecule_set_lattice( - sself: *mut core::ffi::c_void, - a: vtkVector3d, - b: vtkVector3d, - c: vtkVector3d, - ); - } - unsafe { vtk_molecule_set_lattice(self.0, a, b, c) } - } fn get_lattice(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_molecule_get_lattice( @@ -43842,57 +23626,6 @@ impl VtkMolecule for vtkMolecule { } unsafe { vtk_molecule_get_lattice(self.0) } } - fn get_lattice( - &mut self, - a: *mut core::ffi::c_void, - b: *mut core::ffi::c_void, - c: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_molecule_get_lattice( - sself: *mut core::ffi::c_void, - a: *mut core::ffi::c_void, - b: *mut core::ffi::c_void, - c: *mut core::ffi::c_void, - ); - } - unsafe { vtk_molecule_get_lattice(self.0, a, b, c) } - } - fn get_lattice( - &mut self, - a: *mut core::ffi::c_void, - b: *mut core::ffi::c_void, - c: *mut core::ffi::c_void, - origin: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_molecule_get_lattice( - sself: *mut core::ffi::c_void, - a: *mut core::ffi::c_void, - b: *mut core::ffi::c_void, - c: *mut core::ffi::c_void, - origin: *mut core::ffi::c_void, - ); - } - unsafe { vtk_molecule_get_lattice(self.0, a, b, c, origin) } - } - fn get_lattice_origin(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_molecule_get_lattice_origin( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_molecule_get_lattice_origin(self.0) } - } - fn set_lattice_origin(&mut self, _arg: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_molecule_set_lattice_origin( - sself: *mut core::ffi::c_void, - _arg: *mut core::ffi::c_void, - ); - } - unsafe { vtk_molecule_set_lattice_origin(self.0, _arg) } - } fn get_atom_ghost_array(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_molecule_get_atom_ghost_array( @@ -43939,29 +23672,6 @@ impl VtkMolecule for vtkMolecule { vtk_molecule_initialize(self.0, atomPositions, atomicNumberArray, atomData) } } - fn initialize( - &mut self, - atomPositions: *mut core::ffi::c_void, - atomData: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_molecule_initialize( - sself: *mut core::ffi::c_void, - atomPositions: *mut core::ffi::c_void, - atomData: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_molecule_initialize(self.0, atomPositions, atomData) } - } - fn initialize(&mut self, molecule: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_molecule_initialize( - sself: *mut core::ffi::c_void, - molecule: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_molecule_initialize(self.0, molecule) } - } fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_molecule_get_data( @@ -43971,20 +23681,6 @@ impl VtkMolecule for vtkMolecule { } unsafe { vtk_molecule_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_molecule_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_molecule_get_data(self.0, v, i) } - } fn get_atom_data(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_molecule_get_atom_data( @@ -44003,51 +23699,37 @@ impl VtkMolecule for vtkMolecule { } fn get_bond_id( &mut self, - a: core::ffi::c_uchar, - b: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + a: core::ffi::c_longlong, + b: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_molecule_get_bond_id( sself: *mut core::ffi::c_void, - a: core::ffi::c_uchar, - b: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + a: core::ffi::c_longlong, + b: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_molecule_get_bond_id(self.0, a, b) } } - fn set_atomic_number_array_name(&mut self, _arg: core::ffi::c_char) -> () { + fn set_atomic_number_array_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { fn vtk_molecule_set_atomic_number_array_name( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, + _arg: *const core::ffi::c_char, ); } - unsafe { vtk_molecule_set_atomic_number_array_name(self.0, _arg) } - } - fn get_atomic_number_array_name(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_molecule_get_atomic_number_array_name( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_molecule_get_atomic_number_array_name(self.0) } + unsafe { vtk_molecule_set_atomic_number_array_name(self.0, c__arg.as_ptr()) } } - fn set_bond_orders_array_name(&mut self, _arg: core::ffi::c_char) -> () { + fn set_bond_orders_array_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { fn vtk_molecule_set_bond_orders_array_name( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, + _arg: *const core::ffi::c_char, ); } - unsafe { vtk_molecule_set_bond_orders_array_name(self.0, _arg) } - } - fn get_bond_orders_array_name(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_molecule_get_bond_orders_array_name( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_molecule_get_bond_orders_array_name(self.0) } + unsafe { vtk_molecule_set_bond_orders_array_name(self.0, c__arg.as_ptr()) } } } impl VtkMultiBlockDataSet for vtkMultiBlockDataSet { @@ -44152,38 +23834,6 @@ impl VtkMultiBlockDataSet for vtkMultiBlockDataSet { } unsafe { vtk_multi_block_data_set_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_multi_block_data_set_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_multi_block_data_set_get_data(self.0, v, i) } - } - fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_multi_block_data_set_get_meta_data( - sself: *mut core::ffi::c_void, - iter: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_multi_block_data_set_get_meta_data(self.0, iter) } - } - fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_multi_block_data_set_has_meta_data( - sself: *mut core::ffi::c_void, - iter: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_multi_block_data_set_has_meta_data(self.0, iter) } - } } impl VtkMultiPieceDataSet for vtkMultiPieceDataSet { fn new(&mut self) -> *mut core::ffi::c_void { @@ -44272,20 +23922,6 @@ impl VtkMultiPieceDataSet for vtkMultiPieceDataSet { } unsafe { vtk_multi_piece_data_set_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_multi_piece_data_set_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_multi_piece_data_set_get_data(self.0, v, i) } - } } impl VtkMutableDirectedGraph for vtkMutableDirectedGraph { fn new(&mut self) -> *mut core::ffi::c_void { @@ -44315,203 +23951,41 @@ impl VtkMutableDirectedGraph for vtkMutableDirectedGraph { } fn set_number_of_vertices( &mut self, - numVerts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_mutable_directed_graph_set_number_of_vertices( sself: *mut core::ffi::c_void, - numVerts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_mutable_directed_graph_set_number_of_vertices(self.0, numVerts) } } - fn add_vertex(&mut self) -> core::ffi::c_uchar { + fn add_vertex(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_mutable_directed_graph_add_vertex( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_mutable_directed_graph_add_vertex(self.0) } } - fn add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_mutable_directed_graph_add_vertex( - sself: *mut core::ffi::c_void, - propertyArr: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_mutable_directed_graph_add_vertex(self.0, propertyArr) } - } - fn add_vertex(&mut self, pedigreeId: vtkVariant) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_mutable_directed_graph_add_vertex( - sself: *mut core::ffi::c_void, - pedigreeId: vtkVariant, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_mutable_directed_graph_add_vertex(self.0, pedigreeId) } - } - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_mutable_directed_graph_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_mutable_directed_graph_add_edge(self.0, u, v) } - } - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_mutable_directed_graph_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_mutable_directed_graph_add_edge(self.0, u, v, propertyArr) } - } - fn add_edge( - &mut self, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_mutable_directed_graph_add_edge( - sself: *mut core::ffi::c_void, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_mutable_directed_graph_add_edge(self.0, u, v, propertyArr) } - } - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_mutable_directed_graph_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_mutable_directed_graph_add_edge(self.0, u, v, propertyArr) } - } - fn add_edge( - &mut self, - u: vtkVariant, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_mutable_directed_graph_add_edge( - sself: *mut core::ffi::c_void, - u: vtkVariant, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_mutable_directed_graph_add_edge(self.0, u, v, propertyArr) } - } fn lazy_add_vertex(&mut self) -> () { unsafe extern "C" { fn vtk_mutable_directed_graph_lazy_add_vertex(sself: *mut core::ffi::c_void); } unsafe { vtk_mutable_directed_graph_lazy_add_vertex(self.0) } } - fn lazy_add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_mutable_directed_graph_lazy_add_vertex( - sself: *mut core::ffi::c_void, - propertyArr: *mut core::ffi::c_void, - ); - } - unsafe { vtk_mutable_directed_graph_lazy_add_vertex(self.0, propertyArr) } - } - fn lazy_add_vertex(&mut self, pedigreeId: vtkVariant) -> () { - unsafe extern "C" { - fn vtk_mutable_directed_graph_lazy_add_vertex( - sself: *mut core::ffi::c_void, - pedigreeId: vtkVariant, - ); - } - unsafe { vtk_mutable_directed_graph_lazy_add_vertex(self.0, pedigreeId) } - } - fn lazy_add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_mutable_directed_graph_lazy_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ); - } - unsafe { vtk_mutable_directed_graph_lazy_add_edge(self.0, u, v, propertyArr) } - } - fn lazy_add_edge( - &mut self, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_mutable_directed_graph_lazy_add_edge( - sself: *mut core::ffi::c_void, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ); - } - unsafe { vtk_mutable_directed_graph_lazy_add_edge(self.0, u, v, propertyArr) } - } - fn lazy_add_edge( - &mut self, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_mutable_directed_graph_lazy_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ); - } - unsafe { vtk_mutable_directed_graph_lazy_add_edge(self.0, u, v, propertyArr) } - } fn lazy_add_edge( &mut self, - u: vtkVariant, - v: vtkVariant, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, propertyArr: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_mutable_directed_graph_lazy_add_edge( sself: *mut core::ffi::c_void, - u: vtkVariant, - v: vtkVariant, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, propertyArr: *mut core::ffi::c_void, ); } @@ -44519,55 +23993,46 @@ impl VtkMutableDirectedGraph for vtkMutableDirectedGraph { } fn add_graph_edge( &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_mutable_directed_graph_add_graph_edge( sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_mutable_directed_graph_add_graph_edge(self.0, u, v) } } fn add_child( &mut self, - parent: core::ffi::c_uchar, + parent: core::ffi::c_longlong, propertyArr: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_mutable_directed_graph_add_child( sself: *mut core::ffi::c_void, - parent: core::ffi::c_uchar, + parent: core::ffi::c_longlong, propertyArr: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_mutable_directed_graph_add_child(self.0, parent, propertyArr) } } - fn add_child(&mut self, parent: core::ffi::c_uchar) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_mutable_directed_graph_add_child( - sself: *mut core::ffi::c_void, - parent: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_mutable_directed_graph_add_child(self.0, parent) } - } - fn remove_vertex(&mut self, v: core::ffi::c_uchar) -> () { + fn remove_vertex(&mut self, v: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_mutable_directed_graph_remove_vertex( sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, + v: core::ffi::c_longlong, ); } unsafe { vtk_mutable_directed_graph_remove_vertex(self.0, v) } } - fn remove_edge(&mut self, e: core::ffi::c_uchar) -> () { + fn remove_edge(&mut self, e: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_mutable_directed_graph_remove_edge( sself: *mut core::ffi::c_void, - e: core::ffi::c_uchar, + e: core::ffi::c_longlong, ); } unsafe { vtk_mutable_directed_graph_remove_edge(self.0, e) } @@ -44619,120 +24084,24 @@ impl VtkMutableUndirectedGraph for vtkMutableUndirectedGraph { } fn set_number_of_vertices( &mut self, - numVerts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_mutable_undirected_graph_set_number_of_vertices( sself: *mut core::ffi::c_void, - numVerts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_mutable_undirected_graph_set_number_of_vertices(self.0, numVerts) } } - fn add_vertex(&mut self) -> core::ffi::c_uchar { + fn add_vertex(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_mutable_undirected_graph_add_vertex( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_mutable_undirected_graph_add_vertex(self.0) } } - fn add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_add_vertex( - sself: *mut core::ffi::c_void, - propertyArr: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_mutable_undirected_graph_add_vertex(self.0, propertyArr) } - } - fn add_vertex(&mut self, pedigreeId: vtkVariant) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_add_vertex( - sself: *mut core::ffi::c_void, - pedigreeId: vtkVariant, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_mutable_undirected_graph_add_vertex(self.0, pedigreeId) } - } - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_mutable_undirected_graph_add_edge(self.0, u, v) } - } - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_mutable_undirected_graph_add_edge(self.0, u, v, propertyArr) } - } - fn add_edge( - &mut self, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_add_edge( - sself: *mut core::ffi::c_void, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_mutable_undirected_graph_add_edge(self.0, u, v, propertyArr) } - } - fn add_edge( - &mut self, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_mutable_undirected_graph_add_edge(self.0, u, v, propertyArr) } - } - fn add_edge( - &mut self, - u: vtkVariant, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_add_edge( - sself: *mut core::ffi::c_void, - u: vtkVariant, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_mutable_undirected_graph_add_edge(self.0, u, v, propertyArr) } - } fn lazy_add_vertex(&mut self) -> () { unsafe extern "C" { fn vtk_mutable_undirected_graph_lazy_add_vertex( @@ -44741,126 +24110,48 @@ impl VtkMutableUndirectedGraph for vtkMutableUndirectedGraph { } unsafe { vtk_mutable_undirected_graph_lazy_add_vertex(self.0) } } - fn lazy_add_vertex(&mut self, propertyArr: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_lazy_add_vertex( - sself: *mut core::ffi::c_void, - propertyArr: *mut core::ffi::c_void, - ); - } - unsafe { vtk_mutable_undirected_graph_lazy_add_vertex(self.0, propertyArr) } - } - fn lazy_add_vertex(&mut self, pedigreeId: vtkVariant) -> () { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_lazy_add_vertex( - sself: *mut core::ffi::c_void, - pedigreeId: vtkVariant, - ); - } - unsafe { vtk_mutable_undirected_graph_lazy_add_vertex(self.0, pedigreeId) } - } - fn lazy_add_edge(&mut self, u: core::ffi::c_uchar, v: core::ffi::c_uchar) -> () { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_lazy_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - ); - } - unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v) } - } - fn lazy_add_edge( - &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_lazy_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ); - } - unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v, propertyArr) } - } fn lazy_add_edge( &mut self, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_lazy_add_edge( - sself: *mut core::ffi::c_void, - u: vtkVariant, - v: core::ffi::c_uchar, - propertyArr: *mut core::ffi::c_void, - ); - } - unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v, propertyArr) } - } - fn lazy_add_edge( - &mut self, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_mutable_undirected_graph_lazy_add_edge( - sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, - ); - } - unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v, propertyArr) } - } - fn lazy_add_edge( - &mut self, - u: vtkVariant, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_mutable_undirected_graph_lazy_add_edge( sself: *mut core::ffi::c_void, - u: vtkVariant, - v: vtkVariant, - propertyArr: *mut core::ffi::c_void, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, ); } - unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v, propertyArr) } + unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v) } } fn add_graph_edge( &mut self, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_mutable_undirected_graph_add_graph_edge( sself: *mut core::ffi::c_void, - u: core::ffi::c_uchar, - v: core::ffi::c_uchar, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_mutable_undirected_graph_add_graph_edge(self.0, u, v) } } - fn remove_vertex(&mut self, v: core::ffi::c_uchar) -> () { + fn remove_vertex(&mut self, v: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_mutable_undirected_graph_remove_vertex( sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, + v: core::ffi::c_longlong, ); } unsafe { vtk_mutable_undirected_graph_remove_vertex(self.0, v) } } - fn remove_edge(&mut self, e: core::ffi::c_uchar) -> () { + fn remove_edge(&mut self, e: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_mutable_undirected_graph_remove_edge( sself: *mut core::ffi::c_void, - e: core::ffi::c_uchar, + e: core::ffi::c_longlong, ); } unsafe { vtk_mutable_undirected_graph_remove_edge(self.0, e) } @@ -44910,45 +24201,22 @@ impl VtkNonMergingPointLocator for vtkNonMergingPointLocator { } unsafe { vtk_non_merging_point_locator_new_instance(self.0) } } - fn is_inserted_point(&mut self, p0: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_non_merging_point_locator_is_inserted_point( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_non_merging_point_locator_is_inserted_point(self.0, p0) } - } fn is_inserted_point( &mut self, p0: core::ffi::c_double, p1: core::ffi::c_double, p2: core::ffi::c_double, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_non_merging_point_locator_is_inserted_point( sself: *mut core::ffi::c_void, p0: core::ffi::c_double, p1: core::ffi::c_double, p2: core::ffi::c_double, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_non_merging_point_locator_is_inserted_point(self.0, p0, p1, p2) } } - fn insert_unique_point( - &mut self, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_non_merging_point_locator_insert_unique_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_non_merging_point_locator_insert_unique_point(self.0, x, ptId) } - } } impl VtkNonOverlappingAMR for vtkNonOverlappingAMR { fn new(&mut self) -> *mut core::ffi::c_void { @@ -44993,20 +24261,6 @@ impl VtkNonOverlappingAMR for vtkNonOverlappingAMR { } unsafe { vtk_non_overlapping_amr_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_non_overlapping_amr_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_non_overlapping_amr_get_data(self.0, v, i) } - } } impl VtkOctreePointLocator for vtkOctreePointLocator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -45085,23 +24339,6 @@ impl VtkOctreePointLocator for vtkOctreePointLocator { } unsafe { vtk_octree_point_locator_set_fudge_factor(self.0, _arg) } } - fn get_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_octree_point_locator_get_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_octree_point_locator_get_bounds(self.0) } - } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_octree_point_locator_get_bounds(self.0, bounds) } - } fn get_number_of_leaf_nodes(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_octree_point_locator_get_number_of_leaf_nodes( @@ -45110,37 +24347,7 @@ impl VtkOctreePointLocator for vtkOctreePointLocator { } unsafe { vtk_octree_point_locator_get_number_of_leaf_nodes(self.0) } } - fn get_region_bounds( - &mut self, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_get_region_bounds( - sself: *mut core::ffi::c_void, - regionID: core::ffi::c_int, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_octree_point_locator_get_region_bounds(self.0, regionID, bounds) } - } - fn get_region_data_bounds( - &mut self, - leafNodeID: core::ffi::c_int, - bounds: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_get_region_data_bounds( - sself: *mut core::ffi::c_void, - leafNodeID: core::ffi::c_int, - bounds: core::ffi::c_double, - ); - } - unsafe { - vtk_octree_point_locator_get_region_data_bounds(self.0, leafNodeID, bounds) - } - } - fn get_region_containing_point( + fn get_region_containing_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, @@ -45162,142 +24369,24 @@ impl VtkOctreePointLocator for vtkOctreePointLocator { } unsafe { vtk_octree_point_locator_build_locator(self.0) } } - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_octree_point_locator_find_closest_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_octree_point_locator_find_closest_point(self.0, x) } - } fn find_closest_point( &mut self, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { + dist2: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_octree_point_locator_find_closest_point( sself: *mut core::ffi::c_void, x: core::ffi::c_double, y: core::ffi::c_double, z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; + dist2: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; } unsafe { vtk_octree_point_locator_find_closest_point(self.0, x, y, z, dist2) } } - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_octree_point_locator_find_closest_point_within_radius( - sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_octree_point_locator_find_closest_point_within_radius( - self.0, - radius, - x, - dist2, - ) - } - } - fn find_closest_point_in_region( - &mut self, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_octree_point_locator_find_closest_point_in_region( - sself: *mut core::ffi::c_void, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_octree_point_locator_find_closest_point_in_region( - self.0, - regionId, - x, - dist2, - ) - } - } - fn find_closest_point_in_region( - &mut self, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_octree_point_locator_find_closest_point_in_region( - sself: *mut core::ffi::c_void, - regionId: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_octree_point_locator_find_closest_point_in_region( - self.0, - regionId, - x, - y, - z, - dist2, - ) - } - } - fn find_points_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_find_points_within_radius( - sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_octree_point_locator_find_points_within_radius(self.0, radius, x, result) - } - } - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_find_closest_n_points( - sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { vtk_octree_point_locator_find_closest_n_points(self.0, N, x, result) } - } fn get_points_in_region( &mut self, leafNodeId: core::ffi::c_int, @@ -45332,24 +24421,6 @@ impl VtkOctreePointLocator for vtkOctreePointLocator { } unsafe { vtk_octree_point_locator_generate_representation(self.0, level, pd) } } - fn find_points_in_area( - &mut self, - area: core::ffi::c_double, - ids: *mut core::ffi::c_void, - clearArray: bool, - ) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_find_points_in_area( - sself: *mut core::ffi::c_void, - area: core::ffi::c_double, - ids: *mut core::ffi::c_void, - clearArray: bool, - ); - } - unsafe { - vtk_octree_point_locator_find_points_in_area(self.0, area, ids, clearArray) - } - } } impl VtkOctreePointLocatorNode for vtkOctreePointLocatorNode { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -45428,24 +24499,6 @@ impl VtkOctreePointLocatorNode for vtkOctreePointLocatorNode { ) } } - fn set_bounds(&mut self, b: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_node_set_bounds( - sself: *mut core::ffi::c_void, - b: core::ffi::c_double, - ); - } - unsafe { vtk_octree_point_locator_node_set_bounds(self.0, b) } - } - fn get_bounds(&mut self, b: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_node_get_bounds( - sself: *mut core::ffi::c_void, - b: core::ffi::c_double, - ); - } - unsafe { vtk_octree_point_locator_node_get_bounds(self.0, b) } - } fn set_data_bounds( &mut self, xMin: core::ffi::c_double, @@ -45478,87 +24531,6 @@ impl VtkOctreePointLocatorNode for vtkOctreePointLocatorNode { ) } } - fn get_data_bounds(&mut self, b: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_node_get_data_bounds( - sself: *mut core::ffi::c_void, - b: core::ffi::c_double, - ); - } - unsafe { vtk_octree_point_locator_node_get_data_bounds(self.0, b) } - } - fn get_min_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_octree_point_locator_node_get_min_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_octree_point_locator_node_get_min_bounds(self.0) } - } - fn get_max_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_octree_point_locator_node_get_max_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_octree_point_locator_node_get_max_bounds(self.0) } - } - fn set_min_bounds(&mut self, minBounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_node_set_min_bounds( - sself: *mut core::ffi::c_void, - minBounds: core::ffi::c_double, - ); - } - unsafe { vtk_octree_point_locator_node_set_min_bounds(self.0, minBounds) } - } - fn set_max_bounds(&mut self, maxBounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_node_set_max_bounds( - sself: *mut core::ffi::c_void, - maxBounds: core::ffi::c_double, - ); - } - unsafe { vtk_octree_point_locator_node_set_max_bounds(self.0, maxBounds) } - } - fn get_min_data_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_octree_point_locator_node_get_min_data_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_octree_point_locator_node_get_min_data_bounds(self.0) } - } - fn get_max_data_bounds(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_octree_point_locator_node_get_max_data_bounds( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_octree_point_locator_node_get_max_data_bounds(self.0) } - } - fn set_min_data_bounds(&mut self, minDataBounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_node_set_min_data_bounds( - sself: *mut core::ffi::c_void, - minDataBounds: core::ffi::c_double, - ); - } - unsafe { - vtk_octree_point_locator_node_set_min_data_bounds(self.0, minDataBounds) - } - } - fn set_max_data_bounds(&mut self, maxDataBounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_node_set_max_data_bounds( - sself: *mut core::ffi::c_void, - maxDataBounds: core::ffi::c_double, - ); - } - unsafe { - vtk_octree_point_locator_node_set_max_data_bounds(self.0, maxDataBounds) - } - } fn get_id(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_octree_point_locator_node_get_id( @@ -45665,38 +24637,6 @@ impl VtkOctreePointLocatorNode for vtkOctreePointLocatorNode { ) } } - fn get_distance_2_to_boundary( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - boundaryPt: core::ffi::c_double, - top: *mut core::ffi::c_void, - useDataBounds: core::ffi::c_int, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_octree_point_locator_node_get_distance_2_to_boundary( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - boundaryPt: core::ffi::c_double, - top: *mut core::ffi::c_void, - useDataBounds: core::ffi::c_int, - ) -> core::ffi::c_double; - } - unsafe { - vtk_octree_point_locator_node_get_distance_2_to_boundary( - self.0, - x, - y, - z, - boundaryPt, - top, - useDataBounds, - ) - } - } fn get_distance_2_to_inner_boundary( &mut self, x: core::ffi::c_double, @@ -45723,52 +24663,6 @@ impl VtkOctreePointLocatorNode for vtkOctreePointLocatorNode { ) } } - fn get_sub_octant_index( - &mut self, - point: core::ffi::c_double, - CheckContainment: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_octree_point_locator_node_get_sub_octant_index( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - CheckContainment: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_octree_point_locator_node_get_sub_octant_index( - self.0, - point, - CheckContainment, - ) - } - } - fn compute_octree_node_information( - &mut self, - Parent: *mut core::ffi::c_void, - NextLeafId: core::ffi::c_int, - NextMinId: core::ffi::c_int, - coordinates: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_octree_point_locator_node_compute_octree_node_information( - sself: *mut core::ffi::c_void, - Parent: *mut core::ffi::c_void, - NextLeafId: core::ffi::c_int, - NextMinId: core::ffi::c_int, - coordinates: core::ffi::c_float, - ); - } - unsafe { - vtk_octree_point_locator_node_compute_octree_node_information( - self.0, - Parent, - NextLeafId, - NextMinId, - coordinates, - ) - } - } } impl VtkOrderedTriangulator for vtkOrderedTriangulator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -45831,90 +24725,6 @@ impl VtkOrderedTriangulator for vtkOrderedTriangulator { ) } } - fn init_triangulation( - &mut self, - bounds: core::ffi::c_double, - numPts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_ordered_triangulator_init_triangulation( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - numPts: core::ffi::c_int, - ); - } - unsafe { vtk_ordered_triangulator_init_triangulation(self.0, bounds, numPts) } - } - fn insert_point( - &mut self, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - p: core::ffi::c_double, - type_: core::ffi::c_int, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_ordered_triangulator_insert_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - x: core::ffi::c_double, - p: core::ffi::c_double, - type_: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_ordered_triangulator_insert_point(self.0, id, x, p, type_) } - } - fn insert_point( - &mut self, - id: core::ffi::c_uchar, - sortid: core::ffi::c_uchar, - x: core::ffi::c_double, - p: core::ffi::c_double, - type_: core::ffi::c_int, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_ordered_triangulator_insert_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - sortid: core::ffi::c_uchar, - x: core::ffi::c_double, - p: core::ffi::c_double, - type_: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_ordered_triangulator_insert_point(self.0, id, sortid, x, p, type_) } - } - fn insert_point( - &mut self, - id: core::ffi::c_uchar, - sortid: core::ffi::c_uchar, - sortid2: core::ffi::c_uchar, - x: core::ffi::c_double, - p: core::ffi::c_double, - type_: core::ffi::c_int, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_ordered_triangulator_insert_point( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - sortid: core::ffi::c_uchar, - sortid2: core::ffi::c_uchar, - x: core::ffi::c_double, - p: core::ffi::c_double, - type_: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_ordered_triangulator_insert_point( - self.0, - id, - sortid, - sortid2, - x, - p, - type_, - ) - } - } fn triangulate(&mut self) -> () { unsafe extern "C" { fn vtk_ordered_triangulator_triangulate(sself: *mut core::ffi::c_void); @@ -45946,48 +24756,27 @@ impl VtkOrderedTriangulator for vtkOrderedTriangulator { } fn update_point_type( &mut self, - internalId: core::ffi::c_uchar, + internalId: core::ffi::c_longlong, type_: core::ffi::c_int, ) -> () { unsafe extern "C" { fn vtk_ordered_triangulator_update_point_type( sself: *mut core::ffi::c_void, - internalId: core::ffi::c_uchar, + internalId: core::ffi::c_longlong, type_: core::ffi::c_int, ); } unsafe { vtk_ordered_triangulator_update_point_type(self.0, internalId, type_) } } - fn get_point_position( - &mut self, - internalId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_ordered_triangulator_get_point_position( - sself: *mut core::ffi::c_void, - internalId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_ordered_triangulator_get_point_position(self.0, internalId) } - } - fn get_point_location( + fn get_point_id( &mut self, - internalId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_ordered_triangulator_get_point_location( - sself: *mut core::ffi::c_void, - internalId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_ordered_triangulator_get_point_location(self.0, internalId) } - } - fn get_point_id(&mut self, internalId: core::ffi::c_uchar) -> core::ffi::c_uchar { + internalId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_ordered_triangulator_get_point_id( sself: *mut core::ffi::c_void, - internalId: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + internalId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_ordered_triangulator_get_point_id(self.0, internalId) } } @@ -46094,13 +24883,13 @@ impl VtkOrderedTriangulator for vtkOrderedTriangulator { &mut self, classification: core::ffi::c_int, ugrid: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_ordered_triangulator_get_tetras( sself: *mut core::ffi::c_void, classification: core::ffi::c_int, ugrid: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_ordered_triangulator_get_tetras(self.0, classification, ugrid) } } @@ -46108,114 +24897,28 @@ impl VtkOrderedTriangulator for vtkOrderedTriangulator { &mut self, classification: core::ffi::c_int, ugrid: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_ordered_triangulator_add_tetras( sself: *mut core::ffi::c_void, classification: core::ffi::c_int, ugrid: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_ordered_triangulator_add_tetras(self.0, classification, ugrid) } } - fn add_tetras( - &mut self, - classification: core::ffi::c_int, - connectivity: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_ordered_triangulator_add_tetras( - sself: *mut core::ffi::c_void, - classification: core::ffi::c_int, - connectivity: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_ordered_triangulator_add_tetras(self.0, classification, connectivity) - } - } - fn add_tetras( - &mut self, - classification: core::ffi::c_int, - locator: *mut core::ffi::c_void, - outConnectivity: *mut core::ffi::c_void, - inPD: *mut core::ffi::c_void, - outPD: *mut core::ffi::c_void, - inCD: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - outCD: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_ordered_triangulator_add_tetras( - sself: *mut core::ffi::c_void, - classification: core::ffi::c_int, - locator: *mut core::ffi::c_void, - outConnectivity: *mut core::ffi::c_void, - inPD: *mut core::ffi::c_void, - outPD: *mut core::ffi::c_void, - inCD: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - outCD: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_ordered_triangulator_add_tetras( - self.0, - classification, - locator, - outConnectivity, - inPD, - outPD, - inCD, - cellId, - outCD, - ) - } - } - fn add_tetras( - &mut self, - classification: core::ffi::c_int, - ptIds: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_ordered_triangulator_add_tetras( - sself: *mut core::ffi::c_void, - classification: core::ffi::c_int, - ptIds: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_ordered_triangulator_add_tetras(self.0, classification, ptIds, pts) - } - } fn add_triangles( &mut self, connectivity: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_ordered_triangulator_add_triangles( sself: *mut core::ffi::c_void, connectivity: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_ordered_triangulator_add_triangles(self.0, connectivity) } } - fn add_triangles( - &mut self, - id: core::ffi::c_uchar, - connectivity: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_ordered_triangulator_add_triangles( - sself: *mut core::ffi::c_void, - id: core::ffi::c_uchar, - connectivity: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_ordered_triangulator_add_triangles(self.0, id, connectivity) } - } fn init_tetra_traversal(&mut self) -> () { unsafe extern "C" { fn vtk_ordered_triangulator_init_tetra_traversal( @@ -46277,12 +24980,12 @@ impl VtkOutEdgeIterator for vtkOutEdgeIterator { } unsafe { vtk_out_edge_iterator_new_instance(self.0) } } - fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_uchar) -> () { + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_out_edge_iterator_initialize( sself: *mut core::ffi::c_void, g: *mut core::ffi::c_void, - v: core::ffi::c_uchar, + v: core::ffi::c_longlong, ); } unsafe { vtk_out_edge_iterator_initialize(self.0, g, v) } @@ -46295,22 +24998,14 @@ impl VtkOutEdgeIterator for vtkOutEdgeIterator { } unsafe { vtk_out_edge_iterator_get_graph(self.0) } } - fn get_vertex(&mut self) -> core::ffi::c_uchar { + fn get_vertex(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_out_edge_iterator_get_vertex( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_out_edge_iterator_get_vertex(self.0) } } - fn next(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_out_edge_iterator_next( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_out_edge_iterator_next(self.0) } - } fn next_graph_edge(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_out_edge_iterator_next_graph_edge( @@ -46352,113 +25047,6 @@ impl VtkOverlappingAMR for vtkOverlappingAMR { } unsafe { vtk_overlapping_amr_new_instance(self.0) } } - fn set_origin(&mut self, origin: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_overlapping_amr_set_origin( - sself: *mut core::ffi::c_void, - origin: core::ffi::c_double, - ); - } - unsafe { vtk_overlapping_amr_set_origin(self.0, origin) } - } - fn get_origin(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_overlapping_amr_get_origin( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_overlapping_amr_get_origin(self.0) } - } - fn set_spacing( - &mut self, - level: core::ffi::c_uint, - spacing: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_overlapping_amr_set_spacing( - sself: *mut core::ffi::c_void, - level: core::ffi::c_uint, - spacing: core::ffi::c_double, - ); - } - unsafe { vtk_overlapping_amr_set_spacing(self.0, level, spacing) } - } - fn get_spacing( - &mut self, - level: core::ffi::c_uint, - spacing: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_overlapping_amr_get_spacing( - sself: *mut core::ffi::c_void, - level: core::ffi::c_uint, - spacing: core::ffi::c_double, - ); - } - unsafe { vtk_overlapping_amr_get_spacing(self.0, level, spacing) } - } - fn set_amr_box( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - box_: vtkAMRBox, - ) -> () { - unsafe extern "C" { - fn vtk_overlapping_amr_set_amr_box( - sself: *mut core::ffi::c_void, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - box_: vtkAMRBox, - ); - } - unsafe { vtk_overlapping_amr_set_amr_box(self.0, level, id, box_) } - } - fn get_amr_box( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - ) -> vtkAMRBox { - unsafe extern "C" { - fn vtk_overlapping_amr_get_amr_box( - sself: *mut core::ffi::c_void, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - ) -> vtkAMRBox; - } - unsafe { vtk_overlapping_amr_get_amr_box(self.0, level, id) } - } - fn get_bounds( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - bb: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_overlapping_amr_get_bounds( - sself: *mut core::ffi::c_void, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - bb: core::ffi::c_double, - ); - } - unsafe { vtk_overlapping_amr_get_bounds(self.0, level, id, bb) } - } - fn get_origin( - &mut self, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - origin: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_overlapping_amr_get_origin( - sself: *mut core::ffi::c_void, - level: core::ffi::c_uint, - id: core::ffi::c_uint, - origin: core::ffi::c_double, - ); - } - unsafe { vtk_overlapping_amr_get_origin(self.0, level, id, origin) } - } fn number_of_blanked_points(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_overlapping_amr_number_of_blanked_points( @@ -46476,20 +25064,6 @@ impl VtkOverlappingAMR for vtkOverlappingAMR { } unsafe { vtk_overlapping_amr_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_overlapping_amr_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_overlapping_amr_get_data(self.0, v, i) } - } fn set_refinement_ratio( &mut self, level: core::ffi::c_uint, @@ -46545,18 +25119,6 @@ impl VtkOverlappingAMR for vtkOverlappingAMR { } unsafe { vtk_overlapping_amr_get_amr_block_source_index(self.0, level, id) } } - fn get_refinement_ratio( - &mut self, - iter: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_overlapping_amr_get_refinement_ratio( - sself: *mut core::ffi::c_void, - iter: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_overlapping_amr_get_refinement_ratio(self.0, iter) } - } fn has_children_information(&mut self) -> bool { unsafe extern "C" { fn vtk_overlapping_amr_has_children_information( @@ -46573,38 +25135,6 @@ impl VtkOverlappingAMR for vtkOverlappingAMR { } unsafe { vtk_overlapping_amr_generate_parent_child_information(self.0) } } - fn get_parents( - &mut self, - level: core::ffi::c_uint, - index: core::ffi::c_uint, - numParents: core::ffi::c_uint, - ) -> *mut core::ffi::c_uint { - unsafe extern "C" { - fn vtk_overlapping_amr_get_parents( - sself: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uint, - numParents: core::ffi::c_uint, - ) -> *mut core::ffi::c_uint; - } - unsafe { vtk_overlapping_amr_get_parents(self.0, level, index, numParents) } - } - fn get_children( - &mut self, - level: core::ffi::c_uint, - index: core::ffi::c_uint, - numChildren: core::ffi::c_uint, - ) -> *mut core::ffi::c_uint { - unsafe extern "C" { - fn vtk_overlapping_amr_get_children( - sself: *mut core::ffi::c_void, - level: core::ffi::c_uint, - index: core::ffi::c_uint, - numChildren: core::ffi::c_uint, - ) -> *mut core::ffi::c_uint; - } - unsafe { vtk_overlapping_amr_get_children(self.0, level, index, numChildren) } - } fn print_parent_child_info( &mut self, level: core::ffi::c_uint, @@ -46619,31 +25149,6 @@ impl VtkOverlappingAMR for vtkOverlappingAMR { } unsafe { vtk_overlapping_amr_print_parent_child_info(self.0, level, index) } } - fn get_bounds(&mut self, b: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_overlapping_amr_get_bounds( - sself: *mut core::ffi::c_void, - b: core::ffi::c_double, - ); - } - unsafe { vtk_overlapping_amr_get_bounds(self.0, b) } - } - fn find_grid( - &mut self, - q: core::ffi::c_double, - level: core::ffi::c_uint, - gridId: core::ffi::c_uint, - ) -> bool { - unsafe extern "C" { - fn vtk_overlapping_amr_find_grid( - sself: *mut core::ffi::c_void, - q: core::ffi::c_double, - level: core::ffi::c_uint, - gridId: core::ffi::c_uint, - ) -> bool; - } - unsafe { vtk_overlapping_amr_find_grid(self.0, q, level, gridId) } - } fn get_amr_info(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_overlapping_amr_get_amr_info( @@ -46775,59 +25280,27 @@ impl VtkPartitionedDataSet for vtkPartitionedDataSet { } unsafe { vtk_partitioned_data_set_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { + fn remove_null_partitions(&mut self) -> () { unsafe extern "C" { - fn vtk_partitioned_data_set_get_data( + fn vtk_partitioned_data_set_remove_null_partitions( sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; + ); } - unsafe { vtk_partitioned_data_set_get_data(self.0, v, i) } + unsafe { vtk_partitioned_data_set_remove_null_partitions(self.0) } } - fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void { +} +impl VtkPartitionedDataSetCollection for vtkPartitionedDataSetCollection { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_partitioned_data_set_get_meta_data( + fn vtk_partitioned_data_set_collection_new( sself: *mut core::ffi::c_void, - iter: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_partitioned_data_set_get_meta_data(self.0, iter) } + unsafe { vtk_partitioned_data_set_collection_new(self.0) } } - fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_partitioned_data_set_has_meta_data( - sself: *mut core::ffi::c_void, - iter: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_partitioned_data_set_has_meta_data(self.0, iter) } - } - fn remove_null_partitions(&mut self) -> () { - unsafe extern "C" { - fn vtk_partitioned_data_set_remove_null_partitions( - sself: *mut core::ffi::c_void, - ); - } - unsafe { vtk_partitioned_data_set_remove_null_partitions(self.0) } - } -} -impl VtkPartitionedDataSetCollection for vtkPartitionedDataSetCollection { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_partitioned_data_set_collection_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_partitioned_data_set_collection_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_partitioned_data_set_collection_safe_down_cast( + fn vtk_partitioned_data_set_collection_safe_down_cast( sself: *mut core::ffi::c_void, o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; @@ -47052,26 +25525,6 @@ impl VtkPartitionedDataSetCollection for vtkPartitionedDataSetCollection { } unsafe { vtk_partitioned_data_set_collection_get_composite_index(self.0, idx) } } - fn get_composite_index( - &mut self, - idx: core::ffi::c_uint, - partition: core::ffi::c_uint, - ) -> core::ffi::c_uint { - unsafe extern "C" { - fn vtk_partitioned_data_set_collection_get_composite_index( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uint, - partition: core::ffi::c_uint, - ) -> core::ffi::c_uint; - } - unsafe { - vtk_partitioned_data_set_collection_get_composite_index( - self.0, - idx, - partition, - ) - } - } fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_partitioned_data_set_collection_get_data( @@ -47081,38 +25534,6 @@ impl VtkPartitionedDataSetCollection for vtkPartitionedDataSetCollection { } unsafe { vtk_partitioned_data_set_collection_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_partitioned_data_set_collection_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_partitioned_data_set_collection_get_data(self.0, v, i) } - } - fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_partitioned_data_set_collection_get_meta_data( - sself: *mut core::ffi::c_void, - iter: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_partitioned_data_set_collection_get_meta_data(self.0, iter) } - } - fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_partitioned_data_set_collection_has_meta_data( - sself: *mut core::ffi::c_void, - iter: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_partitioned_data_set_collection_has_meta_data(self.0, iter) } - } fn get_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_partitioned_data_set_collection_get_m_time( @@ -47163,34 +25584,6 @@ impl VtkPath for vtkPath { } unsafe { vtk_path_get_data_object_type(self.0) } } - fn insert_next_point( - &mut self, - pts: core::ffi::c_float, - code: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_path_insert_next_point( - sself: *mut core::ffi::c_void, - pts: core::ffi::c_float, - code: core::ffi::c_int, - ); - } - unsafe { vtk_path_insert_next_point(self.0, pts, code) } - } - fn insert_next_point( - &mut self, - pts: core::ffi::c_double, - code: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_path_insert_next_point( - sself: *mut core::ffi::c_void, - pts: core::ffi::c_double, - code: core::ffi::c_int, - ); - } - unsafe { vtk_path_insert_next_point(self.0, pts, code) } - } fn insert_next_point( &mut self, x: core::ffi::c_double, @@ -47226,19 +25619,19 @@ impl VtkPath for vtkPath { } unsafe { vtk_path_get_codes(self.0) } } - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_path_get_number_of_cells( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_path_get_number_of_cells(self.0) } } - fn get_cell(&mut self, p0: core::ffi::c_uchar, p1: *mut core::ffi::c_void) -> () { + fn get_cell(&mut self, p0: core::ffi::c_longlong, p1: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_path_get_cell( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, p1: *mut core::ffi::c_void, ); } @@ -47246,13 +25639,13 @@ impl VtkPath for vtkPath { } fn get_cell_points( &mut self, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_path_get_cell_points( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ); } @@ -47260,13 +25653,13 @@ impl VtkPath for vtkPath { } fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_path_get_point_cells( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ); } @@ -47280,11 +25673,15 @@ impl VtkPath for vtkPath { } unsafe { vtk_path_get_max_cell_size(self.0) } } - fn allocate(&mut self, size: core::ffi::c_uchar, extSize: core::ffi::c_int) -> () { + fn allocate( + &mut self, + size: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ) -> () { unsafe extern "C" { fn vtk_path_allocate( sself: *mut core::ffi::c_void, - size: core::ffi::c_uchar, + size: core::ffi::c_longlong, extSize: core::ffi::c_int, ); } @@ -47305,20 +25702,6 @@ impl VtkPath for vtkPath { } unsafe { vtk_path_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_path_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_path_get_data(self.0, v, i) } - } } impl VtkPentagonalPrism for vtkPentagonalPrism { fn new(&mut self) -> *mut core::ffi::c_void { @@ -47346,149 +25729,6 @@ impl VtkPentagonalPrism for vtkPentagonalPrism { } unsafe { vtk_pentagonal_prism_new_instance(self.0) } } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_pentagonal_prism_get_edge_points(self.0, edgeId, pts) } - } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_pentagonal_prism_get_edge_points(self.0, edgeId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_pentagonal_prism_get_face_points(self.0, faceId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_pentagonal_prism_get_face_points(self.0, faceId, pts) } - } - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_edge_to_adjacent_faces( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_pentagonal_prism_get_edge_to_adjacent_faces(self.0, edgeId, pts) } - } - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_face_to_adjacent_faces( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_pentagonal_prism_get_face_to_adjacent_faces(self.0, faceId, faceIds) - } - } - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_point_to_incident_edges( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_pentagonal_prism_get_point_to_incident_edges(self.0, pointId, edgeIds) - } - } - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_point_to_incident_faces( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_pentagonal_prism_get_point_to_incident_faces(self.0, pointId, faceIds) - } - } - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_point_to_one_ring_points( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_pentagonal_prism_get_point_to_one_ring_points(self.0, pointId, pts) - } - } - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_centroid( - sself: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_pentagonal_prism_get_centroid(self.0, centroid) } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_pentagonal_prism_get_cell_type( @@ -47531,109 +25771,6 @@ impl VtkPentagonalPrism for vtkPentagonalPrism { } unsafe { vtk_pentagonal_prism_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pentagonal_prism_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_pentagonal_prism_cell_boundary(self.0, subId, pcoords, pts) } - } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pentagonal_prism_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_pentagonal_prism_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_pentagonal_prism_evaluate_location(self.0, subId, pcoords, x, weights) - } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pentagonal_prism_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_pentagonal_prism_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -47650,222 +25787,6 @@ impl VtkPentagonalPrism for vtkPentagonalPrism { } unsafe { vtk_pentagonal_prism_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_pentagonal_prism_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_pentagonal_prism_get_parametric_center(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_pentagonal_prism_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_pentagonal_prism_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_pentagonal_prism_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_pentagonal_prism_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pentagonal_prism_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pentagonal_prism_get_face_array(self.0, faceId) } - } - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_edge_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pentagonal_prism_get_edge_to_adjacent_faces_array(self.0, edgeId) } - } - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_face_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pentagonal_prism_get_face_to_adjacent_faces_array(self.0, faceId) } - } - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_point_to_incident_edges_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { - vtk_pentagonal_prism_get_point_to_incident_edges_array(self.0, pointId) - } - } - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_point_to_incident_faces_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { - vtk_pentagonal_prism_get_point_to_incident_faces_array(self.0, pointId) - } - } - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pentagonal_prism_get_point_to_one_ring_points_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { - vtk_pentagonal_prism_get_point_to_one_ring_points_array(self.0, pointId) - } - } - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_pentagonal_prism_compute_centroid( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { - vtk_pentagonal_prism_compute_centroid(self.0, points, pointIds, centroid) - } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pentagonal_prism_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_pentagonal_prism_jacobian_inverse(self.0, pcoords, inverse, derivs) - } - } } impl VtkPerlinNoise for vtkPerlinNoise { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -47893,29 +25814,6 @@ impl VtkPerlinNoise for vtkPerlinNoise { } unsafe { vtk_perlin_noise_new(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_perlin_noise_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_perlin_noise_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_perlin_noise_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_perlin_noise_evaluate_gradient(self.0, x, n) } - } fn set_frequency( &mut self, _arg1: core::ffi::c_double, @@ -47932,32 +25830,6 @@ impl VtkPerlinNoise for vtkPerlinNoise { } unsafe { vtk_perlin_noise_set_frequency(self.0, _arg1, _arg2, _arg3) } } - fn set_frequency(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_perlin_noise_set_frequency( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_perlin_noise_set_frequency(self.0, _arg) } - } - fn get_frequency(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_perlin_noise_get_frequency( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_perlin_noise_get_frequency(self.0) } - } - fn get_frequency(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_perlin_noise_get_frequency( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_perlin_noise_get_frequency(self.0, data) } - } fn set_phase( &mut self, _arg1: core::ffi::c_double, @@ -47974,32 +25846,6 @@ impl VtkPerlinNoise for vtkPerlinNoise { } unsafe { vtk_perlin_noise_set_phase(self.0, _arg1, _arg2, _arg3) } } - fn set_phase(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_perlin_noise_set_phase( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_perlin_noise_set_phase(self.0, _arg) } - } - fn get_phase(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_perlin_noise_get_phase( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_perlin_noise_get_phase(self.0) } - } - fn get_phase(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_perlin_noise_get_phase( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_perlin_noise_get_phase(self.0, data) } - } fn set_amplitude(&mut self, _arg: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_perlin_noise_set_amplitude( @@ -48092,24 +25938,6 @@ impl VtkPiecewiseFunction for vtkPiecewiseFunction { } unsafe { vtk_piecewise_function_add_point(self.0, x, y) } } - fn add_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - midpoint: core::ffi::c_double, - sharpness: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_piecewise_function_add_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - midpoint: core::ffi::c_double, - sharpness: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_piecewise_function_add_point(self.0, x, y, midpoint, sharpness) } - } fn remove_point_by_index(&mut self, id: usize) -> bool { unsafe extern "C" { fn vtk_piecewise_function_remove_point_by_index( @@ -48128,20 +25956,6 @@ impl VtkPiecewiseFunction for vtkPiecewiseFunction { } unsafe { vtk_piecewise_function_remove_point(self.0, x) } } - fn remove_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_piecewise_function_remove_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_piecewise_function_remove_point(self.0, x, y) } - } fn remove_all_points(&mut self) -> () { unsafe extern "C" { fn vtk_piecewise_function_remove_all_points(sself: *mut core::ffi::c_void); @@ -48175,260 +25989,81 @@ impl VtkPiecewiseFunction for vtkPiecewiseFunction { } unsafe { vtk_piecewise_function_get_value(self.0, x) } } - fn get_node_value( - &mut self, - index: core::ffi::c_int, - val: core::ffi::c_double, - ) -> core::ffi::c_int { + fn set_clamping(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_piecewise_function_get_node_value( + fn vtk_piecewise_function_set_clamping( sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - val: core::ffi::c_double, - ) -> core::ffi::c_int; + _arg: core::ffi::c_int, + ); } - unsafe { vtk_piecewise_function_get_node_value(self.0, index, val) } + unsafe { vtk_piecewise_function_set_clamping(self.0, _arg) } } - fn set_node_value( - &mut self, - index: core::ffi::c_int, - val: core::ffi::c_double, - ) -> core::ffi::c_int { + fn get_clamping(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_piecewise_function_set_node_value( + fn vtk_piecewise_function_get_clamping( sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - val: core::ffi::c_double, ) -> core::ffi::c_int; } - unsafe { vtk_piecewise_function_set_node_value(self.0, index, val) } + unsafe { vtk_piecewise_function_get_clamping(self.0) } } - fn get_data_pointer(&mut self) -> *mut core::ffi::c_double { + fn clamping_on(&mut self) -> () { unsafe extern "C" { - fn vtk_piecewise_function_get_data_pointer( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + fn vtk_piecewise_function_clamping_on(sself: *mut core::ffi::c_void); } - unsafe { vtk_piecewise_function_get_data_pointer(self.0) } + unsafe { vtk_piecewise_function_clamping_on(self.0) } } - fn fill_from_data_pointer( - &mut self, - p0: core::ffi::c_int, - p1: core::ffi::c_double, - ) -> () { + fn clamping_off(&mut self) -> () { unsafe extern "C" { - fn vtk_piecewise_function_fill_from_data_pointer( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: core::ffi::c_double, - ); + fn vtk_piecewise_function_clamping_off(sself: *mut core::ffi::c_void); } - unsafe { vtk_piecewise_function_fill_from_data_pointer(self.0, p0, p1) } + unsafe { vtk_piecewise_function_clamping_off(self.0) } } - fn get_range(&mut self) -> *mut core::ffi::c_double { + fn set_use_log_scale(&mut self, _arg: bool) -> () { unsafe extern "C" { - fn vtk_piecewise_function_get_range( + fn vtk_piecewise_function_set_use_log_scale( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + _arg: bool, + ); } - unsafe { vtk_piecewise_function_get_range(self.0) } + unsafe { vtk_piecewise_function_set_use_log_scale(self.0, _arg) } } - fn get_range( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ) -> () { + fn get_use_log_scale(&mut self) -> bool { unsafe extern "C" { - fn vtk_piecewise_function_get_range( + fn vtk_piecewise_function_get_use_log_scale( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - ); + ) -> bool; } - unsafe { vtk_piecewise_function_get_range(self.0, _arg1, _arg2) } + unsafe { vtk_piecewise_function_get_use_log_scale(self.0) } } - fn get_range(&mut self, _arg: core::ffi::c_double) -> () { + fn use_log_scale_on(&mut self) -> () { unsafe extern "C" { - fn vtk_piecewise_function_get_range( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); + fn vtk_piecewise_function_use_log_scale_on(sself: *mut core::ffi::c_void); } - unsafe { vtk_piecewise_function_get_range(self.0, _arg) } + unsafe { vtk_piecewise_function_use_log_scale_on(self.0) } } - fn adjust_range(&mut self, range: core::ffi::c_double) -> core::ffi::c_int { + fn use_log_scale_off(&mut self) -> () { unsafe extern "C" { - fn vtk_piecewise_function_adjust_range( - sself: *mut core::ffi::c_void, - range: core::ffi::c_double, - ) -> core::ffi::c_int; + fn vtk_piecewise_function_use_log_scale_off(sself: *mut core::ffi::c_void); } - unsafe { vtk_piecewise_function_adjust_range(self.0, range) } + unsafe { vtk_piecewise_function_use_log_scale_off(self.0) } } - fn get_table( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - size: core::ffi::c_int, - table: core::ffi::c_float, - stride: core::ffi::c_int, - logIncrements: core::ffi::c_int, - ) -> () { + fn get_type(&mut self) -> &str { unsafe extern "C" { - fn vtk_piecewise_function_get_table( + fn vtk_piecewise_function_get_type( sself: *mut core::ffi::c_void, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - size: core::ffi::c_int, - table: core::ffi::c_float, - stride: core::ffi::c_int, - logIncrements: core::ffi::c_int, - ); + ) -> *const core::ffi::c_char; } - unsafe { - vtk_piecewise_function_get_table( - self.0, - x1, - x2, - size, - table, - stride, - logIncrements, - ) + let ptr = unsafe { vtk_piecewise_function_get_type(self.0) }; + if ptr.is_null() { + return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn get_table( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - size: core::ffi::c_int, - table: core::ffi::c_double, - stride: core::ffi::c_int, - logIncrements: core::ffi::c_int, - ) -> () { + fn get_first_non_zero_value(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_piecewise_function_get_table( + fn vtk_piecewise_function_get_first_non_zero_value( sself: *mut core::ffi::c_void, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - size: core::ffi::c_int, - table: core::ffi::c_double, - stride: core::ffi::c_int, - logIncrements: core::ffi::c_int, - ); - } - unsafe { - vtk_piecewise_function_get_table( - self.0, - x1, - x2, - size, - table, - stride, - logIncrements, - ) - } - } - fn build_function_from_table( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - size: core::ffi::c_int, - table: core::ffi::c_double, - stride: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_piecewise_function_build_function_from_table( - sself: *mut core::ffi::c_void, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - size: core::ffi::c_int, - table: core::ffi::c_double, - stride: core::ffi::c_int, - ); - } - unsafe { - vtk_piecewise_function_build_function_from_table( - self.0, - x1, - x2, - size, - table, - stride, - ) - } - } - fn set_clamping(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_piecewise_function_set_clamping( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_piecewise_function_set_clamping(self.0, _arg) } - } - fn get_clamping(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_piecewise_function_get_clamping( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_piecewise_function_get_clamping(self.0) } - } - fn clamping_on(&mut self) -> () { - unsafe extern "C" { - fn vtk_piecewise_function_clamping_on(sself: *mut core::ffi::c_void); - } - unsafe { vtk_piecewise_function_clamping_on(self.0) } - } - fn clamping_off(&mut self) -> () { - unsafe extern "C" { - fn vtk_piecewise_function_clamping_off(sself: *mut core::ffi::c_void); - } - unsafe { vtk_piecewise_function_clamping_off(self.0) } - } - fn set_use_log_scale(&mut self, _arg: bool) -> () { - unsafe extern "C" { - fn vtk_piecewise_function_set_use_log_scale( - sself: *mut core::ffi::c_void, - _arg: bool, - ); - } - unsafe { vtk_piecewise_function_set_use_log_scale(self.0, _arg) } - } - fn get_use_log_scale(&mut self) -> bool { - unsafe extern "C" { - fn vtk_piecewise_function_get_use_log_scale( - sself: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_piecewise_function_get_use_log_scale(self.0) } - } - fn use_log_scale_on(&mut self) -> () { - unsafe extern "C" { - fn vtk_piecewise_function_use_log_scale_on(sself: *mut core::ffi::c_void); - } - unsafe { vtk_piecewise_function_use_log_scale_on(self.0) } - } - fn use_log_scale_off(&mut self) -> () { - unsafe extern "C" { - fn vtk_piecewise_function_use_log_scale_off(sself: *mut core::ffi::c_void); - } - unsafe { vtk_piecewise_function_use_log_scale_off(self.0) } - } - fn get_type(&mut self) -> *const core::ffi::c_char { - unsafe extern "C" { - fn vtk_piecewise_function_get_type( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - unsafe { vtk_piecewise_function_get_type(self.0) } - } - fn get_first_non_zero_value(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_piecewise_function_get_first_non_zero_value( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; + ) -> core::ffi::c_double; } unsafe { vtk_piecewise_function_get_first_non_zero_value(self.0) } } @@ -48447,20 +26082,6 @@ impl VtkPiecewiseFunction for vtkPiecewiseFunction { } unsafe { vtk_piecewise_function_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_piecewise_function_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_piecewise_function_get_data(self.0, v, i) } - } fn set_allow_duplicate_scalars(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_piecewise_function_set_allow_duplicate_scalars( @@ -48496,14 +26117,14 @@ impl VtkPiecewiseFunction for vtkPiecewiseFunction { } fn estimate_min_number_of_samples( &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, + x1: &core::ffi::c_double, + x2: &core::ffi::c_double, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_piecewise_function_estimate_min_number_of_samples( sself: *mut core::ffi::c_void, - x1: core::ffi::c_double, - x2: core::ffi::c_double, + x1: &core::ffi::c_double, + x2: &core::ffi::c_double, ) -> core::ffi::c_int; } unsafe { vtk_piecewise_function_estimate_min_number_of_samples(self.0, x1, x2) } @@ -48583,22 +26204,6 @@ impl VtkPixel for vtkPixel { } unsafe { vtk_pixel_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pixel_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_pixel_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -48610,7 +26215,7 @@ impl VtkPixel for vtkPixel { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -48625,7 +26230,7 @@ impl VtkPixel for vtkPixel { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -48655,7 +26260,7 @@ impl VtkPixel for vtkPixel { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -48669,7 +26274,7 @@ impl VtkPixel for vtkPixel { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -48690,56 +26295,6 @@ impl VtkPixel for vtkPixel { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pixel_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_pixel_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pixel_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_pixel_evaluate_location(self.0, subId, pcoords, x, weights) } - } fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int { unsafe extern "C" { fn vtk_pixel_inflate( @@ -48749,56 +26304,6 @@ impl VtkPixel for vtkPixel { } unsafe { vtk_pixel_inflate(self.0, dist) } } - fn compute_bounding_sphere( - &mut self, - center: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_pixel_compute_bounding_sphere( - sself: *mut core::ffi::c_void, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_pixel_compute_bounding_sphere(self.0, center) } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pixel_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_pixel_get_parametric_center(self.0, pcoords) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pixel_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_pixel_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -48815,91 +26320,6 @@ impl VtkPixel for vtkPixel { } unsafe { vtk_pixel_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pixel_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_pixel_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pixel_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_pixel_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pixel_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_pixel_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pixel_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_pixel_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pixel_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_pixel_interpolate_derivs(self.0, pcoords, derivs) } - } - fn compute_normal(&mut self, n: core::ffi::c_double) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pixel_compute_normal( - sself: *mut core::ffi::c_void, - n: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_pixel_compute_normal(self.0, n) } - } } impl VtkPlane for vtkPlane { fn new(&mut self) -> *mut core::ffi::c_void { @@ -48925,29 +26345,6 @@ impl VtkPlane for vtkPlane { } unsafe { vtk_plane_new_instance(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_plane_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_plane_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_plane_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - g: core::ffi::c_double, - ); - } - unsafe { vtk_plane_evaluate_gradient(self.0, x, g) } - } fn set_normal( &mut self, _arg1: core::ffi::c_double, @@ -48964,32 +26361,6 @@ impl VtkPlane for vtkPlane { } unsafe { vtk_plane_set_normal(self.0, _arg1, _arg2, _arg3) } } - fn set_normal(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_plane_set_normal( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_plane_set_normal(self.0, _arg) } - } - fn get_normal(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_plane_get_normal( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_plane_get_normal(self.0) } - } - fn get_normal(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_plane_get_normal( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_plane_get_normal(self.0, data) } - } fn set_origin( &mut self, _arg1: core::ffi::c_double, @@ -49006,32 +26377,6 @@ impl VtkPlane for vtkPlane { } unsafe { vtk_plane_set_origin(self.0, _arg1, _arg2, _arg3) } } - fn set_origin(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_plane_set_origin( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_plane_set_origin(self.0, _arg) } - } - fn get_origin(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_plane_get_origin( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_plane_get_origin(self.0) } - } - fn get_origin(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_plane_get_origin( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_plane_get_origin(self.0, data) } - } fn push(&mut self, distance: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_plane_push( @@ -49041,245 +26386,6 @@ impl VtkPlane for vtkPlane { } unsafe { vtk_plane_push(self.0, distance) } } - fn project_point( - &mut self, - x: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - xproj: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_plane_project_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - xproj: core::ffi::c_double, - ); - } - unsafe { vtk_plane_project_point(self.0, x, origin, normal, xproj) } - } - fn project_point( - &mut self, - x: core::ffi::c_double, - xproj: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_plane_project_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - xproj: core::ffi::c_double, - ); - } - unsafe { vtk_plane_project_point(self.0, x, xproj) } - } - fn project_vector( - &mut self, - v: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - vproj: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_plane_project_vector( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - vproj: core::ffi::c_double, - ); - } - unsafe { vtk_plane_project_vector(self.0, v, origin, normal, vproj) } - } - fn project_vector( - &mut self, - v: core::ffi::c_double, - vproj: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_plane_project_vector( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - vproj: core::ffi::c_double, - ); - } - unsafe { vtk_plane_project_vector(self.0, v, vproj) } - } - fn generalized_project_point( - &mut self, - x: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - xproj: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_plane_generalized_project_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - xproj: core::ffi::c_double, - ); - } - unsafe { vtk_plane_generalized_project_point(self.0, x, origin, normal, xproj) } - } - fn generalized_project_point( - &mut self, - x: core::ffi::c_double, - xproj: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_plane_generalized_project_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - xproj: core::ffi::c_double, - ); - } - unsafe { vtk_plane_generalized_project_point(self.0, x, xproj) } - } - fn evaluate( - &mut self, - normal: core::ffi::c_double, - origin: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_plane_evaluate( - sself: *mut core::ffi::c_void, - normal: core::ffi::c_double, - origin: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_plane_evaluate(self.0, normal, origin, x) } - } - fn distance_to_plane( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - p0: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_plane_distance_to_plane( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_double, - p0: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_plane_distance_to_plane(self.0, x, n, p0) } - } - fn distance_to_plane(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_plane_distance_to_plane( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_plane_distance_to_plane(self.0, x) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - n: core::ffi::c_double, - p0: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_plane_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - n: core::ffi::c_double, - p0: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_plane_intersect_with_line(self.0, p1, p2, n, p0, t, x) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_plane_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_plane_intersect_with_line(self.0, p1, p2, t, x) } - } - fn intersect_with_finite_plane( - &mut self, - n: core::ffi::c_double, - o: core::ffi::c_double, - pOrigin: core::ffi::c_double, - px: core::ffi::c_double, - py: core::ffi::c_double, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_plane_intersect_with_finite_plane( - sself: *mut core::ffi::c_void, - n: core::ffi::c_double, - o: core::ffi::c_double, - pOrigin: core::ffi::c_double, - px: core::ffi::c_double, - py: core::ffi::c_double, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_plane_intersect_with_finite_plane(self.0, n, o, pOrigin, px, py, x0, x1) - } - } - fn intersect_with_finite_plane( - &mut self, - pOrigin: core::ffi::c_double, - px: core::ffi::c_double, - py: core::ffi::c_double, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_plane_intersect_with_finite_plane( - sself: *mut core::ffi::c_void, - pOrigin: core::ffi::c_double, - px: core::ffi::c_double, - py: core::ffi::c_double, - x0: core::ffi::c_double, - x1: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_plane_intersect_with_finite_plane(self.0, pOrigin, px, py, x0, x1) } - } - fn compute_best_fitting_plane( - &mut self, - pts: *mut core::ffi::c_void, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_plane_compute_best_fitting_plane( - sself: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_plane_compute_best_fitting_plane(self.0, pts, origin, normal) } - } } impl VtkPlaneCollection for vtkPlaneCollection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -49333,15 +26439,6 @@ impl VtkPlaneCollection for vtkPlaneCollection { } unsafe { vtk_plane_collection_get_item(self.0, i) } } - fn get_next_plane(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_plane_collection_get_next_plane( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_plane_collection_get_next_plane(self.0, cookie) } - } fn get_number_of_items(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_plane_collection_get_number_of_items( @@ -49375,29 +26472,6 @@ impl VtkPlanes for vtkPlanes { } unsafe { vtk_planes_new_instance(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_planes_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_planes_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_planes_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_planes_evaluate_gradient(self.0, x, n) } - } fn set_points(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_planes_set_points( @@ -49432,24 +26506,6 @@ impl VtkPlanes for vtkPlanes { } unsafe { vtk_planes_get_normals(self.0) } } - fn set_frustum_planes(&mut self, planes: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_planes_set_frustum_planes( - sself: *mut core::ffi::c_void, - planes: core::ffi::c_double, - ); - } - unsafe { vtk_planes_set_frustum_planes(self.0, planes) } - } - fn set_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_planes_set_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_planes_set_bounds(self.0, bounds) } - } fn set_bounds( &mut self, xmin: core::ffi::c_double, @@ -49489,16 +26545,6 @@ impl VtkPlanes for vtkPlanes { } unsafe { vtk_planes_get_plane(self.0, i) } } - fn get_plane(&mut self, i: core::ffi::c_int, plane: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_planes_get_plane( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - plane: *mut core::ffi::c_void, - ); - } - unsafe { vtk_planes_get_plane(self.0, i, plane) } - } } impl VtkPlanesIntersection for vtkPlanesIntersection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -49535,20 +26581,6 @@ impl VtkPlanesIntersection for vtkPlanesIntersection { } unsafe { vtk_planes_intersection_set_region_vertices(self.0, pts) } } - fn set_region_vertices( - &mut self, - v: core::ffi::c_double, - nvertices: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_planes_intersection_set_region_vertices( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - nvertices: core::ffi::c_int, - ); - } - unsafe { vtk_planes_intersection_set_region_vertices(self.0, v, nvertices) } - } fn get_number_of_region_vertices(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_planes_intersection_get_number_of_region_vertices( @@ -49565,20 +26597,6 @@ impl VtkPlanesIntersection for vtkPlanesIntersection { } unsafe { vtk_planes_intersection_get_num_region_vertices(self.0) } } - fn get_region_vertices( - &mut self, - v: core::ffi::c_double, - nvertices: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_planes_intersection_get_region_vertices( - sself: *mut core::ffi::c_void, - v: core::ffi::c_double, - nvertices: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_planes_intersection_get_region_vertices(self.0, v, nvertices) } - } fn intersects_region(&mut self, R: *mut core::ffi::c_void) -> core::ffi::c_int { unsafe extern "C" { fn vtk_planes_intersection_intersects_region( @@ -49588,20 +26606,6 @@ impl VtkPlanesIntersection for vtkPlanesIntersection { } unsafe { vtk_planes_intersection_intersects_region(self.0, R) } } - fn polygon_intersects_b_box( - &mut self, - bounds: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_planes_intersection_polygon_intersects_b_box( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_planes_intersection_polygon_intersects_b_box(self.0, bounds, pts) } - } fn convert_3_d_cell( &mut self, cell: *mut core::ffi::c_void, @@ -49649,11 +26653,11 @@ impl VtkPointData for vtkPointData { } unsafe { vtk_point_data_new_instance(self.0) } } - fn null_point(&mut self, ptId: core::ffi::c_uchar) -> () { + fn null_point(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_point_data_null_point( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_point_data_null_point(self.0, ptId) } @@ -49701,32 +26705,6 @@ impl VtkPointLocator for vtkPointLocator { } unsafe { vtk_point_locator_set_divisions(self.0, _arg1, _arg2, _arg3) } } - fn set_divisions(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_point_locator_set_divisions( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_point_locator_set_divisions(self.0, _arg) } - } - fn get_divisions(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_point_locator_get_divisions( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_point_locator_get_divisions(self.0) } - } - fn get_divisions(&mut self, data: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_point_locator_get_divisions( - sself: *mut core::ffi::c_void, - data: core::ffi::c_int, - ); - } - unsafe { vtk_point_locator_get_divisions(self.0, data) } - } fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_point_locator_set_number_of_points_per_bucket( @@ -49760,249 +26738,46 @@ impl VtkPointLocator for vtkPointLocator { } unsafe { vtk_point_locator_get_number_of_points_per_bucket(self.0) } } - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_point_locator_find_closest_point( + fn vtk_point_locator_is_inserted_point( sself: *mut core::ffi::c_void, x: core::ffi::c_double, - ) -> core::ffi::c_uchar; + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; } - unsafe { vtk_point_locator_find_closest_point(self.0, x) } + unsafe { vtk_point_locator_is_inserted_point(self.0, x, y, z) } } - fn find_closest_point_within_radius( + fn find_distributed_points( &mut self, - radius: core::ffi::c_double, + N: core::ffi::c_int, x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ) -> () { unsafe extern "C" { - fn vtk_point_locator_find_closest_point_within_radius( + fn vtk_point_locator_find_distributed_points( sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, + N: core::ffi::c_int, x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_point_locator_find_closest_point_within_radius(self.0, radius, x, dist2) - } - } - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - inputDataLength: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_point_locator_find_closest_point_within_radius( - sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, - x: core::ffi::c_double, - inputDataLength: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_point_locator_find_closest_point_within_radius( - self.0, - radius, - x, - inputDataLength, - dist2, - ) - } - } - fn init_point_insertion( - &mut self, - newPts: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_point_locator_init_point_insertion( - sself: *mut core::ffi::c_void, - newPts: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_point_locator_init_point_insertion(self.0, newPts, bounds) } - } - fn init_point_insertion( - &mut self, - newPts: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - estNumPts: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_point_locator_init_point_insertion( - sself: *mut core::ffi::c_void, - newPts: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - estNumPts: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { - vtk_point_locator_init_point_insertion(self.0, newPts, bounds, estNumPts) - } - } - fn insert_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_point_locator_insert_point( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - x: core::ffi::c_double, - ); - } - unsafe { vtk_point_locator_insert_point(self.0, ptId, x) } - } - fn insert_next_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_point_locator_insert_next_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_point_locator_insert_next_point(self.0, x) } - } - fn is_inserted_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_point_locator_is_inserted_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_point_locator_is_inserted_point(self.0, x, y, z) } - } - fn is_inserted_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_point_locator_is_inserted_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_point_locator_is_inserted_point(self.0, x) } - } - fn insert_unique_point( - &mut self, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_point_locator_insert_unique_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_point_locator_insert_unique_point(self.0, x, ptId) } - } - fn find_closest_inserted_point( - &mut self, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_point_locator_find_closest_inserted_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_point_locator_find_closest_inserted_point(self.0, x) } - } - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_point_locator_find_closest_n_points( - sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { vtk_point_locator_find_closest_n_points(self.0, N, x, result) } - } - fn find_distributed_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - M: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_point_locator_find_distributed_points( - sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - M: core::ffi::c_int, - ); - } - unsafe { vtk_point_locator_find_distributed_points(self.0, N, x, result, M) } - } - fn find_distributed_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - result: *mut core::ffi::c_void, - M: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_point_locator_find_distributed_points( - sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - result: *mut core::ffi::c_void, - M: core::ffi::c_int, - ); + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ); } unsafe { vtk_point_locator_find_distributed_points(self.0, N, x, y, z, result, M) } } - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_point_locator_find_points_within_radius( - sself: *mut core::ffi::c_void, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { vtk_point_locator_find_points_within_radius(self.0, R, x, result) } - } - fn get_points_in_bucket( - &mut self, - x: core::ffi::c_double, - ijk: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_point_locator_get_points_in_bucket( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ijk: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_point_locator_get_points_in_bucket(self.0, x, ijk) } - } fn get_points(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_point_locator_get_points( @@ -50117,111 +26892,19 @@ impl VtkPointSet for vtkPointSet { } unsafe { vtk_point_set_copy_structure(self.0, pd) } } - fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_point_set_get_number_of_points( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_point_set_get_number_of_points(self.0) } } - fn get_point(&mut self, ptId: core::ffi::c_uchar, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_point_set_get_point( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - x: core::ffi::c_double, - ); - } - unsafe { vtk_point_set_get_point(self.0, ptId, x) } - } - fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_point_set_find_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_point_set_find_point(self.0, x) } - } - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_point_set_find_cell( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_point_set_find_cell( - self.0, - x, - cell, - cellId, - tol2, - subId, - pcoords, - weights, - ) - } - } - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_point_set_find_cell( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_point_set_find_cell( - self.0, - x, - cell, - gencell, - cellId, - tol2, - subId, - pcoords, - weights, - ) - } - } - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_point_set_get_number_of_cells( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_point_set_get_number_of_cells(self.0) } } @@ -50233,24 +26916,24 @@ impl VtkPointSet for vtkPointSet { } unsafe { vtk_point_set_get_max_cell_size(self.0) } } - fn get_cell(&mut self, p0: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_cell(&mut self, p0: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_point_set_get_cell( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_point_set_get_cell(self.0, p0) } } fn get_cell_points( &mut self, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, idList: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_point_set_get_cell_points( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, idList: *mut core::ffi::c_void, ); } @@ -50258,46 +26941,27 @@ impl VtkPointSet for vtkPointSet { } fn get_point_cells( &mut self, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, idList: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_point_set_get_point_cells( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, idList: *mut core::ffi::c_void, ); } unsafe { vtk_point_set_get_point_cells(self.0, p0, idList) } } - fn get_cell(&mut self, p0: core::ffi::c_uchar, cell: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_point_set_get_cell( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ); - } - unsafe { vtk_point_set_get_cell(self.0, p0, cell) } - } - fn get_cell_type(&mut self, p0: core::ffi::c_uchar) -> core::ffi::c_int { + fn get_cell_type(&mut self, p0: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_point_set_get_cell_type( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_point_set_get_cell_type(self.0, p0) } } - fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_point_set_get_point( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_point_set_get_point(self.0, ptId) } - } fn build_point_locator(&mut self) -> () { unsafe extern "C" { fn vtk_point_set_build_point_locator(sself: *mut core::ffi::c_void); @@ -50405,20 +27069,6 @@ impl VtkPointSet for vtkPointSet { } unsafe { vtk_point_set_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_point_set_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_point_set_get_data(self.0, v, i) } - } } impl VtkPointSetCellIterator for vtkPointSetCellIterator { fn new(&mut self) -> *mut core::ffi::c_void { @@ -50454,11 +27104,11 @@ impl VtkPointSetCellIterator for vtkPointSetCellIterator { } unsafe { vtk_point_set_cell_iterator_is_done_with_traversal(self.0) } } - fn get_cell_id(&mut self) -> core::ffi::c_uchar { + fn get_cell_id(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_point_set_cell_iterator_get_cell_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_point_set_cell_iterator_get_cell_id(self.0) } } @@ -50501,58 +27151,6 @@ impl VtkPointsProjectedHull for vtkPointsProjectedHull { } unsafe { vtk_points_projected_hull_rectangle_intersection_x(self.0, R) } } - fn rectangle_intersection_x( - &mut self, - ymin: core::ffi::c_float, - ymax: core::ffi::c_float, - zmin: core::ffi::c_float, - zmax: core::ffi::c_float, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_rectangle_intersection_x( - sself: *mut core::ffi::c_void, - ymin: core::ffi::c_float, - ymax: core::ffi::c_float, - zmin: core::ffi::c_float, - zmax: core::ffi::c_float, - ) -> core::ffi::c_int; - } - unsafe { - vtk_points_projected_hull_rectangle_intersection_x( - self.0, - ymin, - ymax, - zmin, - zmax, - ) - } - } - fn rectangle_intersection_x( - &mut self, - ymin: core::ffi::c_double, - ymax: core::ffi::c_double, - zmin: core::ffi::c_double, - zmax: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_rectangle_intersection_x( - sself: *mut core::ffi::c_void, - ymin: core::ffi::c_double, - ymax: core::ffi::c_double, - zmin: core::ffi::c_double, - zmax: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_points_projected_hull_rectangle_intersection_x( - self.0, - ymin, - ymax, - zmin, - zmax, - ) - } - } fn rectangle_intersection_y( &mut self, R: *mut core::ffi::c_void, @@ -50565,58 +27163,6 @@ impl VtkPointsProjectedHull for vtkPointsProjectedHull { } unsafe { vtk_points_projected_hull_rectangle_intersection_y(self.0, R) } } - fn rectangle_intersection_y( - &mut self, - zmin: core::ffi::c_float, - zmax: core::ffi::c_float, - xmin: core::ffi::c_float, - xmax: core::ffi::c_float, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_rectangle_intersection_y( - sself: *mut core::ffi::c_void, - zmin: core::ffi::c_float, - zmax: core::ffi::c_float, - xmin: core::ffi::c_float, - xmax: core::ffi::c_float, - ) -> core::ffi::c_int; - } - unsafe { - vtk_points_projected_hull_rectangle_intersection_y( - self.0, - zmin, - zmax, - xmin, - xmax, - ) - } - } - fn rectangle_intersection_y( - &mut self, - zmin: core::ffi::c_double, - zmax: core::ffi::c_double, - xmin: core::ffi::c_double, - xmax: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_rectangle_intersection_y( - sself: *mut core::ffi::c_void, - zmin: core::ffi::c_double, - zmax: core::ffi::c_double, - xmin: core::ffi::c_double, - xmax: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_points_projected_hull_rectangle_intersection_y( - self.0, - zmin, - zmax, - xmin, - xmax, - ) - } - } fn rectangle_intersection_z( &mut self, R: *mut core::ffi::c_void, @@ -50629,142 +27175,6 @@ impl VtkPointsProjectedHull for vtkPointsProjectedHull { } unsafe { vtk_points_projected_hull_rectangle_intersection_z(self.0, R) } } - fn rectangle_intersection_z( - &mut self, - xmin: core::ffi::c_float, - xmax: core::ffi::c_float, - ymin: core::ffi::c_float, - ymax: core::ffi::c_float, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_rectangle_intersection_z( - sself: *mut core::ffi::c_void, - xmin: core::ffi::c_float, - xmax: core::ffi::c_float, - ymin: core::ffi::c_float, - ymax: core::ffi::c_float, - ) -> core::ffi::c_int; - } - unsafe { - vtk_points_projected_hull_rectangle_intersection_z( - self.0, - xmin, - xmax, - ymin, - ymax, - ) - } - } - fn rectangle_intersection_z( - &mut self, - xmin: core::ffi::c_double, - xmax: core::ffi::c_double, - ymin: core::ffi::c_double, - ymax: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_rectangle_intersection_z( - sself: *mut core::ffi::c_void, - xmin: core::ffi::c_double, - xmax: core::ffi::c_double, - ymin: core::ffi::c_double, - ymax: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_points_projected_hull_rectangle_intersection_z( - self.0, - xmin, - xmax, - ymin, - ymax, - ) - } - } - fn get_ccw_hull_x( - &mut self, - pts: core::ffi::c_float, - len: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_get_ccw_hull_x( - sself: *mut core::ffi::c_void, - pts: core::ffi::c_float, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_points_projected_hull_get_ccw_hull_x(self.0, pts, len) } - } - fn get_ccw_hull_x( - &mut self, - pts: core::ffi::c_double, - len: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_get_ccw_hull_x( - sself: *mut core::ffi::c_void, - pts: core::ffi::c_double, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_points_projected_hull_get_ccw_hull_x(self.0, pts, len) } - } - fn get_ccw_hull_y( - &mut self, - pts: core::ffi::c_float, - len: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_get_ccw_hull_y( - sself: *mut core::ffi::c_void, - pts: core::ffi::c_float, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_points_projected_hull_get_ccw_hull_y(self.0, pts, len) } - } - fn get_ccw_hull_y( - &mut self, - pts: core::ffi::c_double, - len: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_get_ccw_hull_y( - sself: *mut core::ffi::c_void, - pts: core::ffi::c_double, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_points_projected_hull_get_ccw_hull_y(self.0, pts, len) } - } - fn get_ccw_hull_z( - &mut self, - pts: core::ffi::c_float, - len: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_get_ccw_hull_z( - sself: *mut core::ffi::c_void, - pts: core::ffi::c_float, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_points_projected_hull_get_ccw_hull_z(self.0, pts, len) } - } - fn get_ccw_hull_z( - &mut self, - pts: core::ffi::c_double, - len: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_points_projected_hull_get_ccw_hull_z( - sself: *mut core::ffi::c_void, - pts: core::ffi::c_double, - len: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_points_projected_hull_get_ccw_hull_z(self.0, pts, len) } - } fn get_size_ccw_hull_x(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_points_projected_hull_get_size_ccw_hull_x( @@ -50847,42 +27257,28 @@ impl VtkPolyData for vtkPolyData { } unsafe { vtk_poly_data_copy_structure(self.0, ds) } } - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_poly_data_get_number_of_cells( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_poly_data_get_number_of_cells(self.0) } } - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_poly_data_get_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_poly_data_get_cell(self.0, cellId) } } - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_poly_data_get_cell( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ); - } - unsafe { vtk_poly_data_get_cell(self.0, cellId, cell) } - } - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_poly_data_get_cell_type( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_poly_data_get_cell_type(self.0, cellId) } @@ -50905,13 +27301,13 @@ impl VtkPolyData for vtkPolyData { } fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_poly_data_get_cell_points( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ); } @@ -50919,13 +27315,13 @@ impl VtkPolyData for vtkPolyData { } fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_poly_data_get_point_cells( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ); } @@ -50937,15 +27333,6 @@ impl VtkPolyData for vtkPolyData { } unsafe { vtk_poly_data_compute_cells_bounds(self.0) } } - fn get_cells_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_poly_data_get_cells_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_poly_data_get_cells_bounds(self.0, bounds) } - } fn squeeze(&mut self) -> () { unsafe extern "C" { fn vtk_poly_data_squeeze(sself: *mut core::ffi::c_void); @@ -50962,13 +27349,13 @@ impl VtkPolyData for vtkPolyData { } fn get_cell_id_relative_to_cell_array( &mut self, - cellId: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_poly_data_get_cell_id_relative_to_cell_array( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_poly_data_get_cell_id_relative_to_cell_array(self.0, cellId) } } @@ -51040,142 +27427,66 @@ impl VtkPolyData for vtkPolyData { } unsafe { vtk_poly_data_get_strips(self.0) } } - fn get_number_of_verts(&mut self) -> core::ffi::c_uchar { + fn get_number_of_verts(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_poly_data_get_number_of_verts( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_poly_data_get_number_of_verts(self.0) } } - fn get_number_of_lines(&mut self) -> core::ffi::c_uchar { + fn get_number_of_lines(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_poly_data_get_number_of_lines( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_poly_data_get_number_of_lines(self.0) } } - fn get_number_of_polys(&mut self) -> core::ffi::c_uchar { + fn get_number_of_polys(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_poly_data_get_number_of_polys( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_poly_data_get_number_of_polys(self.0) } } - fn get_number_of_strips(&mut self) -> core::ffi::c_uchar { + fn get_number_of_strips(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_poly_data_get_number_of_strips( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_poly_data_get_number_of_strips(self.0) } } fn allocate_estimate( &mut self, - numCells: core::ffi::c_uchar, - maxCellSize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, ) -> bool { unsafe extern "C" { fn vtk_poly_data_allocate_estimate( sself: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, - maxCellSize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_poly_data_allocate_estimate(self.0, numCells, maxCellSize) } } - fn allocate_estimate( - &mut self, - numVerts: core::ffi::c_uchar, - maxVertSize: core::ffi::c_uchar, - numLines: core::ffi::c_uchar, - maxLineSize: core::ffi::c_uchar, - numPolys: core::ffi::c_uchar, - maxPolySize: core::ffi::c_uchar, - numStrips: core::ffi::c_uchar, - maxStripSize: core::ffi::c_uchar, - ) -> bool { - unsafe extern "C" { - fn vtk_poly_data_allocate_estimate( - sself: *mut core::ffi::c_void, - numVerts: core::ffi::c_uchar, - maxVertSize: core::ffi::c_uchar, - numLines: core::ffi::c_uchar, - maxLineSize: core::ffi::c_uchar, - numPolys: core::ffi::c_uchar, - maxPolySize: core::ffi::c_uchar, - numStrips: core::ffi::c_uchar, - maxStripSize: core::ffi::c_uchar, - ) -> bool; - } - unsafe { - vtk_poly_data_allocate_estimate( - self.0, - numVerts, - maxVertSize, - numLines, - maxLineSize, - numPolys, - maxPolySize, - numStrips, - maxStripSize, - ) - } - } fn allocate_exact( &mut self, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool { unsafe extern "C" { fn vtk_poly_data_allocate_exact( sself: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_poly_data_allocate_exact(self.0, numCells, connectivitySize) } } - fn allocate_exact( - &mut self, - numVerts: core::ffi::c_uchar, - vertConnSize: core::ffi::c_uchar, - numLines: core::ffi::c_uchar, - lineConnSize: core::ffi::c_uchar, - numPolys: core::ffi::c_uchar, - polyConnSize: core::ffi::c_uchar, - numStrips: core::ffi::c_uchar, - stripConnSize: core::ffi::c_uchar, - ) -> bool { - unsafe extern "C" { - fn vtk_poly_data_allocate_exact( - sself: *mut core::ffi::c_void, - numVerts: core::ffi::c_uchar, - vertConnSize: core::ffi::c_uchar, - numLines: core::ffi::c_uchar, - lineConnSize: core::ffi::c_uchar, - numPolys: core::ffi::c_uchar, - polyConnSize: core::ffi::c_uchar, - numStrips: core::ffi::c_uchar, - stripConnSize: core::ffi::c_uchar, - ) -> bool; - } - unsafe { - vtk_poly_data_allocate_exact( - self.0, - numVerts, - vertConnSize, - numLines, - lineConnSize, - numPolys, - polyConnSize, - numStrips, - stripConnSize, - ) - } - } fn allocate_copy(&mut self, pd: *mut core::ffi::c_void) -> bool { unsafe extern "C" { fn vtk_poly_data_allocate_copy( @@ -51201,61 +27512,29 @@ impl VtkPolyData for vtkPolyData { } fn allocate( &mut self, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, extSize: core::ffi::c_int, ) -> () { unsafe extern "C" { fn vtk_poly_data_allocate( sself: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, extSize: core::ffi::c_int, ); } unsafe { vtk_poly_data_allocate(self.0, numCells, extSize) } } - fn allocate( - &mut self, - inPolyData: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, - extSize: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_poly_data_allocate( - sself: *mut core::ffi::c_void, - inPolyData: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, - extSize: core::ffi::c_int, - ); - } - unsafe { vtk_poly_data_allocate(self.0, inPolyData, numCells, extSize) } - } - fn insert_next_cell( - &mut self, - type_: core::ffi::c_int, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_poly_data_insert_next_cell( - sself: *mut core::ffi::c_void, - type_: core::ffi::c_int, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_poly_data_insert_next_cell(self.0, type_, npts, pts) } - } fn insert_next_cell( &mut self, type_: core::ffi::c_int, pts: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_poly_data_insert_next_cell( sself: *mut core::ffi::c_void, type_: core::ffi::c_int, pts: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_poly_data_insert_next_cell(self.0, type_, pts) } } @@ -51298,72 +27577,24 @@ impl VtkPolyData for vtkPolyData { } unsafe { vtk_poly_data_delete_links(self.0) } } - fn get_point_cells( - &mut self, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_uchar, - cells: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_poly_data_get_point_cells( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_uchar, - cells: core::ffi::c_uchar, - ); - } - unsafe { vtk_poly_data_get_point_cells(self.0, ptId, ncells, cells) } - } - fn get_point_cells( - &mut self, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_ushort, - cells: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_poly_data_get_point_cells( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_ushort, - cells: core::ffi::c_uchar, - ); - } - unsafe { vtk_poly_data_get_point_cells(self.0, ptId, ncells, cells) } - } fn get_cell_edge_neighbors( &mut self, - cellId: core::ffi::c_uchar, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_poly_data_get_cell_edge_neighbors( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ); } unsafe { vtk_poly_data_get_cell_edge_neighbors(self.0, cellId, p1, p2, cellIds) } } - fn get_cell_points( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_poly_data_get_cell_points( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_poly_data_get_cell_points(self.0, cellId, npts, pts) } - } fn is_triangle( &mut self, v1: core::ffi::c_int, @@ -51382,101 +27613,85 @@ impl VtkPolyData for vtkPolyData { } fn is_edge( &mut self, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_poly_data_is_edge( sself: *mut core::ffi::c_void, - p1: core::ffi::c_uchar, - p2: core::ffi::c_uchar, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_poly_data_is_edge(self.0, p1, p2) } } fn is_point_used_by_cell( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_poly_data_is_point_used_by_cell( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_poly_data_is_point_used_by_cell(self.0, ptId, cellId) } } fn replace_cell( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ids: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_poly_data_replace_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ids: *mut core::ffi::c_void, ); } unsafe { vtk_poly_data_replace_cell(self.0, cellId, ids) } } - fn replace_cell( + fn replace_cell_point( &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_poly_data_replace_cell( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_poly_data_replace_cell(self.0, cellId, npts, pts) } - } - fn replace_cell_point( - &mut self, - cellId: core::ffi::c_uchar, - oldPtId: core::ffi::c_uchar, - newPtId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + oldPtId: core::ffi::c_longlong, + newPtId: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_poly_data_replace_cell_point( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - oldPtId: core::ffi::c_uchar, - newPtId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, + oldPtId: core::ffi::c_longlong, + newPtId: core::ffi::c_longlong, ); } unsafe { vtk_poly_data_replace_cell_point(self.0, cellId, oldPtId, newPtId) } } - fn reverse_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + fn reverse_cell(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_poly_data_reverse_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_poly_data_reverse_cell(self.0, cellId) } } - fn delete_point(&mut self, ptId: core::ffi::c_uchar) -> () { + fn delete_point(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_poly_data_delete_point( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_poly_data_delete_point(self.0, ptId) } } - fn delete_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + fn delete_cell(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_poly_data_delete_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_poly_data_delete_cell(self.0, cellId) } @@ -51490,116 +27705,70 @@ impl VtkPolyData for vtkPolyData { fn insert_next_linked_point( &mut self, numLinks: core::ffi::c_int, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_poly_data_insert_next_linked_point( sself: *mut core::ffi::c_void, numLinks: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_poly_data_insert_next_linked_point(self.0, numLinks) } } - fn insert_next_linked_point( - &mut self, - x: core::ffi::c_double, - numLinks: core::ffi::c_int, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_poly_data_insert_next_linked_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - numLinks: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_poly_data_insert_next_linked_point(self.0, x, numLinks) } - } - fn insert_next_linked_cell( - &mut self, - type_: core::ffi::c_int, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_poly_data_insert_next_linked_cell( - sself: *mut core::ffi::c_void, - type_: core::ffi::c_int, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_poly_data_insert_next_linked_cell(self.0, type_, npts, pts) } - } - fn replace_linked_cell( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_poly_data_replace_linked_cell( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_poly_data_replace_linked_cell(self.0, cellId, npts, pts) } - } - fn remove_cell_reference(&mut self, cellId: core::ffi::c_uchar) -> () { + fn remove_cell_reference(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_poly_data_remove_cell_reference( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_poly_data_remove_cell_reference(self.0, cellId) } } - fn add_cell_reference(&mut self, cellId: core::ffi::c_uchar) -> () { + fn add_cell_reference(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_poly_data_add_cell_reference( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_poly_data_add_cell_reference(self.0, cellId) } } fn remove_reference_to_cell( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_poly_data_remove_reference_to_cell( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_poly_data_remove_reference_to_cell(self.0, ptId, cellId) } } fn add_reference_to_cell( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_poly_data_add_reference_to_cell( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_poly_data_add_reference_to_cell(self.0, ptId, cellId) } } fn resize_cell_list( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, size: core::ffi::c_int, ) -> () { unsafe extern "C" { fn vtk_poly_data_resize_cell_list( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, size: core::ffi::c_int, ); } @@ -51650,29 +27819,15 @@ impl VtkPolyData for vtkPolyData { } unsafe { vtk_poly_data_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_poly_data_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_poly_data_get_data(self.0, v, i) } - } fn get_scalar_field_critical_index( &mut self, - pointId: core::ffi::c_uchar, + pointId: core::ffi::c_longlong, scalarField: *mut core::ffi::c_void, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_poly_data_get_scalar_field_critical_index( sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, + pointId: core::ffi::c_longlong, scalarField: *mut core::ffi::c_void, ) -> core::ffi::c_int; } @@ -51680,38 +27835,6 @@ impl VtkPolyData for vtkPolyData { vtk_poly_data_get_scalar_field_critical_index(self.0, pointId, scalarField) } } - fn get_scalar_field_critical_index( - &mut self, - pointId: core::ffi::c_uchar, - fieldId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_data_get_scalar_field_critical_index( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - fieldId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_poly_data_get_scalar_field_critical_index(self.0, pointId, fieldId) - } - } - fn get_scalar_field_critical_index( - &mut self, - pointId: core::ffi::c_uchar, - fieldName: core::ffi::c_char, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_data_get_scalar_field_critical_index( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - fieldName: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { - vtk_poly_data_get_scalar_field_critical_index(self.0, pointId, fieldName) - } - } fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_poly_data_get_mesh_m_time( @@ -51728,20 +27851,6 @@ impl VtkPolyData for vtkPolyData { } unsafe { vtk_poly_data_get_m_time(self.0) } } - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_poly_data_get_cell( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_poly_data_get_cell(self.0, cellId, pts) } - } } impl VtkPolyDataCollection for vtkPolyDataCollection { fn new(&mut self) -> *mut core::ffi::c_void { @@ -51786,15 +27895,6 @@ impl VtkPolyDataCollection for vtkPolyDataCollection { } unsafe { vtk_poly_data_collection_get_next_item(self.0) } } - fn get_next_poly_data(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_poly_data_collection_get_next_poly_data( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_poly_data_collection_get_next_poly_data(self.0, cookie) } - } } impl VtkPolyLine for vtkPolyLine { fn new(&mut self) -> *mut core::ffi::c_void { @@ -51838,26 +27938,6 @@ impl VtkPolyLine for vtkPolyLine { } unsafe { vtk_poly_line_generate_sliding_normals(self.0, p0, p1, p2) } } - fn generate_sliding_normals( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - firstNormal: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_line_generate_sliding_normals( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - firstNormal: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_poly_line_generate_sliding_normals(self.0, p0, p1, p2, firstNormal) - } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_poly_line_get_cell_type( @@ -51908,22 +27988,6 @@ impl VtkPolyLine for vtkPolyLine { } unsafe { vtk_poly_line_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_line_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_poly_line_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -51935,7 +27999,7 @@ impl VtkPolyLine for vtkPolyLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -51950,7 +28014,7 @@ impl VtkPolyLine for vtkPolyLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -51980,7 +28044,7 @@ impl VtkPolyLine for vtkPolyLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -51994,7 +28058,7 @@ impl VtkPolyLine for vtkPolyLine { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -52015,82 +28079,6 @@ impl VtkPolyLine for vtkPolyLine { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_line_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_poly_line_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_poly_line_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_poly_line_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_line_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_poly_line_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -52107,38 +28095,6 @@ impl VtkPolyLine for vtkPolyLine { } unsafe { vtk_poly_line_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_poly_line_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_poly_line_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_line_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_poly_line_get_parametric_center(self.0, pcoords) } - } } impl VtkPolyPlane for vtkPolyPlane { fn new(&mut self) -> *mut core::ffi::c_void { @@ -52166,29 +28122,6 @@ impl VtkPolyPlane for vtkPolyPlane { } unsafe { vtk_poly_plane_new_instance(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_poly_plane_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_poly_plane_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_poly_plane_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - g: core::ffi::c_double, - ); - } - unsafe { vtk_poly_plane_evaluate_gradient(self.0, x, g) } - } fn set_poly_line(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_poly_plane_set_poly_line( @@ -52291,22 +28224,6 @@ impl VtkPolyVertex for vtkPolyVertex { } unsafe { vtk_poly_vertex_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_vertex_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_poly_vertex_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -52318,7 +28235,7 @@ impl VtkPolyVertex for vtkPolyVertex { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -52333,7 +28250,7 @@ impl VtkPolyVertex for vtkPolyVertex { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -52363,7 +28280,7 @@ impl VtkPolyVertex for vtkPolyVertex { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -52377,7 +28294,7 @@ impl VtkPolyVertex for vtkPolyVertex { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -52398,91 +28315,6 @@ impl VtkPolyVertex for vtkPolyVertex { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_vertex_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_poly_vertex_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_poly_vertex_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_poly_vertex_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_vertex_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_poly_vertex_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -52499,40 +28331,6 @@ impl VtkPolyVertex for vtkPolyVertex { } unsafe { vtk_poly_vertex_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_poly_vertex_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_poly_vertex_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_vertex_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_poly_vertex_get_parametric_center(self.0, pcoords) } - } } impl VtkPolygon for vtkPolygon { fn new(&mut self) -> *mut core::ffi::c_void { @@ -52608,22 +28406,6 @@ impl VtkPolygon for vtkPolygon { } unsafe { vtk_polygon_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polygon_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_polygon_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -52635,7 +28417,7 @@ impl VtkPolygon for vtkPolygon { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -52650,7 +28432,7 @@ impl VtkPolygon for vtkPolygon { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -52680,7 +28462,7 @@ impl VtkPolygon for vtkPolygon { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -52694,7 +28476,7 @@ impl VtkPolygon for vtkPolygon { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -52715,82 +28497,6 @@ impl VtkPolygon for vtkPolygon { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polygon_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polygon_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polygon_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_polygon_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polygon_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polygon_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -52807,26 +28513,6 @@ impl VtkPolygon for vtkPolygon { } unsafe { vtk_polygon_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polygon_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_polygon_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } fn compute_area(&mut self) -> core::ffi::c_double { unsafe extern "C" { fn vtk_polygon_compute_area( @@ -52835,232 +28521,12 @@ impl VtkPolygon for vtkPolygon { } unsafe { vtk_polygon_compute_area(self.0) } } - fn interpolate_functions( - &mut self, - x: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polygon_interpolate_functions( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - sf: core::ffi::c_double, - ); - } - unsafe { vtk_polygon_interpolate_functions(self.0, x, sf) } - } - fn compute_normal( - &mut self, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polygon_compute_normal( - sself: *mut core::ffi::c_void, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - n: core::ffi::c_double, - ); - } - unsafe { vtk_polygon_compute_normal(self.0, p, numPts, pts, n) } - } - fn compute_normal( - &mut self, - p: *mut core::ffi::c_void, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polygon_compute_normal( - sself: *mut core::ffi::c_void, - p: *mut core::ffi::c_void, - n: core::ffi::c_double, - ); - } - unsafe { vtk_polygon_compute_normal(self.0, p, n) } - } - fn compute_normal( - &mut self, - ids: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polygon_compute_normal( - sself: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - n: core::ffi::c_double, - ); - } - unsafe { vtk_polygon_compute_normal(self.0, ids, pts, n) } - } - fn compute_normal( - &mut self, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polygon_compute_normal( - sself: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_polygon_compute_normal(self.0, numPts, pts, n) } - } fn is_convex(&mut self) -> bool { unsafe extern "C" { fn vtk_polygon_is_convex(sself: *mut core::ffi::c_void) -> bool; } unsafe { vtk_polygon_is_convex(self.0) } } - fn is_convex( - &mut self, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> bool { - unsafe extern "C" { - fn vtk_polygon_is_convex( - sself: *mut core::ffi::c_void, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> bool; - } - unsafe { vtk_polygon_is_convex(self.0, p, numPts, pts) } - } - fn is_convex( - &mut self, - ids: *mut core::ffi::c_void, - p: *mut core::ffi::c_void, - ) -> bool { - unsafe extern "C" { - fn vtk_polygon_is_convex( - sself: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - p: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_polygon_is_convex(self.0, ids, p) } - } - fn is_convex(&mut self, p: *mut core::ffi::c_void) -> bool { - unsafe extern "C" { - fn vtk_polygon_is_convex( - sself: *mut core::ffi::c_void, - p: *mut core::ffi::c_void, - ) -> bool; - } - unsafe { vtk_polygon_is_convex(self.0, p) } - } - fn compute_centroid( - &mut self, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_polygon_compute_centroid( - sself: *mut core::ffi::c_void, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_polygon_compute_centroid(self.0, p, numPts, pts, centroid) } - } - fn compute_centroid( - &mut self, - ids: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_polygon_compute_centroid( - sself: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_polygon_compute_centroid(self.0, ids, pts, centroid) } - } - fn compute_area( - &mut self, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - normal: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_polygon_compute_area( - sself: *mut core::ffi::c_void, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - normal: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_polygon_compute_area(self.0, p, numPts, pts, normal) } - } - fn parameterize_polygon( - &mut self, - p0: core::ffi::c_double, - p10: core::ffi::c_double, - l10: core::ffi::c_double, - p20: core::ffi::c_double, - l20: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polygon_parameterize_polygon( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_double, - p10: core::ffi::c_double, - l10: core::ffi::c_double, - p20: core::ffi::c_double, - l20: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_polygon_parameterize_polygon(self.0, p0, p10, l10, p20, l20, n) } - } - fn point_in_polygon( - &mut self, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polygon_point_in_polygon( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_polygon_point_in_polygon(self.0, x, numPts, pts, bounds, n) } - } - fn triangulate(&mut self, outTris: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polygon_triangulate( - sself: *mut core::ffi::c_void, - outTris: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_polygon_triangulate(self.0, outTris) } - } fn non_degenerate_triangulate( &mut self, outTris: *mut core::ffi::c_void, @@ -53087,88 +28553,6 @@ impl VtkPolygon for vtkPolygon { } unsafe { vtk_polygon_bounded_triangulate(self.0, outTris, tol) } } - fn distance_to_polygon( - &mut self, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - closest: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_polygon_distance_to_polygon( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - closest: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { - vtk_polygon_distance_to_polygon(self.0, x, numPts, pts, bounds, closest) - } - } - fn intersect_polygon_with_polygon( - &mut self, - npts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - npts2: core::ffi::c_int, - pts2: core::ffi::c_double, - bounds2: core::ffi::c_double, - tol: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polygon_intersect_polygon_with_polygon( - sself: *mut core::ffi::c_void, - npts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - npts2: core::ffi::c_int, - pts2: core::ffi::c_double, - bounds2: core::ffi::c_double, - tol: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polygon_intersect_polygon_with_polygon( - self.0, - npts, - pts, - bounds, - npts2, - pts2, - bounds2, - tol, - x, - ) - } - } - fn intersect_convex_2_d_cells( - &mut self, - cell1: *mut core::ffi::c_void, - cell2: *mut core::ffi::c_void, - tol: core::ffi::c_double, - p0: core::ffi::c_double, - p1: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polygon_intersect_convex_2_d_cells( - sself: *mut core::ffi::c_void, - cell1: *mut core::ffi::c_void, - cell2: *mut core::ffi::c_void, - tol: core::ffi::c_double, - p0: core::ffi::c_double, - p1: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polygon_intersect_convex_2_d_cells(self.0, cell1, cell2, tol, p0, p1) - } - } fn get_use_mvc_interpolation(&mut self) -> bool { unsafe extern "C" { fn vtk_polygon_get_use_mvc_interpolation( @@ -53228,20 +28612,6 @@ impl VtkPolygon for vtkPolygon { } unsafe { vtk_polygon_ear_cut_triangulation(self.0, measure) } } - fn ear_cut_triangulation( - &mut self, - outTris: *mut core::ffi::c_void, - measure: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polygon_ear_cut_triangulation( - sself: *mut core::ffi::c_void, - outTris: *mut core::ffi::c_void, - measure: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_polygon_ear_cut_triangulation(self.0, outTris, measure) } - } fn unbiased_ear_cut_triangulation( &mut self, seed: core::ffi::c_int, @@ -53256,24 +28626,6 @@ impl VtkPolygon for vtkPolygon { } unsafe { vtk_polygon_unbiased_ear_cut_triangulation(self.0, seed, measure) } } - fn unbiased_ear_cut_triangulation( - &mut self, - seed: core::ffi::c_int, - outTris: *mut core::ffi::c_void, - measure: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polygon_unbiased_ear_cut_triangulation( - sself: *mut core::ffi::c_void, - seed: core::ffi::c_int, - outTris: *mut core::ffi::c_void, - measure: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polygon_unbiased_ear_cut_triangulation(self.0, seed, outTris, measure) - } - } } impl VtkPolyhedron for vtkPolyhedron { fn new(&mut self) -> *mut core::ffi::c_void { @@ -53301,149 +28653,6 @@ impl VtkPolyhedron for vtkPolyhedron { } unsafe { vtk_polyhedron_new_instance(self.0) } } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_polyhedron_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_polyhedron_get_edge_points(self.0, edgeId, pts) } - } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_polyhedron_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_polyhedron_get_edge_points(self.0, edgeId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_polyhedron_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_polyhedron_get_face_points(self.0, faceId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_polyhedron_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_polyhedron_get_face_points(self.0, faceId, pts) } - } - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_polyhedron_get_edge_to_adjacent_faces( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_polyhedron_get_edge_to_adjacent_faces(self.0, edgeId, pts) } - } - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_polyhedron_get_face_to_adjacent_faces( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_polyhedron_get_face_to_adjacent_faces(self.0, faceId, faceIds) } - } - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_polyhedron_get_point_to_incident_edges( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_polyhedron_get_point_to_incident_edges(self.0, pointId, edgeIds) } - } - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_polyhedron_get_point_to_incident_faces( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_polyhedron_get_point_to_incident_faces(self.0, pointId, faceIds) } - } - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_polyhedron_get_point_to_one_ring_points( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_polyhedron_get_point_to_one_ring_points(self.0, pointId, pts) } - } - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { - unsafe extern "C" { - fn vtk_polyhedron_get_centroid( - sself: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_polyhedron_get_centroid(self.0, centroid) } - } - fn get_parametric_coords(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_polyhedron_get_parametric_coords( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_polyhedron_get_parametric_coords(self.0) } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_polyhedron_get_cell_type( @@ -53505,7 +28714,7 @@ impl VtkPolyhedron for vtkPolyhedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -53520,7 +28729,7 @@ impl VtkPolyhedron for vtkPolyhedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -53550,7 +28759,7 @@ impl VtkPolyhedron for vtkPolyhedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -53564,7 +28773,7 @@ impl VtkPolyhedron for vtkPolyhedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -53585,82 +28794,6 @@ impl VtkPolyhedron for vtkPolyhedron { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polyhedron_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polyhedron_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polyhedron_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_polyhedron_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polyhedron_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polyhedron_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -53677,56 +28810,6 @@ impl VtkPolyhedron for vtkPolyhedron { } unsafe { vtk_polyhedron_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polyhedron_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_polyhedron_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polyhedron_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_polyhedron_cell_boundary(self.0, subId, pcoords, pts) } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polyhedron_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_polyhedron_get_parametric_center(self.0, pcoords) } - } fn is_primary_cell(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_polyhedron_is_primary_cell( @@ -53735,34 +28818,6 @@ impl VtkPolyhedron for vtkPolyhedron { } unsafe { vtk_polyhedron_is_primary_cell(self.0) } } - fn interpolate_functions( - &mut self, - x: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polyhedron_interpolate_functions( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - sf: core::ffi::c_double, - ); - } - unsafe { vtk_polyhedron_interpolate_functions(self.0, x, sf) } - } - fn interpolate_derivs( - &mut self, - x: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_polyhedron_interpolate_derivs( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_polyhedron_interpolate_derivs(self.0, x, derivs) } - } fn requires_explicit_face_representation(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_polyhedron_requires_explicit_face_representation( @@ -53771,20 +28826,6 @@ impl VtkPolyhedron for vtkPolyhedron { } unsafe { vtk_polyhedron_requires_explicit_face_representation(self.0) } } - fn is_inside( - &mut self, - x: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polyhedron_is_inside( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_polyhedron_is_inside(self.0, x, tolerance) } - } fn is_convex(&mut self) -> bool { unsafe extern "C" { fn vtk_polyhedron_is_convex(sself: *mut core::ffi::c_void) -> bool; @@ -53824,141 +28865,6 @@ impl VtkPyramid for vtkPyramid { } unsafe { vtk_pyramid_new_instance(self.0) } } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_pyramid_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_pyramid_get_edge_points(self.0, edgeId, pts) } - } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_pyramid_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_pyramid_get_edge_points(self.0, edgeId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_face_points(self.0, faceId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_pyramid_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_pyramid_get_face_points(self.0, faceId, pts) } - } - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_pyramid_get_edge_to_adjacent_faces( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_pyramid_get_edge_to_adjacent_faces(self.0, edgeId, pts) } - } - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_face_to_adjacent_faces( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_face_to_adjacent_faces(self.0, faceId, faceIds) } - } - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_point_to_incident_edges( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_point_to_incident_edges(self.0, pointId, edgeIds) } - } - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_point_to_incident_faces( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_point_to_incident_faces(self.0, pointId, faceIds) } - } - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_point_to_one_ring_points( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_point_to_one_ring_points(self.0, pointId, pts) } - } - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { - unsafe extern "C" { - fn vtk_pyramid_get_centroid( - sself: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_pyramid_get_centroid(self.0, centroid) } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_pyramid_get_cell_type( @@ -54001,98 +28907,6 @@ impl VtkPyramid for vtkPyramid { } unsafe { vtk_pyramid_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pyramid_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_pyramid_cell_boundary(self.0, subId, pcoords, pts) } - } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pyramid_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_pyramid_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pyramid_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_pyramid_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pyramid_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_pyramid_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -54109,219 +28923,6 @@ impl VtkPyramid for vtkPyramid { } unsafe { vtk_pyramid_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pyramid_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_pyramid_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } - fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_pyramid_get_triangle_cases( - sself: *mut core::ffi::c_void, - caseId: core::ffi::c_int, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_pyramid_get_triangle_cases(self.0, caseId) } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pyramid_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_pyramid_get_parametric_center(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pyramid_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_pyramid_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pyramid_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_pyramid_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pyramid_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_pyramid_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_pyramid_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_pyramid_interpolate_derivs(self.0, pcoords, derivs) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pyramid_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_pyramid_jacobian_inverse(self.0, pcoords, inverse, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_face_array(self.0, faceId) } - } - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_edge_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_edge_to_adjacent_faces_array(self.0, edgeId) } - } - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_face_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_face_to_adjacent_faces_array(self.0, faceId) } - } - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_point_to_incident_edges_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_point_to_incident_edges_array(self.0, pointId) } - } - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_point_to_incident_faces_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_point_to_incident_faces_array(self.0, pointId) } - } - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_pyramid_get_point_to_one_ring_points_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_pyramid_get_point_to_one_ring_points_array(self.0, pointId) } - } - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_pyramid_compute_centroid( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_pyramid_compute_centroid(self.0, points, pointIds, centroid) } - } } impl VtkQuad for vtkQuad { fn new(&mut self) -> *mut core::ffi::c_void { @@ -54395,22 +28996,6 @@ impl VtkQuad for vtkQuad { } unsafe { vtk_quad_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quad_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quad_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -54422,7 +29007,7 @@ impl VtkQuad for vtkQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -54437,7 +29022,7 @@ impl VtkQuad for vtkQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -54458,82 +29043,6 @@ impl VtkQuad for vtkQuad { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quad_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quad_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quad_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quad_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quad_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quad_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -54550,38 +29059,6 @@ impl VtkQuad for vtkQuad { } unsafe { vtk_quad_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quad_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quad_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quad_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_quad_get_parametric_center(self.0, pcoords) } - } fn clip( &mut self, value: core::ffi::c_double, @@ -54591,7 +29068,7 @@ impl VtkQuad for vtkQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -54605,7 +29082,7 @@ impl VtkQuad for vtkQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -54626,74 +29103,6 @@ impl VtkQuad for vtkQuad { ) } } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quad_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ); - } - unsafe { vtk_quad_interpolation_functions(self.0, pcoords, sf) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quad_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quad_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quad_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ); - } - unsafe { vtk_quad_interpolate_functions(self.0, pcoords, sf) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quad_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quad_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quad_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quad_get_edge_array(self.0, edgeId) } - } } impl VtkQuadraticEdge for vtkQuadraticEdge { fn new(&mut self) -> *mut core::ffi::c_void { @@ -54771,22 +29180,6 @@ impl VtkQuadraticEdge for vtkQuadraticEdge { } unsafe { vtk_quadratic_edge_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_edge_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_edge_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -54798,7 +29191,7 @@ impl VtkQuadraticEdge for vtkQuadraticEdge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -54813,7 +29206,7 @@ impl VtkQuadraticEdge for vtkQuadraticEdge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -54834,58 +29227,6 @@ impl VtkQuadraticEdge for vtkQuadraticEdge { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_edge_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_edge_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_edge_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_edge_evaluate_location(self.0, subId, pcoords, x, weights) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -54902,28 +29243,6 @@ impl VtkQuadraticEdge for vtkQuadraticEdge { } unsafe { vtk_quadratic_edge_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_edge_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_edge_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -54933,7 +29252,7 @@ impl VtkQuadraticEdge for vtkQuadraticEdge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -54947,7 +29266,7 @@ impl VtkQuadraticEdge for vtkQuadraticEdge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -54968,109 +29287,6 @@ impl VtkQuadraticEdge for vtkQuadraticEdge { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_edge_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_edge_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_edge_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_edge_get_parametric_center(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_edge_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_edge_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_edge_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_edge_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_edge_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_edge_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_edge_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_edge_interpolate_derivs(self.0, pcoords, derivs) } - } } impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { fn new(&mut self) -> *mut core::ffi::c_void { @@ -55148,22 +29364,6 @@ impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { } unsafe { vtk_quadratic_hexahedron_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_hexahedron_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -55175,7 +29375,7 @@ impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -55190,7 +29390,7 @@ impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -55211,64 +29411,6 @@ impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_hexahedron_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_hexahedron_evaluate_location( - self.0, - subId, - pcoords, - x, - weights, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -55285,35 +29427,6 @@ impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { } unsafe { vtk_quadratic_hexahedron_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_hexahedron_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -55323,7 +29436,7 @@ impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -55337,7 +29450,7 @@ impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -55358,143 +29471,6 @@ impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_hexahedron_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_hexahedron_interpolation_functions(self.0, pcoords, weights) - } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_hexahedron_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_hexahedron_interpolate_functions(self.0, pcoords, weights) - } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_hexahedron_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quadratic_hexahedron_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quadratic_hexahedron_get_face_array(self.0, faceId) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_hexahedron_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_hexahedron_jacobian_inverse(self.0, pcoords, inverse, derivs) - } - } } impl VtkQuadraticLinearQuad for vtkQuadraticLinearQuad { fn new(&mut self) -> *mut core::ffi::c_void { @@ -55572,22 +29548,6 @@ impl VtkQuadraticLinearQuad for vtkQuadraticLinearQuad { } unsafe { vtk_quadratic_linear_quad_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_linear_quad_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -55599,7 +29559,7 @@ impl VtkQuadraticLinearQuad for vtkQuadraticLinearQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -55614,7 +29574,7 @@ impl VtkQuadraticLinearQuad for vtkQuadraticLinearQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -55635,110 +29595,23 @@ impl VtkQuadraticLinearQuad for vtkQuadraticLinearQuad { ) } } - fn evaluate_position( + fn triangulate( &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, ) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_quadratic_linear_quad_evaluate_position( + fn vtk_quadratic_linear_quad_triangulate( sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, ) -> core::ffi::c_int; } - unsafe { - vtk_quadratic_linear_quad_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } + unsafe { vtk_quadratic_linear_quad_triangulate(self.0, index, ptIds, pts) } } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_quad_evaluate_location( - self.0, - subId, - pcoords, - x, - weights, - ) - } - } - fn triangulate( - &mut self, - index: core::ffi::c_int, - ptIds: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_triangulate( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ptIds: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_linear_quad_triangulate(self.0, index, ptIds, pts) } - } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_quad_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } - fn clip( + fn clip( &mut self, value: core::ffi::c_double, cellScalars: *mut core::ffi::c_void, @@ -55747,7 +29620,7 @@ impl VtkQuadraticLinearQuad for vtkQuadraticLinearQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -55761,7 +29634,7 @@ impl VtkQuadraticLinearQuad for vtkQuadraticLinearQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -55782,124 +29655,6 @@ impl VtkQuadraticLinearQuad for vtkQuadraticLinearQuad { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_linear_quad_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_linear_quad_get_parametric_center(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_quad_interpolation_functions(self.0, pcoords, weights) - } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_quad_interpolation_derivs(self.0, pcoords, derivs) - } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_quad_interpolate_functions(self.0, pcoords, weights) - } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_linear_quad_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array(&mut self, edgeId: core::ffi::c_uchar) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_linear_quad_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_quadratic_linear_quad_get_edge_array(self.0, edgeId) } - } } impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { fn new(&mut self) -> *mut core::ffi::c_void { @@ -55977,22 +29732,6 @@ impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { } unsafe { vtk_quadratic_linear_wedge_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_linear_wedge_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -56004,7 +29743,7 @@ impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -56019,7 +29758,7 @@ impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -56040,64 +29779,6 @@ impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_linear_wedge_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_wedge_evaluate_location( - self.0, - subId, - pcoords, - x, - weights, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -56114,35 +29795,6 @@ impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { } unsafe { vtk_quadratic_linear_wedge_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_wedge_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -56152,7 +29804,7 @@ impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -56166,7 +29818,7 @@ impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -56187,157 +29839,6 @@ impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_linear_wedge_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_linear_wedge_get_parametric_center(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_wedge_interpolation_functions(self.0, pcoords, weights) - } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_wedge_interpolation_derivs(self.0, pcoords, derivs) - } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_wedge_interpolate_functions(self.0, pcoords, weights) - } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_linear_wedge_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quadratic_linear_wedge_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quadratic_linear_wedge_get_face_array(self.0, faceId) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_linear_wedge_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_linear_wedge_jacobian_inverse(self.0, pcoords, inverse, derivs) - } - } } impl VtkQuadraticPolygon for vtkQuadraticPolygon { fn new(&mut self) -> *mut core::ffi::c_void { @@ -56415,22 +29916,6 @@ impl VtkQuadraticPolygon for vtkQuadraticPolygon { } unsafe { vtk_quadratic_polygon_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_polygon_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_polygon_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -56442,7 +29927,7 @@ impl VtkQuadraticPolygon for vtkQuadraticPolygon { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -56457,7 +29942,7 @@ impl VtkQuadraticPolygon for vtkQuadraticPolygon { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -56487,7 +29972,7 @@ impl VtkQuadraticPolygon for vtkQuadraticPolygon { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -56501,7 +29986,7 @@ impl VtkQuadraticPolygon for vtkQuadraticPolygon { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -56522,169 +30007,6 @@ impl VtkQuadraticPolygon for vtkQuadraticPolygon { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_polygon_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_polygon_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_polygon_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_polygon_evaluate_location(self.0, subId, pcoords, x, weights) - } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_polygon_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_polygon_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn interpolate_functions( - &mut self, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_polygon_interpolate_functions( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_polygon_interpolate_functions(self.0, x, weights) } - } - fn compute_centroid( - &mut self, - ids: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_polygon_compute_centroid( - sself: *mut core::ffi::c_void, - ids: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_polygon_compute_centroid(self.0, ids, pts, centroid) } - } - fn parameterize_polygon( - &mut self, - p0: core::ffi::c_double, - p10: core::ffi::c_double, - l10: core::ffi::c_double, - p20: core::ffi::c_double, - l20: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_polygon_parameterize_polygon( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_double, - p10: core::ffi::c_double, - l10: core::ffi::c_double, - p20: core::ffi::c_double, - l20: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_polygon_parameterize_polygon(self.0, p0, p10, l10, p20, l20, n) - } - } - fn point_in_polygon( - &mut self, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_polygon_point_in_polygon( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - n: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_polygon_point_in_polygon(self.0, x, numPts, pts, bounds, n) - } - } fn triangulate(&mut self, outTris: *mut core::ffi::c_void) -> core::ffi::c_int { unsafe extern "C" { fn vtk_quadratic_polygon_triangulate( @@ -56694,22 +30016,6 @@ impl VtkQuadraticPolygon for vtkQuadraticPolygon { } unsafe { vtk_quadratic_polygon_triangulate(self.0, outTris) } } - fn triangulate( - &mut self, - index: core::ffi::c_int, - ptIds: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_polygon_triangulate( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ptIds: *mut core::ffi::c_void, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_polygon_triangulate(self.0, index, ptIds, pts) } - } fn non_degenerate_triangulate( &mut self, outTris: *mut core::ffi::c_void, @@ -56722,131 +30028,6 @@ impl VtkQuadraticPolygon for vtkQuadraticPolygon { } unsafe { vtk_quadratic_polygon_non_degenerate_triangulate(self.0, outTris) } } - fn distance_to_polygon( - &mut self, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - closest: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_quadratic_polygon_distance_to_polygon( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - numPts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - closest: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { - vtk_quadratic_polygon_distance_to_polygon( - self.0, - x, - numPts, - pts, - bounds, - closest, - ) - } - } - fn intersect_polygon_with_polygon( - &mut self, - npts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - npts2: core::ffi::c_int, - pts2: core::ffi::c_double, - bounds2: core::ffi::c_double, - tol: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_polygon_intersect_polygon_with_polygon( - sself: *mut core::ffi::c_void, - npts: core::ffi::c_int, - pts: core::ffi::c_double, - bounds: core::ffi::c_double, - npts2: core::ffi::c_int, - pts2: core::ffi::c_double, - bounds2: core::ffi::c_double, - tol: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_polygon_intersect_polygon_with_polygon( - self.0, - npts, - pts, - bounds, - npts2, - pts2, - bounds2, - tol, - x, - ) - } - } - fn intersect_convex_2_d_cells( - &mut self, - cell1: *mut core::ffi::c_void, - cell2: *mut core::ffi::c_void, - tol: core::ffi::c_double, - p0: core::ffi::c_double, - p1: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_polygon_intersect_convex_2_d_cells( - sself: *mut core::ffi::c_void, - cell1: *mut core::ffi::c_void, - cell2: *mut core::ffi::c_void, - tol: core::ffi::c_double, - p0: core::ffi::c_double, - p1: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_polygon_intersect_convex_2_d_cells( - self.0, - cell1, - cell2, - tol, - p0, - p1, - ) - } - } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_polygon_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_polygon_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn get_use_mvc_interpolation(&mut self) -> bool { unsafe extern "C" { fn vtk_quadratic_polygon_get_use_mvc_interpolation( @@ -56941,22 +30122,6 @@ impl VtkQuadraticPyramid for vtkQuadraticPyramid { } unsafe { vtk_quadratic_pyramid_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_pyramid_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_pyramid_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -56968,7 +30133,7 @@ impl VtkQuadraticPyramid for vtkQuadraticPyramid { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -56983,7 +30148,7 @@ impl VtkQuadraticPyramid for vtkQuadraticPyramid { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -57004,58 +30169,6 @@ impl VtkQuadraticPyramid for vtkQuadraticPyramid { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_pyramid_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_pyramid_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_pyramid_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_pyramid_evaluate_location(self.0, subId, pcoords, x, weights) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -57072,35 +30185,6 @@ impl VtkQuadraticPyramid for vtkQuadraticPyramid { } unsafe { vtk_quadratic_pyramid_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_pyramid_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_pyramid_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -57110,7 +30194,7 @@ impl VtkQuadraticPyramid for vtkQuadraticPyramid { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -57124,7 +30208,7 @@ impl VtkQuadraticPyramid for vtkQuadraticPyramid { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -57145,171 +30229,24 @@ impl VtkQuadraticPyramid for vtkQuadraticPyramid { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { +} +impl VtkQuadraticQuad for vtkQuadraticQuad { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_quadratic_pyramid_intersect_with_line( + fn vtk_quadratic_quad_new( sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_pyramid_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) + ) -> *mut core::ffi::c_void; } + unsafe { vtk_quadratic_quad_new(self.0) } } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_quadratic_pyramid_get_parametric_center( + fn vtk_quadratic_quad_safe_down_cast( sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_quadratic_pyramid_get_parametric_center(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_pyramid_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_pyramid_interpolation_functions(self.0, pcoords, weights) - } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_pyramid_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_pyramid_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_pyramid_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_pyramid_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_pyramid_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_pyramid_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quadratic_pyramid_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quadratic_pyramid_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quadratic_pyramid_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quadratic_pyramid_get_face_array(self.0, faceId) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_pyramid_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_pyramid_jacobian_inverse(self.0, pcoords, inverse, derivs) - } - } -} -impl VtkQuadraticQuad for vtkQuadraticQuad { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_quadratic_quad_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_quadratic_quad_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_quadratic_quad_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_quadratic_quad_safe_down_cast(self.0, o) } + unsafe { vtk_quadratic_quad_safe_down_cast(self.0, o) } } fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -57369,22 +30306,6 @@ impl VtkQuadraticQuad for vtkQuadraticQuad { } unsafe { vtk_quadratic_quad_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_quad_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_quad_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -57396,7 +30317,7 @@ impl VtkQuadraticQuad for vtkQuadraticQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -57411,7 +30332,7 @@ impl VtkQuadraticQuad for vtkQuadraticQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -57432,58 +30353,6 @@ impl VtkQuadraticQuad for vtkQuadraticQuad { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_quad_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_quad_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_quad_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_quad_evaluate_location(self.0, subId, pcoords, x, weights) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -57500,28 +30369,6 @@ impl VtkQuadraticQuad for vtkQuadraticQuad { } unsafe { vtk_quadratic_quad_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_quad_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_quad_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -57531,7 +30378,7 @@ impl VtkQuadraticQuad for vtkQuadraticQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -57545,7 +30392,7 @@ impl VtkQuadraticQuad for vtkQuadraticQuad { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -57566,109 +30413,6 @@ impl VtkQuadraticQuad for vtkQuadraticQuad { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_quad_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_quad_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_quad_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_quad_get_parametric_center(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_quad_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_quad_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_quad_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_quad_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_quad_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_quad_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_quad_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_quad_interpolate_derivs(self.0, pcoords, derivs) } - } } impl VtkQuadraticTetra for vtkQuadraticTetra { fn new(&mut self) -> *mut core::ffi::c_void { @@ -57746,22 +30490,6 @@ impl VtkQuadraticTetra for vtkQuadraticTetra { } unsafe { vtk_quadratic_tetra_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_tetra_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_tetra_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -57773,7 +30501,7 @@ impl VtkQuadraticTetra for vtkQuadraticTetra { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -57788,7 +30516,7 @@ impl VtkQuadraticTetra for vtkQuadraticTetra { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -57809,58 +30537,6 @@ impl VtkQuadraticTetra for vtkQuadraticTetra { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_tetra_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_tetra_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_tetra_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_tetra_evaluate_location(self.0, subId, pcoords, x, weights) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -57877,28 +30553,6 @@ impl VtkQuadraticTetra for vtkQuadraticTetra { } unsafe { vtk_quadratic_tetra_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_tetra_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_tetra_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -57908,7 +30562,7 @@ impl VtkQuadraticTetra for vtkQuadraticTetra { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -57922,7 +30576,7 @@ impl VtkQuadraticTetra for vtkQuadraticTetra { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -57943,161 +30597,6 @@ impl VtkQuadraticTetra for vtkQuadraticTetra { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_tetra_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_tetra_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_tetra_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_tetra_get_parametric_center(self.0, pcoords) } - } - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_quadratic_tetra_get_parametric_distance( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_quadratic_tetra_get_parametric_distance(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_tetra_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_tetra_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_tetra_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_tetra_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_tetra_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_tetra_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_tetra_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_tetra_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quadratic_tetra_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quadratic_tetra_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quadratic_tetra_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quadratic_tetra_get_face_array(self.0, faceId) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_tetra_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_tetra_jacobian_inverse(self.0, pcoords, inverse, derivs) } - } } impl VtkQuadraticTriangle for vtkQuadraticTriangle { fn new(&mut self) -> *mut core::ffi::c_void { @@ -58175,22 +30674,6 @@ impl VtkQuadraticTriangle for vtkQuadraticTriangle { } unsafe { vtk_quadratic_triangle_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_triangle_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_triangle_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -58202,7 +30685,7 @@ impl VtkQuadraticTriangle for vtkQuadraticTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -58217,7 +30700,7 @@ impl VtkQuadraticTriangle for vtkQuadraticTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -58238,58 +30721,6 @@ impl VtkQuadraticTriangle for vtkQuadraticTriangle { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_triangle_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_triangle_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_triangle_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_triangle_evaluate_location(self.0, subId, pcoords, x, weights) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -58306,35 +30737,6 @@ impl VtkQuadraticTriangle for vtkQuadraticTriangle { } unsafe { vtk_quadratic_triangle_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_triangle_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_triangle_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -58344,7 +30746,7 @@ impl VtkQuadraticTriangle for vtkQuadraticTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -58358,7 +30760,7 @@ impl VtkQuadraticTriangle for vtkQuadraticTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -58379,123 +30781,6 @@ impl VtkQuadraticTriangle for vtkQuadraticTriangle { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_triangle_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_triangle_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_triangle_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_triangle_get_parametric_center(self.0, pcoords) } - } - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_quadratic_triangle_get_parametric_distance( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_quadratic_triangle_get_parametric_distance(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_triangle_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_triangle_interpolation_functions(self.0, pcoords, weights) - } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_triangle_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_triangle_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_triangle_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_triangle_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_triangle_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_triangle_interpolate_derivs(self.0, pcoords, derivs) } - } } impl VtkQuadraticWedge for vtkQuadraticWedge { fn new(&mut self) -> *mut core::ffi::c_void { @@ -58573,22 +30858,6 @@ impl VtkQuadraticWedge for vtkQuadraticWedge { } unsafe { vtk_quadratic_wedge_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_wedge_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadratic_wedge_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -58600,7 +30869,7 @@ impl VtkQuadraticWedge for vtkQuadraticWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -58615,7 +30884,7 @@ impl VtkQuadraticWedge for vtkQuadraticWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -58636,58 +30905,6 @@ impl VtkQuadraticWedge for vtkQuadraticWedge { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadratic_wedge_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_wedge_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_wedge_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_wedge_evaluate_location(self.0, subId, pcoords, x, weights) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -58704,28 +30921,6 @@ impl VtkQuadraticWedge for vtkQuadraticWedge { } unsafe { vtk_quadratic_wedge_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_wedge_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_quadratic_wedge_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -58735,7 +30930,7 @@ impl VtkQuadraticWedge for vtkQuadraticWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -58749,7 +30944,7 @@ impl VtkQuadraticWedge for vtkQuadraticWedge { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -58770,201 +30965,49 @@ impl VtkQuadraticWedge for vtkQuadraticWedge { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { +} +impl VtkQuadratureSchemeDefinition for vtkQuadratureSchemeDefinition { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_quadratic_wedge_intersect_with_line( + fn vtk_quadrature_scheme_definition_safe_down_cast( sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_quadratic_wedge_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } + unsafe { vtk_quadrature_scheme_definition_safe_down_cast(self.0, o) } } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_quadratic_wedge_get_parametric_center( + fn vtk_quadrature_scheme_definition_new_instance( sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_quadratic_wedge_get_parametric_center(self.0, pcoords) } + unsafe { vtk_quadrature_scheme_definition_new_instance(self.0) } } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { + fn dictionary(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_quadratic_wedge_interpolation_functions( + fn vtk_quadrature_scheme_definition_dictionary( sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_quadratic_wedge_interpolation_functions(self.0, pcoords, weights) } + unsafe { vtk_quadrature_scheme_definition_dictionary(self.0) } } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { + fn quadrature_offset_array_name(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_quadratic_wedge_interpolation_derivs( + fn vtk_quadrature_scheme_definition_quadrature_offset_array_name( sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_quadratic_wedge_interpolation_derivs(self.0, pcoords, derivs) } + unsafe { vtk_quadrature_scheme_definition_quadrature_offset_array_name(self.0) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_quadratic_wedge_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_wedge_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_wedge_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_wedge_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quadratic_wedge_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quadratic_wedge_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_quadratic_wedge_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_quadratic_wedge_get_face_array(self.0, faceId) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadratic_wedge_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_quadratic_wedge_jacobian_inverse(self.0, pcoords, inverse, derivs) } - } -} -impl VtkQuadratureSchemeDefinition for vtkQuadratureSchemeDefinition { - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_quadrature_scheme_definition_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_quadrature_scheme_definition_new_instance(self.0) } - } - fn dictionary(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_dictionary( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_quadrature_scheme_definition_dictionary(self.0) } - } - fn quadrature_offset_array_name(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_quadrature_offset_array_name( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_quadrature_scheme_definition_quadrature_offset_array_name(self.0) } - } - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_new( + fn vtk_quadrature_scheme_definition_new( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } unsafe { vtk_quadrature_scheme_definition_new(self.0) } } - fn deep_copy(&mut self, other: vtkQuadratureSchemeDefinition) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_deep_copy( - sself: *mut core::ffi::c_void, - other: vtkQuadratureSchemeDefinition, - ) -> core::ffi::c_int; - } - unsafe { vtk_quadrature_scheme_definition_deep_copy(self.0, other) } - } fn save_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int { unsafe extern "C" { fn vtk_quadrature_scheme_definition_save_state( @@ -58989,61 +31032,6 @@ impl VtkQuadratureSchemeDefinition for vtkQuadratureSchemeDefinition { } unsafe { vtk_quadrature_scheme_definition_clear(self.0) } } - fn initialize( - &mut self, - cellType: core::ffi::c_int, - numberOfNodes: core::ffi::c_int, - numberOfQuadraturePoints: core::ffi::c_int, - shapeFunctionWeights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_initialize( - sself: *mut core::ffi::c_void, - cellType: core::ffi::c_int, - numberOfNodes: core::ffi::c_int, - numberOfQuadraturePoints: core::ffi::c_int, - shapeFunctionWeights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadrature_scheme_definition_initialize( - self.0, - cellType, - numberOfNodes, - numberOfQuadraturePoints, - shapeFunctionWeights, - ) - } - } - fn initialize( - &mut self, - cellType: core::ffi::c_int, - numberOfNodes: core::ffi::c_int, - numberOfQuadraturePoints: core::ffi::c_int, - shapeFunctionWeights: core::ffi::c_double, - quadratureWeights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_initialize( - sself: *mut core::ffi::c_void, - cellType: core::ffi::c_int, - numberOfNodes: core::ffi::c_int, - numberOfQuadraturePoints: core::ffi::c_int, - shapeFunctionWeights: core::ffi::c_double, - quadratureWeights: core::ffi::c_double, - ); - } - unsafe { - vtk_quadrature_scheme_definition_initialize( - self.0, - cellType, - numberOfNodes, - numberOfQuadraturePoints, - shapeFunctionWeights, - quadratureWeights, - ) - } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_quadrature_scheme_definition_get_cell_type( @@ -59078,39 +31066,6 @@ impl VtkQuadratureSchemeDefinition for vtkQuadratureSchemeDefinition { vtk_quadrature_scheme_definition_get_number_of_quadrature_points(self.0) } } - fn get_shape_function_weights(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_get_shape_function_weights( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_quadrature_scheme_definition_get_shape_function_weights(self.0) } - } - fn get_shape_function_weights( - &mut self, - quadraturePointId: core::ffi::c_int, - ) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_get_shape_function_weights( - sself: *mut core::ffi::c_void, - quadraturePointId: core::ffi::c_int, - ) -> *const core::ffi::c_double; - } - unsafe { - vtk_quadrature_scheme_definition_get_shape_function_weights( - self.0, - quadraturePointId, - ) - } - } - fn get_quadrature_weights(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_quadrature_scheme_definition_get_quadrature_weights( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_quadrature_scheme_definition_get_quadrature_weights(self.0) } - } } impl VtkQuadric for vtkQuadric { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -59136,38 +31091,6 @@ impl VtkQuadric for vtkQuadric { } unsafe { vtk_quadric_new(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_quadric_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_quadric_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quadric_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - g: core::ffi::c_double, - ); - } - unsafe { vtk_quadric_evaluate_gradient(self.0, x, g) } - } - fn set_coefficients(&mut self, a: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_quadric_set_coefficients( - sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - ); - } - unsafe { vtk_quadric_set_coefficients(self.0, a) } - } fn set_coefficients( &mut self, a0: core::ffi::c_double, @@ -59200,23 +31123,6 @@ impl VtkQuadric for vtkQuadric { vtk_quadric_set_coefficients(self.0, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) } } - fn get_coefficients(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_quadric_get_coefficients( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_quadric_get_coefficients(self.0) } - } - fn get_coefficients(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_quadric_get_coefficients( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_quadric_get_coefficients(self.0, data) } - } } impl VtkRectilinearGrid for vtkRectilinearGrid { fn new(&mut self) -> *mut core::ffi::c_void { @@ -59275,154 +31181,49 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { } unsafe { vtk_rectilinear_grid_initialize(self.0) } } - fn get_number_of_cells(&mut self) -> core::ffi::c_uchar { + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_rectilinear_grid_get_number_of_cells( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_rectilinear_grid_get_number_of_cells(self.0) } } - fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_rectilinear_grid_get_number_of_points( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_rectilinear_grid_get_number_of_points(self.0) } } - fn get_point(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_point( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_rectilinear_grid_get_point(self.0, ptId) } - } - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_rectilinear_grid_get_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_rectilinear_grid_get_cell(self.0, cellId) } } - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_cell( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ); - } - unsafe { vtk_rectilinear_grid_get_cell(self.0, cellId, cell) } - } - fn find_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_rectilinear_grid_find_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_rectilinear_grid_find_point(self.0, x) } - } - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_rectilinear_grid_find_cell( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_rectilinear_grid_find_cell( - self.0, - x, - cell, - cellId, - tol2, - subId, - pcoords, - weights, - ) - } - } - fn find_cell( - &mut self, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_rectilinear_grid_find_cell( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - cell: *mut core::ffi::c_void, - gencell: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - tol2: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_rectilinear_grid_find_cell( - self.0, - x, - cell, - gencell, - cellId, - tol2, - subId, - pcoords, - weights, - ) - } - } - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_rectilinear_grid_get_cell_type( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_rectilinear_grid_get_cell_type(self.0, cellId) } } fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_rectilinear_grid_get_cell_points( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ); } @@ -59430,13 +31231,13 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { } fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_rectilinear_grid_get_point_cells( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ); } @@ -59450,46 +31251,20 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { } unsafe { vtk_rectilinear_grid_get_max_cell_size(self.0) } } - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - seedLoc: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_cell_neighbors( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - seedLoc: core::ffi::c_int, - ); - } - unsafe { - vtk_rectilinear_grid_get_cell_neighbors( - self.0, - cellId, - ptIds, - cellIds, - seedLoc, - ) - } - } - fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_rectilinear_grid_is_point_visible( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_rectilinear_grid_is_point_visible(self.0, ptId) } } - fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_rectilinear_grid_is_cell_visible( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_rectilinear_grid_is_cell_visible(self.0, cellId) } @@ -59510,15 +31285,6 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { } unsafe { vtk_rectilinear_grid_has_any_blank_cells(self.0) } } - fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_cell_dims( - sself: *mut core::ffi::c_void, - cellDims: core::ffi::c_int, - ); - } - unsafe { vtk_rectilinear_grid_get_cell_dims(self.0, cellDims) } - } fn get_points(&mut self, pnts: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_rectilinear_grid_get_points( @@ -59544,32 +31310,6 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { } unsafe { vtk_rectilinear_grid_set_dimensions(self.0, i, j, k) } } - fn set_dimensions(&mut self, dim: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_set_dimensions( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - ); - } - unsafe { vtk_rectilinear_grid_set_dimensions(self.0, dim) } - } - fn get_dimensions(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_dimensions( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_rectilinear_grid_get_dimensions(self.0) } - } - fn get_dimensions(&mut self, data: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_dimensions( - sself: *mut core::ffi::c_void, - data: core::ffi::c_int, - ); - } - unsafe { vtk_rectilinear_grid_get_dimensions(self.0, data) } - } fn get_data_dimension(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_rectilinear_grid_get_data_dimension( @@ -59578,60 +31318,6 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { } unsafe { vtk_rectilinear_grid_get_data_dimension(self.0) } } - fn compute_structured_coordinates( - &mut self, - x: core::ffi::c_double, - ijk: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_rectilinear_grid_compute_structured_coordinates( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ijk: core::ffi::c_int, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_rectilinear_grid_compute_structured_coordinates(self.0, x, ijk, pcoords) - } - } - fn compute_point_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_rectilinear_grid_compute_point_id( - sself: *mut core::ffi::c_void, - ijk: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_rectilinear_grid_compute_point_id(self.0, ijk) } - } - fn compute_cell_id(&mut self, ijk: core::ffi::c_int) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_rectilinear_grid_compute_cell_id( - sself: *mut core::ffi::c_void, - ijk: core::ffi::c_int, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_rectilinear_grid_compute_cell_id(self.0, ijk) } - } - fn get_point( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - p: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_point( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - p: core::ffi::c_double, - ); - } - unsafe { vtk_rectilinear_grid_get_point(self.0, i, j, k, p) } - } fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_rectilinear_grid_set_x_coordinates( @@ -59683,15 +31369,6 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { } unsafe { vtk_rectilinear_grid_get_z_coordinates(self.0) } } - fn set_extent(&mut self, extent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_set_extent( - sself: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_rectilinear_grid_set_extent(self.0, extent) } - } fn set_extent( &mut self, xMin: core::ffi::c_int, @@ -59716,55 +31393,6 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { vtk_rectilinear_grid_set_extent(self.0, xMin, xMax, yMin, yMax, zMin, zMax) } } - fn get_extent(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_extent( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_rectilinear_grid_get_extent(self.0) } - } - fn get_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_extent( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ); - } - unsafe { - vtk_rectilinear_grid_get_extent( - self.0, - _arg1, - _arg2, - _arg3, - _arg4, - _arg5, - _arg6, - ) - } - } - fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_extent( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_rectilinear_grid_get_extent(self.0, _arg) } - } fn get_extent_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_rectilinear_grid_get_extent_type( @@ -59773,15 +31401,6 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { } unsafe { vtk_rectilinear_grid_get_extent_type(self.0) } } - fn crop(&mut self, updateExtent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_crop( - sself: *mut core::ffi::c_void, - updateExtent: core::ffi::c_int, - ); - } - unsafe { vtk_rectilinear_grid_crop(self.0, updateExtent) } - } fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_rectilinear_grid_get_data( @@ -59791,20 +31410,6 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { } unsafe { vtk_rectilinear_grid_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_rectilinear_grid_get_data(self.0, v, i) } - } fn set_scalar_type( &mut self, p0: core::ffi::c_int, @@ -59840,21 +31445,17 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { } unsafe { vtk_rectilinear_grid_has_scalar_type(self.0, meta_data) } } - fn get_scalar_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_scalar_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_rectilinear_grid_get_scalar_type(self.0) } - } - fn get_scalar_type_as_string(&mut self) -> *const core::ffi::c_char { + fn get_scalar_type_as_string(&mut self) -> &str { unsafe extern "C" { fn vtk_rectilinear_grid_get_scalar_type_as_string( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_rectilinear_grid_get_scalar_type_as_string(self.0) } + let ptr = unsafe { vtk_rectilinear_grid_get_scalar_type_as_string(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn set_number_of_scalar_components( &mut self, @@ -59900,14 +31501,6 @@ impl VtkRectilinearGrid for vtkRectilinearGrid { vtk_rectilinear_grid_has_number_of_scalar_components(self.0, meta_data) } } - fn get_number_of_scalar_components(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_rectilinear_grid_get_number_of_scalar_components( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_rectilinear_grid_get_number_of_scalar_components(self.0) } - } } impl VtkReebGraph for vtkReebGraph { fn new(&mut self) -> *mut core::ffi::c_void { @@ -59949,93 +31542,23 @@ impl VtkReebGraph for vtkReebGraph { } unsafe { vtk_reeb_graph_build(self.0, mesh, scalarField) } } - fn build( - &mut self, - mesh: *mut core::ffi::c_void, - scalarField: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_reeb_graph_build( - sself: *mut core::ffi::c_void, - mesh: *mut core::ffi::c_void, - scalarField: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_reeb_graph_build(self.0, mesh, scalarField) } - } - fn build( - &mut self, - mesh: *mut core::ffi::c_void, - scalarFieldId: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_reeb_graph_build( - sself: *mut core::ffi::c_void, - mesh: *mut core::ffi::c_void, - scalarFieldId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_reeb_graph_build(self.0, mesh, scalarFieldId) } - } - fn build( - &mut self, - mesh: *mut core::ffi::c_void, - scalarFieldId: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_reeb_graph_build( - sself: *mut core::ffi::c_void, - mesh: *mut core::ffi::c_void, - scalarFieldId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_reeb_graph_build(self.0, mesh, scalarFieldId) } - } - fn build( - &mut self, - mesh: *mut core::ffi::c_void, - scalarFieldName: core::ffi::c_char, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_reeb_graph_build( - sself: *mut core::ffi::c_void, - mesh: *mut core::ffi::c_void, - scalarFieldName: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { vtk_reeb_graph_build(self.0, mesh, scalarFieldName) } - } - fn build( - &mut self, - mesh: *mut core::ffi::c_void, - scalarFieldName: core::ffi::c_char, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_reeb_graph_build( - sself: *mut core::ffi::c_void, - mesh: *mut core::ffi::c_void, - scalarFieldName: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { vtk_reeb_graph_build(self.0, mesh, scalarFieldName) } - } fn stream_triangle( &mut self, - vertex0Id: core::ffi::c_uchar, + vertex0Id: core::ffi::c_longlong, scalar0: core::ffi::c_double, - vertex1Id: core::ffi::c_uchar, + vertex1Id: core::ffi::c_longlong, scalar1: core::ffi::c_double, - vertex2Id: core::ffi::c_uchar, + vertex2Id: core::ffi::c_longlong, scalar2: core::ffi::c_double, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_reeb_graph_stream_triangle( sself: *mut core::ffi::c_void, - vertex0Id: core::ffi::c_uchar, + vertex0Id: core::ffi::c_longlong, scalar0: core::ffi::c_double, - vertex1Id: core::ffi::c_uchar, + vertex1Id: core::ffi::c_longlong, scalar1: core::ffi::c_double, - vertex2Id: core::ffi::c_uchar, + vertex2Id: core::ffi::c_longlong, scalar2: core::ffi::c_double, ) -> core::ffi::c_int; } @@ -60053,25 +31576,25 @@ impl VtkReebGraph for vtkReebGraph { } fn stream_tetrahedron( &mut self, - vertex0Id: core::ffi::c_uchar, + vertex0Id: core::ffi::c_longlong, scalar0: core::ffi::c_double, - vertex1Id: core::ffi::c_uchar, + vertex1Id: core::ffi::c_longlong, scalar1: core::ffi::c_double, - vertex2Id: core::ffi::c_uchar, + vertex2Id: core::ffi::c_longlong, scalar2: core::ffi::c_double, - vertex3Id: core::ffi::c_uchar, + vertex3Id: core::ffi::c_longlong, scalar3: core::ffi::c_double, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_reeb_graph_stream_tetrahedron( sself: *mut core::ffi::c_void, - vertex0Id: core::ffi::c_uchar, + vertex0Id: core::ffi::c_longlong, scalar0: core::ffi::c_double, - vertex1Id: core::ffi::c_uchar, + vertex1Id: core::ffi::c_longlong, scalar1: core::ffi::c_double, - vertex2Id: core::ffi::c_uchar, + vertex2Id: core::ffi::c_longlong, scalar2: core::ffi::c_double, - vertex3Id: core::ffi::c_uchar, + vertex3Id: core::ffi::c_longlong, scalar3: core::ffi::c_double, ) -> core::ffi::c_int; } @@ -60198,18 +31721,18 @@ impl VtkReebGraphSimplificationMetric for vtkReebGraphSimplificationMetric { &mut self, mesh: *mut core::ffi::c_void, field: *mut core::ffi::c_void, - startCriticalPoint: core::ffi::c_uchar, + startCriticalPoint: core::ffi::c_longlong, vertexList: *mut core::ffi::c_void, - endCriticalPoint: core::ffi::c_uchar, + endCriticalPoint: core::ffi::c_longlong, ) -> core::ffi::c_double { unsafe extern "C" { fn vtk_reeb_graph_simplification_metric_compute_metric( sself: *mut core::ffi::c_void, mesh: *mut core::ffi::c_void, field: *mut core::ffi::c_void, - startCriticalPoint: core::ffi::c_uchar, + startCriticalPoint: core::ffi::c_longlong, vertexList: *mut core::ffi::c_void, - endCriticalPoint: core::ffi::c_uchar, + endCriticalPoint: core::ffi::c_longlong, ) -> core::ffi::c_double; } unsafe { @@ -60275,29 +31798,6 @@ impl VtkSelection for vtkSelection { } unsafe { vtk_selection_get_node(self.0, idx) } } - fn get_node(&mut self, name: &str) -> *mut core::ffi::c_void { - let c_name = std::ffi::CString::new(name).expect("CString::new failed"); - unsafe extern "C" { - fn vtk_selection_get_node( - sself: *mut core::ffi::c_void, - name: *const core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_selection_get_node(self.0, c_name.as_ptr()) } - } - fn add_node(&mut self, p0: *mut core::ffi::c_void) -> &str { - unsafe extern "C" { - fn vtk_selection_add_node( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { vtk_selection_add_node(self.0, p0) }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } fn set_node(&mut self, name: &str, p1: *mut core::ffi::c_void) -> () { let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { @@ -60309,19 +31809,6 @@ impl VtkSelection for vtkSelection { } unsafe { vtk_selection_set_node(self.0, c_name.as_ptr(), p1) } } - fn get_node_name_at_index(&mut self, idx: core::ffi::c_uint) -> &str { - unsafe extern "C" { - fn vtk_selection_get_node_name_at_index( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_uint, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { vtk_selection_get_node_name_at_index(self.0, idx) }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } fn remove_node(&mut self, idx: core::ffi::c_uint) -> () { unsafe extern "C" { fn vtk_selection_remove_node( @@ -60331,25 +31818,6 @@ impl VtkSelection for vtkSelection { } unsafe { vtk_selection_remove_node(self.0, idx) } } - fn remove_node(&mut self, name: &str) -> () { - let c_name = std::ffi::CString::new(name).expect("CString::new failed"); - unsafe extern "C" { - fn vtk_selection_remove_node( - sself: *mut core::ffi::c_void, - name: *const core::ffi::c_char, - ); - } - unsafe { vtk_selection_remove_node(self.0, c_name.as_ptr()) } - } - fn remove_node(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_selection_remove_node( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_selection_remove_node(self.0, p0) } - } fn remove_all_nodes(&mut self) -> () { unsafe extern "C" { fn vtk_selection_remove_all_nodes(sself: *mut core::ffi::c_void); @@ -60366,18 +31834,6 @@ impl VtkSelection for vtkSelection { } unsafe { vtk_selection_set_expression(self.0, c__arg.as_ptr()) } } - fn get_expression(&mut self) -> &str { - unsafe extern "C" { - fn vtk_selection_get_expression( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { vtk_selection_get_expression(self.0) }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_selection_deep_copy( @@ -60405,15 +31861,6 @@ impl VtkSelection for vtkSelection { } unsafe { vtk_selection_union(self.0, selection) } } - fn union(&mut self, node: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_selection_union( - sself: *mut core::ffi::c_void, - node: *mut core::ffi::c_void, - ); - } - unsafe { vtk_selection_union(self.0, node) } - } fn subtract(&mut self, selection: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_selection_subtract( @@ -60423,15 +31870,6 @@ impl VtkSelection for vtkSelection { } unsafe { vtk_selection_subtract(self.0, selection) } } - fn subtract(&mut self, node: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_selection_subtract( - sself: *mut core::ffi::c_void, - node: *mut core::ffi::c_void, - ); - } - unsafe { vtk_selection_subtract(self.0, node) } - } fn get_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_selection_get_m_time( @@ -60455,20 +31893,6 @@ impl VtkSelection for vtkSelection { } unsafe { vtk_selection_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_selection_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_selection_get_data(self.0, v, i) } - } } impl VtkSelectionNode for vtkSelectionNode { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -60595,17 +32019,20 @@ impl VtkSelectionNode for vtkSelectionNode { } unsafe { vtk_selection_node_get_content_type(self.0) } } - fn get_content_type_as_string( - &mut self, - type_: core::ffi::c_int, - ) -> *const core::ffi::c_char { + fn get_content_type_as_string(&mut self, type_: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_selection_node_get_content_type_as_string( sself: *mut core::ffi::c_void, type_: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_selection_node_get_content_type_as_string(self.0, type_) } + let ptr = unsafe { + vtk_selection_node_get_content_type_as_string(self.0, type_) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn field_type(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -60632,29 +32059,28 @@ impl VtkSelectionNode for vtkSelectionNode { } unsafe { vtk_selection_node_get_field_type(self.0) } } - fn get_field_type_as_string( - &mut self, - type_: core::ffi::c_int, - ) -> *const core::ffi::c_char { + fn get_field_type_as_string(&mut self, type_: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_selection_node_get_field_type_as_string( sself: *mut core::ffi::c_void, type_: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_selection_node_get_field_type_as_string(self.0, type_) } + let ptr = unsafe { vtk_selection_node_get_field_type_as_string(self.0, type_) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn get_field_type_from_string( - &mut self, - type_: core::ffi::c_char, - ) -> core::ffi::c_int { + fn get_field_type_from_string(&mut self, type_: &str) -> core::ffi::c_int { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); unsafe extern "C" { fn vtk_selection_node_get_field_type_from_string( sself: *mut core::ffi::c_void, - type_: core::ffi::c_char, + type_: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_selection_node_get_field_type_from_string(self.0, type_) } + unsafe { vtk_selection_node_get_field_type_from_string(self.0, c_type.as_ptr()) } } fn convert_selection_field_to_attribute_type( &mut self, @@ -60684,22 +32110,15 @@ impl VtkSelectionNode for vtkSelectionNode { vtk_selection_node_convert_attribute_type_to_selection_field(self.0, val) } } - fn set_query_string(&mut self, _arg: core::ffi::c_char) -> () { + fn set_query_string(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { fn vtk_selection_node_set_query_string( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, + _arg: *const core::ffi::c_char, ); } - unsafe { vtk_selection_node_set_query_string(self.0, _arg) } - } - fn get_query_string(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_selection_node_get_query_string( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_selection_node_get_query_string(self.0) } + unsafe { vtk_selection_node_set_query_string(self.0, c__arg.as_ptr()) } } fn epsilon(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -60916,7 +32335,7 @@ impl VtkSimpleCellTessellator for vtkSimpleCellTessellator { &mut self, cell: *mut core::ffi::c_void, att: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, points: *mut core::ffi::c_void, cellArray: *mut core::ffi::c_void, internalPd: *mut core::ffi::c_void, @@ -60926,7 +32345,7 @@ impl VtkSimpleCellTessellator for vtkSimpleCellTessellator { sself: *mut core::ffi::c_void, cell: *mut core::ffi::c_void, att: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, points: *mut core::ffi::c_void, cellArray: *mut core::ffi::c_void, internalPd: *mut core::ffi::c_void, @@ -61119,58 +32538,6 @@ impl VtkSmoothErrorMetric for vtkSmoothErrorMetric { } unsafe { vtk_smooth_error_metric_set_angle_tolerance(self.0, value) } } - fn requires_edge_subdivision( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_smooth_error_metric_requires_edge_subdivision( - sself: *mut core::ffi::c_void, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_smooth_error_metric_requires_edge_subdivision( - self.0, - leftPoint, - midPoint, - rightPoint, - alpha, - ) - } - } - fn get_error( - &mut self, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_smooth_error_metric_get_error( - sself: *mut core::ffi::c_void, - leftPoint: core::ffi::c_double, - midPoint: core::ffi::c_double, - rightPoint: core::ffi::c_double, - alpha: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { - vtk_smooth_error_metric_get_error( - self.0, - leftPoint, - midPoint, - rightPoint, - alpha, - ) - } - } } impl VtkSortFieldData for vtkSortFieldData { fn new(&mut self) -> *mut core::ffi::c_void { @@ -61198,44 +32565,6 @@ impl VtkSortFieldData for vtkSortFieldData { } unsafe { vtk_sort_field_data_new_instance(self.0) } } - fn sort( - &mut self, - fd: *mut core::ffi::c_void, - arrayName: core::ffi::c_char, - k: core::ffi::c_int, - returnIndices: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_sort_field_data_sort( - sself: *mut core::ffi::c_void, - fd: *mut core::ffi::c_void, - arrayName: core::ffi::c_char, - k: core::ffi::c_int, - returnIndices: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_sort_field_data_sort(self.0, fd, arrayName, k, returnIndices) } - } - fn sort( - &mut self, - fd: *mut core::ffi::c_void, - arrayName: core::ffi::c_char, - k: core::ffi::c_int, - returnIndices: core::ffi::c_int, - dir: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_sort_field_data_sort( - sself: *mut core::ffi::c_void, - fd: *mut core::ffi::c_void, - arrayName: core::ffi::c_char, - k: core::ffi::c_int, - returnIndices: core::ffi::c_int, - dir: core::ffi::c_int, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_sort_field_data_sort(self.0, fd, arrayName, k, returnIndices, dir) } - } } impl VtkSphere for vtkSphere { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -61261,29 +32590,6 @@ impl VtkSphere for vtkSphere { } unsafe { vtk_sphere_new(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_sphere_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_sphere_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_sphere_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_sphere_evaluate_gradient(self.0, x, n) } - } fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_sphere_set_radius( @@ -61317,136 +32623,6 @@ impl VtkSphere for vtkSphere { } unsafe { vtk_sphere_set_center(self.0, _arg1, _arg2, _arg3) } } - fn set_center(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_sphere_set_center( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_sphere_set_center(self.0, _arg) } - } - fn get_center(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_sphere_get_center( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_sphere_get_center(self.0) } - } - fn get_center(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_sphere_get_center( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_sphere_get_center(self.0, data) } - } - fn evaluate( - &mut self, - center: core::ffi::c_double, - R: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_sphere_evaluate( - sself: *mut core::ffi::c_void, - center: core::ffi::c_double, - R: core::ffi::c_double, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_sphere_evaluate(self.0, center, R, x) } - } - fn compute_bounding_sphere( - &mut self, - pts: core::ffi::c_float, - numPts: core::ffi::c_uchar, - sphere: core::ffi::c_float, - hints: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_sphere_compute_bounding_sphere( - sself: *mut core::ffi::c_void, - pts: core::ffi::c_float, - numPts: core::ffi::c_uchar, - sphere: core::ffi::c_float, - hints: core::ffi::c_uchar, - ); - } - unsafe { vtk_sphere_compute_bounding_sphere(self.0, pts, numPts, sphere, hints) } - } - fn compute_bounding_sphere( - &mut self, - pts: core::ffi::c_double, - numPts: core::ffi::c_uchar, - sphere: core::ffi::c_double, - hints: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_sphere_compute_bounding_sphere( - sself: *mut core::ffi::c_void, - pts: core::ffi::c_double, - numPts: core::ffi::c_uchar, - sphere: core::ffi::c_double, - hints: core::ffi::c_uchar, - ); - } - unsafe { vtk_sphere_compute_bounding_sphere(self.0, pts, numPts, sphere, hints) } - } - fn compute_bounding_sphere( - &mut self, - spheres: core::ffi::c_float, - numSpheres: core::ffi::c_uchar, - sphere: core::ffi::c_float, - hints: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_sphere_compute_bounding_sphere( - sself: *mut core::ffi::c_void, - spheres: core::ffi::c_float, - numSpheres: core::ffi::c_uchar, - sphere: core::ffi::c_float, - hints: core::ffi::c_uchar, - ); - } - unsafe { - vtk_sphere_compute_bounding_sphere( - self.0, - spheres, - numSpheres, - sphere, - hints, - ) - } - } - fn compute_bounding_sphere( - &mut self, - spheres: core::ffi::c_double, - numSpheres: core::ffi::c_uchar, - sphere: core::ffi::c_double, - hints: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_sphere_compute_bounding_sphere( - sself: *mut core::ffi::c_void, - spheres: core::ffi::c_double, - numSpheres: core::ffi::c_uchar, - sphere: core::ffi::c_double, - hints: core::ffi::c_uchar, - ); - } - unsafe { - vtk_sphere_compute_bounding_sphere( - self.0, - spheres, - numSpheres, - sphere, - hints, - ) - } - } } impl VtkSpheres for vtkSpheres { fn new(&mut self) -> *mut core::ffi::c_void { @@ -61472,29 +32648,6 @@ impl VtkSpheres for vtkSpheres { } unsafe { vtk_spheres_new_instance(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_spheres_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_spheres_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_spheres_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_spheres_evaluate_gradient(self.0, x, n) } - } fn set_centers(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_spheres_set_centers( @@ -61546,16 +32699,6 @@ impl VtkSpheres for vtkSpheres { } unsafe { vtk_spheres_get_sphere(self.0, i) } } - fn get_sphere(&mut self, i: core::ffi::c_int, sphere: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_spheres_get_sphere( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - sphere: *mut core::ffi::c_void, - ); - } - unsafe { vtk_spheres_get_sphere(self.0, i, sphere) } - } } impl VtkStaticCellLinks for vtkStaticCellLinks { fn new(&mut self) -> *mut core::ffi::c_void { @@ -61592,49 +32735,27 @@ impl VtkStaticCellLinks for vtkStaticCellLinks { } unsafe { vtk_static_cell_links_build_links(self.0, ds) } } - fn get_number_of_cells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn get_number_of_cells( + &mut self, + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_cell_links_get_number_of_cells( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_static_cell_links_get_number_of_cells(self.0, ptId) } } - fn get_ncells(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn get_ncells(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_cell_links_get_ncells( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_static_cell_links_get_ncells(self.0, ptId) } } - fn get_cells(&mut self, ptId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_static_cell_links_get_cells( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_static_cell_links_get_cells(self.0, ptId) } - } - fn select_cells( - &mut self, - minMaxDegree: core::ffi::c_uchar, - cellSelection: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_static_cell_links_select_cells( - sself: *mut core::ffi::c_void, - minMaxDegree: core::ffi::c_uchar, - cellSelection: core::ffi::c_uchar, - ); - } - unsafe { - vtk_static_cell_links_select_cells(self.0, minMaxDegree, cellSelection) - } - } fn initialize(&mut self) -> () { unsafe extern "C" { fn vtk_static_cell_links_initialize(sself: *mut core::ffi::c_void); @@ -61713,249 +32834,6 @@ impl VtkStaticCellLocator for vtkStaticCellLocator { } unsafe { vtk_static_cell_locator_set_divisions(self.0, _arg1, _arg2, _arg3) } } - fn set_divisions(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_static_cell_locator_set_divisions( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_static_cell_locator_set_divisions(self.0, _arg) } - } - fn get_divisions(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_static_cell_locator_get_divisions( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_static_cell_locator_get_divisions(self.0) } - } - fn get_divisions(&mut self, data: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_static_cell_locator_get_divisions( - sself: *mut core::ffi::c_void, - data: core::ffi::c_int, - ); - } - unsafe { vtk_static_cell_locator_get_divisions(self.0, data) } - } - fn find_cell( - &mut self, - pos: core::ffi::c_double, - tol2: core::ffi::c_double, - cell: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_static_cell_locator_find_cell( - sself: *mut core::ffi::c_void, - pos: core::ffi::c_double, - tol2: core::ffi::c_double, - cell: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_static_cell_locator_find_cell(self.0, pos, tol2, cell, pcoords, weights) - } - } - fn find_cell(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_static_cell_locator_find_cell( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_static_cell_locator_find_cell(self.0, x) } - } - fn find_cells_along_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tolerance: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_static_cell_locator_find_cells_along_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tolerance: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_static_cell_locator_find_cells_along_line( - self.0, - p1, - p2, - tolerance, - cells, - ) - } - } - fn find_cells_along_plane( - &mut self, - o: core::ffi::c_double, - n: core::ffi::c_double, - tolerance: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_static_cell_locator_find_cells_along_plane( - sself: *mut core::ffi::c_void, - o: core::ffi::c_double, - n: core::ffi::c_double, - tolerance: core::ffi::c_double, - cells: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_static_cell_locator_find_cells_along_plane( - self.0, - o, - n, - tolerance, - cells, - ) - } - } - fn intersect_with_line( - &mut self, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_static_cell_locator_intersect_with_line( - sself: *mut core::ffi::c_void, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_static_cell_locator_intersect_with_line( - self.0, - a0, - a1, - tol, - t, - x, - pcoords, - subId, - cellId, - cell, - ) - } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_static_cell_locator_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_static_cell_locator_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_static_cell_locator_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - cellId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { - vtk_static_cell_locator_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - cellId, - ) - } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - points: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_static_cell_locator_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - points: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_static_cell_locator_intersect_with_line(self.0, p1, p2, points, cellIds) - } - } fn generate_representation( &mut self, level: core::ffi::c_int, @@ -61984,36 +32862,36 @@ impl VtkStaticCellLocator for vtkStaticCellLocator { } unsafe { vtk_static_cell_locator_build_locator(self.0) } } - fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_static_cell_locator_set_max_number_of_buckets( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_static_cell_locator_set_max_number_of_buckets(self.0, _arg) } } - fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar { + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_cell_locator_get_max_number_of_buckets_min_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_static_cell_locator_get_max_number_of_buckets_min_value(self.0) } } - fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar { + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_cell_locator_get_max_number_of_buckets_max_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_static_cell_locator_get_max_number_of_buckets_max_value(self.0) } } - fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar { + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_cell_locator_get_max_number_of_buckets( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_static_cell_locator_get_max_number_of_buckets(self.0) } } @@ -62140,173 +33018,6 @@ impl VtkStaticPointLocator for vtkStaticPointLocator { } unsafe { vtk_static_point_locator_set_divisions(self.0, _arg1, _arg2, _arg3) } } - fn set_divisions(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_set_divisions( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_static_point_locator_set_divisions(self.0, _arg) } - } - fn get_divisions(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_static_point_locator_get_divisions( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_static_point_locator_get_divisions(self.0) } - } - fn get_divisions(&mut self, data: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_get_divisions( - sself: *mut core::ffi::c_void, - data: core::ffi::c_int, - ); - } - unsafe { vtk_static_point_locator_get_divisions(self.0, data) } - } - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_static_point_locator_find_closest_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_static_point_locator_find_closest_point(self.0, x) } - } - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_static_point_locator_find_closest_point_within_radius( - sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_static_point_locator_find_closest_point_within_radius( - self.0, - radius, - x, - dist2, - ) - } - } - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - inputDataLength: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_static_point_locator_find_closest_point_within_radius( - sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, - x: core::ffi::c_double, - inputDataLength: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_static_point_locator_find_closest_point_within_radius( - self.0, - radius, - x, - inputDataLength, - dist2, - ) - } - } - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_find_closest_n_points( - sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { vtk_static_point_locator_find_closest_n_points(self.0, N, x, result) } - } - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_find_points_within_radius( - sself: *mut core::ffi::c_void, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_static_point_locator_find_points_within_radius(self.0, R, x, result) - } - } - fn intersect_with_line( - &mut self, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - lineX: core::ffi::c_double, - ptX: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_static_point_locator_intersect_with_line( - sself: *mut core::ffi::c_void, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - lineX: core::ffi::c_double, - ptX: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { - vtk_static_point_locator_intersect_with_line( - self.0, - a0, - a1, - tol, - t, - lineX, - ptX, - ptId, - ) - } - } - fn merge_points( - &mut self, - tol: core::ffi::c_double, - mergeMap: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_merge_points( - sself: *mut core::ffi::c_void, - tol: core::ffi::c_double, - mergeMap: core::ffi::c_uchar, - ); - } - unsafe { vtk_static_point_locator_merge_points(self.0, tol, mergeMap) } - } fn initialize(&mut self) -> () { unsafe extern "C" { fn vtk_static_point_locator_initialize(sself: *mut core::ffi::c_void); @@ -62327,15 +33038,6 @@ impl VtkStaticPointLocator for vtkStaticPointLocator { } unsafe { vtk_static_point_locator_build_locator(self.0) } } - fn build_locator(&mut self, inBounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_build_locator( - sself: *mut core::ffi::c_void, - inBounds: core::ffi::c_double, - ); - } - unsafe { vtk_static_point_locator_build_locator(self.0, inBounds) } - } fn generate_representation( &mut self, level: core::ffi::c_int, @@ -62352,60 +33054,60 @@ impl VtkStaticPointLocator for vtkStaticPointLocator { } fn get_number_of_points_in_bucket( &mut self, - bNum: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_point_locator_get_number_of_points_in_bucket( sself: *mut core::ffi::c_void, - bNum: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_static_point_locator_get_number_of_points_in_bucket(self.0, bNum) } } fn get_bucket_ids( &mut self, - bNum: core::ffi::c_uchar, + bNum: core::ffi::c_longlong, bList: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_static_point_locator_get_bucket_ids( sself: *mut core::ffi::c_void, - bNum: core::ffi::c_uchar, + bNum: core::ffi::c_longlong, bList: *mut core::ffi::c_void, ); } unsafe { vtk_static_point_locator_get_bucket_ids(self.0, bNum, bList) } } - fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_static_point_locator_set_max_number_of_buckets( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_static_point_locator_set_max_number_of_buckets(self.0, _arg) } } - fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar { + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_point_locator_get_max_number_of_buckets_min_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_static_point_locator_get_max_number_of_buckets_min_value(self.0) } } - fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar { + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_point_locator_get_max_number_of_buckets_max_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_static_point_locator_get_max_number_of_buckets_max_value(self.0) } } - fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar { + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_point_locator_get_max_number_of_buckets( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_static_point_locator_get_max_number_of_buckets(self.0) } } @@ -62417,23 +33119,6 @@ impl VtkStaticPointLocator for vtkStaticPointLocator { } unsafe { vtk_static_point_locator_get_large_ids(self.0) } } - fn get_spacing(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_static_point_locator_get_spacing( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_static_point_locator_get_spacing(self.0) } - } - fn get_spacing(&mut self, spacing: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_get_spacing( - sself: *mut core::ffi::c_void, - spacing: core::ffi::c_double, - ); - } - unsafe { vtk_static_point_locator_get_spacing(self.0, spacing) } - } } impl VtkStaticPointLocator2D for vtkStaticPointLocator2D { fn new(&mut self) -> *mut core::ffi::c_void { @@ -62514,198 +33199,6 @@ impl VtkStaticPointLocator2D for vtkStaticPointLocator2D { } unsafe { vtk_static_point_locator_2_d_set_divisions(self.0, _arg1, _arg2) } } - fn set_divisions(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_set_divisions( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_static_point_locator_2_d_set_divisions(self.0, _arg) } - } - fn get_divisions(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_get_divisions( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_static_point_locator_2_d_get_divisions(self.0) } - } - fn get_divisions(&mut self, data: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_get_divisions( - sself: *mut core::ffi::c_void, - data: core::ffi::c_int, - ); - } - unsafe { vtk_static_point_locator_2_d_get_divisions(self.0, data) } - } - fn find_closest_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_find_closest_point( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_static_point_locator_2_d_find_closest_point(self.0, x) } - } - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_find_closest_point_within_radius( - sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, - x: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_static_point_locator_2_d_find_closest_point_within_radius( - self.0, - radius, - x, - dist2, - ) - } - } - fn find_closest_point_within_radius( - &mut self, - radius: core::ffi::c_double, - x: core::ffi::c_double, - inputDataLength: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_find_closest_point_within_radius( - sself: *mut core::ffi::c_void, - radius: core::ffi::c_double, - x: core::ffi::c_double, - inputDataLength: core::ffi::c_double, - dist2: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_static_point_locator_2_d_find_closest_point_within_radius( - self.0, - radius, - x, - inputDataLength, - dist2, - ) - } - } - fn find_closest_n_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_find_closest_n_points( - sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_static_point_locator_2_d_find_closest_n_points(self.0, N, x, result) - } - } - fn find_points_within_radius( - &mut self, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_find_points_within_radius( - sself: *mut core::ffi::c_void, - R: core::ffi::c_double, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_static_point_locator_2_d_find_points_within_radius(self.0, R, x, result) - } - } - fn intersect_with_line( - &mut self, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - lineX: core::ffi::c_double, - ptX: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_intersect_with_line( - sself: *mut core::ffi::c_void, - a0: core::ffi::c_double, - a1: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - lineX: core::ffi::c_double, - ptX: core::ffi::c_double, - ptId: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { - vtk_static_point_locator_2_d_intersect_with_line( - self.0, - a0, - a1, - tol, - t, - lineX, - ptX, - ptId, - ) - } - } - fn find_close_n_bounded_points( - &mut self, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_find_close_n_bounded_points( - sself: *mut core::ffi::c_void, - N: core::ffi::c_int, - x: core::ffi::c_double, - result: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { - vtk_static_point_locator_2_d_find_close_n_bounded_points( - self.0, - N, - x, - result, - ) - } - } - fn merge_points( - &mut self, - tol: core::ffi::c_double, - mergeMap: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_merge_points( - sself: *mut core::ffi::c_void, - tol: core::ffi::c_double, - mergeMap: core::ffi::c_uchar, - ); - } - unsafe { vtk_static_point_locator_2_d_merge_points(self.0, tol, mergeMap) } - } fn initialize(&mut self) -> () { unsafe extern "C" { fn vtk_static_point_locator_2_d_initialize(sself: *mut core::ffi::c_void); @@ -62728,13 +33221,13 @@ impl VtkStaticPointLocator2D for vtkStaticPointLocator2D { } fn get_number_of_points_in_bucket( &mut self, - bNum: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_point_locator_2_d_get_number_of_points_in_bucket( sself: *mut core::ffi::c_void, - bNum: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_static_point_locator_2_d_get_number_of_points_in_bucket(self.0, bNum) @@ -62742,52 +33235,52 @@ impl VtkStaticPointLocator2D for vtkStaticPointLocator2D { } fn get_bucket_ids( &mut self, - bNum: core::ffi::c_uchar, + bNum: core::ffi::c_longlong, bList: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_static_point_locator_2_d_get_bucket_ids( sself: *mut core::ffi::c_void, - bNum: core::ffi::c_uchar, + bNum: core::ffi::c_longlong, bList: *mut core::ffi::c_void, ); } unsafe { vtk_static_point_locator_2_d_get_bucket_ids(self.0, bNum, bList) } } - fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_static_point_locator_2_d_set_max_number_of_buckets( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_static_point_locator_2_d_set_max_number_of_buckets(self.0, _arg) } } - fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_uchar { + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(self.0) } } - fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_uchar { + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(self.0) } } - fn get_max_number_of_buckets(&mut self) -> core::ffi::c_uchar { + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_static_point_locator_2_d_get_max_number_of_buckets( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_static_point_locator_2_d_get_max_number_of_buckets(self.0) } } @@ -62799,55 +33292,6 @@ impl VtkStaticPointLocator2D for vtkStaticPointLocator2D { } unsafe { vtk_static_point_locator_2_d_get_large_ids(self.0) } } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_static_point_locator_2_d_get_bounds(self.0, bounds) } - } - fn get_spacing(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_get_spacing( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_static_point_locator_2_d_get_spacing(self.0) } - } - fn get_spacing(&mut self, spacing: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_get_spacing( - sself: *mut core::ffi::c_void, - spacing: core::ffi::c_double, - ); - } - unsafe { vtk_static_point_locator_2_d_get_spacing(self.0, spacing) } - } - fn get_bucket_indices( - &mut self, - x: core::ffi::c_double, - ij: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_get_bucket_indices( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ij: core::ffi::c_int, - ); - } - unsafe { vtk_static_point_locator_2_d_get_bucket_indices(self.0, x, ij) } - } - fn get_bucket_index(&mut self, x: core::ffi::c_double) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_static_point_locator_2_d_get_bucket_index( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_static_point_locator_2_d_get_bucket_index(self.0, x) } - } fn generate_representation( &mut self, level: core::ffi::c_int, @@ -62891,86 +33335,6 @@ impl VtkStructuredExtent for vtkStructuredExtent { } unsafe { vtk_structured_extent_new_instance(self.0) } } - fn clamp(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_structured_extent_clamp( - sself: *mut core::ffi::c_void, - ext: core::ffi::c_int, - wholeExt: core::ffi::c_int, - ); - } - unsafe { vtk_structured_extent_clamp(self.0, ext, wholeExt) } - } - fn strictly_smaller( - &mut self, - ext: core::ffi::c_int, - wholeExt: core::ffi::c_int, - ) -> bool { - unsafe extern "C" { - fn vtk_structured_extent_strictly_smaller( - sself: *mut core::ffi::c_void, - ext: core::ffi::c_int, - wholeExt: core::ffi::c_int, - ) -> bool; - } - unsafe { vtk_structured_extent_strictly_smaller(self.0, ext, wholeExt) } - } - fn smaller(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> bool { - unsafe extern "C" { - fn vtk_structured_extent_smaller( - sself: *mut core::ffi::c_void, - ext: core::ffi::c_int, - wholeExt: core::ffi::c_int, - ) -> bool; - } - unsafe { vtk_structured_extent_smaller(self.0, ext, wholeExt) } - } - fn grow(&mut self, ext: core::ffi::c_int, count: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_structured_extent_grow( - sself: *mut core::ffi::c_void, - ext: core::ffi::c_int, - count: core::ffi::c_int, - ); - } - unsafe { vtk_structured_extent_grow(self.0, ext, count) } - } - fn grow( - &mut self, - ext: core::ffi::c_int, - count: core::ffi::c_int, - wholeExt: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_structured_extent_grow( - sself: *mut core::ffi::c_void, - ext: core::ffi::c_int, - count: core::ffi::c_int, - wholeExt: core::ffi::c_int, - ); - } - unsafe { vtk_structured_extent_grow(self.0, ext, count, wholeExt) } - } - fn transform(&mut self, ext: core::ffi::c_int, wholeExt: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_structured_extent_transform( - sself: *mut core::ffi::c_void, - ext: core::ffi::c_int, - wholeExt: core::ffi::c_int, - ); - } - unsafe { vtk_structured_extent_transform(self.0, ext, wholeExt) } - } - fn get_dimensions(&mut self, ext: core::ffi::c_int, dims: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_structured_extent_get_dimensions( - sself: *mut core::ffi::c_void, - ext: core::ffi::c_int, - dims: core::ffi::c_int, - ); - } - unsafe { vtk_structured_extent_get_dimensions(self.0, ext, dims) } - } } impl VtkStructuredGrid for vtkStructuredGrid { fn new(&mut self) -> *mut core::ffi::c_void { @@ -63023,65 +33387,41 @@ impl VtkStructuredGrid for vtkStructuredGrid { } unsafe { vtk_structured_grid_copy_structure(self.0, ds) } } - fn get_number_of_points(&mut self) -> core::ffi::c_uchar { + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_structured_grid_get_number_of_points( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_structured_grid_get_number_of_points(self.0) } } - fn get_point(&mut self, ptId: core::ffi::c_uchar, p: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_structured_grid_get_point( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - p: core::ffi::c_double, - ); - } - unsafe { vtk_structured_grid_get_point(self.0, ptId, p) } - } - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_structured_grid_get_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_structured_grid_get_cell(self.0, cellId) } } - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_structured_grid_get_cell( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ); - } - unsafe { vtk_structured_grid_get_cell(self.0, cellId, cell) } - } - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_structured_grid_get_cell_type( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_structured_grid_get_cell_type(self.0, cellId) } } fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_structured_grid_get_cell_points( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ); } @@ -63089,44 +33429,18 @@ impl VtkStructuredGrid for vtkStructuredGrid { } fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_structured_grid_get_point_cells( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ); } unsafe { vtk_structured_grid_get_point_cells(self.0, ptId, cellIds) } } - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - seedLoc: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_structured_grid_get_cell_neighbors( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ptIds: *mut core::ffi::c_void, - cellIds: *mut core::ffi::c_void, - seedLoc: core::ffi::c_int, - ); - } - unsafe { - vtk_structured_grid_get_cell_neighbors( - self.0, - cellId, - ptIds, - cellIds, - seedLoc, - ) - } - } fn set_dimensions( &mut self, i: core::ffi::c_int, @@ -63143,32 +33457,6 @@ impl VtkStructuredGrid for vtkStructuredGrid { } unsafe { vtk_structured_grid_set_dimensions(self.0, i, j, k) } } - fn set_dimensions(&mut self, dim: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_structured_grid_set_dimensions( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - ); - } - unsafe { vtk_structured_grid_set_dimensions(self.0, dim) } - } - fn get_dimensions(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_structured_grid_get_dimensions( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_structured_grid_get_dimensions(self.0) } - } - fn get_dimensions(&mut self, dim: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_structured_grid_get_dimensions( - sself: *mut core::ffi::c_void, - dim: core::ffi::c_int, - ); - } - unsafe { vtk_structured_grid_get_dimensions(self.0, dim) } - } fn get_data_dimension(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_structured_grid_get_data_dimension( @@ -63177,15 +33465,6 @@ impl VtkStructuredGrid for vtkStructuredGrid { } unsafe { vtk_structured_grid_get_data_dimension(self.0) } } - fn set_extent(&mut self, extent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_structured_grid_set_extent( - sself: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_structured_grid_set_extent(self.0, extent) } - } fn set_extent( &mut self, xMin: core::ffi::c_int, @@ -63210,55 +33489,6 @@ impl VtkStructuredGrid for vtkStructuredGrid { vtk_structured_grid_set_extent(self.0, xMin, xMax, yMin, yMax, zMin, zMax) } } - fn get_extent(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_structured_grid_get_extent( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_structured_grid_get_extent(self.0) } - } - fn get_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_structured_grid_get_extent( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ); - } - unsafe { - vtk_structured_grid_get_extent( - self.0, - _arg1, - _arg2, - _arg3, - _arg4, - _arg5, - _arg6, - ) - } - } - fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_structured_grid_get_extent( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_structured_grid_get_extent(self.0, _arg) } - } fn get_extent_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_structured_grid_get_extent_type( @@ -63267,56 +33497,56 @@ impl VtkStructuredGrid for vtkStructuredGrid { } unsafe { vtk_structured_grid_get_extent_type(self.0) } } - fn blank_point(&mut self, ptId: core::ffi::c_uchar) -> () { + fn blank_point(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_structured_grid_blank_point( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_structured_grid_blank_point(self.0, ptId) } } - fn un_blank_point(&mut self, ptId: core::ffi::c_uchar) -> () { + fn un_blank_point(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_structured_grid_un_blank_point( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_structured_grid_un_blank_point(self.0, ptId) } } - fn blank_cell(&mut self, ptId: core::ffi::c_uchar) -> () { + fn blank_cell(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_structured_grid_blank_cell( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_structured_grid_blank_cell(self.0, ptId) } } - fn un_blank_cell(&mut self, ptId: core::ffi::c_uchar) -> () { + fn un_blank_cell(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_structured_grid_un_blank_cell( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_structured_grid_un_blank_cell(self.0, ptId) } } - fn is_point_visible(&mut self, ptId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_structured_grid_is_point_visible( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_structured_grid_is_point_visible(self.0, ptId) } } - fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_structured_grid_is_cell_visible( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_structured_grid_is_cell_visible(self.0, cellId) } @@ -63337,24 +33567,6 @@ impl VtkStructuredGrid for vtkStructuredGrid { } unsafe { vtk_structured_grid_has_any_blank_cells(self.0) } } - fn get_cell_dims(&mut self, cellDims: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_structured_grid_get_cell_dims( - sself: *mut core::ffi::c_void, - cellDims: core::ffi::c_int, - ); - } - unsafe { vtk_structured_grid_get_cell_dims(self.0, cellDims) } - } - fn crop(&mut self, updateExtent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_structured_grid_crop( - sself: *mut core::ffi::c_void, - updateExtent: core::ffi::c_int, - ); - } - unsafe { vtk_structured_grid_crop(self.0, updateExtent) } - } fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_structured_grid_get_data( @@ -63364,40 +33576,6 @@ impl VtkStructuredGrid for vtkStructuredGrid { } unsafe { vtk_structured_grid_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_structured_grid_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_structured_grid_get_data(self.0, v, i) } - } - fn get_point( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - p: core::ffi::c_double, - adjustForExtent: bool, - ) -> () { - unsafe extern "C" { - fn vtk_structured_grid_get_point( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - p: core::ffi::c_double, - adjustForExtent: bool, - ); - } - unsafe { vtk_structured_grid_get_point(self.0, i, j, k, p, adjustForExtent) } - } } impl VtkStructuredPoints for vtkStructuredPoints { fn new(&mut self) -> *mut core::ffi::c_void { @@ -63477,17 +33655,6 @@ impl VtkStructuredPointsCollection for vtkStructuredPointsCollection { } unsafe { vtk_structured_points_collection_get_next_item(self.0) } } - fn get_next_structured_points(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_structured_points_collection_get_next_structured_points( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { - vtk_structured_points_collection_get_next_structured_points(self.0, cookie) - } - } } impl VtkSuperquadric for vtkSuperquadric { fn new(&mut self) -> *mut core::ffi::c_void { @@ -63515,29 +33682,6 @@ impl VtkSuperquadric for vtkSuperquadric { } unsafe { vtk_superquadric_new_instance(self.0) } } - fn evaluate_function(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_superquadric_evaluate_function( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_superquadric_evaluate_function(self.0, x) } - } - fn evaluate_gradient( - &mut self, - x: core::ffi::c_double, - g: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_superquadric_evaluate_gradient( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - g: core::ffi::c_double, - ); - } - unsafe { vtk_superquadric_evaluate_gradient(self.0, x, g) } - } fn set_center( &mut self, _arg1: core::ffi::c_double, @@ -63554,32 +33698,6 @@ impl VtkSuperquadric for vtkSuperquadric { } unsafe { vtk_superquadric_set_center(self.0, _arg1, _arg2, _arg3) } } - fn set_center(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_superquadric_set_center( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_superquadric_set_center(self.0, _arg) } - } - fn get_center(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_superquadric_get_center( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_superquadric_get_center(self.0) } - } - fn get_center(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_superquadric_get_center( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_superquadric_get_center(self.0, data) } - } fn set_scale( &mut self, _arg1: core::ffi::c_double, @@ -63596,32 +33714,6 @@ impl VtkSuperquadric for vtkSuperquadric { } unsafe { vtk_superquadric_set_scale(self.0, _arg1, _arg2, _arg3) } } - fn set_scale(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_superquadric_set_scale( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_superquadric_set_scale(self.0, _arg) } - } - fn get_scale(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_superquadric_get_scale( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_superquadric_get_scale(self.0) } - } - fn get_scale(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_superquadric_get_scale( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_superquadric_get_scale(self.0, data) } - } fn get_thickness(&mut self) -> core::ffi::c_double { unsafe extern "C" { fn vtk_superquadric_get_thickness( @@ -63803,121 +33895,115 @@ impl VtkTable for vtkTable { } unsafe { vtk_table_set_row_data(self.0, data) } } - fn get_number_of_rows(&mut self) -> core::ffi::c_uchar { + fn get_number_of_rows(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_table_get_number_of_rows( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_table_get_number_of_rows(self.0) } } - fn set_number_of_rows(&mut self, p0: core::ffi::c_uchar) -> () { + fn set_number_of_rows(&mut self, p0: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_table_set_number_of_rows( sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, + p0: core::ffi::c_longlong, ); } unsafe { vtk_table_set_number_of_rows(self.0, p0) } } - fn get_row(&mut self, row: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_row(&mut self, row: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_table_get_row( sself: *mut core::ffi::c_void, - row: core::ffi::c_uchar, + row: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_table_get_row(self.0, row) } } - fn get_row( + fn set_row( &mut self, - row: core::ffi::c_uchar, + row: core::ffi::c_longlong, values: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { - fn vtk_table_get_row( + fn vtk_table_set_row( sself: *mut core::ffi::c_void, - row: core::ffi::c_uchar, + row: core::ffi::c_longlong, values: *mut core::ffi::c_void, ); } - unsafe { vtk_table_get_row(self.0, row, values) } - } - fn set_row( - &mut self, - row: core::ffi::c_uchar, - values: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_table_set_row( - sself: *mut core::ffi::c_void, - row: core::ffi::c_uchar, - values: *mut core::ffi::c_void, - ); - } - unsafe { vtk_table_set_row(self.0, row, values) } + unsafe { vtk_table_set_row(self.0, row, values) } } fn insert_next_blank_row( &mut self, default_num_val: core::ffi::c_double, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_table_insert_next_blank_row( sself: *mut core::ffi::c_void, default_num_val: core::ffi::c_double, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_table_insert_next_blank_row(self.0, default_num_val) } } - fn insert_next_row(&mut self, values: *mut core::ffi::c_void) -> core::ffi::c_uchar { + fn insert_next_row( + &mut self, + values: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_table_insert_next_row( sself: *mut core::ffi::c_void, values: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_table_insert_next_row(self.0, values) } } - fn remove_row(&mut self, row: core::ffi::c_uchar) -> () { + fn remove_row(&mut self, row: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_table_remove_row( sself: *mut core::ffi::c_void, - row: core::ffi::c_uchar, + row: core::ffi::c_longlong, ); } unsafe { vtk_table_remove_row(self.0, row) } } - fn get_number_of_columns(&mut self) -> core::ffi::c_uchar { + fn get_number_of_columns(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_table_get_number_of_columns( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_table_get_number_of_columns(self.0) } } - fn get_column_name(&mut self, col: core::ffi::c_uchar) -> *const core::ffi::c_char { + fn get_column_name(&mut self, col: core::ffi::c_longlong) -> &str { unsafe extern "C" { fn vtk_table_get_column_name( sself: *mut core::ffi::c_void, - col: core::ffi::c_uchar, + col: core::ffi::c_longlong, ) -> *const core::ffi::c_char; } - unsafe { vtk_table_get_column_name(self.0, col) } + let ptr = unsafe { vtk_table_get_column_name(self.0, col) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn get_column_by_name(&mut self, name: core::ffi::c_char) -> *mut core::ffi::c_void { + fn get_column_by_name(&mut self, name: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_table_get_column_by_name( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } - unsafe { vtk_table_get_column_by_name(self.0, name) } + unsafe { vtk_table_get_column_by_name(self.0, c_name.as_ptr()) } } - fn get_column(&mut self, col: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_column(&mut self, col: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_table_get_column( sself: *mut core::ffi::c_void, - col: core::ffi::c_uchar, + col: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_table_get_column(self.0, col) } @@ -63931,84 +34017,25 @@ impl VtkTable for vtkTable { } unsafe { vtk_table_add_column(self.0, arr) } } - fn remove_column_by_name(&mut self, name: core::ffi::c_char) -> () { + fn remove_column_by_name(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_table_remove_column_by_name( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ); } - unsafe { vtk_table_remove_column_by_name(self.0, name) } + unsafe { vtk_table_remove_column_by_name(self.0, c_name.as_ptr()) } } - fn remove_column(&mut self, col: core::ffi::c_uchar) -> () { + fn remove_column(&mut self, col: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_table_remove_column( sself: *mut core::ffi::c_void, - col: core::ffi::c_uchar, + col: core::ffi::c_longlong, ); } unsafe { vtk_table_remove_column(self.0, col) } } - fn get_value( - &mut self, - row: core::ffi::c_uchar, - col: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_table_get_value( - sself: *mut core::ffi::c_void, - row: core::ffi::c_uchar, - col: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_table_get_value(self.0, row, col) } - } - fn get_value_by_name( - &mut self, - row: core::ffi::c_uchar, - col: core::ffi::c_char, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_table_get_value_by_name( - sself: *mut core::ffi::c_void, - row: core::ffi::c_uchar, - col: core::ffi::c_char, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_table_get_value_by_name(self.0, row, col) } - } - fn set_value( - &mut self, - row: core::ffi::c_uchar, - col: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_table_set_value( - sself: *mut core::ffi::c_void, - row: core::ffi::c_uchar, - col: core::ffi::c_uchar, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_table_set_value(self.0, row, col, value) } - } - fn set_value_by_name( - &mut self, - row: core::ffi::c_uchar, - col: core::ffi::c_char, - value: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_table_set_value_by_name( - sself: *mut core::ffi::c_void, - row: core::ffi::c_uchar, - col: core::ffi::c_char, - value: *mut core::ffi::c_void, - ); - } - unsafe { vtk_table_set_value_by_name(self.0, row, col, value) } - } fn initialize(&mut self) -> () { unsafe extern "C" { fn vtk_table_initialize(sself: *mut core::ffi::c_void); @@ -64024,20 +34051,6 @@ impl VtkTable for vtkTable { } unsafe { vtk_table_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_table_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_table_get_data(self.0, v, i) } - } fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_table_shallow_copy( @@ -64047,12 +34060,15 @@ impl VtkTable for vtkTable { } unsafe { vtk_table_shallow_copy(self.0, src) } } - fn get_number_of_elements(&mut self, type_: core::ffi::c_int) -> core::ffi::c_uchar { + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_table_get_number_of_elements( sself: *mut core::ffi::c_void, type_: core::ffi::c_int, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_table_get_number_of_elements(self.0, type_) } } @@ -64081,141 +34097,6 @@ impl VtkTetra for vtkTetra { } unsafe { vtk_tetra_new_instance(self.0) } } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_tetra_get_edge_points(self.0, edgeId, pts) } - } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_tetra_get_edge_points(self.0, edgeId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_face_points(self.0, faceId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_tetra_get_face_points(self.0, faceId, pts) } - } - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_get_edge_to_adjacent_faces( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_tetra_get_edge_to_adjacent_faces(self.0, edgeId, pts) } - } - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_face_to_adjacent_faces( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_face_to_adjacent_faces(self.0, faceId, faceIds) } - } - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_point_to_incident_edges( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_point_to_incident_edges(self.0, pointId, edgeIds) } - } - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_point_to_incident_faces( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_point_to_incident_faces(self.0, pointId, faceIds) } - } - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_point_to_one_ring_points( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_point_to_one_ring_points(self.0, pointId, pts) } - } - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { - unsafe extern "C" { - fn vtk_tetra_get_centroid( - sself: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_tetra_get_centroid(self.0, centroid) } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_tetra_get_cell_type( @@ -64258,82 +34139,6 @@ impl VtkTetra for vtkTetra { } unsafe { vtk_tetra_get_face(self.0, faceId) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tetra_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_tetra_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_tetra_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tetra_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_tetra_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -64350,345 +34155,6 @@ impl VtkTetra for vtkTetra { } unsafe { vtk_tetra_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_tetra_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } - fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_tetra_get_triangle_cases( - sself: *mut core::ffi::c_void, - caseId: core::ffi::c_int, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_tetra_get_triangle_cases(self.0, caseId) } - } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tetra_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_tetra_cell_boundary(self.0, subId, pcoords, pts) } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tetra_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_tetra_get_parametric_center(self.0, pcoords) } - } - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_tetra_get_parametric_distance( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_tetra_get_parametric_distance(self.0, pcoords) } - } - fn tetra_center( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - p4: core::ffi::c_double, - center: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_tetra_center( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - p4: core::ffi::c_double, - center: core::ffi::c_double, - ); - } - unsafe { vtk_tetra_tetra_center(self.0, p1, p2, p3, p4, center) } - } - fn circumsphere( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - x4: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_tetra_circumsphere( - sself: *mut core::ffi::c_void, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - x4: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_tetra_circumsphere(self.0, x1, x2, x3, x4, center) } - } - fn insphere( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - p4: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_tetra_insphere( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - p4: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_tetra_insphere(self.0, p1, p2, p3, p4, center) } - } - fn barycentric_coords( - &mut self, - x: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - x4: core::ffi::c_double, - bcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tetra_barycentric_coords( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - x4: core::ffi::c_double, - bcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_tetra_barycentric_coords(self.0, x, x1, x2, x3, x4, bcoords) } - } - fn compute_volume( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - p4: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_tetra_compute_volume( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - p4: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_tetra_compute_volume(self.0, p1, p2, p3, p4) } - } - fn jacobian_inverse( - &mut self, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tetra_jacobian_inverse( - sself: *mut core::ffi::c_void, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_tetra_jacobian_inverse(self.0, inverse, derivs) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_tetra_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_tetra_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_tetra_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tetra_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_tetra_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_face_array(self.0, faceId) } - } - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_edge_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_edge_to_adjacent_faces_array(self.0, edgeId) } - } - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_face_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_face_to_adjacent_faces_array(self.0, faceId) } - } - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_point_to_incident_edges_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_point_to_incident_edges_array(self.0, pointId) } - } - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_point_to_incident_faces_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_point_to_incident_faces_array(self.0, pointId) } - } - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tetra_get_point_to_one_ring_points_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_tetra_get_point_to_one_ring_points_array(self.0, pointId) } - } - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_tetra_compute_centroid( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_tetra_compute_centroid(self.0, points, pointIds, centroid) } - } } impl VtkTree for vtkTree { fn new(&mut self) -> *mut core::ffi::c_void { @@ -64714,77 +34180,75 @@ impl VtkTree for vtkTree { } unsafe { vtk_tree_new_instance(self.0) } } - fn get_root(&mut self) -> core::ffi::c_uchar { + fn get_root(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { - fn vtk_tree_get_root(sself: *mut core::ffi::c_void) -> core::ffi::c_uchar; + fn vtk_tree_get_root(sself: *mut core::ffi::c_void) -> core::ffi::c_longlong; } unsafe { vtk_tree_get_root(self.0) } } - fn get_number_of_children(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn get_number_of_children( + &mut self, + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_tree_get_number_of_children( sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_tree_get_number_of_children(self.0, v) } } fn get_child( &mut self, - v: core::ffi::c_uchar, - i: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { + v: core::ffi::c_longlong, + i: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_tree_get_child( sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, - i: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + v: core::ffi::c_longlong, + i: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_tree_get_child(self.0, v, i) } } - fn get_children(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> () { + fn get_children( + &mut self, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ) -> () { unsafe extern "C" { fn vtk_tree_get_children( sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, + v: core::ffi::c_longlong, it: *mut core::ffi::c_void, ); } unsafe { vtk_tree_get_children(self.0, v, it) } } - fn get_parent(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn get_parent(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_tree_get_parent( sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_tree_get_parent(self.0, v) } } - fn get_parent_edge(&mut self, v: core::ffi::c_uchar) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_tree_get_parent_edge( - sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_tree_get_parent_edge(self.0, v) } - } - fn get_level(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn get_level(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_tree_get_level( sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_tree_get_level(self.0, v) } } - fn is_leaf(&mut self, vertex: core::ffi::c_uchar) -> bool { + fn is_leaf(&mut self, vertex: core::ffi::c_longlong) -> bool { unsafe extern "C" { fn vtk_tree_is_leaf( sself: *mut core::ffi::c_void, - vertex: core::ffi::c_uchar, + vertex: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_tree_is_leaf(self.0, vertex) } @@ -64798,29 +34262,15 @@ impl VtkTree for vtkTree { } unsafe { vtk_tree_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_tree_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_tree_get_data(self.0, v, i) } - } fn reorder_children( &mut self, - parent: core::ffi::c_uchar, + parent: core::ffi::c_longlong, children: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_tree_reorder_children( sself: *mut core::ffi::c_void, - parent: core::ffi::c_uchar, + parent: core::ffi::c_longlong, children: *mut core::ffi::c_void, ); } @@ -64974,24 +34424,6 @@ impl VtkTriQuadraticHexahedron for vtkTriQuadraticHexahedron { } unsafe { vtk_tri_quadratic_hexahedron_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_tri_quadratic_hexahedron_cell_boundary(self.0, subId, pcoords, pts) - } - } fn contour( &mut self, value: core::ffi::c_double, @@ -65003,7 +34435,7 @@ impl VtkTriQuadraticHexahedron for vtkTriQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -65018,7 +34450,7 @@ impl VtkTriQuadraticHexahedron for vtkTriQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -65039,64 +34471,6 @@ impl VtkTriQuadraticHexahedron for vtkTriQuadraticHexahedron { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_tri_quadratic_hexahedron_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_hexahedron_evaluate_location( - self.0, - subId, - pcoords, - x, - weights, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -65113,35 +34487,6 @@ impl VtkTriQuadraticHexahedron for vtkTriQuadraticHexahedron { } unsafe { vtk_tri_quadratic_hexahedron_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_hexahedron_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -65151,7 +34496,7 @@ impl VtkTriQuadraticHexahedron for vtkTriQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -65165,7 +34510,7 @@ impl VtkTriQuadraticHexahedron for vtkTriQuadraticHexahedron { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -65186,216 +34531,66 @@ impl VtkTriQuadraticHexahedron for vtkTriQuadraticHexahedron { ) } } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { +} +impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_intersect_with_line( + fn vtk_tri_quadratic_pyramid_new( sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_tri_quadratic_hexahedron_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) + ) -> *mut core::ffi::c_void; } + unsafe { vtk_tri_quadratic_pyramid_new(self.0) } } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_interpolation_functions( + fn vtk_tri_quadratic_pyramid_safe_down_cast( sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_hexahedron_interpolation_functions( - self.0, - pcoords, - weights, - ) + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } + unsafe { vtk_tri_quadratic_pyramid_safe_down_cast(self.0, o) } } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_interpolation_derivs( + fn vtk_tri_quadratic_pyramid_new_instance( sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_hexahedron_interpolation_derivs(self.0, pcoords, derivs) + ) -> *mut core::ffi::c_void; } + unsafe { vtk_tri_quadratic_pyramid_new_instance(self.0) } } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { + fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_interpolate_functions( + fn vtk_tri_quadratic_pyramid_get_cell_type( sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_hexahedron_interpolate_functions(self.0, pcoords, weights) + ) -> core::ffi::c_int; } + unsafe { vtk_tri_quadratic_pyramid_get_cell_type(self.0) } } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { + fn get_cell_dimension(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_interpolate_derivs( + fn vtk_tri_quadratic_pyramid_get_cell_dimension( sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_hexahedron_interpolate_derivs(self.0, pcoords, derivs) + ) -> core::ffi::c_int; } + unsafe { vtk_tri_quadratic_pyramid_get_cell_dimension(self.0) } } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { + fn get_number_of_edges(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_get_edge_array( + fn vtk_tri_quadratic_pyramid_get_number_of_edges( sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; + ) -> core::ffi::c_int; } - unsafe { vtk_tri_quadratic_hexahedron_get_edge_array(self.0, edgeId) } + unsafe { vtk_tri_quadratic_pyramid_get_number_of_edges(self.0) } } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { + fn get_number_of_faces(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_get_face_array( + fn vtk_tri_quadratic_pyramid_get_number_of_faces( sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; + ) -> core::ffi::c_int; } - unsafe { vtk_tri_quadratic_hexahedron_get_face_array(self.0, faceId) } + unsafe { vtk_tri_quadratic_pyramid_get_number_of_faces(self.0) } } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tri_quadratic_hexahedron_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_hexahedron_jacobian_inverse( - self.0, - pcoords, - inverse, - derivs, - ) - } - } -} -impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_tri_quadratic_pyramid_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_tri_quadratic_pyramid_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_tri_quadratic_pyramid_new_instance(self.0) } - } - fn get_cell_type(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_get_cell_type( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_tri_quadratic_pyramid_get_cell_type(self.0) } - } - fn get_cell_dimension(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_get_cell_dimension( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_tri_quadratic_pyramid_get_cell_dimension(self.0) } - } - fn get_number_of_edges(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_get_number_of_edges( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_tri_quadratic_pyramid_get_number_of_edges(self.0) } - } - fn get_number_of_faces(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_get_number_of_faces( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_tri_quadratic_pyramid_get_number_of_faces(self.0) } - } - fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_tri_quadratic_pyramid_get_edge( sself: *mut core::ffi::c_void, @@ -65413,22 +34608,6 @@ impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { } unsafe { vtk_tri_quadratic_pyramid_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_tri_quadratic_pyramid_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -65440,7 +34619,7 @@ impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -65455,7 +34634,7 @@ impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -65476,99 +34655,6 @@ impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_tri_quadratic_pyramid_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_pyramid_evaluate_location( - self.0, - subId, - pcoords, - x, - weights, - ) - } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_tri_quadratic_pyramid_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -65585,35 +34671,6 @@ impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { } unsafe { vtk_tri_quadratic_pyramid_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_pyramid_derivatives( - self.0, - subId, - pcoords, - values, - dim, - derivs, - ) - } - } fn clip( &mut self, value: core::ffi::c_double, @@ -65623,7 +34680,7 @@ impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -65637,7 +34694,7 @@ impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -65658,134 +34715,6 @@ impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { ) } } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_tri_quadratic_pyramid_get_parametric_center(self.0, pcoords) } - } - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_get_parametric_distance( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_tri_quadratic_pyramid_get_parametric_distance(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_pyramid_interpolation_functions(self.0, pcoords, weights) - } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_pyramid_interpolation_derivs(self.0, pcoords, derivs) - } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_pyramid_interpolate_functions(self.0, pcoords, weights) - } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_tri_quadratic_pyramid_interpolate_derivs(self.0, pcoords, derivs) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_tri_quadratic_pyramid_jacobian_inverse(self.0, pcoords, inverse, derivs) - } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_tri_quadratic_pyramid_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_tri_quadratic_pyramid_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_tri_quadratic_pyramid_get_face_array(self.0, faceId) } - } } impl VtkTriangle for vtkTriangle { fn new(&mut self) -> *mut core::ffi::c_void { @@ -65861,22 +34790,6 @@ impl VtkTriangle for vtkTriangle { } unsafe { vtk_triangle_get_face(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_triangle_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -65888,7 +34801,7 @@ impl VtkTriangle for vtkTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -65903,7 +34816,7 @@ impl VtkTriangle for vtkTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -65924,56 +34837,6 @@ impl VtkTriangle for vtkTriangle { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_triangle_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_evaluate_location(self.0, subId, pcoords, x, weights) } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -65990,26 +34853,6 @@ impl VtkTriangle for vtkTriangle { } unsafe { vtk_triangle_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } fn compute_area(&mut self) -> core::ffi::c_double { unsafe extern "C" { fn vtk_triangle_compute_area( @@ -66027,7 +34870,7 @@ impl VtkTriangle for vtkTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -66041,7 +34884,7 @@ impl VtkTriangle for vtkTriangle { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -66062,366 +34905,6 @@ impl VtkTriangle for vtkTriangle { ) } } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_interpolation_functions(self.0, pcoords, sf) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - sf: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_interpolate_functions(self.0, pcoords, sf) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_interpolate_derivs(self.0, pcoords, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_triangle_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_triangle_get_edge_array(self.0, edgeId) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_triangle_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_triangle_get_parametric_center(self.0, pcoords) } - } - fn get_parametric_distance( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_triangle_get_parametric_distance( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_triangle_get_parametric_distance(self.0, pcoords) } - } - fn triangle_center( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - center: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_triangle_center( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - center: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_triangle_center(self.0, p1, p2, p3, center) } - } - fn triangle_area( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_triangle_triangle_area( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_triangle_triangle_area(self.0, p1, p2, p3) } - } - fn circumcircle( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_triangle_circumcircle( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - p3: core::ffi::c_double, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_triangle_circumcircle(self.0, p1, p2, p3, center) } - } - fn barycentric_coords( - &mut self, - x: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - bcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_barycentric_coords( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - bcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_triangle_barycentric_coords(self.0, x, x1, x2, x3, bcoords) } - } - fn project_to_2_d( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_project_to_2_d( - sself: *mut core::ffi::c_void, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_triangle_project_to_2_d(self.0, x1, x2, x3, v1, v2, v3) } - } - fn compute_normal( - &mut self, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_compute_normal( - sself: *mut core::ffi::c_void, - p: *mut core::ffi::c_void, - numPts: core::ffi::c_int, - pts: core::ffi::c_uchar, - n: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_compute_normal(self.0, p, numPts, pts, n) } - } - fn compute_normal( - &mut self, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_compute_normal( - sself: *mut core::ffi::c_void, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_compute_normal(self.0, v1, v2, v3, n) } - } - fn compute_normal_direction( - &mut self, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - n: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_compute_normal_direction( - sself: *mut core::ffi::c_void, - v1: core::ffi::c_double, - v2: core::ffi::c_double, - v3: core::ffi::c_double, - n: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_compute_normal_direction(self.0, v1, v2, v3, n) } - } - fn triangles_intersect( - &mut self, - p1: core::ffi::c_double, - q1: core::ffi::c_double, - r1: core::ffi::c_double, - p2: core::ffi::c_double, - q2: core::ffi::c_double, - r2: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_triangles_intersect( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - q1: core::ffi::c_double, - r1: core::ffi::c_double, - p2: core::ffi::c_double, - q2: core::ffi::c_double, - r2: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_triangle_triangles_intersect(self.0, p1, q1, r1, p2, q2, r2) } - } - fn point_in_triangle( - &mut self, - x: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - tol2: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_point_in_triangle( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - tol2: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_triangle_point_in_triangle(self.0, x, x1, x2, x3, tol2) } - } - fn compute_quadric( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - quadric: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_compute_quadric( - sself: *mut core::ffi::c_void, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - quadric: core::ffi::c_double, - ); - } - unsafe { vtk_triangle_compute_quadric(self.0, x1, x2, x3, quadric) } - } - fn compute_quadric( - &mut self, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - quadric: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_compute_quadric( - sself: *mut core::ffi::c_void, - x1: core::ffi::c_double, - x2: core::ffi::c_double, - x3: core::ffi::c_double, - quadric: *mut core::ffi::c_void, - ); - } - unsafe { vtk_triangle_compute_quadric(self.0, x1, x2, x3, quadric) } - } - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_triangle_compute_centroid( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_triangle_compute_centroid(self.0, points, pointIds, centroid) } - } } impl VtkTriangleStrip for vtkTriangleStrip { fn new(&mut self) -> *mut core::ffi::c_void { @@ -66499,22 +34982,6 @@ impl VtkTriangleStrip for vtkTriangleStrip { } unsafe { vtk_triangle_strip_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_strip_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_triangle_strip_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -66526,7 +34993,7 @@ impl VtkTriangleStrip for vtkTriangleStrip { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -66541,7 +35008,7 @@ impl VtkTriangleStrip for vtkTriangleStrip { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -66571,7 +35038,7 @@ impl VtkTriangleStrip for vtkTriangleStrip { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -66585,7 +35052,7 @@ impl VtkTriangleStrip for vtkTriangleStrip { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -66606,93 +35073,6 @@ impl VtkTriangleStrip for vtkTriangleStrip { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_strip_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_triangle_strip_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_strip_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { - vtk_triangle_strip_evaluate_location(self.0, subId, pcoords, x, weights) - } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_strip_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_triangle_strip_intersect_with_line( - self.0, - p1, - p2, - tol, - t, - x, - pcoords, - subId, - ) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -66709,56 +35089,6 @@ impl VtkTriangleStrip for vtkTriangleStrip { } unsafe { vtk_triangle_strip_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_strip_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { - vtk_triangle_strip_derivatives(self.0, subId, pcoords, values, dim, derivs) - } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_triangle_strip_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_triangle_strip_get_parametric_center(self.0, pcoords) } - } - fn decompose_strip( - &mut self, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - tris: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_triangle_strip_decompose_strip( - sself: *mut core::ffi::c_void, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - tris: *mut core::ffi::c_void, - ); - } - unsafe { vtk_triangle_strip_decompose_strip(self.0, npts, pts, tris) } - } } impl VtkUndirectedGraph for vtkUndirectedGraph { fn new(&mut self) -> *mut core::ffi::c_void { @@ -66786,45 +35116,15 @@ impl VtkUndirectedGraph for vtkUndirectedGraph { } unsafe { vtk_undirected_graph_new_instance(self.0) } } - fn get_in_degree(&mut self, v: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn get_in_degree(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_undirected_graph_get_in_degree( sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; } unsafe { vtk_undirected_graph_get_in_degree(self.0, v) } } - fn get_in_edge( - &mut self, - v: core::ffi::c_uchar, - i: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_undirected_graph_get_in_edge( - sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, - i: core::ffi::c_uchar, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_undirected_graph_get_in_edge(self.0, v, i) } - } - fn get_in_edge( - &mut self, - v: core::ffi::c_uchar, - i: core::ffi::c_uchar, - e: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_undirected_graph_get_in_edge( - sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, - i: core::ffi::c_uchar, - e: *mut core::ffi::c_void, - ); - } - unsafe { vtk_undirected_graph_get_in_edge(self.0, v, i, e) } - } fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_undirected_graph_get_data( @@ -66834,25 +35134,15 @@ impl VtkUndirectedGraph for vtkUndirectedGraph { } unsafe { vtk_undirected_graph_get_data(self.0, info) } } - fn get_data( + fn get_in_edges( &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_undirected_graph_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_undirected_graph_get_data(self.0, v, i) } - } - fn get_in_edges(&mut self, v: core::ffi::c_uchar, it: *mut core::ffi::c_void) -> () { + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ) -> () { unsafe extern "C" { fn vtk_undirected_graph_get_in_edges( sself: *mut core::ffi::c_void, - v: core::ffi::c_uchar, + v: core::ffi::c_longlong, it: *mut core::ffi::c_void, ); } @@ -66918,204 +35208,59 @@ impl VtkUniformGrid for vtkUniformGrid { } unsafe { vtk_uniform_grid_get_grid_description(self.0) } } - fn initialize( - &mut self, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_uniform_grid_initialize( - sself: *mut core::ffi::c_void, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_uniform_grid_initialize(self.0, def, origin, spacing) } - } - fn initialize( - &mut self, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - nGhosts: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_uniform_grid_initialize( - sself: *mut core::ffi::c_void, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - nGhosts: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_uniform_grid_initialize(self.0, def, origin, spacing, nGhosts) } - } - fn initialize( - &mut self, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - nGhosts: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_uniform_grid_initialize( - sself: *mut core::ffi::c_void, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - nGhosts: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_uniform_grid_initialize(self.0, def, origin, spacing, nGhosts) } - } - fn initialize( - &mut self, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - nGhostsI: core::ffi::c_int, - nGhostsJ: core::ffi::c_int, - nGhostsK: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_uniform_grid_initialize( - sself: *mut core::ffi::c_void, - def: vtkAMRBox, - origin: core::ffi::c_double, - spacing: core::ffi::c_double, - nGhostsI: core::ffi::c_int, - nGhostsJ: core::ffi::c_int, - nGhostsK: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_uniform_grid_initialize( - self.0, - def, - origin, - spacing, - nGhostsI, - nGhostsJ, - nGhostsK, - ) - } - } - fn blank_point(&mut self, ptId: core::ffi::c_uchar) -> () { + fn blank_point(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_uniform_grid_blank_point( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_uniform_grid_blank_point(self.0, ptId) } } - fn un_blank_point(&mut self, ptId: core::ffi::c_uchar) -> () { + fn un_blank_point(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_uniform_grid_un_blank_point( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_uniform_grid_un_blank_point(self.0, ptId) } } - fn blank_point( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_uniform_grid_blank_point( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ); - } - unsafe { vtk_uniform_grid_blank_point(self.0, i, j, k) } - } - fn un_blank_point( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_uniform_grid_un_blank_point( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ); - } - unsafe { vtk_uniform_grid_un_blank_point(self.0, i, j, k) } - } - fn blank_cell(&mut self, ptId: core::ffi::c_uchar) -> () { + fn blank_cell(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_uniform_grid_blank_cell( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_uniform_grid_blank_cell(self.0, ptId) } } - fn un_blank_cell(&mut self, ptId: core::ffi::c_uchar) -> () { + fn un_blank_cell(&mut self, ptId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_uniform_grid_un_blank_cell( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, ); } unsafe { vtk_uniform_grid_un_blank_cell(self.0, ptId) } } - fn blank_cell( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_uniform_grid_blank_cell( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ); - } - unsafe { vtk_uniform_grid_blank_cell(self.0, i, j, k) } - } - fn un_blank_cell( + fn is_point_visible( &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_uniform_grid_un_blank_cell( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - k: core::ffi::c_int, - ); - } - unsafe { vtk_uniform_grid_un_blank_cell(self.0, i, j, k) } - } - fn is_point_visible(&mut self, pointId: core::ffi::c_uchar) -> core::ffi::c_uchar { + pointId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_uniform_grid_is_point_visible( sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, + pointId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_uniform_grid_is_point_visible(self.0, pointId) } } - fn is_cell_visible(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_uchar { + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { unsafe extern "C" { fn vtk_uniform_grid_is_cell_visible( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_uchar; } unsafe { vtk_uniform_grid_is_cell_visible(self.0, cellId) } @@ -67137,20 +35282,6 @@ impl VtkUniformGrid for vtkUniformGrid { } unsafe { vtk_uniform_grid_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_uniform_grid_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_uniform_grid_get_data(self.0, v, i) } - } } impl VtkUniformGridAMR for vtkUniformGridAMR { fn new(&mut self) -> *mut core::ffi::c_void { @@ -67200,20 +35331,6 @@ impl VtkUniformGridAMR for vtkUniformGridAMR { } unsafe { vtk_uniform_grid_amr_initialize(self.0) } } - fn initialize( - &mut self, - numLevels: core::ffi::c_int, - blocksPerLevel: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_uniform_grid_amr_initialize( - sself: *mut core::ffi::c_void, - numLevels: core::ffi::c_int, - blocksPerLevel: core::ffi::c_int, - ); - } - unsafe { vtk_uniform_grid_amr_initialize(self.0, numLevels, blocksPerLevel) } - } fn set_grid_description(&mut self, gridDescription: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_uniform_grid_amr_set_grid_description( @@ -67259,41 +35376,6 @@ impl VtkUniformGridAMR for vtkUniformGridAMR { } unsafe { vtk_uniform_grid_amr_get_number_of_data_sets(self.0, level) } } - fn get_bounds(&mut self, bounds: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_uniform_grid_amr_get_bounds( - sself: *mut core::ffi::c_void, - bounds: core::ffi::c_double, - ); - } - unsafe { vtk_uniform_grid_amr_get_bounds(self.0, bounds) } - } - fn get_bounds(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_uniform_grid_amr_get_bounds( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_uniform_grid_amr_get_bounds(self.0) } - } - fn get_min(&mut self, min: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_uniform_grid_amr_get_min( - sself: *mut core::ffi::c_void, - min: core::ffi::c_double, - ); - } - unsafe { vtk_uniform_grid_amr_get_min(self.0, min) } - } - fn get_max(&mut self, max: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_uniform_grid_amr_get_max( - sself: *mut core::ffi::c_void, - max: core::ffi::c_double, - ); - } - unsafe { vtk_uniform_grid_amr_get_max(self.0, max) } - } fn set_data_set( &mut self, iter: *mut core::ffi::c_void, @@ -67308,22 +35390,6 @@ impl VtkUniformGridAMR for vtkUniformGridAMR { } unsafe { vtk_uniform_grid_amr_set_data_set(self.0, iter, dataObj) } } - fn set_data_set( - &mut self, - level: core::ffi::c_uint, - idx: core::ffi::c_uint, - grid: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_uniform_grid_amr_set_data_set( - sself: *mut core::ffi::c_void, - level: core::ffi::c_uint, - idx: core::ffi::c_uint, - grid: *mut core::ffi::c_void, - ); - } - unsafe { vtk_uniform_grid_amr_set_data_set(self.0, level, idx, grid) } - } fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_uniform_grid_amr_get_data_set( @@ -67333,20 +35399,6 @@ impl VtkUniformGridAMR for vtkUniformGridAMR { } unsafe { vtk_uniform_grid_amr_get_data_set(self.0, iter) } } - fn get_data_set( - &mut self, - level: core::ffi::c_uint, - idx: core::ffi::c_uint, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_uniform_grid_amr_get_data_set( - sself: *mut core::ffi::c_void, - level: core::ffi::c_uint, - idx: core::ffi::c_uint, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_uniform_grid_amr_get_data_set(self.0, level, idx) } - } fn get_composite_index( &mut self, level: core::ffi::c_uint, @@ -67364,15 +35416,15 @@ impl VtkUniformGridAMR for vtkUniformGridAMR { fn get_level_and_index( &mut self, compositeIdx: core::ffi::c_uint, - level: core::ffi::c_uint, - idx: core::ffi::c_uint, + level: &mut core::ffi::c_uint, + idx: &mut core::ffi::c_uint, ) -> () { unsafe extern "C" { fn vtk_uniform_grid_amr_get_level_and_index( sself: *mut core::ffi::c_void, compositeIdx: core::ffi::c_uint, - level: core::ffi::c_uint, - idx: core::ffi::c_uint, + level: &mut core::ffi::c_uint, + idx: &mut core::ffi::c_uint, ); } unsafe { @@ -67424,20 +35476,6 @@ impl VtkUniformGridAMR for vtkUniformGridAMR { } unsafe { vtk_uniform_grid_amr_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_uniform_grid_amr_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_uniform_grid_amr_get_data(self.0, v, i) } - } } impl VtkUniformGridAMRDataIterator for vtkUniformGridAMRDataIterator { fn new(&mut self) -> *mut core::ffi::c_void { @@ -67589,48 +35627,6 @@ impl VtkUniformHyperTreeGrid for vtkUniformHyperTreeGrid { } unsafe { vtk_uniform_hyper_tree_grid_set_origin(self.0, _arg1, _arg2, _arg3) } } - fn set_origin(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_uniform_hyper_tree_grid_set_origin( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_uniform_hyper_tree_grid_set_origin(self.0, _arg) } - } - fn get_origin(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_uniform_hyper_tree_grid_get_origin( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_uniform_hyper_tree_grid_get_origin(self.0) } - } - fn get_origin( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_uniform_hyper_tree_grid_get_origin( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { vtk_uniform_hyper_tree_grid_get_origin(self.0, _arg1, _arg2, _arg3) } - } - fn get_origin(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_uniform_hyper_tree_grid_get_origin( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_uniform_hyper_tree_grid_get_origin(self.0, _arg) } - } fn set_grid_scale( &mut self, p0: core::ffi::c_double, @@ -67647,59 +35643,6 @@ impl VtkUniformHyperTreeGrid for vtkUniformHyperTreeGrid { } unsafe { vtk_uniform_hyper_tree_grid_set_grid_scale(self.0, p0, p1, p2) } } - fn set_grid_scale(&mut self, p0: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_uniform_hyper_tree_grid_set_grid_scale( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_double, - ); - } - unsafe { vtk_uniform_hyper_tree_grid_set_grid_scale(self.0, p0) } - } - fn get_grid_scale(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_uniform_hyper_tree_grid_get_grid_scale( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_uniform_hyper_tree_grid_get_grid_scale(self.0) } - } - fn get_grid_scale( - &mut self, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_uniform_hyper_tree_grid_get_grid_scale( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_double, - _arg2: core::ffi::c_double, - _arg3: core::ffi::c_double, - ); - } - unsafe { - vtk_uniform_hyper_tree_grid_get_grid_scale(self.0, _arg1, _arg2, _arg3) - } - } - fn get_grid_scale(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_uniform_hyper_tree_grid_get_grid_scale( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_uniform_hyper_tree_grid_get_grid_scale(self.0, _arg) } - } - fn set_grid_scale(&mut self, p0: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_uniform_hyper_tree_grid_set_grid_scale( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_double, - ); - } - unsafe { vtk_uniform_hyper_tree_grid_set_grid_scale(self.0, p0) } - } fn set_x_coordinates(&mut self, XCoordinates: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_uniform_hyper_tree_grid_set_x_coordinates( @@ -67727,22 +35670,6 @@ impl VtkUniformHyperTreeGrid for vtkUniformHyperTreeGrid { } unsafe { vtk_uniform_hyper_tree_grid_set_z_coordinates(self.0, ZCoordinates) } } - fn get_level_zero_origin_from_index( - &mut self, - p0: core::ffi::c_uchar, - p1: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_uniform_hyper_tree_grid_get_level_zero_origin_from_index( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_uchar, - p1: core::ffi::c_double, - ); - } - unsafe { - vtk_uniform_hyper_tree_grid_get_level_zero_origin_from_index(self.0, p0, p1) - } - } fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes( @@ -67796,28 +35723,28 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } fn allocate_estimate( &mut self, - numCells: core::ffi::c_uchar, - maxCellSize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, ) -> bool { unsafe extern "C" { fn vtk_unstructured_grid_allocate_estimate( sself: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, - maxCellSize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, ) -> bool; } unsafe { vtk_unstructured_grid_allocate_estimate(self.0, numCells, maxCellSize) } } fn allocate_exact( &mut self, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool { unsafe extern "C" { fn vtk_unstructured_grid_allocate_exact( sself: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, - connectivitySize: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, ) -> bool; } unsafe { @@ -67826,13 +35753,13 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } fn allocate( &mut self, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, extSize: core::ffi::c_int, ) -> () { unsafe extern "C" { fn vtk_unstructured_grid_allocate( sself: *mut core::ffi::c_void, - numCells: core::ffi::c_uchar, + numCells: core::ffi::c_longlong, extSize: core::ffi::c_int, ); } @@ -67853,38 +35780,24 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } unsafe { vtk_unstructured_grid_copy_structure(self.0, ds) } } - fn get_cell(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_void { + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_unstructured_grid_get_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> *mut core::ffi::c_void; } unsafe { vtk_unstructured_grid_get_cell(self.0, cellId) } } - fn get_cell( - &mut self, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_get_cell( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - cell: *mut core::ffi::c_void, - ); - } - unsafe { vtk_unstructured_grid_get_cell(self.0, cellId, cell) } - } fn get_cell_points( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_unstructured_grid_get_cell_points( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ); } @@ -67892,23 +35805,23 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } fn get_point_cells( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_unstructured_grid_get_point_cells( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, cellIds: *mut core::ffi::c_void, ); } unsafe { vtk_unstructured_grid_get_point_cells(self.0, ptId, cellIds) } } - fn get_cell_type(&mut self, cellId: core::ffi::c_uchar) -> core::ffi::c_int { + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { unsafe extern "C" { fn vtk_unstructured_grid_get_cell_type( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { vtk_unstructured_grid_get_cell_type(self.0, cellId) } @@ -67922,54 +35835,6 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } unsafe { vtk_unstructured_grid_get_cell_types(self.0, types) } } - fn get_cell_points( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_get_cell_points( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_unstructured_grid_get_cell_points(self.0, cellId, npts, pts) } - } - fn get_point_cells( - &mut self, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_uchar, - cells: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_get_point_cells( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_uchar, - cells: core::ffi::c_uchar, - ); - } - unsafe { vtk_unstructured_grid_get_point_cells(self.0, ptId, ncells, cells) } - } - fn get_point_cells( - &mut self, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_ushort, - cells: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_get_point_cells( - sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - ncells: core::ffi::c_ushort, - cells: core::ffi::c_uchar, - ); - } - unsafe { vtk_unstructured_grid_get_point_cells(self.0, ptId, ncells, cells) } - } fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_unstructured_grid_get_cell_types_array( @@ -68014,34 +35879,18 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } fn get_face_stream( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_unstructured_grid_get_face_stream( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, ); } unsafe { vtk_unstructured_grid_get_face_stream(self.0, cellId, ptIds) } } - fn get_face_stream( - &mut self, - cellId: core::ffi::c_uchar, - nfaces: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_get_face_stream( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - nfaces: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - ); - } - unsafe { vtk_unstructured_grid_get_face_stream(self.0, cellId, nfaces, ptIds) } - } fn set_cells( &mut self, type_: core::ffi::c_int, @@ -68056,60 +35905,6 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } unsafe { vtk_unstructured_grid_set_cells(self.0, type_, cells) } } - fn set_cells( - &mut self, - types: core::ffi::c_int, - cells: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_set_cells( - sself: *mut core::ffi::c_void, - types: core::ffi::c_int, - cells: *mut core::ffi::c_void, - ); - } - unsafe { vtk_unstructured_grid_set_cells(self.0, types, cells) } - } - fn set_cells( - &mut self, - cellTypes: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_set_cells( - sself: *mut core::ffi::c_void, - cellTypes: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - ); - } - unsafe { vtk_unstructured_grid_set_cells(self.0, cellTypes, cells) } - } - fn set_cells( - &mut self, - cellTypes: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - faceLocations: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_set_cells( - sself: *mut core::ffi::c_void, - cellTypes: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - faceLocations: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_unstructured_grid_set_cells( - self.0, - cellTypes, - cells, - faceLocations, - faces, - ) - } - } fn get_cells(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_unstructured_grid_get_cells( @@ -68120,14 +35915,14 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } fn get_cell_neighbors( &mut self, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellIds: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { fn vtk_unstructured_grid_get_cell_neighbors( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellIds: *mut core::ffi::c_void, ); @@ -68136,103 +35931,43 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { vtk_unstructured_grid_get_cell_neighbors(self.0, cellId, ptIds, cellIds) } } - fn get_cell_neighbors( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - cellIds: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_get_cell_neighbors( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - cellIds: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_unstructured_grid_get_cell_neighbors( - self.0, - cellId, - npts, - ptIds, - cellIds, - ) - } - } - fn is_cell_boundary( - &mut self, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - ) -> bool { - unsafe extern "C" { - fn vtk_unstructured_grid_is_cell_boundary( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - npts: core::ffi::c_uchar, - ptIds: core::ffi::c_uchar, - ) -> bool; - } - unsafe { vtk_unstructured_grid_is_cell_boundary(self.0, cellId, npts, ptIds) } - } - fn insert_next_linked_cell( - &mut self, - type_: core::ffi::c_int, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unstructured_grid_insert_next_linked_cell( - sself: *mut core::ffi::c_void, - type_: core::ffi::c_int, - npts: core::ffi::c_int, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { - vtk_unstructured_grid_insert_next_linked_cell(self.0, type_, npts, pts) - } - } fn remove_reference_to_cell( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_unstructured_grid_remove_reference_to_cell( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_unstructured_grid_remove_reference_to_cell(self.0, ptId, cellId) } } fn add_reference_to_cell( &mut self, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ) -> () { unsafe extern "C" { fn vtk_unstructured_grid_add_reference_to_cell( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, - cellId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_unstructured_grid_add_reference_to_cell(self.0, ptId, cellId) } } fn resize_cell_list( &mut self, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, size: core::ffi::c_int, ) -> () { unsafe extern "C" { fn vtk_unstructured_grid_resize_cell_list( sself: *mut core::ffi::c_void, - ptId: core::ffi::c_uchar, + ptId: core::ffi::c_longlong, size: core::ffi::c_int, ); } @@ -68299,37 +36034,6 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } unsafe { vtk_unstructured_grid_get_data(self.0, info) } } - fn get_data( - &mut self, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_unstructured_grid_get_data( - sself: *mut core::ffi::c_void, - v: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_unstructured_grid_get_data(self.0, v, i) } - } - fn get_faces(&mut self, cellId: core::ffi::c_uchar) -> *mut core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_unstructured_grid_get_faces( - sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, - ) -> *mut core::ffi::c_uchar; - } - unsafe { vtk_unstructured_grid_get_faces(self.0, cellId) } - } - fn get_faces(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_unstructured_grid_get_faces( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_unstructured_grid_get_faces(self.0) } - } fn get_face_locations(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_unstructured_grid_get_face_locations( @@ -68340,12 +36044,12 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } fn initialize_faces_representation( &mut self, - numPrevCells: core::ffi::c_uchar, + numPrevCells: core::ffi::c_longlong, ) -> core::ffi::c_int { unsafe extern "C" { fn vtk_unstructured_grid_initialize_faces_representation( sself: *mut core::ffi::c_void, - numPrevCells: core::ffi::c_uchar, + numPrevCells: core::ffi::c_longlong, ) -> core::ffi::c_int; } unsafe { @@ -68363,8 +36067,8 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { fn decompose_a_polyhedron_cell( &mut self, polyhedronCellArray: *mut core::ffi::c_void, - nCellpts: core::ffi::c_uchar, - nCellfaces: core::ffi::c_uchar, + nCellpts: &mut core::ffi::c_longlong, + nCellfaces: &mut core::ffi::c_longlong, cellArray: *mut core::ffi::c_void, faces: *mut core::ffi::c_void, ) -> () { @@ -68372,8 +36076,8 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { fn vtk_unstructured_grid_decompose_a_polyhedron_cell( sself: *mut core::ffi::c_void, polyhedronCellArray: *mut core::ffi::c_void, - nCellpts: core::ffi::c_uchar, - nCellfaces: core::ffi::c_uchar, + nCellpts: &mut core::ffi::c_longlong, + nCellfaces: &mut core::ffi::c_longlong, cellArray: *mut core::ffi::c_void, faces: *mut core::ffi::c_void, ); @@ -68389,107 +36093,6 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { ) } } - fn decompose_a_polyhedron_cell( - &mut self, - polyhedronCellStream: core::ffi::c_uchar, - nCellpts: core::ffi::c_uchar, - nCellfaces: core::ffi::c_uchar, - cellArray: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_decompose_a_polyhedron_cell( - sself: *mut core::ffi::c_void, - polyhedronCellStream: core::ffi::c_uchar, - nCellpts: core::ffi::c_uchar, - nCellfaces: core::ffi::c_uchar, - cellArray: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_unstructured_grid_decompose_a_polyhedron_cell( - self.0, - polyhedronCellStream, - nCellpts, - nCellfaces, - cellArray, - faces, - ) - } - } - fn decompose_a_polyhedron_cell( - &mut self, - nCellFaces: core::ffi::c_uchar, - inFaceStream: core::ffi::c_uchar, - nCellpts: core::ffi::c_uchar, - cellArray: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_decompose_a_polyhedron_cell( - sself: *mut core::ffi::c_void, - nCellFaces: core::ffi::c_uchar, - inFaceStream: core::ffi::c_uchar, - nCellpts: core::ffi::c_uchar, - cellArray: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_unstructured_grid_decompose_a_polyhedron_cell( - self.0, - nCellFaces, - inFaceStream, - nCellpts, - cellArray, - faces, - ) - } - } - fn convert_face_stream_point_ids( - &mut self, - faceStream: *mut core::ffi::c_void, - idMap: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_convert_face_stream_point_ids( - sself: *mut core::ffi::c_void, - faceStream: *mut core::ffi::c_void, - idMap: core::ffi::c_uchar, - ); - } - unsafe { - vtk_unstructured_grid_convert_face_stream_point_ids( - self.0, - faceStream, - idMap, - ) - } - } - fn convert_face_stream_point_ids( - &mut self, - nfaces: core::ffi::c_uchar, - faceStream: core::ffi::c_uchar, - idMap: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_convert_face_stream_point_ids( - sself: *mut core::ffi::c_void, - nfaces: core::ffi::c_uchar, - faceStream: core::ffi::c_uchar, - idMap: core::ffi::c_uchar, - ); - } - unsafe { - vtk_unstructured_grid_convert_face_stream_point_ids( - self.0, - nfaces, - faceStream, - idMap, - ) - } - } fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_unstructured_grid_get_cell_locations_array( @@ -68498,53 +36101,6 @@ impl VtkUnstructuredGrid for vtkUnstructuredGrid { } unsafe { vtk_unstructured_grid_get_cell_locations_array(self.0) } } - fn set_cells( - &mut self, - cellTypes: *mut core::ffi::c_void, - cellLocations: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_set_cells( - sself: *mut core::ffi::c_void, - cellTypes: *mut core::ffi::c_void, - cellLocations: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_unstructured_grid_set_cells(self.0, cellTypes, cellLocations, cells) - } - } - fn set_cells( - &mut self, - cellTypes: *mut core::ffi::c_void, - cellLocations: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - faceLocations: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_set_cells( - sself: *mut core::ffi::c_void, - cellTypes: *mut core::ffi::c_void, - cellLocations: *mut core::ffi::c_void, - cells: *mut core::ffi::c_void, - faceLocations: *mut core::ffi::c_void, - faces: *mut core::ffi::c_void, - ); - } - unsafe { - vtk_unstructured_grid_set_cells( - self.0, - cellTypes, - cellLocations, - cells, - faceLocations, - faces, - ) - } - } } impl VtkUnstructuredGridCellIterator for vtkUnstructuredGridCellIterator { fn new(&mut self) -> *mut core::ffi::c_void { @@ -68580,19 +36136,19 @@ impl VtkUnstructuredGridCellIterator for vtkUnstructuredGridCellIterator { } unsafe { vtk_unstructured_grid_cell_iterator_is_done_with_traversal(self.0) } } - fn get_cell_id(&mut self) -> core::ffi::c_uchar { + fn get_cell_id(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_unstructured_grid_cell_iterator_get_cell_id( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_unstructured_grid_cell_iterator_get_cell_id(self.0) } } - fn go_to_cell(&mut self, cellId: core::ffi::c_uchar) -> () { + fn go_to_cell(&mut self, cellId: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_unstructured_grid_cell_iterator_go_to_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, ); } unsafe { vtk_unstructured_grid_cell_iterator_go_to_cell(self.0, cellId) } @@ -68681,7 +36237,7 @@ impl VtkVertex for vtkVertex { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ) -> () { @@ -68695,7 +36251,7 @@ impl VtkVertex for vtkVertex { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, insideOut: core::ffi::c_int, ); @@ -68716,56 +36272,6 @@ impl VtkVertex for vtkVertex { ) } } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_vertex_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_vertex_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_vertex_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_vertex_evaluate_location(self.0, subId, pcoords, x, weights) } - } fn inflate(&mut self, p0: core::ffi::c_double) -> core::ffi::c_int { unsafe extern "C" { fn vtk_vertex_inflate( @@ -68775,22 +36281,6 @@ impl VtkVertex for vtkVertex { } unsafe { vtk_vertex_inflate(self.0, p0) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_vertex_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_vertex_cell_boundary(self.0, subId, pcoords, pts) } - } fn contour( &mut self, value: core::ffi::c_double, @@ -68802,7 +36292,7 @@ impl VtkVertex for vtkVertex { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ) -> () { unsafe extern "C" { @@ -68817,7 +36307,7 @@ impl VtkVertex for vtkVertex { inPd: *mut core::ffi::c_void, outPd: *mut core::ffi::c_void, inCd: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: core::ffi::c_longlong, outCd: *mut core::ffi::c_void, ); } @@ -68838,44 +36328,6 @@ impl VtkVertex for vtkVertex { ) } } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_vertex_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_vertex_get_parametric_center(self.0, pcoords) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_vertex_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_vertex_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -68892,82 +36344,6 @@ impl VtkVertex for vtkVertex { } unsafe { vtk_vertex_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_vertex_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_vertex_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_vertex_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_vertex_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_vertex_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_vertex_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_vertex_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_vertex_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_vertex_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_vertex_interpolate_derivs(self.0, pcoords, derivs) } - } } impl VtkVertexListIterator for vtkVertexListIterator { fn new(&mut self) -> *mut core::ffi::c_void { @@ -69012,11 +36388,11 @@ impl VtkVertexListIterator for vtkVertexListIterator { } unsafe { vtk_vertex_list_iterator_get_graph(self.0) } } - fn next(&mut self) -> core::ffi::c_uchar { + fn next(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_vertex_list_iterator_next( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_vertex_list_iterator_next(self.0) } } @@ -69051,153 +36427,6 @@ impl VtkVoxel for vtkVoxel { } unsafe { vtk_voxel_new_instance(self.0) } } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_voxel_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_voxel_get_edge_points(self.0, edgeId, pts) } - } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_voxel_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_voxel_get_edge_points(self.0, edgeId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_face_points(self.0, faceId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_voxel_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_voxel_get_face_points(self.0, faceId, pts) } - } - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_voxel_get_edge_to_adjacent_faces( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_voxel_get_edge_to_adjacent_faces(self.0, edgeId, pts) } - } - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faces: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_face_to_adjacent_faces( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - faces: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_face_to_adjacent_faces(self.0, faceId, faces) } - } - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edges: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_point_to_incident_edges( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - edges: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_point_to_incident_edges(self.0, pointId, edges) } - } - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faces: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_point_to_incident_faces( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - faces: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_point_to_incident_faces(self.0, pointId, faces) } - } - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_point_to_one_ring_points( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_point_to_one_ring_points(self.0, pointId, pts) } - } - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { - unsafe extern "C" { - fn vtk_voxel_get_centroid( - sself: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_voxel_get_centroid(self.0, centroid) } - } - fn compute_bounding_sphere( - &mut self, - center: core::ffi::c_double, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_voxel_compute_bounding_sphere( - sself: *mut core::ffi::c_void, - center: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_voxel_compute_bounding_sphere(self.0, center) } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_voxel_get_cell_type( @@ -69240,98 +36469,6 @@ impl VtkVoxel for vtkVoxel { } unsafe { vtk_voxel_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_voxel_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_voxel_cell_boundary(self.0, subId, pcoords, pts) } - } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_voxel_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_voxel_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_voxel_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_voxel_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_voxel_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_voxel_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -69348,26 +36485,6 @@ impl VtkVoxel for vtkVoxel { } unsafe { vtk_voxel_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_voxel_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_voxel_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int { unsafe extern "C" { fn vtk_voxel_inflate( @@ -69377,171 +36494,6 @@ impl VtkVoxel for vtkVoxel { } unsafe { vtk_voxel_inflate(self.0, dist) } } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_voxel_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_voxel_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_voxel_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_voxel_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_voxel_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_voxel_interpolate_derivs(self.0, pcoords, derivs) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_voxel_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_voxel_interpolation_functions(self.0, pcoords, weights) } - } - fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_voxel_get_triangle_cases( - sself: *mut core::ffi::c_void, - caseId: core::ffi::c_int, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_voxel_get_triangle_cases(self.0, caseId) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_face_array(self.0, faceId) } - } - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_edge_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_edge_to_adjacent_faces_array(self.0, edgeId) } - } - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_face_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_face_to_adjacent_faces_array(self.0, faceId) } - } - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_point_to_incident_edges_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_point_to_incident_edges_array(self.0, pointId) } - } - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_point_to_incident_faces_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_point_to_incident_faces_array(self.0, pointId) } - } - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_voxel_get_point_to_one_ring_points_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_voxel_get_point_to_one_ring_points_array(self.0, pointId) } - } - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_voxel_compute_centroid( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_voxel_compute_centroid(self.0, points, pointIds, centroid) } - } } impl VtkWedge for vtkWedge { fn new(&mut self) -> *mut core::ffi::c_void { @@ -69567,141 +36519,6 @@ impl VtkWedge for vtkWedge { } unsafe { vtk_wedge_new_instance(self.0) } } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_wedge_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_wedge_get_edge_points(self.0, edgeId, pts) } - } - fn get_edge_points( - &mut self, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_wedge_get_edge_points( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_wedge_get_edge_points(self.0, edgeId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_face_points(self.0, faceId, pts) } - } - fn get_face_points( - &mut self, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_wedge_get_face_points( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_int, - pts: core::ffi::c_int, - ); - } - unsafe { vtk_wedge_get_face_points(self.0, faceId, pts) } - } - fn get_edge_to_adjacent_faces( - &mut self, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_wedge_get_edge_to_adjacent_faces( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ); - } - unsafe { vtk_wedge_get_edge_to_adjacent_faces(self.0, edgeId, pts) } - } - fn get_face_to_adjacent_faces( - &mut self, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_face_to_adjacent_faces( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_face_to_adjacent_faces(self.0, faceId, faceIds) } - } - fn get_point_to_incident_edges( - &mut self, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_point_to_incident_edges( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - edgeIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_point_to_incident_edges(self.0, pointId, edgeIds) } - } - fn get_point_to_incident_faces( - &mut self, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_point_to_incident_faces( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - faceIds: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_point_to_incident_faces(self.0, pointId, faceIds) } - } - fn get_point_to_one_ring_points( - &mut self, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_point_to_one_ring_points( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - pts: core::ffi::c_uchar, - ) -> core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_point_to_one_ring_points(self.0, pointId, pts) } - } - fn get_centroid(&mut self, centroid: core::ffi::c_double) -> bool { - unsafe extern "C" { - fn vtk_wedge_get_centroid( - sself: *mut core::ffi::c_void, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_wedge_get_centroid(self.0, centroid) } - } fn get_cell_type(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_wedge_get_cell_type( @@ -69744,98 +36561,6 @@ impl VtkWedge for vtkWedge { } unsafe { vtk_wedge_get_face(self.0, faceId) } } - fn cell_boundary( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_wedge_cell_boundary( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - pts: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_wedge_cell_boundary(self.0, subId, pcoords, pts) } - } - fn evaluate_position( - &mut self, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_wedge_evaluate_position( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - closestPoint: core::ffi::c_double, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - dist2: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_wedge_evaluate_position( - self.0, - x, - closestPoint, - subId, - pcoords, - dist2, - weights, - ) - } - } - fn evaluate_location( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_wedge_evaluate_location( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - x: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_wedge_evaluate_location(self.0, subId, pcoords, x, weights) } - } - fn intersect_with_line( - &mut self, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_wedge_intersect_with_line( - sself: *mut core::ffi::c_void, - p1: core::ffi::c_double, - p2: core::ffi::c_double, - tol: core::ffi::c_double, - t: core::ffi::c_double, - x: core::ffi::c_double, - pcoords: core::ffi::c_double, - subId: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_wedge_intersect_with_line(self.0, p1, p2, tol, t, x, pcoords, subId) - } - } fn triangulate( &mut self, index: core::ffi::c_int, @@ -69852,219 +36577,6 @@ impl VtkWedge for vtkWedge { } unsafe { vtk_wedge_triangulate(self.0, index, ptIds, pts) } } - fn derivatives( - &mut self, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_wedge_derivatives( - sself: *mut core::ffi::c_void, - subId: core::ffi::c_int, - pcoords: core::ffi::c_double, - values: core::ffi::c_double, - dim: core::ffi::c_int, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_wedge_derivatives(self.0, subId, pcoords, values, dim, derivs) } - } - fn get_triangle_cases(&mut self, caseId: core::ffi::c_int) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_wedge_get_triangle_cases( - sself: *mut core::ffi::c_void, - caseId: core::ffi::c_int, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_wedge_get_triangle_cases(self.0, caseId) } - } - fn get_parametric_center( - &mut self, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_wedge_get_parametric_center( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_wedge_get_parametric_center(self.0, pcoords) } - } - fn interpolation_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_wedge_interpolation_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_wedge_interpolation_functions(self.0, pcoords, weights) } - } - fn interpolation_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_wedge_interpolation_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_wedge_interpolation_derivs(self.0, pcoords, derivs) } - } - fn interpolate_functions( - &mut self, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_wedge_interpolate_functions( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - weights: core::ffi::c_double, - ); - } - unsafe { vtk_wedge_interpolate_functions(self.0, pcoords, weights) } - } - fn interpolate_derivs( - &mut self, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_wedge_interpolate_derivs( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - derivs: core::ffi::c_double, - ); - } - unsafe { vtk_wedge_interpolate_derivs(self.0, pcoords, derivs) } - } - fn jacobian_inverse( - &mut self, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_wedge_jacobian_inverse( - sself: *mut core::ffi::c_void, - pcoords: core::ffi::c_double, - inverse: core::ffi::c_double, - derivs: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_wedge_jacobian_inverse(self.0, pcoords, inverse, derivs) } - } - fn get_edge_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_edge_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_edge_array(self.0, edgeId) } - } - fn get_face_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_face_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_face_array(self.0, faceId) } - } - fn get_edge_to_adjacent_faces_array( - &mut self, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_edge_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - edgeId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_edge_to_adjacent_faces_array(self.0, edgeId) } - } - fn get_face_to_adjacent_faces_array( - &mut self, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_face_to_adjacent_faces_array( - sself: *mut core::ffi::c_void, - faceId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_face_to_adjacent_faces_array(self.0, faceId) } - } - fn get_point_to_incident_edges_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_point_to_incident_edges_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_point_to_incident_edges_array(self.0, pointId) } - } - fn get_point_to_incident_faces_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_point_to_incident_faces_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_point_to_incident_faces_array(self.0, pointId) } - } - fn get_point_to_one_ring_points_array( - &mut self, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_wedge_get_point_to_one_ring_points_array( - sself: *mut core::ffi::c_void, - pointId: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_wedge_get_point_to_one_ring_points_array(self.0, pointId) } - } - fn compute_centroid( - &mut self, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool { - unsafe extern "C" { - fn vtk_wedge_compute_centroid( - sself: *mut core::ffi::c_void, - points: *mut core::ffi::c_void, - pointIds: core::ffi::c_uchar, - centroid: core::ffi::c_double, - ) -> bool; - } - unsafe { vtk_wedge_compute_centroid(self.0, points, pointIds, centroid) } - } } impl VtkXMLDataElement for vtkXMLDataElement { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -70092,470 +36604,169 @@ impl VtkXMLDataElement for vtkXMLDataElement { } unsafe { vtk_xml_data_element_new(self.0) } } - fn get_name(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_xml_data_element_get_name( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_xml_data_element_get_name(self.0) } - } - fn set_name(&mut self, _arg: core::ffi::c_char) -> () { + fn set_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_set_name( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, + _arg: *const core::ffi::c_char, ); } - unsafe { vtk_xml_data_element_set_name(self.0, _arg) } + unsafe { vtk_xml_data_element_set_name(self.0, c__arg.as_ptr()) } } - fn get_id(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_xml_data_element_get_id( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_xml_data_element_get_id(self.0) } - } - fn set_id(&mut self, _arg: core::ffi::c_char) -> () { + fn set_id(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_set_id( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_char, + _arg: *const core::ffi::c_char, ); } - unsafe { vtk_xml_data_element_set_id(self.0, _arg) } + unsafe { vtk_xml_data_element_set_id(self.0, c__arg.as_ptr()) } } - fn get_attribute(&mut self, name: core::ffi::c_char) -> *const core::ffi::c_char { + fn get_attribute(&mut self, name: &str) -> &str { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_get_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> *const core::ffi::c_char; } - unsafe { vtk_xml_data_element_get_attribute(self.0, name) } + let ptr = unsafe { vtk_xml_data_element_get_attribute(self.0, c_name.as_ptr()) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn set_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_char, - ) -> () { + fn set_attribute(&mut self, name: &str, value: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_value = std::ffi::CString::new(value).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_set_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - value: core::ffi::c_char, + name: *const core::ffi::c_char, + value: *const core::ffi::c_char, ); } - unsafe { vtk_xml_data_element_set_attribute(self.0, name, value) } + unsafe { + vtk_xml_data_element_set_attribute(self.0, c_name.as_ptr(), c_value.as_ptr()) + } } - fn set_character_data( - &mut self, - data: core::ffi::c_char, - length: core::ffi::c_int, - ) -> () { + fn set_character_data(&mut self, data: &str, length: core::ffi::c_int) -> () { + let c_data = std::ffi::CString::new(data).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_set_character_data( sself: *mut core::ffi::c_void, - data: core::ffi::c_char, + data: *const core::ffi::c_char, length: core::ffi::c_int, ); } - unsafe { vtk_xml_data_element_set_character_data(self.0, data, length) } + unsafe { + vtk_xml_data_element_set_character_data(self.0, c_data.as_ptr(), length) + } } - fn add_character_data(&mut self, c: core::ffi::c_char, length: usize) -> () { + fn add_character_data(&mut self, c: &str, length: usize) -> () { + let c_c = std::ffi::CString::new(c).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_add_character_data( sself: *mut core::ffi::c_void, - c: core::ffi::c_char, + c: *const core::ffi::c_char, length: usize, ); } - unsafe { vtk_xml_data_element_add_character_data(self.0, c, length) } - } - fn get_character_data(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_xml_data_element_get_character_data( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_xml_data_element_get_character_data(self.0) } - } - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_scalar_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - value: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } + unsafe { vtk_xml_data_element_add_character_data(self.0, c_c.as_ptr(), length) } } fn get_scalar_attribute( &mut self, - name: core::ffi::c_char, - value: core::ffi::c_float, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_scalar_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - value: core::ffi::c_float, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } - } - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_scalar_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - value: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } - } - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_long, + name: &str, + value: &mut core::ffi::c_int, ) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_get_scalar_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - value: core::ffi::c_long, + name: *const core::ffi::c_char, + value: &mut core::ffi::c_int, ) -> core::ffi::c_int; } - unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } - } - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_ulong, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_scalar_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - value: core::ffi::c_ulong, - ) -> core::ffi::c_int; + unsafe { + vtk_xml_data_element_get_scalar_attribute(self.0, c_name.as_ptr(), value) } - unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } } - fn set_int_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_int, - ) -> () { + fn set_int_attribute(&mut self, name: &str, value: core::ffi::c_int) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_set_int_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, value: core::ffi::c_int, ); } - unsafe { vtk_xml_data_element_set_int_attribute(self.0, name, value) } + unsafe { vtk_xml_data_element_set_int_attribute(self.0, c_name.as_ptr(), value) } } - fn set_float_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_float, - ) -> () { + fn set_float_attribute(&mut self, name: &str, value: core::ffi::c_float) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_set_float_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, value: core::ffi::c_float, ); } - unsafe { vtk_xml_data_element_set_float_attribute(self.0, name, value) } + unsafe { + vtk_xml_data_element_set_float_attribute(self.0, c_name.as_ptr(), value) + } } - fn set_double_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_double, - ) -> () { + fn set_double_attribute(&mut self, name: &str, value: core::ffi::c_double) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_set_double_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, value: core::ffi::c_double, ); } - unsafe { vtk_xml_data_element_set_double_attribute(self.0, name, value) } + unsafe { + vtk_xml_data_element_set_double_attribute(self.0, c_name.as_ptr(), value) + } } fn set_unsigned_long_attribute( &mut self, - name: core::ffi::c_char, + name: &str, value: core::ffi::c_ulong, ) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_set_unsigned_long_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - value: core::ffi::c_ulong, - ); - } - unsafe { vtk_xml_data_element_set_unsigned_long_attribute(self.0, name, value) } - } - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } - } - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_float, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_float, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } - } - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } - } - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_long, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_long, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } - } - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulong, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulong, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } - } - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_xml_data_element_set_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_int, - ); - } - unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } - } - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_xml_data_element_set_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_float, - ); - } - unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } - } - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_xml_data_element_set_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_double, - ); - } - unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } - } - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulong, - ) -> () { - unsafe extern "C" { - fn vtk_xml_data_element_set_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, + name: *const core::ffi::c_char, value: core::ffi::c_ulong, ); } - unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } - } - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_scalar_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - value: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } - } - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_uchar, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_uchar, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } - } - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_uchar, - ) -> () { - unsafe extern "C" { - fn vtk_xml_data_element_set_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_uchar, - ); - } - unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } - } - fn get_scalar_attribute( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_ulonglong, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_scalar_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - value: core::ffi::c_ulonglong, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_scalar_attribute(self.0, name, value) } - } - fn get_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulonglong, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_xml_data_element_get_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulonglong, - ) -> core::ffi::c_int; - } - unsafe { vtk_xml_data_element_get_vector_attribute(self.0, name, length, value) } - } - fn set_vector_attribute( - &mut self, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulonglong, - ) -> () { - unsafe extern "C" { - fn vtk_xml_data_element_set_vector_attribute( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - length: core::ffi::c_int, - value: core::ffi::c_ulonglong, - ); + unsafe { + vtk_xml_data_element_set_unsigned_long_attribute( + self.0, + c_name.as_ptr(), + value, + ) } - unsafe { vtk_xml_data_element_set_vector_attribute(self.0, name, length, value) } } fn get_word_type_attribute( &mut self, - name: core::ffi::c_char, - value: core::ffi::c_int, + name: &str, + value: &mut core::ffi::c_int, ) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_get_word_type_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - value: core::ffi::c_int, + name: *const core::ffi::c_char, + value: &mut core::ffi::c_int, ) -> core::ffi::c_int; } - unsafe { vtk_xml_data_element_get_word_type_attribute(self.0, name, value) } + unsafe { + vtk_xml_data_element_get_word_type_attribute(self.0, c_name.as_ptr(), value) + } } fn get_number_of_attributes(&mut self) -> core::ffi::c_int { unsafe extern "C" { @@ -70565,35 +36776,41 @@ impl VtkXMLDataElement for vtkXMLDataElement { } unsafe { vtk_xml_data_element_get_number_of_attributes(self.0) } } - fn get_attribute_name(&mut self, idx: core::ffi::c_int) -> *const core::ffi::c_char { + fn get_attribute_name(&mut self, idx: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_xml_data_element_get_attribute_name( sself: *mut core::ffi::c_void, idx: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_xml_data_element_get_attribute_name(self.0, idx) } + let ptr = unsafe { vtk_xml_data_element_get_attribute_name(self.0, idx) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn get_attribute_value( - &mut self, - idx: core::ffi::c_int, - ) -> *const core::ffi::c_char { + fn get_attribute_value(&mut self, idx: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_xml_data_element_get_attribute_value( sself: *mut core::ffi::c_void, idx: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_xml_data_element_get_attribute_value(self.0, idx) } + let ptr = unsafe { vtk_xml_data_element_get_attribute_value(self.0, idx) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn remove_attribute(&mut self, name: core::ffi::c_char) -> () { + fn remove_attribute(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_remove_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ); } - unsafe { vtk_xml_data_element_remove_attribute(self.0, name) } + unsafe { vtk_xml_data_element_remove_attribute(self.0, c_name.as_ptr()) } } fn remove_all_attributes(&mut self) -> () { unsafe extern "C" { @@ -70669,100 +36886,110 @@ impl VtkXMLDataElement for vtkXMLDataElement { } unsafe { vtk_xml_data_element_remove_all_nested_elements(self.0) } } - fn find_nested_element(&mut self, id: core::ffi::c_char) -> *mut core::ffi::c_void { + fn find_nested_element(&mut self, id: &str) -> *mut core::ffi::c_void { + let c_id = std::ffi::CString::new(id).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_find_nested_element( sself: *mut core::ffi::c_void, - id: core::ffi::c_char, + id: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } - unsafe { vtk_xml_data_element_find_nested_element(self.0, id) } + unsafe { vtk_xml_data_element_find_nested_element(self.0, c_id.as_ptr()) } } - fn find_nested_element_with_name( - &mut self, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void { + fn find_nested_element_with_name(&mut self, name: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_find_nested_element_with_name( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } - unsafe { vtk_xml_data_element_find_nested_element_with_name(self.0, name) } + unsafe { + vtk_xml_data_element_find_nested_element_with_name(self.0, c_name.as_ptr()) + } } fn find_nested_element_with_name_and_id( &mut self, - name: core::ffi::c_char, - id: core::ffi::c_char, + name: &str, + id: &str, ) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_id = std::ffi::CString::new(id).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_find_nested_element_with_name_and_id( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - id: core::ffi::c_char, + name: *const core::ffi::c_char, + id: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } unsafe { - vtk_xml_data_element_find_nested_element_with_name_and_id(self.0, name, id) + vtk_xml_data_element_find_nested_element_with_name_and_id( + self.0, + c_name.as_ptr(), + c_id.as_ptr(), + ) } } fn find_nested_element_with_name_and_attribute( &mut self, - name: core::ffi::c_char, - att_name: core::ffi::c_char, - att_value: core::ffi::c_char, + name: &str, + att_name: &str, + att_value: &str, ) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_att_name = std::ffi::CString::new(att_name).expect("CString::new failed"); + let c_att_value = std::ffi::CString::new(att_value) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_find_nested_element_with_name_and_attribute( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - att_name: core::ffi::c_char, - att_value: core::ffi::c_char, + name: *const core::ffi::c_char, + att_name: *const core::ffi::c_char, + att_value: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } unsafe { vtk_xml_data_element_find_nested_element_with_name_and_attribute( self.0, - name, - att_name, - att_value, + c_name.as_ptr(), + c_att_name.as_ptr(), + c_att_value.as_ptr(), ) } } - fn lookup_element_with_name( - &mut self, - name: core::ffi::c_char, - ) -> *mut core::ffi::c_void { + fn lookup_element_with_name(&mut self, name: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_lookup_element_with_name( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } - unsafe { vtk_xml_data_element_lookup_element_with_name(self.0, name) } + unsafe { vtk_xml_data_element_lookup_element_with_name(self.0, c_name.as_ptr()) } } - fn lookup_element(&mut self, id: core::ffi::c_char) -> *mut core::ffi::c_void { + fn lookup_element(&mut self, id: &str) -> *mut core::ffi::c_void { + let c_id = std::ffi::CString::new(id).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_lookup_element( sself: *mut core::ffi::c_void, - id: core::ffi::c_char, + id: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } - unsafe { vtk_xml_data_element_lookup_element(self.0, id) } + unsafe { vtk_xml_data_element_lookup_element(self.0, c_id.as_ptr()) } } - fn get_xml_byte_index(&mut self) -> core::ffi::c_uchar { + fn get_xml_byte_index(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_xml_data_element_get_xml_byte_index( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_xml_data_element_get_xml_byte_index(self.0) } } - fn set_xml_byte_index(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_xml_byte_index(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_xml_data_element_set_xml_byte_index( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_xml_data_element_set_xml_byte_index(self.0, _arg) } @@ -70818,14 +37045,15 @@ impl VtkXMLDataElement for vtkXMLDataElement { } unsafe { vtk_xml_data_element_get_attribute_encoding(self.0) } } - fn print_xml(&mut self, fname: core::ffi::c_char) -> () { + fn print_xml(&mut self, fname: &str) -> () { + let c_fname = std::ffi::CString::new(fname).expect("CString::new failed"); unsafe extern "C" { fn vtk_xml_data_element_print_xml( sself: *mut core::ffi::c_void, - fname: core::ffi::c_char, + fname: *const core::ffi::c_char, ); } - unsafe { vtk_xml_data_element_print_xml(self.0, fname) } + unsafe { vtk_xml_data_element_print_xml(self.0, c_fname.as_ptr()) } } fn get_character_data_width(&mut self) -> core::ffi::c_int { unsafe extern "C" { @@ -70856,22 +37084,13 @@ impl VtkXMLDataElement for vtkXMLDataElement { #[allow(non_camel_case_types)] pub struct vtkAMRDataInternals(*mut core::ffi::c_void); impl vtkAMRDataInternals { - /// Creates a new [vtkAMRDataInternals] wrapped inside `vtkNew` + /// Creates a new [vtkAMRDataInternals] via `vtkAMRDataInternals::New()` #[doc(alias = "vtkAMRDataInternals")] pub fn new() -> Self { unsafe extern "C" { fn vtkAMRDataInternals_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAMRDataInternals_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAMRDataInternals_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAMRDataInternals_get_ptr(self.0) } + Self(unsafe { vtkAMRDataInternals_new() }) } } impl std::default::Default for vtkAMRDataInternals { @@ -70891,12 +37110,8 @@ impl Drop for vtkAMRDataInternals { #[test] fn test_vtkAMRDataInternals_create_drop() { let obj = vtkAMRDataInternals::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAMRDataInternals(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates through adjacent vertices in a graph. /// @@ -70909,22 +37124,13 @@ fn test_vtkAMRDataInternals_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAdjacentVertexIterator(*mut core::ffi::c_void); impl vtkAdjacentVertexIterator { - /// Creates a new [vtkAdjacentVertexIterator] wrapped inside `vtkNew` + /// Creates a new [vtkAdjacentVertexIterator] via `vtkAdjacentVertexIterator::New()` #[doc(alias = "vtkAdjacentVertexIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkAdjacentVertexIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAdjacentVertexIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAdjacentVertexIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAdjacentVertexIterator_get_ptr(self.0) } + Self(unsafe { vtkAdjacentVertexIterator_new() }) } } impl std::default::Default for vtkAdjacentVertexIterator { @@ -70944,12 +37150,8 @@ impl Drop for vtkAdjacentVertexIterator { #[test] fn test_vtkAdjacentVertexIterator_create_drop() { let obj = vtkAdjacentVertexIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAdjacentVertexIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// the animation scene manager. /// @@ -70966,22 +37168,13 @@ fn test_vtkAdjacentVertexIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAnimationScene(*mut core::ffi::c_void); impl vtkAnimationScene { - /// Creates a new [vtkAnimationScene] wrapped inside `vtkNew` + /// Creates a new [vtkAnimationScene] via `vtkAnimationScene::New()` #[doc(alias = "vtkAnimationScene")] pub fn new() -> Self { unsafe extern "C" { fn vtkAnimationScene_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAnimationScene_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAnimationScene_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAnimationScene_get_ptr(self.0) } + Self(unsafe { vtkAnimationScene_new() }) } } impl std::default::Default for vtkAnimationScene { @@ -71001,12 +37194,8 @@ impl Drop for vtkAnimationScene { #[test] fn test_vtkAnimationScene_create_drop() { let obj = vtkAnimationScene::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAnimationScene(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Stores a collection of annotation artifacts. /// @@ -71022,22 +37211,13 @@ fn test_vtkAnimationScene_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAnnotation(*mut core::ffi::c_void); impl vtkAnnotation { - /// Creates a new [vtkAnnotation] wrapped inside `vtkNew` + /// Creates a new [vtkAnnotation] via `vtkAnnotation::New()` #[doc(alias = "vtkAnnotation")] pub fn new() -> Self { unsafe extern "C" { fn vtkAnnotation_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAnnotation_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAnnotation_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAnnotation_get_ptr(self.0) } + Self(unsafe { vtkAnnotation_new() }) } } impl std::default::Default for vtkAnnotation { @@ -71057,12 +37237,8 @@ impl Drop for vtkAnnotation { #[test] fn test_vtkAnnotation_create_drop() { let obj = vtkAnnotation::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAnnotation(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Stores a ordered collection of annotation sets /// @@ -71075,22 +37251,13 @@ fn test_vtkAnnotation_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAnnotationLayers(*mut core::ffi::c_void); impl vtkAnnotationLayers { - /// Creates a new [vtkAnnotationLayers] wrapped inside `vtkNew` + /// Creates a new [vtkAnnotationLayers] via `vtkAnnotationLayers::New()` #[doc(alias = "vtkAnnotationLayers")] pub fn new() -> Self { unsafe extern "C" { fn vtkAnnotationLayers_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAnnotationLayers_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAnnotationLayers_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAnnotationLayers_get_ptr(self.0) } + Self(unsafe { vtkAnnotationLayers_new() }) } } impl std::default::Default for vtkAnnotationLayers { @@ -71110,12 +37277,8 @@ impl Drop for vtkAnnotationLayers { #[test] fn test_vtkAnnotationLayers_create_drop() { let obj = vtkAnnotationLayers::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAnnotationLayers(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Pipeline data object that contains multiple vtkArray objects. /// @@ -71135,22 +37298,13 @@ fn test_vtkAnnotationLayers_create_drop() { #[allow(non_camel_case_types)] pub struct vtkArrayData(*mut core::ffi::c_void); impl vtkArrayData { - /// Creates a new [vtkArrayData] wrapped inside `vtkNew` + /// Creates a new [vtkArrayData] via `vtkArrayData::New()` #[doc(alias = "vtkArrayData")] pub fn new() -> Self { unsafe extern "C" { fn vtkArrayData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkArrayData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkArrayData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkArrayData_get_ptr(self.0) } + Self(unsafe { vtkArrayData_new() }) } } impl std::default::Default for vtkArrayData { @@ -71170,12 +37324,8 @@ impl Drop for vtkArrayData { #[test] fn test_vtkArrayData_create_drop() { let obj = vtkArrayData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkArrayData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects that compute /// @@ -71190,22 +37340,13 @@ fn test_vtkArrayData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAttributesErrorMetric(*mut core::ffi::c_void); impl vtkAttributesErrorMetric { - /// Creates a new [vtkAttributesErrorMetric] wrapped inside `vtkNew` + /// Creates a new [vtkAttributesErrorMetric] via `vtkAttributesErrorMetric::New()` #[doc(alias = "vtkAttributesErrorMetric")] pub fn new() -> Self { unsafe extern "C" { fn vtkAttributesErrorMetric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAttributesErrorMetric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAttributesErrorMetric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAttributesErrorMetric_get_ptr(self.0) } + Self(unsafe { vtkAttributesErrorMetric_new() }) } } impl std::default::Default for vtkAttributesErrorMetric { @@ -71225,12 +37366,8 @@ impl Drop for vtkAttributesErrorMetric { #[test] fn test_vtkAttributesErrorMetric_create_drop() { let obj = vtkAttributesErrorMetric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAttributesErrorMetric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// This class represents an axis-aligned Binary Spatial /// @@ -71248,22 +37385,13 @@ fn test_vtkAttributesErrorMetric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBSPCuts(*mut core::ffi::c_void); impl vtkBSPCuts { - /// Creates a new [vtkBSPCuts] wrapped inside `vtkNew` + /// Creates a new [vtkBSPCuts] via `vtkBSPCuts::New()` #[doc(alias = "vtkBSPCuts")] pub fn new() -> Self { unsafe extern "C" { fn vtkBSPCuts_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBSPCuts_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBSPCuts_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBSPCuts_get_ptr(self.0) } + Self(unsafe { vtkBSPCuts_new() }) } } impl std::default::Default for vtkBSPCuts { @@ -71283,12 +37411,8 @@ impl Drop for vtkBSPCuts { #[test] fn test_vtkBSPCuts_create_drop() { let obj = vtkBSPCuts::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBSPCuts(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Perform calculations (mostly intersection /// @@ -71304,22 +37428,13 @@ fn test_vtkBSPCuts_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBSPIntersections(*mut core::ffi::c_void); impl vtkBSPIntersections { - /// Creates a new [vtkBSPIntersections] wrapped inside `vtkNew` + /// Creates a new [vtkBSPIntersections] via `vtkBSPIntersections::New()` #[doc(alias = "vtkBSPIntersections")] pub fn new() -> Self { unsafe extern "C" { fn vtkBSPIntersections_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBSPIntersections_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBSPIntersections_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBSPIntersections_get_ptr(self.0) } + Self(unsafe { vtkBSPIntersections_new() }) } } impl std::default::Default for vtkBSPIntersections { @@ -71339,33 +37454,20 @@ impl Drop for vtkBSPIntersections { #[test] fn test_vtkBSPIntersections_create_drop() { let obj = vtkBSPIntersections::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBSPIntersections(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkBezierCurve(*mut core::ffi::c_void); impl vtkBezierCurve { - /// Creates a new [vtkBezierCurve] wrapped inside `vtkNew` + /// Creates a new [vtkBezierCurve] via `vtkBezierCurve::New()` #[doc(alias = "vtkBezierCurve")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierCurve_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierCurve_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierCurve_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierCurve_get_ptr(self.0) } + Self(unsafe { vtkBezierCurve_new() }) } } impl std::default::Default for vtkBezierCurve { @@ -71385,12 +37487,8 @@ impl Drop for vtkBezierCurve { #[test] fn test_vtkBezierCurve_create_drop() { let obj = vtkBezierCurve::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierCurve(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Bezier hex /// @@ -71403,22 +37501,13 @@ fn test_vtkBezierCurve_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBezierHexahedron(*mut core::ffi::c_void); impl vtkBezierHexahedron { - /// Creates a new [vtkBezierHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkBezierHexahedron] via `vtkBezierHexahedron::New()` #[doc(alias = "vtkBezierHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierHexahedron_get_ptr(self.0) } + Self(unsafe { vtkBezierHexahedron_new() }) } } impl std::default::Default for vtkBezierHexahedron { @@ -71438,33 +37527,20 @@ impl Drop for vtkBezierHexahedron { #[test] fn test_vtkBezierHexahedron_create_drop() { let obj = vtkBezierHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkBezierInterpolation(*mut core::ffi::c_void); impl vtkBezierInterpolation { - /// Creates a new [vtkBezierInterpolation] wrapped inside `vtkNew` + /// Creates a new [vtkBezierInterpolation] via `vtkBezierInterpolation::New()` #[doc(alias = "vtkBezierInterpolation")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierInterpolation_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierInterpolation_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierInterpolation_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierInterpolation_get_ptr(self.0) } + Self(unsafe { vtkBezierInterpolation_new() }) } } impl std::default::Default for vtkBezierInterpolation { @@ -71484,33 +37560,20 @@ impl Drop for vtkBezierInterpolation { #[test] fn test_vtkBezierInterpolation_create_drop() { let obj = vtkBezierInterpolation::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierInterpolation(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkBezierQuadrilateral(*mut core::ffi::c_void); impl vtkBezierQuadrilateral { - /// Creates a new [vtkBezierQuadrilateral] wrapped inside `vtkNew` + /// Creates a new [vtkBezierQuadrilateral] via `vtkBezierQuadrilateral::New()` #[doc(alias = "vtkBezierQuadrilateral")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierQuadrilateral_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierQuadrilateral_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierQuadrilateral_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierQuadrilateral_get_ptr(self.0) } + Self(unsafe { vtkBezierQuadrilateral_new() }) } } impl std::default::Default for vtkBezierQuadrilateral { @@ -71530,12 +37593,8 @@ impl Drop for vtkBezierQuadrilateral { #[test] fn test_vtkBezierQuadrilateral_create_drop() { let obj = vtkBezierQuadrilateral::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierQuadrilateral(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Bezier tetrahedron /// @@ -71553,22 +37612,13 @@ fn test_vtkBezierQuadrilateral_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBezierTetra(*mut core::ffi::c_void); impl vtkBezierTetra { - /// Creates a new [vtkBezierTetra] wrapped inside `vtkNew` + /// Creates a new [vtkBezierTetra] via `vtkBezierTetra::New()` #[doc(alias = "vtkBezierTetra")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierTetra_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierTetra_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierTetra_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierTetra_get_ptr(self.0) } + Self(unsafe { vtkBezierTetra_new() }) } } impl std::default::Default for vtkBezierTetra { @@ -71588,12 +37638,8 @@ impl Drop for vtkBezierTetra { #[test] fn test_vtkBezierTetra_create_drop() { let obj = vtkBezierTetra::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierTetra(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 2D cell that represents an arbitrary order Bezier triangle /// @@ -71611,22 +37657,13 @@ fn test_vtkBezierTetra_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBezierTriangle(*mut core::ffi::c_void); impl vtkBezierTriangle { - /// Creates a new [vtkBezierTriangle] wrapped inside `vtkNew` + /// Creates a new [vtkBezierTriangle] via `vtkBezierTriangle::New()` #[doc(alias = "vtkBezierTriangle")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierTriangle_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierTriangle_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierTriangle_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierTriangle_get_ptr(self.0) } + Self(unsafe { vtkBezierTriangle_new() }) } } impl std::default::Default for vtkBezierTriangle { @@ -71646,12 +37683,8 @@ impl Drop for vtkBezierTriangle { #[test] fn test_vtkBezierTriangle_create_drop() { let obj = vtkBezierTriangle::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierTriangle(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Bezier wedge /// @@ -71672,22 +37705,13 @@ fn test_vtkBezierTriangle_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBezierWedge(*mut core::ffi::c_void); impl vtkBezierWedge { - /// Creates a new [vtkBezierWedge] wrapped inside `vtkNew` + /// Creates a new [vtkBezierWedge] via `vtkBezierWedge::New()` #[doc(alias = "vtkBezierWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierWedge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierWedge_get_ptr(self.0) } + Self(unsafe { vtkBezierWedge_new() }) } } impl std::default::Default for vtkBezierWedge { @@ -71707,12 +37731,8 @@ impl Drop for vtkBezierWedge { #[test] fn test_vtkBezierWedge_create_drop() { let obj = vtkBezierWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 9-node /// @@ -71739,22 +37759,13 @@ fn test_vtkBezierWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBiQuadraticQuad(*mut core::ffi::c_void); impl vtkBiQuadraticQuad { - /// Creates a new [vtkBiQuadraticQuad] wrapped inside `vtkNew` + /// Creates a new [vtkBiQuadraticQuad] via `vtkBiQuadraticQuad::New()` #[doc(alias = "vtkBiQuadraticQuad")] pub fn new() -> Self { unsafe extern "C" { fn vtkBiQuadraticQuad_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBiQuadraticQuad_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBiQuadraticQuad_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBiQuadraticQuad_get_ptr(self.0) } + Self(unsafe { vtkBiQuadraticQuad_new() }) } } impl std::default::Default for vtkBiQuadraticQuad { @@ -71774,12 +37785,8 @@ impl Drop for vtkBiQuadraticQuad { #[test] fn test_vtkBiQuadraticQuad_create_drop() { let obj = vtkBiQuadraticQuad::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBiQuadraticQuad(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a biquadratic, /// @@ -71834,22 +37841,13 @@ fn test_vtkBiQuadraticQuad_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBiQuadraticQuadraticHexahedron(*mut core::ffi::c_void); impl vtkBiQuadraticQuadraticHexahedron { - /// Creates a new [vtkBiQuadraticQuadraticHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkBiQuadraticQuadraticHexahedron] via `vtkBiQuadraticQuadraticHexahedron::New()` #[doc(alias = "vtkBiQuadraticQuadraticHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkBiQuadraticQuadraticHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBiQuadraticQuadraticHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBiQuadraticQuadraticHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBiQuadraticQuadraticHexahedron_get_ptr(self.0) } + Self(unsafe { vtkBiQuadraticQuadraticHexahedron_new() }) } } impl std::default::Default for vtkBiQuadraticQuadraticHexahedron { @@ -71871,12 +37869,8 @@ impl Drop for vtkBiQuadraticQuadraticHexahedron { #[test] fn test_vtkBiQuadraticQuadraticHexahedron_create_drop() { let obj = vtkBiQuadraticQuadraticHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBiQuadraticQuadraticHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 18-node isoparametric wedge /// @@ -71904,22 +37898,13 @@ fn test_vtkBiQuadraticQuadraticHexahedron_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBiQuadraticQuadraticWedge(*mut core::ffi::c_void); impl vtkBiQuadraticQuadraticWedge { - /// Creates a new [vtkBiQuadraticQuadraticWedge] wrapped inside `vtkNew` + /// Creates a new [vtkBiQuadraticQuadraticWedge] via `vtkBiQuadraticQuadraticWedge::New()` #[doc(alias = "vtkBiQuadraticQuadraticWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkBiQuadraticQuadraticWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBiQuadraticQuadraticWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBiQuadraticQuadraticWedge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBiQuadraticQuadraticWedge_get_ptr(self.0) } + Self(unsafe { vtkBiQuadraticQuadraticWedge_new() }) } } impl std::default::Default for vtkBiQuadraticQuadraticWedge { @@ -71939,12 +37924,8 @@ impl Drop for vtkBiQuadraticQuadraticWedge { #[test] fn test_vtkBiQuadraticQuadraticWedge_create_drop() { let obj = vtkBiQuadraticQuadraticWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBiQuadraticQuadraticWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, isoparametric triangle /// @@ -71969,22 +37950,13 @@ fn test_vtkBiQuadraticQuadraticWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBiQuadraticTriangle(*mut core::ffi::c_void); impl vtkBiQuadraticTriangle { - /// Creates a new [vtkBiQuadraticTriangle] wrapped inside `vtkNew` + /// Creates a new [vtkBiQuadraticTriangle] via `vtkBiQuadraticTriangle::New()` #[doc(alias = "vtkBiQuadraticTriangle")] pub fn new() -> Self { unsafe extern "C" { fn vtkBiQuadraticTriangle_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBiQuadraticTriangle_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBiQuadraticTriangle_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBiQuadraticTriangle_get_ptr(self.0) } + Self(unsafe { vtkBiQuadraticTriangle_new() }) } } impl std::default::Default for vtkBiQuadraticTriangle { @@ -72004,12 +37976,8 @@ impl Drop for vtkBiQuadraticTriangle { #[test] fn test_vtkBiQuadraticTriangle_create_drop() { let obj = vtkBiQuadraticTriangle::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBiQuadraticTriangle(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a bounding box /// @@ -72027,20 +37995,13 @@ fn test_vtkBiQuadraticTriangle_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBox(*mut core::ffi::c_void); impl vtkBox { - /// Creates a new [vtkBox] wrapped inside `vtkNew` + /// Creates a new [vtkBox] via `vtkBox::New()` #[doc(alias = "vtkBox")] pub fn new() -> Self { unsafe extern "C" { fn vtkBox_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBox_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBox_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkBox_get_ptr(self.0) } + Self(unsafe { vtkBox_new() }) } } impl std::default::Default for vtkBox { @@ -72060,12 +38021,8 @@ impl Drop for vtkBox { #[test] fn test_vtkBox_create_drop() { let obj = vtkBox::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBox(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// object to represent cell connectivity /// @@ -72187,22 +38144,13 @@ fn test_vtkBox_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellArray(*mut core::ffi::c_void); impl vtkCellArray { - /// Creates a new [vtkCellArray] wrapped inside `vtkNew` + /// Creates a new [vtkCellArray] via `vtkCellArray::New()` #[doc(alias = "vtkCellArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellArray_get_ptr(self.0) } + Self(unsafe { vtkCellArray_new() }) } } impl std::default::Default for vtkCellArray { @@ -72222,12 +38170,8 @@ impl Drop for vtkCellArray { #[test] fn test_vtkCellArray_create_drop() { let obj = vtkCellArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Encapsulate traversal logic for vtkCellArray. /// @@ -72278,22 +38222,13 @@ fn test_vtkCellArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellArrayIterator(*mut core::ffi::c_void); impl vtkCellArrayIterator { - /// Creates a new [vtkCellArrayIterator] wrapped inside `vtkNew` + /// Creates a new [vtkCellArrayIterator] via `vtkCellArrayIterator::New()` #[doc(alias = "vtkCellArrayIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellArrayIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellArrayIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellArrayIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellArrayIterator_get_ptr(self.0) } + Self(unsafe { vtkCellArrayIterator_new() }) } } impl std::default::Default for vtkCellArrayIterator { @@ -72313,12 +38248,8 @@ impl Drop for vtkCellArrayIterator { #[test] fn test_vtkCellArrayIterator_create_drop() { let obj = vtkCellArrayIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellArrayIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate cell attribute data /// @@ -72331,22 +38262,13 @@ fn test_vtkCellArrayIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellData(*mut core::ffi::c_void); impl vtkCellData { - /// Creates a new [vtkCellData] wrapped inside `vtkNew` + /// Creates a new [vtkCellData] via `vtkCellData::New()` #[doc(alias = "vtkCellData")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellData_get_ptr(self.0) } + Self(unsafe { vtkCellData_new() }) } } impl std::default::Default for vtkCellData { @@ -72366,12 +38288,8 @@ impl Drop for vtkCellData { #[test] fn test_vtkCellData_create_drop() { let obj = vtkCellData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// object represents upward pointers from points to list of cells using each point /// @@ -72394,22 +38312,13 @@ fn test_vtkCellData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellLinks(*mut core::ffi::c_void); impl vtkCellLinks { - /// Creates a new [vtkCellLinks] wrapped inside `vtkNew` + /// Creates a new [vtkCellLinks] via `vtkCellLinks::New()` #[doc(alias = "vtkCellLinks")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellLinks_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellLinks_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellLinks_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellLinks_get_ptr(self.0) } + Self(unsafe { vtkCellLinks_new() }) } } impl std::default::Default for vtkCellLinks { @@ -72429,12 +38338,8 @@ impl Drop for vtkCellLinks { #[test] fn test_vtkCellLinks_create_drop() { let obj = vtkCellLinks::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellLinks(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// octree-based spatial search object to quickly locate cells /// @@ -72463,22 +38368,13 @@ fn test_vtkCellLinks_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellLocator(*mut core::ffi::c_void); impl vtkCellLocator { - /// Creates a new [vtkCellLocator] wrapped inside `vtkNew` + /// Creates a new [vtkCellLocator] via `vtkCellLocator::New()` #[doc(alias = "vtkCellLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellLocator_get_ptr(self.0) } + Self(unsafe { vtkCellLocator_new() }) } } impl std::default::Default for vtkCellLocator { @@ -72498,12 +38394,8 @@ impl Drop for vtkCellLocator { #[test] fn test_vtkCellLocator_create_drop() { let obj = vtkCellLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implement a specific vtkPointSet::FindCell() strategy based /// @@ -72518,22 +38410,13 @@ fn test_vtkCellLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellLocatorStrategy(*mut core::ffi::c_void); impl vtkCellLocatorStrategy { - /// Creates a new [vtkCellLocatorStrategy] wrapped inside `vtkNew` + /// Creates a new [vtkCellLocatorStrategy] via `vtkCellLocatorStrategy::New()` #[doc(alias = "vtkCellLocatorStrategy")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellLocatorStrategy_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellLocatorStrategy_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellLocatorStrategy_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellLocatorStrategy_get_ptr(self.0) } + Self(unsafe { vtkCellLocatorStrategy_new() }) } } impl std::default::Default for vtkCellLocatorStrategy { @@ -72553,12 +38436,8 @@ impl Drop for vtkCellLocatorStrategy { #[test] fn test_vtkCellLocatorStrategy_create_drop() { let obj = vtkCellLocatorStrategy::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellLocatorStrategy(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// object provides direct access to cells in vtkCellArray and type information /// @@ -72581,22 +38460,13 @@ fn test_vtkCellLocatorStrategy_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellTypes(*mut core::ffi::c_void); impl vtkCellTypes { - /// Creates a new [vtkCellTypes] wrapped inside `vtkNew` + /// Creates a new [vtkCellTypes] via `vtkCellTypes::New()` #[doc(alias = "vtkCellTypes")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellTypes_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellTypes_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellTypes_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellTypes_get_ptr(self.0) } + Self(unsafe { vtkCellTypes_new() }) } } impl std::default::Default for vtkCellTypes { @@ -72616,12 +38486,8 @@ impl Drop for vtkCellTypes { #[test] fn test_vtkCellTypes_create_drop() { let obj = vtkCellTypes::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellTypes(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implement a specific vtkPointSet::FindCell() strategy based /// @@ -72637,22 +38503,13 @@ fn test_vtkCellTypes_create_drop() { #[allow(non_camel_case_types)] pub struct vtkClosestNPointsStrategy(*mut core::ffi::c_void); impl vtkClosestNPointsStrategy { - /// Creates a new [vtkClosestNPointsStrategy] wrapped inside `vtkNew` + /// Creates a new [vtkClosestNPointsStrategy] via `vtkClosestNPointsStrategy::New()` #[doc(alias = "vtkClosestNPointsStrategy")] pub fn new() -> Self { unsafe extern "C" { fn vtkClosestNPointsStrategy_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkClosestNPointsStrategy_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkClosestNPointsStrategy_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkClosestNPointsStrategy_get_ptr(self.0) } + Self(unsafe { vtkClosestNPointsStrategy_new() }) } } impl std::default::Default for vtkClosestNPointsStrategy { @@ -72672,12 +38529,8 @@ impl Drop for vtkClosestNPointsStrategy { #[test] fn test_vtkClosestNPointsStrategy_create_drop() { let obj = vtkClosestNPointsStrategy::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkClosestNPointsStrategy(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implement a specific vtkPointSet::FindCell() strategy based /// @@ -72696,22 +38549,13 @@ fn test_vtkClosestNPointsStrategy_create_drop() { #[allow(non_camel_case_types)] pub struct vtkClosestPointStrategy(*mut core::ffi::c_void); impl vtkClosestPointStrategy { - /// Creates a new [vtkClosestPointStrategy] wrapped inside `vtkNew` + /// Creates a new [vtkClosestPointStrategy] via `vtkClosestPointStrategy::New()` #[doc(alias = "vtkClosestPointStrategy")] pub fn new() -> Self { unsafe extern "C" { fn vtkClosestPointStrategy_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkClosestPointStrategy_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkClosestPointStrategy_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkClosestPointStrategy_get_ptr(self.0) } + Self(unsafe { vtkClosestPointStrategy_new() }) } } impl std::default::Default for vtkClosestPointStrategy { @@ -72731,12 +38575,8 @@ impl Drop for vtkClosestPointStrategy { #[test] fn test_vtkClosestPointStrategy_create_drop() { let obj = vtkClosestPointStrategy::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkClosestPointStrategy(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a cone /// @@ -72754,20 +38594,13 @@ fn test_vtkClosestPointStrategy_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCone(*mut core::ffi::c_void); impl vtkCone { - /// Creates a new [vtkCone] wrapped inside `vtkNew` + /// Creates a new [vtkCone] via `vtkCone::New()` #[doc(alias = "vtkCone")] pub fn new() -> Self { unsafe extern "C" { fn vtkCone_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCone_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCone_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkCone_get_ptr(self.0) } + Self(unsafe { vtkCone_new() }) } } impl std::default::Default for vtkCone { @@ -72787,12 +38620,8 @@ impl Drop for vtkCone { #[test] fn test_vtkCone_create_drop() { let obj = vtkCone::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCone(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell defined by a set of convex points /// @@ -72809,22 +38638,13 @@ fn test_vtkCone_create_drop() { #[allow(non_camel_case_types)] pub struct vtkConvexPointSet(*mut core::ffi::c_void); impl vtkConvexPointSet { - /// Creates a new [vtkConvexPointSet] wrapped inside `vtkNew` + /// Creates a new [vtkConvexPointSet] via `vtkConvexPointSet::New()` #[doc(alias = "vtkConvexPointSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkConvexPointSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkConvexPointSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkConvexPointSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkConvexPointSet_get_ptr(self.0) } + Self(unsafe { vtkConvexPointSet_new() }) } } impl std::default::Default for vtkConvexPointSet { @@ -72844,12 +38664,8 @@ impl Drop for vtkConvexPointSet { #[test] fn test_vtkConvexPointSet_create_drop() { let obj = vtkConvexPointSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkConvexPointSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a cubic , isoparametric 1D line /// @@ -72869,22 +38685,13 @@ fn test_vtkConvexPointSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCubicLine(*mut core::ffi::c_void); impl vtkCubicLine { - /// Creates a new [vtkCubicLine] wrapped inside `vtkNew` + /// Creates a new [vtkCubicLine] via `vtkCubicLine::New()` #[doc(alias = "vtkCubicLine")] pub fn new() -> Self { unsafe extern "C" { fn vtkCubicLine_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCubicLine_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCubicLine_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCubicLine_get_ptr(self.0) } + Self(unsafe { vtkCubicLine_new() }) } } impl std::default::Default for vtkCubicLine { @@ -72904,12 +38711,8 @@ impl Drop for vtkCubicLine { #[test] fn test_vtkCubicLine_create_drop() { let obj = vtkCubicLine::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCubicLine(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a cylinder /// @@ -72931,22 +38734,13 @@ fn test_vtkCubicLine_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCylinder(*mut core::ffi::c_void); impl vtkCylinder { - /// Creates a new [vtkCylinder] wrapped inside `vtkNew` + /// Creates a new [vtkCylinder] via `vtkCylinder::New()` #[doc(alias = "vtkCylinder")] pub fn new() -> Self { unsafe extern "C" { fn vtkCylinder_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCylinder_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCylinder_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCylinder_get_ptr(self.0) } + Self(unsafe { vtkCylinder_new() }) } } impl std::default::Default for vtkCylinder { @@ -72966,12 +38760,8 @@ impl Drop for vtkCylinder { #[test] fn test_vtkCylinder_create_drop() { let obj = vtkCylinder::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCylinder(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// hierarchical representation to use with /// @@ -73074,22 +38864,13 @@ fn test_vtkCylinder_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataAssembly(*mut core::ffi::c_void); impl vtkDataAssembly { - /// Creates a new [vtkDataAssembly] wrapped inside `vtkNew` + /// Creates a new [vtkDataAssembly] via `vtkDataAssembly::New()` #[doc(alias = "vtkDataAssembly")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataAssembly_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataAssembly_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataAssembly_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataAssembly_get_ptr(self.0) } + Self(unsafe { vtkDataAssembly_new() }) } } impl std::default::Default for vtkDataAssembly { @@ -73109,12 +38890,8 @@ impl Drop for vtkDataAssembly { #[test] fn test_vtkDataAssembly_create_drop() { let obj = vtkDataAssembly::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataAssembly(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// collections of utilities for vtkDataAssembly /// @@ -73124,22 +38901,13 @@ fn test_vtkDataAssembly_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataAssemblyUtilities(*mut core::ffi::c_void); impl vtkDataAssemblyUtilities { - /// Creates a new [vtkDataAssemblyUtilities] wrapped inside `vtkNew` + /// Creates a new [vtkDataAssemblyUtilities] via `vtkDataAssemblyUtilities::New()` #[doc(alias = "vtkDataAssemblyUtilities")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataAssemblyUtilities_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataAssemblyUtilities_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataAssemblyUtilities_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataAssemblyUtilities_get_ptr(self.0) } + Self(unsafe { vtkDataAssemblyUtilities_new() }) } } impl std::default::Default for vtkDataAssemblyUtilities { @@ -73159,12 +38927,8 @@ impl Drop for vtkDataAssemblyUtilities { #[test] fn test_vtkDataAssemblyUtilities_create_drop() { let obj = vtkDataAssemblyUtilities::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataAssemblyUtilities(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// general representation of visualization data /// @@ -73185,22 +38949,13 @@ fn test_vtkDataAssemblyUtilities_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataObject(*mut core::ffi::c_void); impl vtkDataObject { - /// Creates a new [vtkDataObject] wrapped inside `vtkNew` + /// Creates a new [vtkDataObject] via `vtkDataObject::New()` #[doc(alias = "vtkDataObject")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataObject_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataObject_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataObject_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataObject_get_ptr(self.0) } + Self(unsafe { vtkDataObject_new() }) } } impl std::default::Default for vtkDataObject { @@ -73220,12 +38975,8 @@ impl Drop for vtkDataObject { #[test] fn test_vtkDataObject_create_drop() { let obj = vtkDataObject::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataObject(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain an unordered list of data objects /// @@ -73235,22 +38986,13 @@ fn test_vtkDataObject_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataObjectCollection(*mut core::ffi::c_void); impl vtkDataObjectCollection { - /// Creates a new [vtkDataObjectCollection] wrapped inside `vtkNew` + /// Creates a new [vtkDataObjectCollection] via `vtkDataObjectCollection::New()` #[doc(alias = "vtkDataObjectCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataObjectCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataObjectCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataObjectCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataObjectCollection_get_ptr(self.0) } + Self(unsafe { vtkDataObjectCollection_new() }) } } impl std::default::Default for vtkDataObjectCollection { @@ -73270,12 +39012,8 @@ impl Drop for vtkDataObjectCollection { #[test] fn test_vtkDataObjectCollection_create_drop() { let obj = vtkDataObjectCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataObjectCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// superclass for composite data iterators /// @@ -73285,22 +39023,13 @@ fn test_vtkDataObjectCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataObjectTreeIterator(*mut core::ffi::c_void); impl vtkDataObjectTreeIterator { - /// Creates a new [vtkDataObjectTreeIterator] wrapped inside `vtkNew` + /// Creates a new [vtkDataObjectTreeIterator] via `vtkDataObjectTreeIterator::New()` #[doc(alias = "vtkDataObjectTreeIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataObjectTreeIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataObjectTreeIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataObjectTreeIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataObjectTreeIterator_get_ptr(self.0) } + Self(unsafe { vtkDataObjectTreeIterator_new() }) } } impl std::default::Default for vtkDataObjectTreeIterator { @@ -73320,33 +39049,20 @@ impl Drop for vtkDataObjectTreeIterator { #[test] fn test_vtkDataObjectTreeIterator_create_drop() { let obj = vtkDataObjectTreeIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataObjectTreeIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkDataObjectTypes(*mut core::ffi::c_void); impl vtkDataObjectTypes { - /// Creates a new [vtkDataObjectTypes] wrapped inside `vtkNew` + /// Creates a new [vtkDataObjectTypes] via `vtkDataObjectTypes::New()` #[doc(alias = "vtkDataObjectTypes")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataObjectTypes_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataObjectTypes_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataObjectTypes_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataObjectTypes_get_ptr(self.0) } + Self(unsafe { vtkDataObjectTypes_new() }) } } impl std::default::Default for vtkDataObjectTypes { @@ -73366,12 +39082,8 @@ impl Drop for vtkDataObjectTypes { #[test] fn test_vtkDataObjectTypes_create_drop() { let obj = vtkDataObjectTypes::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataObjectTypes(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate attribute data in a dataset /// @@ -73409,22 +39121,13 @@ fn test_vtkDataObjectTypes_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataSetAttributes(*mut core::ffi::c_void); impl vtkDataSetAttributes { - /// Creates a new [vtkDataSetAttributes] wrapped inside `vtkNew` + /// Creates a new [vtkDataSetAttributes] via `vtkDataSetAttributes::New()` #[doc(alias = "vtkDataSetAttributes")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataSetAttributes_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataSetAttributes_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataSetAttributes_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataSetAttributes_get_ptr(self.0) } + Self(unsafe { vtkDataSetAttributes_new() }) } } impl std::default::Default for vtkDataSetAttributes { @@ -73444,12 +39147,8 @@ impl Drop for vtkDataSetAttributes { #[test] fn test_vtkDataSetAttributes_create_drop() { let obj = vtkDataSetAttributes::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataSetAttributes(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Implementation of vtkCellIterator using /// @@ -73457,22 +39156,13 @@ fn test_vtkDataSetAttributes_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataSetCellIterator(*mut core::ffi::c_void); impl vtkDataSetCellIterator { - /// Creates a new [vtkDataSetCellIterator] wrapped inside `vtkNew` + /// Creates a new [vtkDataSetCellIterator] via `vtkDataSetCellIterator::New()` #[doc(alias = "vtkDataSetCellIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataSetCellIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataSetCellIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataSetCellIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataSetCellIterator_get_ptr(self.0) } + Self(unsafe { vtkDataSetCellIterator_new() }) } } impl std::default::Default for vtkDataSetCellIterator { @@ -73492,12 +39182,8 @@ impl Drop for vtkDataSetCellIterator { #[test] fn test_vtkDataSetCellIterator_create_drop() { let obj = vtkDataSetCellIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataSetCellIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain an unordered list of dataset objects /// @@ -73507,22 +39193,13 @@ fn test_vtkDataSetCellIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataSetCollection(*mut core::ffi::c_void); impl vtkDataSetCollection { - /// Creates a new [vtkDataSetCollection] wrapped inside `vtkNew` + /// Creates a new [vtkDataSetCollection] via `vtkDataSetCollection::New()` #[doc(alias = "vtkDataSetCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataSetCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataSetCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataSetCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataSetCollection_get_ptr(self.0) } + Self(unsafe { vtkDataSetCollection_new() }) } } impl std::default::Default for vtkDataSetCollection { @@ -73542,12 +39219,8 @@ impl Drop for vtkDataSetCollection { #[test] fn test_vtkDataSetCollection_create_drop() { let obj = vtkDataSetCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataSetCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A rooted tree data structure. /// @@ -73575,22 +39248,13 @@ fn test_vtkDataSetCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDirectedAcyclicGraph(*mut core::ffi::c_void); impl vtkDirectedAcyclicGraph { - /// Creates a new [vtkDirectedAcyclicGraph] wrapped inside `vtkNew` + /// Creates a new [vtkDirectedAcyclicGraph] via `vtkDirectedAcyclicGraph::New()` #[doc(alias = "vtkDirectedAcyclicGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkDirectedAcyclicGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDirectedAcyclicGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDirectedAcyclicGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDirectedAcyclicGraph_get_ptr(self.0) } + Self(unsafe { vtkDirectedAcyclicGraph_new() }) } } impl std::default::Default for vtkDirectedAcyclicGraph { @@ -73610,12 +39274,8 @@ impl Drop for vtkDirectedAcyclicGraph { #[test] fn test_vtkDirectedAcyclicGraph_create_drop() { let obj = vtkDirectedAcyclicGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDirectedAcyclicGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A directed graph. /// @@ -73635,22 +39295,13 @@ fn test_vtkDirectedAcyclicGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDirectedGraph(*mut core::ffi::c_void); impl vtkDirectedGraph { - /// Creates a new [vtkDirectedGraph] wrapped inside `vtkNew` + /// Creates a new [vtkDirectedGraph] via `vtkDirectedGraph::New()` #[doc(alias = "vtkDirectedGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkDirectedGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDirectedGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDirectedGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDirectedGraph_get_ptr(self.0) } + Self(unsafe { vtkDirectedGraph_new() }) } } impl std::default::Default for vtkDirectedGraph { @@ -73670,12 +39321,8 @@ impl Drop for vtkDirectedGraph { #[test] fn test_vtkDirectedGraph_create_drop() { let obj = vtkDirectedGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDirectedGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates through all edges in a graph. /// @@ -73695,22 +39342,13 @@ fn test_vtkDirectedGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkEdgeListIterator(*mut core::ffi::c_void); impl vtkEdgeListIterator { - /// Creates a new [vtkEdgeListIterator] wrapped inside `vtkNew` + /// Creates a new [vtkEdgeListIterator] via `vtkEdgeListIterator::New()` #[doc(alias = "vtkEdgeListIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkEdgeListIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEdgeListIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEdgeListIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEdgeListIterator_get_ptr(self.0) } + Self(unsafe { vtkEdgeListIterator_new() }) } } impl std::default::Default for vtkEdgeListIterator { @@ -73730,12 +39368,8 @@ impl Drop for vtkEdgeListIterator { #[test] fn test_vtkEdgeListIterator_create_drop() { let obj = vtkEdgeListIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEdgeListIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// keep track of edges (edge is pair of integer id's) /// @@ -73752,22 +39386,13 @@ fn test_vtkEdgeListIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkEdgeTable(*mut core::ffi::c_void); impl vtkEdgeTable { - /// Creates a new [vtkEdgeTable] wrapped inside `vtkNew` + /// Creates a new [vtkEdgeTable] via `vtkEdgeTable::New()` #[doc(alias = "vtkEdgeTable")] pub fn new() -> Self { unsafe extern "C" { fn vtkEdgeTable_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEdgeTable_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEdgeTable_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEdgeTable_get_ptr(self.0) } + Self(unsafe { vtkEdgeTable_new() }) } } impl std::default::Default for vtkEdgeTable { @@ -73787,12 +39412,8 @@ impl Drop for vtkEdgeTable { #[test] fn test_vtkEdgeTable_create_drop() { let obj = vtkEdgeTable::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEdgeTable(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// an empty cell used as a place-holder during processing /// @@ -73802,22 +39423,13 @@ fn test_vtkEdgeTable_create_drop() { #[allow(non_camel_case_types)] pub struct vtkEmptyCell(*mut core::ffi::c_void); impl vtkEmptyCell { - /// Creates a new [vtkEmptyCell] wrapped inside `vtkNew` + /// Creates a new [vtkEmptyCell] via `vtkEmptyCell::New()` #[doc(alias = "vtkEmptyCell")] pub fn new() -> Self { unsafe extern "C" { fn vtkEmptyCell_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEmptyCell_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEmptyCell_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEmptyCell_get_ptr(self.0) } + Self(unsafe { vtkEmptyCell_new() }) } } impl std::default::Default for vtkEmptyCell { @@ -73837,12 +39449,8 @@ impl Drop for vtkEmptyCell { #[test] fn test_vtkEmptyCell_create_drop() { let obj = vtkEmptyCell::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEmptyCell(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// structured grid with explicit topology and geometry /// @@ -73883,22 +39491,13 @@ fn test_vtkEmptyCell_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExplicitStructuredGrid(*mut core::ffi::c_void); impl vtkExplicitStructuredGrid { - /// Creates a new [vtkExplicitStructuredGrid] wrapped inside `vtkNew` + /// Creates a new [vtkExplicitStructuredGrid] via `vtkExplicitStructuredGrid::New()` #[doc(alias = "vtkExplicitStructuredGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkExplicitStructuredGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExplicitStructuredGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExplicitStructuredGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExplicitStructuredGrid_get_ptr(self.0) } + Self(unsafe { vtkExplicitStructuredGrid_new() }) } } impl std::default::Default for vtkExplicitStructuredGrid { @@ -73918,12 +39517,8 @@ impl Drop for vtkExplicitStructuredGrid { #[test] fn test_vtkExplicitStructuredGrid_create_drop() { let obj = vtkExplicitStructuredGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExplicitStructuredGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// helper for extracting/sub-sampling /// @@ -73940,22 +39535,13 @@ fn test_vtkExplicitStructuredGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExtractStructuredGridHelper(*mut core::ffi::c_void); impl vtkExtractStructuredGridHelper { - /// Creates a new [vtkExtractStructuredGridHelper] wrapped inside `vtkNew` + /// Creates a new [vtkExtractStructuredGridHelper] via `vtkExtractStructuredGridHelper::New()` #[doc(alias = "vtkExtractStructuredGridHelper")] pub fn new() -> Self { unsafe extern "C" { fn vtkExtractStructuredGridHelper_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExtractStructuredGridHelper_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExtractStructuredGridHelper_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExtractStructuredGridHelper_get_ptr(self.0) } + Self(unsafe { vtkExtractStructuredGridHelper_new() }) } } impl std::default::Default for vtkExtractStructuredGridHelper { @@ -73975,12 +39561,8 @@ impl Drop for vtkExtractStructuredGridHelper { #[test] fn test_vtkExtractStructuredGridHelper_create_drop() { let obj = vtkExtractStructuredGridHelper::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExtractStructuredGridHelper(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate fields of data /// @@ -74010,22 +39592,13 @@ fn test_vtkExtractStructuredGridHelper_create_drop() { #[allow(non_camel_case_types)] pub struct vtkFieldData(*mut core::ffi::c_void); impl vtkFieldData { - /// Creates a new [vtkFieldData] wrapped inside `vtkNew` + /// Creates a new [vtkFieldData] via `vtkFieldData::New()` #[doc(alias = "vtkFieldData")] pub fn new() -> Self { unsafe extern "C" { fn vtkFieldData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkFieldData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkFieldData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkFieldData_get_ptr(self.0) } + Self(unsafe { vtkFieldData_new() }) } } impl std::default::Default for vtkFieldData { @@ -74045,12 +39618,8 @@ impl Drop for vtkFieldData { #[test] fn test_vtkFieldData_create_drop() { let obj = vtkFieldData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkFieldData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a collection of attributes /// @@ -74060,22 +39629,13 @@ fn test_vtkFieldData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGenericAttributeCollection(*mut core::ffi::c_void); impl vtkGenericAttributeCollection { - /// Creates a new [vtkGenericAttributeCollection] wrapped inside `vtkNew` + /// Creates a new [vtkGenericAttributeCollection] via `vtkGenericAttributeCollection::New()` #[doc(alias = "vtkGenericAttributeCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkGenericAttributeCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGenericAttributeCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGenericAttributeCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGenericAttributeCollection_get_ptr(self.0) } + Self(unsafe { vtkGenericAttributeCollection_new() }) } } impl std::default::Default for vtkGenericAttributeCollection { @@ -74095,12 +39655,8 @@ impl Drop for vtkGenericAttributeCollection { #[test] fn test_vtkGenericAttributeCollection_create_drop() { let obj = vtkGenericAttributeCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGenericAttributeCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// provides thread-safe access to cells /// @@ -74117,22 +39673,13 @@ fn test_vtkGenericAttributeCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGenericCell(*mut core::ffi::c_void); impl vtkGenericCell { - /// Creates a new [vtkGenericCell] wrapped inside `vtkNew` + /// Creates a new [vtkGenericCell] via `vtkGenericCell::New()` #[doc(alias = "vtkGenericCell")] pub fn new() -> Self { unsafe extern "C" { fn vtkGenericCell_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGenericCell_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGenericCell_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGenericCell_get_ptr(self.0) } + Self(unsafe { vtkGenericCell_new() }) } } impl std::default::Default for vtkGenericCell { @@ -74152,12 +39699,8 @@ impl Drop for vtkGenericCell { #[test] fn test_vtkGenericCell_create_drop() { let obj = vtkGenericCell::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGenericCell(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// keep track of edges (defined by pair of integer id's) /// @@ -74174,22 +39717,13 @@ fn test_vtkGenericCell_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGenericEdgeTable(*mut core::ffi::c_void); impl vtkGenericEdgeTable { - /// Creates a new [vtkGenericEdgeTable] wrapped inside `vtkNew` + /// Creates a new [vtkGenericEdgeTable] via `vtkGenericEdgeTable::New()` #[doc(alias = "vtkGenericEdgeTable")] pub fn new() -> Self { unsafe extern "C" { fn vtkGenericEdgeTable_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGenericEdgeTable_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGenericEdgeTable_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGenericEdgeTable_get_ptr(self.0) } + Self(unsafe { vtkGenericEdgeTable_new() }) } } impl std::default::Default for vtkGenericEdgeTable { @@ -74209,12 +39743,8 @@ impl Drop for vtkGenericEdgeTable { #[test] fn test_vtkGenericEdgeTable_create_drop() { let obj = vtkGenericEdgeTable::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGenericEdgeTable(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Interface for obtaining /// @@ -74243,22 +39773,13 @@ fn test_vtkGenericEdgeTable_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGenericInterpolatedVelocityField(*mut core::ffi::c_void); impl vtkGenericInterpolatedVelocityField { - /// Creates a new [vtkGenericInterpolatedVelocityField] wrapped inside `vtkNew` + /// Creates a new [vtkGenericInterpolatedVelocityField] via `vtkGenericInterpolatedVelocityField::New()` #[doc(alias = "vtkGenericInterpolatedVelocityField")] pub fn new() -> Self { unsafe extern "C" { fn vtkGenericInterpolatedVelocityField_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGenericInterpolatedVelocityField_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGenericInterpolatedVelocityField_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGenericInterpolatedVelocityField_get_ptr(self.0) } + Self(unsafe { vtkGenericInterpolatedVelocityField_new() }) } } impl std::default::Default for vtkGenericInterpolatedVelocityField { @@ -74280,12 +39801,8 @@ impl Drop for vtkGenericInterpolatedVelocityField { #[test] fn test_vtkGenericInterpolatedVelocityField_create_drop() { let obj = vtkGenericInterpolatedVelocityField::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGenericInterpolatedVelocityField(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects that compute /// @@ -74300,22 +39817,13 @@ fn test_vtkGenericInterpolatedVelocityField_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGeometricErrorMetric(*mut core::ffi::c_void); impl vtkGeometricErrorMetric { - /// Creates a new [vtkGeometricErrorMetric] wrapped inside `vtkNew` + /// Creates a new [vtkGeometricErrorMetric] via `vtkGeometricErrorMetric::New()` #[doc(alias = "vtkGeometricErrorMetric")] pub fn new() -> Self { unsafe extern "C" { fn vtkGeometricErrorMetric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGeometricErrorMetric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGeometricErrorMetric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGeometricErrorMetric_get_ptr(self.0) } + Self(unsafe { vtkGeometricErrorMetric_new() }) } } impl std::default::Default for vtkGeometricErrorMetric { @@ -74335,12 +39843,8 @@ impl Drop for vtkGeometricErrorMetric { #[test] fn test_vtkGeometricErrorMetric_create_drop() { let obj = vtkGeometricErrorMetric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGeometricErrorMetric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Representation of a single graph edge. /// @@ -74355,22 +39859,13 @@ fn test_vtkGeometricErrorMetric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGraphEdge(*mut core::ffi::c_void); impl vtkGraphEdge { - /// Creates a new [vtkGraphEdge] wrapped inside `vtkNew` + /// Creates a new [vtkGraphEdge] via `vtkGraphEdge::New()` #[doc(alias = "vtkGraphEdge")] pub fn new() -> Self { unsafe extern "C" { fn vtkGraphEdge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGraphEdge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGraphEdge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGraphEdge_get_ptr(self.0) } + Self(unsafe { vtkGraphEdge_new() }) } } impl std::default::Default for vtkGraphEdge { @@ -74390,12 +39885,8 @@ impl Drop for vtkGraphEdge { #[test] fn test_vtkGraphEdge_create_drop() { let obj = vtkGraphEdge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGraphEdge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Internal representation of vtkGraph /// @@ -74406,22 +39897,13 @@ fn test_vtkGraphEdge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGraphInternals(*mut core::ffi::c_void); impl vtkGraphInternals { - /// Creates a new [vtkGraphInternals] wrapped inside `vtkNew` + /// Creates a new [vtkGraphInternals] via `vtkGraphInternals::New()` #[doc(alias = "vtkGraphInternals")] pub fn new() -> Self { unsafe extern "C" { fn vtkGraphInternals_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGraphInternals_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGraphInternals_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGraphInternals_get_ptr(self.0) } + Self(unsafe { vtkGraphInternals_new() }) } } impl std::default::Default for vtkGraphInternals { @@ -74441,12 +39923,8 @@ impl Drop for vtkGraphInternals { #[test] fn test_vtkGraphInternals_create_drop() { let obj = vtkGraphInternals::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGraphInternals(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell that represents a prism with /// @@ -74468,22 +39946,13 @@ fn test_vtkGraphInternals_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHexagonalPrism(*mut core::ffi::c_void); impl vtkHexagonalPrism { - /// Creates a new [vtkHexagonalPrism] wrapped inside `vtkNew` + /// Creates a new [vtkHexagonalPrism] via `vtkHexagonalPrism::New()` #[doc(alias = "vtkHexagonalPrism")] pub fn new() -> Self { unsafe extern "C" { fn vtkHexagonalPrism_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHexagonalPrism_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHexagonalPrism_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHexagonalPrism_get_ptr(self.0) } + Self(unsafe { vtkHexagonalPrism_new() }) } } impl std::default::Default for vtkHexagonalPrism { @@ -74503,12 +39972,8 @@ impl Drop for vtkHexagonalPrism { #[test] fn test_vtkHexagonalPrism_create_drop() { let obj = vtkHexagonalPrism::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHexagonalPrism(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a linear 3D hexahedron /// @@ -74526,22 +39991,13 @@ fn test_vtkHexagonalPrism_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHexahedron(*mut core::ffi::c_void); impl vtkHexahedron { - /// Creates a new [vtkHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkHexahedron] via `vtkHexahedron::New()` #[doc(alias = "vtkHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHexahedron_get_ptr(self.0) } + Self(unsafe { vtkHexahedron_new() }) } } impl std::default::Default for vtkHexahedron { @@ -74561,34 +40017,21 @@ impl Drop for vtkHexahedron { #[test] fn test_vtkHexahedron_create_drop() { let obj = vtkHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Empty class for backwards compatibility. /// #[allow(non_camel_case_types)] pub struct vtkHierarchicalBoxDataIterator(*mut core::ffi::c_void); impl vtkHierarchicalBoxDataIterator { - /// Creates a new [vtkHierarchicalBoxDataIterator] wrapped inside `vtkNew` + /// Creates a new [vtkHierarchicalBoxDataIterator] via `vtkHierarchicalBoxDataIterator::New()` #[doc(alias = "vtkHierarchicalBoxDataIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkHierarchicalBoxDataIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHierarchicalBoxDataIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHierarchicalBoxDataIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHierarchicalBoxDataIterator_get_ptr(self.0) } + Self(unsafe { vtkHierarchicalBoxDataIterator_new() }) } } impl std::default::Default for vtkHierarchicalBoxDataIterator { @@ -74608,12 +40051,8 @@ impl Drop for vtkHierarchicalBoxDataIterator { #[test] fn test_vtkHierarchicalBoxDataIterator_create_drop() { let obj = vtkHierarchicalBoxDataIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHierarchicalBoxDataIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Backwards compatibility class /// @@ -74626,22 +40065,13 @@ fn test_vtkHierarchicalBoxDataIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHierarchicalBoxDataSet(*mut core::ffi::c_void); impl vtkHierarchicalBoxDataSet { - /// Creates a new [vtkHierarchicalBoxDataSet] wrapped inside `vtkNew` + /// Creates a new [vtkHierarchicalBoxDataSet] via `vtkHierarchicalBoxDataSet::New()` #[doc(alias = "vtkHierarchicalBoxDataSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkHierarchicalBoxDataSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHierarchicalBoxDataSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHierarchicalBoxDataSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHierarchicalBoxDataSet_get_ptr(self.0) } + Self(unsafe { vtkHierarchicalBoxDataSet_new() }) } } impl std::default::Default for vtkHierarchicalBoxDataSet { @@ -74661,12 +40091,8 @@ impl Drop for vtkHierarchicalBoxDataSet { #[test] fn test_vtkHierarchicalBoxDataSet_create_drop() { let obj = vtkHierarchicalBoxDataSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHierarchicalBoxDataSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A dataset containing a grid of vtkHyperTree instances /// @@ -74712,22 +40138,13 @@ fn test_vtkHierarchicalBoxDataSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGrid(*mut core::ffi::c_void); impl vtkHyperTreeGrid { - /// Creates a new [vtkHyperTreeGrid] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGrid] via `vtkHyperTreeGrid::New()` #[doc(alias = "vtkHyperTreeGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGrid_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGrid_new() }) } } impl std::default::Default for vtkHyperTreeGrid { @@ -74747,12 +40164,8 @@ impl Drop for vtkHyperTreeGrid { #[test] fn test_vtkHyperTreeGrid_create_drop() { let obj = vtkHyperTreeGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -74777,22 +40190,13 @@ fn test_vtkHyperTreeGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedCursor { - /// Creates a new [vtkHyperTreeGridNonOrientedCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedCursor] via `vtkHyperTreeGridNonOrientedCursor::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridNonOrientedCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedCursor { @@ -74814,12 +40218,8 @@ impl Drop for vtkHyperTreeGridNonOrientedCursor { #[test] fn test_vtkHyperTreeGridNonOrientedCursor_create_drop() { let obj = vtkHyperTreeGridNonOrientedCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -74845,22 +40245,13 @@ fn test_vtkHyperTreeGridNonOrientedCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedGeometryCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedGeometryCursor { - /// Creates a new [vtkHyperTreeGridNonOrientedGeometryCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedGeometryCursor] via `vtkHyperTreeGridNonOrientedGeometryCursor::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedGeometryCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedGeometryCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridNonOrientedGeometryCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedGeometryCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedGeometryCursor { @@ -74882,12 +40273,8 @@ impl Drop for vtkHyperTreeGridNonOrientedGeometryCursor { #[test] fn test_vtkHyperTreeGridNonOrientedGeometryCursor_create_drop() { let obj = vtkHyperTreeGridNonOrientedGeometryCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedGeometryCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -74912,22 +40299,13 @@ fn test_vtkHyperTreeGridNonOrientedGeometryCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedMooreSuperCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedMooreSuperCursor { - /// Creates a new [vtkHyperTreeGridNonOrientedMooreSuperCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedMooreSuperCursor] via `vtkHyperTreeGridNonOrientedMooreSuperCursor::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedMooreSuperCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedMooreSuperCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridNonOrientedMooreSuperCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedMooreSuperCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedMooreSuperCursor { @@ -74949,12 +40327,8 @@ impl Drop for vtkHyperTreeGridNonOrientedMooreSuperCursor { #[test] fn test_vtkHyperTreeGridNonOrientedMooreSuperCursor_create_drop() { let obj = vtkHyperTreeGridNonOrientedMooreSuperCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedMooreSuperCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -74979,22 +40353,13 @@ fn test_vtkHyperTreeGridNonOrientedMooreSuperCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedMooreSuperCursorLight(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedMooreSuperCursorLight { - /// Creates a new [vtkHyperTreeGridNonOrientedMooreSuperCursorLight] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedMooreSuperCursorLight] via `vtkHyperTreeGridNonOrientedMooreSuperCursorLight::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedMooreSuperCursorLight")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedMooreSuperCursorLight { @@ -75016,12 +40381,8 @@ impl Drop for vtkHyperTreeGridNonOrientedMooreSuperCursorLight { #[test] fn test_vtkHyperTreeGridNonOrientedMooreSuperCursorLight_create_drop() { let obj = vtkHyperTreeGridNonOrientedMooreSuperCursorLight::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedMooreSuperCursorLight(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -75046,22 +40407,13 @@ fn test_vtkHyperTreeGridNonOrientedMooreSuperCursorLight_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedVonNeumannSuperCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedVonNeumannSuperCursor { - /// Creates a new [vtkHyperTreeGridNonOrientedVonNeumannSuperCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedVonNeumannSuperCursor] via `vtkHyperTreeGridNonOrientedVonNeumannSuperCursor::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedVonNeumannSuperCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedVonNeumannSuperCursor { @@ -75083,12 +40435,8 @@ impl Drop for vtkHyperTreeGridNonOrientedVonNeumannSuperCursor { #[test] fn test_vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_create_drop() { let obj = vtkHyperTreeGridNonOrientedVonNeumannSuperCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedVonNeumannSuperCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -75113,24 +40461,13 @@ fn test_vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { - /// Creates a new [vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight] via `vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new() -> *mut core::ffi::c_void; } - Self(unsafe { - &mut *vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new() - }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { @@ -75154,12 +40491,8 @@ impl Drop for vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { #[test] fn test_vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_create_drop() { let obj = vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -75184,22 +40517,13 @@ fn test_vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridOrientedCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridOrientedCursor { - /// Creates a new [vtkHyperTreeGridOrientedCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridOrientedCursor] via `vtkHyperTreeGridOrientedCursor::New()` #[doc(alias = "vtkHyperTreeGridOrientedCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridOrientedCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridOrientedCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridOrientedCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridOrientedCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridOrientedCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridOrientedCursor { @@ -75219,12 +40543,8 @@ impl Drop for vtkHyperTreeGridOrientedCursor { #[test] fn test_vtkHyperTreeGridOrientedCursor_create_drop() { let obj = vtkHyperTreeGridOrientedCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridOrientedCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -75250,22 +40570,13 @@ fn test_vtkHyperTreeGridOrientedCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridOrientedGeometryCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridOrientedGeometryCursor { - /// Creates a new [vtkHyperTreeGridOrientedGeometryCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridOrientedGeometryCursor] via `vtkHyperTreeGridOrientedGeometryCursor::New()` #[doc(alias = "vtkHyperTreeGridOrientedGeometryCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridOrientedGeometryCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridOrientedGeometryCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridOrientedGeometryCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridOrientedGeometryCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridOrientedGeometryCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridOrientedGeometryCursor { @@ -75287,12 +40598,8 @@ impl Drop for vtkHyperTreeGridOrientedGeometryCursor { #[test] fn test_vtkHyperTreeGridOrientedGeometryCursor_create_drop() { let obj = vtkHyperTreeGridOrientedGeometryCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridOrientedGeometryCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// topologically and geometrically regular array of data /// @@ -75310,22 +40617,13 @@ fn test_vtkHyperTreeGridOrientedGeometryCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImageData(*mut core::ffi::c_void); impl vtkImageData { - /// Creates a new [vtkImageData] wrapped inside `vtkNew` + /// Creates a new [vtkImageData] via `vtkImageData::New()` #[doc(alias = "vtkImageData")] pub fn new() -> Self { unsafe extern "C" { fn vtkImageData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImageData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImageData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImageData_get_ptr(self.0) } + Self(unsafe { vtkImageData_new() }) } } impl std::default::Default for vtkImageData { @@ -75345,12 +40643,8 @@ impl Drop for vtkImageData { #[test] fn test_vtkImageData_create_drop() { let obj = vtkImageData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImageData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// helper class to transform output of non-axis-aligned images /// @@ -75379,22 +40673,13 @@ fn test_vtkImageData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImageTransform(*mut core::ffi::c_void); impl vtkImageTransform { - /// Creates a new [vtkImageTransform] wrapped inside `vtkNew` + /// Creates a new [vtkImageTransform] via `vtkImageTransform::New()` #[doc(alias = "vtkImageTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkImageTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImageTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImageTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImageTransform_get_ptr(self.0) } + Self(unsafe { vtkImageTransform_new() }) } } impl std::default::Default for vtkImageTransform { @@ -75414,12 +40699,8 @@ impl Drop for vtkImageTransform { #[test] fn test_vtkImageTransform_create_drop() { let obj = vtkImageTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImageTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function consisting of boolean combinations of implicit functions /// @@ -75441,22 +40722,13 @@ fn test_vtkImageTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitBoolean(*mut core::ffi::c_void); impl vtkImplicitBoolean { - /// Creates a new [vtkImplicitBoolean] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitBoolean] via `vtkImplicitBoolean::New()` #[doc(alias = "vtkImplicitBoolean")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitBoolean_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitBoolean_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitBoolean_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitBoolean_get_ptr(self.0) } + Self(unsafe { vtkImplicitBoolean_new() }) } } impl std::default::Default for vtkImplicitBoolean { @@ -75476,12 +40748,8 @@ impl Drop for vtkImplicitBoolean { #[test] fn test_vtkImplicitBoolean_create_drop() { let obj = vtkImplicitBoolean::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitBoolean(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// treat a dataset as if it were an implicit function /// @@ -75508,22 +40776,13 @@ fn test_vtkImplicitBoolean_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitDataSet(*mut core::ffi::c_void); impl vtkImplicitDataSet { - /// Creates a new [vtkImplicitDataSet] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitDataSet] via `vtkImplicitDataSet::New()` #[doc(alias = "vtkImplicitDataSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitDataSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitDataSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitDataSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitDataSet_get_ptr(self.0) } + Self(unsafe { vtkImplicitDataSet_new() }) } } impl std::default::Default for vtkImplicitDataSet { @@ -75543,12 +40802,8 @@ impl Drop for vtkImplicitDataSet { #[test] fn test_vtkImplicitDataSet_create_drop() { let obj = vtkImplicitDataSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitDataSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of implicit functions /// @@ -75560,22 +40815,13 @@ fn test_vtkImplicitDataSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitFunctionCollection(*mut core::ffi::c_void); impl vtkImplicitFunctionCollection { - /// Creates a new [vtkImplicitFunctionCollection] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitFunctionCollection] via `vtkImplicitFunctionCollection::New()` #[doc(alias = "vtkImplicitFunctionCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitFunctionCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitFunctionCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitFunctionCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitFunctionCollection_get_ptr(self.0) } + Self(unsafe { vtkImplicitFunctionCollection_new() }) } } impl std::default::Default for vtkImplicitFunctionCollection { @@ -75595,12 +40841,8 @@ impl Drop for vtkImplicitFunctionCollection { #[test] fn test_vtkImplicitFunctionCollection_create_drop() { let obj = vtkImplicitFunctionCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitFunctionCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for an halo /// @@ -75619,22 +40861,13 @@ fn test_vtkImplicitFunctionCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitHalo(*mut core::ffi::c_void); impl vtkImplicitHalo { - /// Creates a new [vtkImplicitHalo] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitHalo] via `vtkImplicitHalo::New()` #[doc(alias = "vtkImplicitHalo")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitHalo_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitHalo_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitHalo_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitHalo_get_ptr(self.0) } + Self(unsafe { vtkImplicitHalo_new() }) } } impl std::default::Default for vtkImplicitHalo { @@ -75654,12 +40887,8 @@ impl Drop for vtkImplicitHalo { #[test] fn test_vtkImplicitHalo_create_drop() { let obj = vtkImplicitHalo::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitHalo(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a selection loop /// @@ -75694,22 +40923,13 @@ fn test_vtkImplicitHalo_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitSelectionLoop(*mut core::ffi::c_void); impl vtkImplicitSelectionLoop { - /// Creates a new [vtkImplicitSelectionLoop] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitSelectionLoop] via `vtkImplicitSelectionLoop::New()` #[doc(alias = "vtkImplicitSelectionLoop")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitSelectionLoop_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitSelectionLoop_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitSelectionLoop_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitSelectionLoop_get_ptr(self.0) } + Self(unsafe { vtkImplicitSelectionLoop_new() }) } } impl std::default::Default for vtkImplicitSelectionLoop { @@ -75729,12 +40949,8 @@ impl Drop for vtkImplicitSelectionLoop { #[test] fn test_vtkImplicitSelectionLoop_create_drop() { let obj = vtkImplicitSelectionLoop::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitSelectionLoop(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit sum of other implicit functions /// @@ -75747,22 +40963,13 @@ fn test_vtkImplicitSelectionLoop_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitSum(*mut core::ffi::c_void); impl vtkImplicitSum { - /// Creates a new [vtkImplicitSum] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitSum] via `vtkImplicitSum::New()` #[doc(alias = "vtkImplicitSum")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitSum_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitSum_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitSum_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitSum_get_ptr(self.0) } + Self(unsafe { vtkImplicitSum_new() }) } } impl std::default::Default for vtkImplicitSum { @@ -75782,12 +40989,8 @@ impl Drop for vtkImplicitSum { #[test] fn test_vtkImplicitSum_create_drop() { let obj = vtkImplicitSum::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitSum(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// treat a volume as if it were an implicit function /// @@ -75814,22 +41017,13 @@ fn test_vtkImplicitSum_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitVolume(*mut core::ffi::c_void); impl vtkImplicitVolume { - /// Creates a new [vtkImplicitVolume] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitVolume] via `vtkImplicitVolume::New()` #[doc(alias = "vtkImplicitVolume")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitVolume_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitVolume_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitVolume_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitVolume_get_ptr(self.0) } + Self(unsafe { vtkImplicitVolume_new() }) } } impl std::default::Default for vtkImplicitVolume { @@ -75849,12 +41043,8 @@ impl Drop for vtkImplicitVolume { #[test] fn test_vtkImplicitVolume_create_drop() { let obj = vtkImplicitVolume::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitVolume(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function maps another implicit function to lie within a specified range /// @@ -75874,22 +41064,13 @@ fn test_vtkImplicitVolume_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitWindowFunction(*mut core::ffi::c_void); impl vtkImplicitWindowFunction { - /// Creates a new [vtkImplicitWindowFunction] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitWindowFunction] via `vtkImplicitWindowFunction::New()` #[doc(alias = "vtkImplicitWindowFunction")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitWindowFunction_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitWindowFunction_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitWindowFunction_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitWindowFunction_get_ptr(self.0) } + Self(unsafe { vtkImplicitWindowFunction_new() }) } } impl std::default::Default for vtkImplicitWindowFunction { @@ -75909,12 +41090,8 @@ impl Drop for vtkImplicitWindowFunction { #[test] fn test_vtkImplicitWindowFunction_create_drop() { let obj = vtkImplicitWindowFunction::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitWindowFunction(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates through all incoming edges to a vertex. /// @@ -75931,22 +41108,13 @@ fn test_vtkImplicitWindowFunction_create_drop() { #[allow(non_camel_case_types)] pub struct vtkInEdgeIterator(*mut core::ffi::c_void); impl vtkInEdgeIterator { - /// Creates a new [vtkInEdgeIterator] wrapped inside `vtkNew` + /// Creates a new [vtkInEdgeIterator] via `vtkInEdgeIterator::New()` #[doc(alias = "vtkInEdgeIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkInEdgeIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkInEdgeIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkInEdgeIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkInEdgeIterator_get_ptr(self.0) } + Self(unsafe { vtkInEdgeIterator_new() }) } } impl std::default::Default for vtkInEdgeIterator { @@ -75966,12 +41134,8 @@ impl Drop for vtkInEdgeIterator { #[test] fn test_vtkInEdgeIterator_create_drop() { let obj = vtkInEdgeIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkInEdgeIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Octree node constituting incremental /// @@ -76017,22 +41181,13 @@ fn test_vtkInEdgeIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIncrementalOctreeNode(*mut core::ffi::c_void); impl vtkIncrementalOctreeNode { - /// Creates a new [vtkIncrementalOctreeNode] wrapped inside `vtkNew` + /// Creates a new [vtkIncrementalOctreeNode] via `vtkIncrementalOctreeNode::New()` #[doc(alias = "vtkIncrementalOctreeNode")] pub fn new() -> Self { unsafe extern "C" { fn vtkIncrementalOctreeNode_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIncrementalOctreeNode_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIncrementalOctreeNode_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIncrementalOctreeNode_get_ptr(self.0) } + Self(unsafe { vtkIncrementalOctreeNode_new() }) } } impl std::default::Default for vtkIncrementalOctreeNode { @@ -76052,12 +41207,8 @@ impl Drop for vtkIncrementalOctreeNode { #[test] fn test_vtkIncrementalOctreeNode_create_drop() { let obj = vtkIncrementalOctreeNode::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIncrementalOctreeNode(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Incremental octree in support /// @@ -76092,22 +41243,13 @@ fn test_vtkIncrementalOctreeNode_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIncrementalOctreePointLocator(*mut core::ffi::c_void); impl vtkIncrementalOctreePointLocator { - /// Creates a new [vtkIncrementalOctreePointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkIncrementalOctreePointLocator] via `vtkIncrementalOctreePointLocator::New()` #[doc(alias = "vtkIncrementalOctreePointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkIncrementalOctreePointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIncrementalOctreePointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIncrementalOctreePointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIncrementalOctreePointLocator_get_ptr(self.0) } + Self(unsafe { vtkIncrementalOctreePointLocator_new() }) } } impl std::default::Default for vtkIncrementalOctreePointLocator { @@ -76129,12 +41271,8 @@ impl Drop for vtkIncrementalOctreePointLocator { #[test] fn test_vtkIncrementalOctreePointLocator_create_drop() { let obj = vtkIncrementalOctreePointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIncrementalOctreePointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Implementation of the ICP algorithm. /// @@ -76159,22 +41297,13 @@ fn test_vtkIncrementalOctreePointLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIterativeClosestPointTransform(*mut core::ffi::c_void); impl vtkIterativeClosestPointTransform { - /// Creates a new [vtkIterativeClosestPointTransform] wrapped inside `vtkNew` + /// Creates a new [vtkIterativeClosestPointTransform] via `vtkIterativeClosestPointTransform::New()` #[doc(alias = "vtkIterativeClosestPointTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkIterativeClosestPointTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIterativeClosestPointTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIterativeClosestPointTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIterativeClosestPointTransform_get_ptr(self.0) } + Self(unsafe { vtkIterativeClosestPointTransform_new() }) } } impl std::default::Default for vtkIterativeClosestPointTransform { @@ -76196,12 +41325,8 @@ impl Drop for vtkIterativeClosestPointTransform { #[test] fn test_vtkIterativeClosestPointTransform_create_drop() { let obj = vtkIterativeClosestPointTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIterativeClosestPointTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// This class represents a single spatial region /// @@ -76216,22 +41341,13 @@ fn test_vtkIterativeClosestPointTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkKdNode(*mut core::ffi::c_void); impl vtkKdNode { - /// Creates a new [vtkKdNode] wrapped inside `vtkNew` + /// Creates a new [vtkKdNode] via `vtkKdNode::New()` #[doc(alias = "vtkKdNode")] pub fn new() -> Self { unsafe extern "C" { fn vtkKdNode_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkKdNode_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkKdNode_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkKdNode_get_ptr(self.0) } + Self(unsafe { vtkKdNode_new() }) } } impl std::default::Default for vtkKdNode { @@ -76251,12 +41367,8 @@ impl Drop for vtkKdNode { #[test] fn test_vtkKdNode_create_drop() { let obj = vtkKdNode::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkKdNode(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a Kd-tree spatial decomposition of a set of points /// @@ -76294,22 +41406,13 @@ fn test_vtkKdNode_create_drop() { #[allow(non_camel_case_types)] pub struct vtkKdTree(*mut core::ffi::c_void); impl vtkKdTree { - /// Creates a new [vtkKdTree] wrapped inside `vtkNew` + /// Creates a new [vtkKdTree] via `vtkKdTree::New()` #[doc(alias = "vtkKdTree")] pub fn new() -> Self { unsafe extern "C" { fn vtkKdTree_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkKdTree_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkKdTree_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkKdTree_get_ptr(self.0) } + Self(unsafe { vtkKdTree_new() }) } } impl std::default::Default for vtkKdTree { @@ -76329,12 +41432,8 @@ impl Drop for vtkKdTree { #[test] fn test_vtkKdTree_create_drop() { let obj = vtkKdTree::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkKdTree(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// class to quickly locate points in 3-space /// @@ -76347,22 +41446,13 @@ fn test_vtkKdTree_create_drop() { #[allow(non_camel_case_types)] pub struct vtkKdTreePointLocator(*mut core::ffi::c_void); impl vtkKdTreePointLocator { - /// Creates a new [vtkKdTreePointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkKdTreePointLocator] via `vtkKdTreePointLocator::New()` #[doc(alias = "vtkKdTreePointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkKdTreePointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkKdTreePointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkKdTreePointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkKdTreePointLocator_get_ptr(self.0) } + Self(unsafe { vtkKdTreePointLocator_new() }) } } impl std::default::Default for vtkKdTreePointLocator { @@ -76382,33 +41472,20 @@ impl Drop for vtkKdTreePointLocator { #[test] fn test_vtkKdTreePointLocator_create_drop() { let obj = vtkKdTreePointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkKdTreePointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkLagrangeCurve(*mut core::ffi::c_void); impl vtkLagrangeCurve { - /// Creates a new [vtkLagrangeCurve] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeCurve] via `vtkLagrangeCurve::New()` #[doc(alias = "vtkLagrangeCurve")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeCurve_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeCurve_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeCurve_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeCurve_get_ptr(self.0) } + Self(unsafe { vtkLagrangeCurve_new() }) } } impl std::default::Default for vtkLagrangeCurve { @@ -76428,12 +41505,8 @@ impl Drop for vtkLagrangeCurve { #[test] fn test_vtkLagrangeCurve_create_drop() { let obj = vtkLagrangeCurve::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeCurve(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Lagrange hex /// @@ -76446,22 +41519,13 @@ fn test_vtkLagrangeCurve_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLagrangeHexahedron(*mut core::ffi::c_void); impl vtkLagrangeHexahedron { - /// Creates a new [vtkLagrangeHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeHexahedron] via `vtkLagrangeHexahedron::New()` #[doc(alias = "vtkLagrangeHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeHexahedron_get_ptr(self.0) } + Self(unsafe { vtkLagrangeHexahedron_new() }) } } impl std::default::Default for vtkLagrangeHexahedron { @@ -76481,33 +41545,20 @@ impl Drop for vtkLagrangeHexahedron { #[test] fn test_vtkLagrangeHexahedron_create_drop() { let obj = vtkLagrangeHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkLagrangeInterpolation(*mut core::ffi::c_void); impl vtkLagrangeInterpolation { - /// Creates a new [vtkLagrangeInterpolation] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeInterpolation] via `vtkLagrangeInterpolation::New()` #[doc(alias = "vtkLagrangeInterpolation")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeInterpolation_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeInterpolation_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeInterpolation_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeInterpolation_get_ptr(self.0) } + Self(unsafe { vtkLagrangeInterpolation_new() }) } } impl std::default::Default for vtkLagrangeInterpolation { @@ -76527,33 +41578,20 @@ impl Drop for vtkLagrangeInterpolation { #[test] fn test_vtkLagrangeInterpolation_create_drop() { let obj = vtkLagrangeInterpolation::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeInterpolation(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkLagrangeQuadrilateral(*mut core::ffi::c_void); impl vtkLagrangeQuadrilateral { - /// Creates a new [vtkLagrangeQuadrilateral] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeQuadrilateral] via `vtkLagrangeQuadrilateral::New()` #[doc(alias = "vtkLagrangeQuadrilateral")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeQuadrilateral_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeQuadrilateral_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeQuadrilateral_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeQuadrilateral_get_ptr(self.0) } + Self(unsafe { vtkLagrangeQuadrilateral_new() }) } } impl std::default::Default for vtkLagrangeQuadrilateral { @@ -76573,12 +41611,8 @@ impl Drop for vtkLagrangeQuadrilateral { #[test] fn test_vtkLagrangeQuadrilateral_create_drop() { let obj = vtkLagrangeQuadrilateral::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeQuadrilateral(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Lagrange tetrahedron /// @@ -76596,22 +41630,13 @@ fn test_vtkLagrangeQuadrilateral_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLagrangeTetra(*mut core::ffi::c_void); impl vtkLagrangeTetra { - /// Creates a new [vtkLagrangeTetra] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeTetra] via `vtkLagrangeTetra::New()` #[doc(alias = "vtkLagrangeTetra")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeTetra_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeTetra_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeTetra_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeTetra_get_ptr(self.0) } + Self(unsafe { vtkLagrangeTetra_new() }) } } impl std::default::Default for vtkLagrangeTetra { @@ -76631,12 +41656,8 @@ impl Drop for vtkLagrangeTetra { #[test] fn test_vtkLagrangeTetra_create_drop() { let obj = vtkLagrangeTetra::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeTetra(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 2D cell that represents an arbitrary order Lagrange triangle /// @@ -76654,22 +41675,13 @@ fn test_vtkLagrangeTetra_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLagrangeTriangle(*mut core::ffi::c_void); impl vtkLagrangeTriangle { - /// Creates a new [vtkLagrangeTriangle] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeTriangle] via `vtkLagrangeTriangle::New()` #[doc(alias = "vtkLagrangeTriangle")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeTriangle_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeTriangle_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeTriangle_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeTriangle_get_ptr(self.0) } + Self(unsafe { vtkLagrangeTriangle_new() }) } } impl std::default::Default for vtkLagrangeTriangle { @@ -76689,12 +41701,8 @@ impl Drop for vtkLagrangeTriangle { #[test] fn test_vtkLagrangeTriangle_create_drop() { let obj = vtkLagrangeTriangle::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeTriangle(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Lagrange wedge /// @@ -76715,22 +41723,13 @@ fn test_vtkLagrangeTriangle_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLagrangeWedge(*mut core::ffi::c_void); impl vtkLagrangeWedge { - /// Creates a new [vtkLagrangeWedge] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeWedge] via `vtkLagrangeWedge::New()` #[doc(alias = "vtkLagrangeWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeWedge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeWedge_get_ptr(self.0) } + Self(unsafe { vtkLagrangeWedge_new() }) } } impl std::default::Default for vtkLagrangeWedge { @@ -76750,12 +41749,8 @@ impl Drop for vtkLagrangeWedge { #[test] fn test_vtkLagrangeWedge_create_drop() { let obj = vtkLagrangeWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a 1D line /// @@ -76764,20 +41759,13 @@ fn test_vtkLagrangeWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLine(*mut core::ffi::c_void); impl vtkLine { - /// Creates a new [vtkLine] wrapped inside `vtkNew` + /// Creates a new [vtkLine] via `vtkLine::New()` #[doc(alias = "vtkLine")] pub fn new() -> Self { unsafe extern "C" { fn vtkLine_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLine_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLine_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkLine_get_ptr(self.0) } + Self(unsafe { vtkLine_new() }) } } impl std::default::Default for vtkLine { @@ -76797,12 +41785,8 @@ impl Drop for vtkLine { #[test] fn test_vtkLine_create_drop() { let obj = vtkLine::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLine(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// compute interpolation computes /// @@ -76831,22 +41815,13 @@ fn test_vtkLine_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMeanValueCoordinatesInterpolator(*mut core::ffi::c_void); impl vtkMeanValueCoordinatesInterpolator { - /// Creates a new [vtkMeanValueCoordinatesInterpolator] wrapped inside `vtkNew` + /// Creates a new [vtkMeanValueCoordinatesInterpolator] via `vtkMeanValueCoordinatesInterpolator::New()` #[doc(alias = "vtkMeanValueCoordinatesInterpolator")] pub fn new() -> Self { unsafe extern "C" { fn vtkMeanValueCoordinatesInterpolator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMeanValueCoordinatesInterpolator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMeanValueCoordinatesInterpolator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMeanValueCoordinatesInterpolator_get_ptr(self.0) } + Self(unsafe { vtkMeanValueCoordinatesInterpolator_new() }) } } impl std::default::Default for vtkMeanValueCoordinatesInterpolator { @@ -76868,12 +41843,8 @@ impl Drop for vtkMeanValueCoordinatesInterpolator { #[test] fn test_vtkMeanValueCoordinatesInterpolator_create_drop() { let obj = vtkMeanValueCoordinatesInterpolator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMeanValueCoordinatesInterpolator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// merge exactly coincident points /// @@ -76887,22 +41858,13 @@ fn test_vtkMeanValueCoordinatesInterpolator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMergePoints(*mut core::ffi::c_void); impl vtkMergePoints { - /// Creates a new [vtkMergePoints] wrapped inside `vtkNew` + /// Creates a new [vtkMergePoints] via `vtkMergePoints::New()` #[doc(alias = "vtkMergePoints")] pub fn new() -> Self { unsafe extern "C" { fn vtkMergePoints_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMergePoints_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMergePoints_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMergePoints_get_ptr(self.0) } + Self(unsafe { vtkMergePoints_new() }) } } impl std::default::Default for vtkMergePoints { @@ -76922,12 +41884,8 @@ impl Drop for vtkMergePoints { #[test] fn test_vtkMergePoints_create_drop() { let obj = vtkMergePoints::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMergePoints(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// class describing a molecule /// @@ -76983,22 +41941,13 @@ fn test_vtkMergePoints_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMolecule(*mut core::ffi::c_void); impl vtkMolecule { - /// Creates a new [vtkMolecule] wrapped inside `vtkNew` + /// Creates a new [vtkMolecule] via `vtkMolecule::New()` #[doc(alias = "vtkMolecule")] pub fn new() -> Self { unsafe extern "C" { fn vtkMolecule_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMolecule_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMolecule_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMolecule_get_ptr(self.0) } + Self(unsafe { vtkMolecule_new() }) } } impl std::default::Default for vtkMolecule { @@ -77018,12 +41967,8 @@ impl Drop for vtkMolecule { #[test] fn test_vtkMolecule_create_drop() { let obj = vtkMolecule::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMolecule(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Composite dataset that organizes datasets into /// @@ -77049,22 +41994,13 @@ fn test_vtkMolecule_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMultiBlockDataSet(*mut core::ffi::c_void); impl vtkMultiBlockDataSet { - /// Creates a new [vtkMultiBlockDataSet] wrapped inside `vtkNew` + /// Creates a new [vtkMultiBlockDataSet] via `vtkMultiBlockDataSet::New()` #[doc(alias = "vtkMultiBlockDataSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkMultiBlockDataSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMultiBlockDataSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMultiBlockDataSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMultiBlockDataSet_get_ptr(self.0) } + Self(unsafe { vtkMultiBlockDataSet_new() }) } } impl std::default::Default for vtkMultiBlockDataSet { @@ -77084,12 +42020,8 @@ impl Drop for vtkMultiBlockDataSet { #[test] fn test_vtkMultiBlockDataSet_create_drop() { let obj = vtkMultiBlockDataSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMultiBlockDataSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// composite dataset to encapsulates pieces of /// @@ -77109,22 +42041,13 @@ fn test_vtkMultiBlockDataSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMultiPieceDataSet(*mut core::ffi::c_void); impl vtkMultiPieceDataSet { - /// Creates a new [vtkMultiPieceDataSet] wrapped inside `vtkNew` + /// Creates a new [vtkMultiPieceDataSet] via `vtkMultiPieceDataSet::New()` #[doc(alias = "vtkMultiPieceDataSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkMultiPieceDataSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMultiPieceDataSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMultiPieceDataSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMultiPieceDataSet_get_ptr(self.0) } + Self(unsafe { vtkMultiPieceDataSet_new() }) } } impl std::default::Default for vtkMultiPieceDataSet { @@ -77144,12 +42067,8 @@ impl Drop for vtkMultiPieceDataSet { #[test] fn test_vtkMultiPieceDataSet_create_drop() { let obj = vtkMultiPieceDataSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMultiPieceDataSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// An editable directed graph. /// @@ -77166,22 +42085,13 @@ fn test_vtkMultiPieceDataSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMutableDirectedGraph(*mut core::ffi::c_void); impl vtkMutableDirectedGraph { - /// Creates a new [vtkMutableDirectedGraph] wrapped inside `vtkNew` + /// Creates a new [vtkMutableDirectedGraph] via `vtkMutableDirectedGraph::New()` #[doc(alias = "vtkMutableDirectedGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkMutableDirectedGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMutableDirectedGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMutableDirectedGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMutableDirectedGraph_get_ptr(self.0) } + Self(unsafe { vtkMutableDirectedGraph_new() }) } } impl std::default::Default for vtkMutableDirectedGraph { @@ -77201,12 +42111,8 @@ impl Drop for vtkMutableDirectedGraph { #[test] fn test_vtkMutableDirectedGraph_create_drop() { let obj = vtkMutableDirectedGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMutableDirectedGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// An editable undirected graph. /// @@ -77222,22 +42128,13 @@ fn test_vtkMutableDirectedGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMutableUndirectedGraph(*mut core::ffi::c_void); impl vtkMutableUndirectedGraph { - /// Creates a new [vtkMutableUndirectedGraph] wrapped inside `vtkNew` + /// Creates a new [vtkMutableUndirectedGraph] via `vtkMutableUndirectedGraph::New()` #[doc(alias = "vtkMutableUndirectedGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkMutableUndirectedGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMutableUndirectedGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMutableUndirectedGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMutableUndirectedGraph_get_ptr(self.0) } + Self(unsafe { vtkMutableUndirectedGraph_new() }) } } impl std::default::Default for vtkMutableUndirectedGraph { @@ -77257,12 +42154,8 @@ impl Drop for vtkMutableUndirectedGraph { #[test] fn test_vtkMutableUndirectedGraph_create_drop() { let obj = vtkMutableUndirectedGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMutableUndirectedGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// direct / check-free point insertion. /// @@ -77283,22 +42176,13 @@ fn test_vtkMutableUndirectedGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkNonMergingPointLocator(*mut core::ffi::c_void); impl vtkNonMergingPointLocator { - /// Creates a new [vtkNonMergingPointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkNonMergingPointLocator] via `vtkNonMergingPointLocator::New()` #[doc(alias = "vtkNonMergingPointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkNonMergingPointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkNonMergingPointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkNonMergingPointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkNonMergingPointLocator_get_ptr(self.0) } + Self(unsafe { vtkNonMergingPointLocator_new() }) } } impl std::default::Default for vtkNonMergingPointLocator { @@ -77318,12 +42202,8 @@ impl Drop for vtkNonMergingPointLocator { #[test] fn test_vtkNonMergingPointLocator_create_drop() { let obj = vtkNonMergingPointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkNonMergingPointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A concrete instance of vtkUniformGridAMR to store uniform grids at different /// @@ -77334,22 +42214,13 @@ fn test_vtkNonMergingPointLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkNonOverlappingAMR(*mut core::ffi::c_void); impl vtkNonOverlappingAMR { - /// Creates a new [vtkNonOverlappingAMR] wrapped inside `vtkNew` + /// Creates a new [vtkNonOverlappingAMR] via `vtkNonOverlappingAMR::New()` #[doc(alias = "vtkNonOverlappingAMR")] pub fn new() -> Self { unsafe extern "C" { fn vtkNonOverlappingAMR_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkNonOverlappingAMR_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkNonOverlappingAMR_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkNonOverlappingAMR_get_ptr(self.0) } + Self(unsafe { vtkNonOverlappingAMR_new() }) } } impl std::default::Default for vtkNonOverlappingAMR { @@ -77369,12 +42240,8 @@ impl Drop for vtkNonOverlappingAMR { #[test] fn test_vtkNonOverlappingAMR_create_drop() { let obj = vtkNonOverlappingAMR::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkNonOverlappingAMR(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// an octree spatial decomposition of a set of points /// @@ -77393,22 +42260,13 @@ fn test_vtkNonOverlappingAMR_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOctreePointLocator(*mut core::ffi::c_void); impl vtkOctreePointLocator { - /// Creates a new [vtkOctreePointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkOctreePointLocator] via `vtkOctreePointLocator::New()` #[doc(alias = "vtkOctreePointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkOctreePointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOctreePointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOctreePointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOctreePointLocator_get_ptr(self.0) } + Self(unsafe { vtkOctreePointLocator_new() }) } } impl std::default::Default for vtkOctreePointLocator { @@ -77428,12 +42286,8 @@ impl Drop for vtkOctreePointLocator { #[test] fn test_vtkOctreePointLocator_create_drop() { let obj = vtkOctreePointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOctreePointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Octree node that has 8 children each of equal size /// @@ -77452,22 +42306,13 @@ fn test_vtkOctreePointLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOctreePointLocatorNode(*mut core::ffi::c_void); impl vtkOctreePointLocatorNode { - /// Creates a new [vtkOctreePointLocatorNode] wrapped inside `vtkNew` + /// Creates a new [vtkOctreePointLocatorNode] via `vtkOctreePointLocatorNode::New()` #[doc(alias = "vtkOctreePointLocatorNode")] pub fn new() -> Self { unsafe extern "C" { fn vtkOctreePointLocatorNode_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOctreePointLocatorNode_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOctreePointLocatorNode_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOctreePointLocatorNode_get_ptr(self.0) } + Self(unsafe { vtkOctreePointLocatorNode_new() }) } } impl std::default::Default for vtkOctreePointLocatorNode { @@ -77487,12 +42332,8 @@ impl Drop for vtkOctreePointLocatorNode { #[test] fn test_vtkOctreePointLocatorNode_create_drop() { let obj = vtkOctreePointLocatorNode::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOctreePointLocatorNode(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// helper class to generate triangulations /// @@ -77564,22 +42405,13 @@ fn test_vtkOctreePointLocatorNode_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOrderedTriangulator(*mut core::ffi::c_void); impl vtkOrderedTriangulator { - /// Creates a new [vtkOrderedTriangulator] wrapped inside `vtkNew` + /// Creates a new [vtkOrderedTriangulator] via `vtkOrderedTriangulator::New()` #[doc(alias = "vtkOrderedTriangulator")] pub fn new() -> Self { unsafe extern "C" { fn vtkOrderedTriangulator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOrderedTriangulator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOrderedTriangulator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOrderedTriangulator_get_ptr(self.0) } + Self(unsafe { vtkOrderedTriangulator_new() }) } } impl std::default::Default for vtkOrderedTriangulator { @@ -77599,12 +42431,8 @@ impl Drop for vtkOrderedTriangulator { #[test] fn test_vtkOrderedTriangulator_create_drop() { let obj = vtkOrderedTriangulator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOrderedTriangulator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates through all outgoing edges from a vertex. /// @@ -77621,22 +42449,13 @@ fn test_vtkOrderedTriangulator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOutEdgeIterator(*mut core::ffi::c_void); impl vtkOutEdgeIterator { - /// Creates a new [vtkOutEdgeIterator] wrapped inside `vtkNew` + /// Creates a new [vtkOutEdgeIterator] via `vtkOutEdgeIterator::New()` #[doc(alias = "vtkOutEdgeIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkOutEdgeIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOutEdgeIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOutEdgeIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOutEdgeIterator_get_ptr(self.0) } + Self(unsafe { vtkOutEdgeIterator_new() }) } } impl std::default::Default for vtkOutEdgeIterator { @@ -77656,12 +42475,8 @@ impl Drop for vtkOutEdgeIterator { #[test] fn test_vtkOutEdgeIterator_create_drop() { let obj = vtkOutEdgeIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOutEdgeIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// hierarchical dataset of vtkUniformGrids /// @@ -77676,22 +42491,13 @@ fn test_vtkOutEdgeIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOverlappingAMR(*mut core::ffi::c_void); impl vtkOverlappingAMR { - /// Creates a new [vtkOverlappingAMR] wrapped inside `vtkNew` + /// Creates a new [vtkOverlappingAMR] via `vtkOverlappingAMR::New()` #[doc(alias = "vtkOverlappingAMR")] pub fn new() -> Self { unsafe extern "C" { fn vtkOverlappingAMR_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOverlappingAMR_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOverlappingAMR_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOverlappingAMR_get_ptr(self.0) } + Self(unsafe { vtkOverlappingAMR_new() }) } } impl std::default::Default for vtkOverlappingAMR { @@ -77711,12 +42517,8 @@ impl Drop for vtkOverlappingAMR { #[test] fn test_vtkOverlappingAMR_create_drop() { let obj = vtkOverlappingAMR::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOverlappingAMR(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// composite dataset to encapsulates a dataset consisting of /// @@ -77742,22 +42544,13 @@ fn test_vtkOverlappingAMR_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPartitionedDataSet(*mut core::ffi::c_void); impl vtkPartitionedDataSet { - /// Creates a new [vtkPartitionedDataSet] wrapped inside `vtkNew` + /// Creates a new [vtkPartitionedDataSet] via `vtkPartitionedDataSet::New()` #[doc(alias = "vtkPartitionedDataSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkPartitionedDataSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPartitionedDataSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPartitionedDataSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPartitionedDataSet_get_ptr(self.0) } + Self(unsafe { vtkPartitionedDataSet_new() }) } } impl std::default::Default for vtkPartitionedDataSet { @@ -77777,12 +42570,8 @@ impl Drop for vtkPartitionedDataSet { #[test] fn test_vtkPartitionedDataSet_create_drop() { let obj = vtkPartitionedDataSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPartitionedDataSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Composite dataset that groups datasets as a collection. /// @@ -77796,22 +42585,13 @@ fn test_vtkPartitionedDataSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPartitionedDataSetCollection(*mut core::ffi::c_void); impl vtkPartitionedDataSetCollection { - /// Creates a new [vtkPartitionedDataSetCollection] wrapped inside `vtkNew` + /// Creates a new [vtkPartitionedDataSetCollection] via `vtkPartitionedDataSetCollection::New()` #[doc(alias = "vtkPartitionedDataSetCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkPartitionedDataSetCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPartitionedDataSetCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPartitionedDataSetCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPartitionedDataSetCollection_get_ptr(self.0) } + Self(unsafe { vtkPartitionedDataSetCollection_new() }) } } impl std::default::Default for vtkPartitionedDataSetCollection { @@ -77831,12 +42611,8 @@ impl Drop for vtkPartitionedDataSetCollection { #[test] fn test_vtkPartitionedDataSetCollection_create_drop() { let obj = vtkPartitionedDataSetCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPartitionedDataSetCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// concrete dataset representing a path defined by Bezier /// @@ -77847,20 +42623,13 @@ fn test_vtkPartitionedDataSetCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPath(*mut core::ffi::c_void); impl vtkPath { - /// Creates a new [vtkPath] wrapped inside `vtkNew` + /// Creates a new [vtkPath] via `vtkPath::New()` #[doc(alias = "vtkPath")] pub fn new() -> Self { unsafe extern "C" { fn vtkPath_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPath_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPath_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkPath_get_ptr(self.0) } + Self(unsafe { vtkPath_new() }) } } impl std::default::Default for vtkPath { @@ -77880,12 +42649,8 @@ impl Drop for vtkPath { #[test] fn test_vtkPath_create_drop() { let obj = vtkPath::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPath(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell that represents a convex prism with /// @@ -77914,22 +42679,13 @@ fn test_vtkPath_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPentagonalPrism(*mut core::ffi::c_void); impl vtkPentagonalPrism { - /// Creates a new [vtkPentagonalPrism] wrapped inside `vtkNew` + /// Creates a new [vtkPentagonalPrism] via `vtkPentagonalPrism::New()` #[doc(alias = "vtkPentagonalPrism")] pub fn new() -> Self { unsafe extern "C" { fn vtkPentagonalPrism_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPentagonalPrism_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPentagonalPrism_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPentagonalPrism_get_ptr(self.0) } + Self(unsafe { vtkPentagonalPrism_new() }) } } impl std::default::Default for vtkPentagonalPrism { @@ -77949,12 +42705,8 @@ impl Drop for vtkPentagonalPrism { #[test] fn test_vtkPentagonalPrism_create_drop() { let obj = vtkPentagonalPrism::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPentagonalPrism(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// an implicit function that implements Perlin noise /// @@ -77973,22 +42725,13 @@ fn test_vtkPentagonalPrism_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPerlinNoise(*mut core::ffi::c_void); impl vtkPerlinNoise { - /// Creates a new [vtkPerlinNoise] wrapped inside `vtkNew` + /// Creates a new [vtkPerlinNoise] via `vtkPerlinNoise::New()` #[doc(alias = "vtkPerlinNoise")] pub fn new() -> Self { unsafe extern "C" { fn vtkPerlinNoise_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPerlinNoise_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPerlinNoise_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPerlinNoise_get_ptr(self.0) } + Self(unsafe { vtkPerlinNoise_new() }) } } impl std::default::Default for vtkPerlinNoise { @@ -78008,12 +42751,8 @@ impl Drop for vtkPerlinNoise { #[test] fn test_vtkPerlinNoise_create_drop() { let obj = vtkPerlinNoise::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPerlinNoise(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Defines a 1D piecewise function. /// @@ -78036,22 +42775,13 @@ fn test_vtkPerlinNoise_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPiecewiseFunction(*mut core::ffi::c_void); impl vtkPiecewiseFunction { - /// Creates a new [vtkPiecewiseFunction] wrapped inside `vtkNew` + /// Creates a new [vtkPiecewiseFunction] via `vtkPiecewiseFunction::New()` #[doc(alias = "vtkPiecewiseFunction")] pub fn new() -> Self { unsafe extern "C" { fn vtkPiecewiseFunction_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPiecewiseFunction_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPiecewiseFunction_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPiecewiseFunction_get_ptr(self.0) } + Self(unsafe { vtkPiecewiseFunction_new() }) } } impl std::default::Default for vtkPiecewiseFunction { @@ -78071,12 +42801,8 @@ impl Drop for vtkPiecewiseFunction { #[test] fn test_vtkPiecewiseFunction_create_drop() { let obj = vtkPiecewiseFunction::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPiecewiseFunction(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents an orthogonal quadrilateral /// @@ -78088,20 +42814,13 @@ fn test_vtkPiecewiseFunction_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPixel(*mut core::ffi::c_void); impl vtkPixel { - /// Creates a new [vtkPixel] wrapped inside `vtkNew` + /// Creates a new [vtkPixel] via `vtkPixel::New()` #[doc(alias = "vtkPixel")] pub fn new() -> Self { unsafe extern "C" { fn vtkPixel_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPixel_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPixel_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkPixel_get_ptr(self.0) } + Self(unsafe { vtkPixel_new() }) } } impl std::default::Default for vtkPixel { @@ -78121,12 +42840,8 @@ impl Drop for vtkPixel { #[test] fn test_vtkPixel_create_drop() { let obj = vtkPixel::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPixel(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// perform various plane computations /// @@ -78138,20 +42853,13 @@ fn test_vtkPixel_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPlane(*mut core::ffi::c_void); impl vtkPlane { - /// Creates a new [vtkPlane] wrapped inside `vtkNew` + /// Creates a new [vtkPlane] via `vtkPlane::New()` #[doc(alias = "vtkPlane")] pub fn new() -> Self { unsafe extern "C" { fn vtkPlane_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPlane_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPlane_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkPlane_get_ptr(self.0) } + Self(unsafe { vtkPlane_new() }) } } impl std::default::Default for vtkPlane { @@ -78171,12 +42879,8 @@ impl Drop for vtkPlane { #[test] fn test_vtkPlane_create_drop() { let obj = vtkPlane::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPlane(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of planes /// @@ -78188,22 +42892,13 @@ fn test_vtkPlane_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPlaneCollection(*mut core::ffi::c_void); impl vtkPlaneCollection { - /// Creates a new [vtkPlaneCollection] wrapped inside `vtkNew` + /// Creates a new [vtkPlaneCollection] via `vtkPlaneCollection::New()` #[doc(alias = "vtkPlaneCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkPlaneCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPlaneCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPlaneCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPlaneCollection_get_ptr(self.0) } + Self(unsafe { vtkPlaneCollection_new() }) } } impl std::default::Default for vtkPlaneCollection { @@ -78223,12 +42918,8 @@ impl Drop for vtkPlaneCollection { #[test] fn test_vtkPlaneCollection_create_drop() { let obj = vtkPlaneCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPlaneCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for convex set of planes /// @@ -78254,22 +42945,13 @@ fn test_vtkPlaneCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPlanes(*mut core::ffi::c_void); impl vtkPlanes { - /// Creates a new [vtkPlanes] wrapped inside `vtkNew` + /// Creates a new [vtkPlanes] via `vtkPlanes::New()` #[doc(alias = "vtkPlanes")] pub fn new() -> Self { unsafe extern "C" { fn vtkPlanes_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPlanes_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPlanes_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPlanes_get_ptr(self.0) } + Self(unsafe { vtkPlanes_new() }) } } impl std::default::Default for vtkPlanes { @@ -78289,12 +42971,8 @@ impl Drop for vtkPlanes { #[test] fn test_vtkPlanes_create_drop() { let obj = vtkPlanes::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPlanes(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A vtkPlanesIntersection object is a /// @@ -78317,22 +42995,13 @@ fn test_vtkPlanes_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPlanesIntersection(*mut core::ffi::c_void); impl vtkPlanesIntersection { - /// Creates a new [vtkPlanesIntersection] wrapped inside `vtkNew` + /// Creates a new [vtkPlanesIntersection] via `vtkPlanesIntersection::New()` #[doc(alias = "vtkPlanesIntersection")] pub fn new() -> Self { unsafe extern "C" { fn vtkPlanesIntersection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPlanesIntersection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPlanesIntersection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPlanesIntersection_get_ptr(self.0) } + Self(unsafe { vtkPlanesIntersection_new() }) } } impl std::default::Default for vtkPlanesIntersection { @@ -78352,12 +43021,8 @@ impl Drop for vtkPlanesIntersection { #[test] fn test_vtkPlanesIntersection_create_drop() { let obj = vtkPlanesIntersection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPlanesIntersection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate point attribute data /// @@ -78369,22 +43034,13 @@ fn test_vtkPlanesIntersection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPointData(*mut core::ffi::c_void); impl vtkPointData { - /// Creates a new [vtkPointData] wrapped inside `vtkNew` + /// Creates a new [vtkPointData] via `vtkPointData::New()` #[doc(alias = "vtkPointData")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointData_get_ptr(self.0) } + Self(unsafe { vtkPointData_new() }) } } impl std::default::Default for vtkPointData { @@ -78404,12 +43060,8 @@ impl Drop for vtkPointData { #[test] fn test_vtkPointData_create_drop() { let obj = vtkPointData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// quickly locate points in 3-space /// @@ -78435,22 +43087,13 @@ fn test_vtkPointData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPointLocator(*mut core::ffi::c_void); impl vtkPointLocator { - /// Creates a new [vtkPointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkPointLocator] via `vtkPointLocator::New()` #[doc(alias = "vtkPointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointLocator_get_ptr(self.0) } + Self(unsafe { vtkPointLocator_new() }) } } impl std::default::Default for vtkPointLocator { @@ -78470,12 +43113,8 @@ impl Drop for vtkPointLocator { #[test] fn test_vtkPointLocator_create_drop() { let obj = vtkPointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// concrete class for storing a set of points /// @@ -78514,22 +43153,13 @@ fn test_vtkPointLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPointSet(*mut core::ffi::c_void); impl vtkPointSet { - /// Creates a new [vtkPointSet] wrapped inside `vtkNew` + /// Creates a new [vtkPointSet] via `vtkPointSet::New()` #[doc(alias = "vtkPointSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointSet_get_ptr(self.0) } + Self(unsafe { vtkPointSet_new() }) } } impl std::default::Default for vtkPointSet { @@ -78549,12 +43179,8 @@ impl Drop for vtkPointSet { #[test] fn test_vtkPointSet_create_drop() { let obj = vtkPointSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Implementation of vtkCellIterator using /// @@ -78562,22 +43188,13 @@ fn test_vtkPointSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPointSetCellIterator(*mut core::ffi::c_void); impl vtkPointSetCellIterator { - /// Creates a new [vtkPointSetCellIterator] wrapped inside `vtkNew` + /// Creates a new [vtkPointSetCellIterator] via `vtkPointSetCellIterator::New()` #[doc(alias = "vtkPointSetCellIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointSetCellIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointSetCellIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointSetCellIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointSetCellIterator_get_ptr(self.0) } + Self(unsafe { vtkPointSetCellIterator_new() }) } } impl std::default::Default for vtkPointSetCellIterator { @@ -78597,12 +43214,8 @@ impl Drop for vtkPointSetCellIterator { #[test] fn test_vtkPointSetCellIterator_create_drop() { let obj = vtkPointSetCellIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointSetCellIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// the convex hull of the orthogonal /// @@ -78616,22 +43229,13 @@ fn test_vtkPointSetCellIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPointsProjectedHull(*mut core::ffi::c_void); impl vtkPointsProjectedHull { - /// Creates a new [vtkPointsProjectedHull] wrapped inside `vtkNew` + /// Creates a new [vtkPointsProjectedHull] via `vtkPointsProjectedHull::New()` #[doc(alias = "vtkPointsProjectedHull")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointsProjectedHull_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointsProjectedHull_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointsProjectedHull_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointsProjectedHull_get_ptr(self.0) } + Self(unsafe { vtkPointsProjectedHull_new() }) } } impl std::default::Default for vtkPointsProjectedHull { @@ -78651,12 +43255,8 @@ impl Drop for vtkPointsProjectedHull { #[test] fn test_vtkPointsProjectedHull_create_drop() { let obj = vtkPointsProjectedHull::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointsProjectedHull(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// concrete dataset represents vertices, lines, polygons, and triangle strips /// @@ -78705,22 +43305,13 @@ fn test_vtkPointsProjectedHull_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyData(*mut core::ffi::c_void); impl vtkPolyData { - /// Creates a new [vtkPolyData] wrapped inside `vtkNew` + /// Creates a new [vtkPolyData] via `vtkPolyData::New()` #[doc(alias = "vtkPolyData")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyData_get_ptr(self.0) } + Self(unsafe { vtkPolyData_new() }) } } impl std::default::Default for vtkPolyData { @@ -78740,12 +43331,8 @@ impl Drop for vtkPolyData { #[test] fn test_vtkPolyData_create_drop() { let obj = vtkPolyData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of polygonal data objects /// @@ -78758,22 +43345,13 @@ fn test_vtkPolyData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyDataCollection(*mut core::ffi::c_void); impl vtkPolyDataCollection { - /// Creates a new [vtkPolyDataCollection] wrapped inside `vtkNew` + /// Creates a new [vtkPolyDataCollection] via `vtkPolyDataCollection::New()` #[doc(alias = "vtkPolyDataCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyDataCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyDataCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyDataCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyDataCollection_get_ptr(self.0) } + Self(unsafe { vtkPolyDataCollection_new() }) } } impl std::default::Default for vtkPolyDataCollection { @@ -78793,12 +43371,8 @@ impl Drop for vtkPolyDataCollection { #[test] fn test_vtkPolyDataCollection_create_drop() { let obj = vtkPolyDataCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyDataCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a set of 1D lines /// @@ -78808,22 +43382,13 @@ fn test_vtkPolyDataCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyLine(*mut core::ffi::c_void); impl vtkPolyLine { - /// Creates a new [vtkPolyLine] wrapped inside `vtkNew` + /// Creates a new [vtkPolyLine] via `vtkPolyLine::New()` #[doc(alias = "vtkPolyLine")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyLine_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyLine_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyLine_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyLine_get_ptr(self.0) } + Self(unsafe { vtkPolyLine_new() }) } } impl std::default::Default for vtkPolyLine { @@ -78843,12 +43408,8 @@ impl Drop for vtkPolyLine { #[test] fn test_vtkPolyLine_create_drop() { let obj = vtkPolyLine::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyLine(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Implicit function that is generated by extrusion of a polyline along the Z axis /// @@ -78864,22 +43425,13 @@ fn test_vtkPolyLine_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyPlane(*mut core::ffi::c_void); impl vtkPolyPlane { - /// Creates a new [vtkPolyPlane] wrapped inside `vtkNew` + /// Creates a new [vtkPolyPlane] via `vtkPolyPlane::New()` #[doc(alias = "vtkPolyPlane")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyPlane_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyPlane_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyPlane_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyPlane_get_ptr(self.0) } + Self(unsafe { vtkPolyPlane_new() }) } } impl std::default::Default for vtkPolyPlane { @@ -78899,12 +43451,8 @@ impl Drop for vtkPolyPlane { #[test] fn test_vtkPolyPlane_create_drop() { let obj = vtkPolyPlane::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyPlane(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a set of 0D vertices /// @@ -78914,22 +43462,13 @@ fn test_vtkPolyPlane_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyVertex(*mut core::ffi::c_void); impl vtkPolyVertex { - /// Creates a new [vtkPolyVertex] wrapped inside `vtkNew` + /// Creates a new [vtkPolyVertex] via `vtkPolyVertex::New()` #[doc(alias = "vtkPolyVertex")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyVertex_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyVertex_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyVertex_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyVertex_get_ptr(self.0) } + Self(unsafe { vtkPolyVertex_new() }) } } impl std::default::Default for vtkPolyVertex { @@ -78949,12 +43488,8 @@ impl Drop for vtkPolyVertex { #[test] fn test_vtkPolyVertex_create_drop() { let obj = vtkPolyVertex::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyVertex(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents an n-sided polygon /// @@ -78966,22 +43501,13 @@ fn test_vtkPolyVertex_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolygon(*mut core::ffi::c_void); impl vtkPolygon { - /// Creates a new [vtkPolygon] wrapped inside `vtkNew` + /// Creates a new [vtkPolygon] via `vtkPolygon::New()` #[doc(alias = "vtkPolygon")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolygon_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolygon_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolygon_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolygon_get_ptr(self.0) } + Self(unsafe { vtkPolygon_new() }) } } impl std::default::Default for vtkPolygon { @@ -79001,12 +43527,8 @@ impl Drop for vtkPolygon { #[test] fn test_vtkPolygon_create_drop() { let obj = vtkPolygon::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolygon(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell defined by a set of polygonal faces /// @@ -79028,22 +43550,13 @@ fn test_vtkPolygon_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyhedron(*mut core::ffi::c_void); impl vtkPolyhedron { - /// Creates a new [vtkPolyhedron] wrapped inside `vtkNew` + /// Creates a new [vtkPolyhedron] via `vtkPolyhedron::New()` #[doc(alias = "vtkPolyhedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyhedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyhedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyhedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyhedron_get_ptr(self.0) } + Self(unsafe { vtkPolyhedron_new() }) } } impl std::default::Default for vtkPolyhedron { @@ -79063,12 +43576,8 @@ impl Drop for vtkPolyhedron { #[test] fn test_vtkPolyhedron_create_drop() { let obj = vtkPolyhedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyhedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell that represents a linear pyramid /// @@ -79086,22 +43595,13 @@ fn test_vtkPolyhedron_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPyramid(*mut core::ffi::c_void); impl vtkPyramid { - /// Creates a new [vtkPyramid] wrapped inside `vtkNew` + /// Creates a new [vtkPyramid] via `vtkPyramid::New()` #[doc(alias = "vtkPyramid")] pub fn new() -> Self { unsafe extern "C" { fn vtkPyramid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPyramid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPyramid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPyramid_get_ptr(self.0) } + Self(unsafe { vtkPyramid_new() }) } } impl std::default::Default for vtkPyramid { @@ -79121,12 +43621,8 @@ impl Drop for vtkPyramid { #[test] fn test_vtkPyramid_create_drop() { let obj = vtkPyramid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPyramid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a 2D quadrilateral /// @@ -79138,20 +43634,13 @@ fn test_vtkPyramid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuad(*mut core::ffi::c_void); impl vtkQuad { - /// Creates a new [vtkQuad] wrapped inside `vtkNew` + /// Creates a new [vtkQuad] via `vtkQuad::New()` #[doc(alias = "vtkQuad")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuad_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuad_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuad_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkQuad_get_ptr(self.0) } + Self(unsafe { vtkQuad_new() }) } } impl std::default::Default for vtkQuad { @@ -79171,12 +43660,8 @@ impl Drop for vtkQuad { #[test] fn test_vtkQuad_create_drop() { let obj = vtkQuad::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuad(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, isoparametric edge /// @@ -79194,22 +43679,13 @@ fn test_vtkQuad_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticEdge(*mut core::ffi::c_void); impl vtkQuadraticEdge { - /// Creates a new [vtkQuadraticEdge] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticEdge] via `vtkQuadraticEdge::New()` #[doc(alias = "vtkQuadraticEdge")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticEdge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticEdge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticEdge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticEdge_get_ptr(self.0) } + Self(unsafe { vtkQuadraticEdge_new() }) } } impl std::default::Default for vtkQuadraticEdge { @@ -79229,12 +43705,8 @@ impl Drop for vtkQuadraticEdge { #[test] fn test_vtkQuadraticEdge_create_drop() { let obj = vtkQuadraticEdge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticEdge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 20-node isoparametric hexahedron /// @@ -79255,22 +43727,13 @@ fn test_vtkQuadraticEdge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticHexahedron(*mut core::ffi::c_void); impl vtkQuadraticHexahedron { - /// Creates a new [vtkQuadraticHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticHexahedron] via `vtkQuadraticHexahedron::New()` #[doc(alias = "vtkQuadraticHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticHexahedron_get_ptr(self.0) } + Self(unsafe { vtkQuadraticHexahedron_new() }) } } impl std::default::Default for vtkQuadraticHexahedron { @@ -79290,12 +43753,8 @@ impl Drop for vtkQuadraticHexahedron { #[test] fn test_vtkQuadraticHexahedron_create_drop() { let obj = vtkQuadraticHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a quadratic-linear, 6-node isoparametric quad /// @@ -79318,22 +43777,13 @@ fn test_vtkQuadraticHexahedron_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticLinearQuad(*mut core::ffi::c_void); impl vtkQuadraticLinearQuad { - /// Creates a new [vtkQuadraticLinearQuad] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticLinearQuad] via `vtkQuadraticLinearQuad::New()` #[doc(alias = "vtkQuadraticLinearQuad")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticLinearQuad_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticLinearQuad_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticLinearQuad_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticLinearQuad_get_ptr(self.0) } + Self(unsafe { vtkQuadraticLinearQuad_new() }) } } impl std::default::Default for vtkQuadraticLinearQuad { @@ -79353,12 +43803,8 @@ impl Drop for vtkQuadraticLinearQuad { #[test] fn test_vtkQuadraticLinearQuad_create_drop() { let obj = vtkQuadraticLinearQuad::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticLinearQuad(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a, 12-node isoparametric wedge /// @@ -79384,22 +43830,13 @@ fn test_vtkQuadraticLinearQuad_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticLinearWedge(*mut core::ffi::c_void); impl vtkQuadraticLinearWedge { - /// Creates a new [vtkQuadraticLinearWedge] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticLinearWedge] via `vtkQuadraticLinearWedge::New()` #[doc(alias = "vtkQuadraticLinearWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticLinearWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticLinearWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticLinearWedge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticLinearWedge_get_ptr(self.0) } + Self(unsafe { vtkQuadraticLinearWedge_new() }) } } impl std::default::Default for vtkQuadraticLinearWedge { @@ -79419,12 +43856,8 @@ impl Drop for vtkQuadraticLinearWedge { #[test] fn test_vtkQuadraticLinearWedge_create_drop() { let obj = vtkQuadraticLinearWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticLinearWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a parabolic n-sided polygon /// @@ -79444,22 +43877,13 @@ fn test_vtkQuadraticLinearWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticPolygon(*mut core::ffi::c_void); impl vtkQuadraticPolygon { - /// Creates a new [vtkQuadraticPolygon] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticPolygon] via `vtkQuadraticPolygon::New()` #[doc(alias = "vtkQuadraticPolygon")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticPolygon_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticPolygon_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticPolygon_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticPolygon_get_ptr(self.0) } + Self(unsafe { vtkQuadraticPolygon_new() }) } } impl std::default::Default for vtkQuadraticPolygon { @@ -79479,12 +43903,8 @@ impl Drop for vtkQuadraticPolygon { #[test] fn test_vtkQuadraticPolygon_create_drop() { let obj = vtkQuadraticPolygon::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticPolygon(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 13-node isoparametric pyramid /// @@ -79510,22 +43930,13 @@ fn test_vtkQuadraticPolygon_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticPyramid(*mut core::ffi::c_void); impl vtkQuadraticPyramid { - /// Creates a new [vtkQuadraticPyramid] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticPyramid] via `vtkQuadraticPyramid::New()` #[doc(alias = "vtkQuadraticPyramid")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticPyramid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticPyramid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticPyramid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticPyramid_get_ptr(self.0) } + Self(unsafe { vtkQuadraticPyramid_new() }) } } impl std::default::Default for vtkQuadraticPyramid { @@ -79545,12 +43956,8 @@ impl Drop for vtkQuadraticPyramid { #[test] fn test_vtkQuadraticPyramid_create_drop() { let obj = vtkQuadraticPyramid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticPyramid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 8-node isoparametric quad /// @@ -79570,22 +43977,13 @@ fn test_vtkQuadraticPyramid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticQuad(*mut core::ffi::c_void); impl vtkQuadraticQuad { - /// Creates a new [vtkQuadraticQuad] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticQuad] via `vtkQuadraticQuad::New()` #[doc(alias = "vtkQuadraticQuad")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticQuad_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticQuad_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticQuad_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticQuad_get_ptr(self.0) } + Self(unsafe { vtkQuadraticQuad_new() }) } } impl std::default::Default for vtkQuadraticQuad { @@ -79605,12 +44003,8 @@ impl Drop for vtkQuadraticQuad { #[test] fn test_vtkQuadraticQuad_create_drop() { let obj = vtkQuadraticQuad::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticQuad(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 10-node isoparametric tetrahedron /// @@ -79634,22 +44028,13 @@ fn test_vtkQuadraticQuad_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticTetra(*mut core::ffi::c_void); impl vtkQuadraticTetra { - /// Creates a new [vtkQuadraticTetra] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticTetra] via `vtkQuadraticTetra::New()` #[doc(alias = "vtkQuadraticTetra")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticTetra_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticTetra_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticTetra_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticTetra_get_ptr(self.0) } + Self(unsafe { vtkQuadraticTetra_new() }) } } impl std::default::Default for vtkQuadraticTetra { @@ -79669,12 +44054,8 @@ impl Drop for vtkQuadraticTetra { #[test] fn test_vtkQuadraticTetra_create_drop() { let obj = vtkQuadraticTetra::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticTetra(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, isoparametric triangle /// @@ -79694,22 +44075,13 @@ fn test_vtkQuadraticTetra_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticTriangle(*mut core::ffi::c_void); impl vtkQuadraticTriangle { - /// Creates a new [vtkQuadraticTriangle] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticTriangle] via `vtkQuadraticTriangle::New()` #[doc(alias = "vtkQuadraticTriangle")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticTriangle_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticTriangle_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticTriangle_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticTriangle_get_ptr(self.0) } + Self(unsafe { vtkQuadraticTriangle_new() }) } } impl std::default::Default for vtkQuadraticTriangle { @@ -79729,12 +44101,8 @@ impl Drop for vtkQuadraticTriangle { #[test] fn test_vtkQuadraticTriangle_create_drop() { let obj = vtkQuadraticTriangle::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticTriangle(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 15-node isoparametric wedge /// @@ -79757,22 +44125,13 @@ fn test_vtkQuadraticTriangle_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticWedge(*mut core::ffi::c_void); impl vtkQuadraticWedge { - /// Creates a new [vtkQuadraticWedge] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticWedge] via `vtkQuadraticWedge::New()` #[doc(alias = "vtkQuadraticWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticWedge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticWedge_get_ptr(self.0) } + Self(unsafe { vtkQuadraticWedge_new() }) } } impl std::default::Default for vtkQuadraticWedge { @@ -79792,12 +44151,8 @@ impl Drop for vtkQuadraticWedge { #[test] fn test_vtkQuadraticWedge_create_drop() { let obj = vtkQuadraticWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// An Elemental data type that holds a definition of a @@ -79818,22 +44173,13 @@ fn test_vtkQuadraticWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadratureSchemeDefinition(*mut core::ffi::c_void); impl vtkQuadratureSchemeDefinition { - /// Creates a new [vtkQuadratureSchemeDefinition] wrapped inside `vtkNew` + /// Creates a new [vtkQuadratureSchemeDefinition] via `vtkQuadratureSchemeDefinition::New()` #[doc(alias = "vtkQuadratureSchemeDefinition")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadratureSchemeDefinition_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadratureSchemeDefinition_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadratureSchemeDefinition_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadratureSchemeDefinition_get_ptr(self.0) } + Self(unsafe { vtkQuadratureSchemeDefinition_new() }) } } impl std::default::Default for vtkQuadratureSchemeDefinition { @@ -79853,12 +44199,8 @@ impl Drop for vtkQuadratureSchemeDefinition { #[test] fn test_vtkQuadratureSchemeDefinition_create_drop() { let obj = vtkQuadratureSchemeDefinition::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadratureSchemeDefinition(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// evaluate implicit quadric function /// @@ -79869,22 +44211,13 @@ fn test_vtkQuadratureSchemeDefinition_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadric(*mut core::ffi::c_void); impl vtkQuadric { - /// Creates a new [vtkQuadric] wrapped inside `vtkNew` + /// Creates a new [vtkQuadric] via `vtkQuadric::New()` #[doc(alias = "vtkQuadric")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadric_get_ptr(self.0) } + Self(unsafe { vtkQuadric_new() }) } } impl std::default::Default for vtkQuadric { @@ -79904,12 +44237,8 @@ impl Drop for vtkQuadric { #[test] fn test_vtkQuadric_create_drop() { let obj = vtkQuadric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a dataset that is topologically regular with variable spacing in the three coordinate /// @@ -79933,22 +44262,13 @@ fn test_vtkQuadric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRectilinearGrid(*mut core::ffi::c_void); impl vtkRectilinearGrid { - /// Creates a new [vtkRectilinearGrid] wrapped inside `vtkNew` + /// Creates a new [vtkRectilinearGrid] via `vtkRectilinearGrid::New()` #[doc(alias = "vtkRectilinearGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkRectilinearGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRectilinearGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRectilinearGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRectilinearGrid_get_ptr(self.0) } + Self(unsafe { vtkRectilinearGrid_new() }) } } impl std::default::Default for vtkRectilinearGrid { @@ -79968,12 +44288,8 @@ impl Drop for vtkRectilinearGrid { #[test] fn test_vtkRectilinearGrid_create_drop() { let obj = vtkRectilinearGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRectilinearGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Reeb graph computation for PL scalar fields. /// @@ -80073,22 +44389,13 @@ fn test_vtkRectilinearGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkReebGraph(*mut core::ffi::c_void); impl vtkReebGraph { - /// Creates a new [vtkReebGraph] wrapped inside `vtkNew` + /// Creates a new [vtkReebGraph] via `vtkReebGraph::New()` #[doc(alias = "vtkReebGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkReebGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkReebGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkReebGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkReebGraph_get_ptr(self.0) } + Self(unsafe { vtkReebGraph_new() }) } } impl std::default::Default for vtkReebGraph { @@ -80108,12 +44415,8 @@ impl Drop for vtkReebGraph { #[test] fn test_vtkReebGraph_create_drop() { let obj = vtkReebGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkReebGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// abstract class for custom Reeb graph /// @@ -80146,22 +44449,13 @@ fn test_vtkReebGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkReebGraphSimplificationMetric(*mut core::ffi::c_void); impl vtkReebGraphSimplificationMetric { - /// Creates a new [vtkReebGraphSimplificationMetric] wrapped inside `vtkNew` + /// Creates a new [vtkReebGraphSimplificationMetric] via `vtkReebGraphSimplificationMetric::New()` #[doc(alias = "vtkReebGraphSimplificationMetric")] pub fn new() -> Self { unsafe extern "C" { fn vtkReebGraphSimplificationMetric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkReebGraphSimplificationMetric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkReebGraphSimplificationMetric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkReebGraphSimplificationMetric_get_ptr(self.0) } + Self(unsafe { vtkReebGraphSimplificationMetric_new() }) } } impl std::default::Default for vtkReebGraphSimplificationMetric { @@ -80183,12 +44477,8 @@ impl Drop for vtkReebGraphSimplificationMetric { #[test] fn test_vtkReebGraphSimplificationMetric_create_drop() { let obj = vtkReebGraphSimplificationMetric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkReebGraphSimplificationMetric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// data object that represents a "selection" in VTK. /// @@ -80215,22 +44505,13 @@ fn test_vtkReebGraphSimplificationMetric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSelection(*mut core::ffi::c_void); impl vtkSelection { - /// Creates a new [vtkSelection] wrapped inside `vtkNew` + /// Creates a new [vtkSelection] via `vtkSelection::New()` #[doc(alias = "vtkSelection")] pub fn new() -> Self { unsafe extern "C" { fn vtkSelection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSelection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSelection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSelection_get_ptr(self.0) } + Self(unsafe { vtkSelection_new() }) } } impl std::default::Default for vtkSelection { @@ -80250,12 +44531,8 @@ impl Drop for vtkSelection { #[test] fn test_vtkSelection_create_drop() { let obj = vtkSelection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSelection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a node in a vtkSelection the defines the selection criteria. /// @@ -80455,22 +44732,13 @@ fn test_vtkSelection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSelectionNode(*mut core::ffi::c_void); impl vtkSelectionNode { - /// Creates a new [vtkSelectionNode] wrapped inside `vtkNew` + /// Creates a new [vtkSelectionNode] via `vtkSelectionNode::New()` #[doc(alias = "vtkSelectionNode")] pub fn new() -> Self { unsafe extern "C" { fn vtkSelectionNode_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSelectionNode_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSelectionNode_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSelectionNode_get_ptr(self.0) } + Self(unsafe { vtkSelectionNode_new() }) } } impl std::default::Default for vtkSelectionNode { @@ -80490,12 +44758,8 @@ impl Drop for vtkSelectionNode { #[test] fn test_vtkSelectionNode_create_drop() { let obj = vtkSelectionNode::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSelectionNode(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// helper class to perform cell tessellation /// @@ -80527,22 +44791,13 @@ fn test_vtkSelectionNode_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSimpleCellTessellator(*mut core::ffi::c_void); impl vtkSimpleCellTessellator { - /// Creates a new [vtkSimpleCellTessellator] wrapped inside `vtkNew` + /// Creates a new [vtkSimpleCellTessellator] via `vtkSimpleCellTessellator::New()` #[doc(alias = "vtkSimpleCellTessellator")] pub fn new() -> Self { unsafe extern "C" { fn vtkSimpleCellTessellator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSimpleCellTessellator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSimpleCellTessellator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSimpleCellTessellator_get_ptr(self.0) } + Self(unsafe { vtkSimpleCellTessellator_new() }) } } impl std::default::Default for vtkSimpleCellTessellator { @@ -80562,12 +44817,8 @@ impl Drop for vtkSimpleCellTessellator { #[test] fn test_vtkSimpleCellTessellator_create_drop() { let obj = vtkSimpleCellTessellator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSimpleCellTessellator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects that compute /// @@ -80585,22 +44836,13 @@ fn test_vtkSimpleCellTessellator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSmoothErrorMetric(*mut core::ffi::c_void); impl vtkSmoothErrorMetric { - /// Creates a new [vtkSmoothErrorMetric] wrapped inside `vtkNew` + /// Creates a new [vtkSmoothErrorMetric] via `vtkSmoothErrorMetric::New()` #[doc(alias = "vtkSmoothErrorMetric")] pub fn new() -> Self { unsafe extern "C" { fn vtkSmoothErrorMetric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSmoothErrorMetric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSmoothErrorMetric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSmoothErrorMetric_get_ptr(self.0) } + Self(unsafe { vtkSmoothErrorMetric_new() }) } } impl std::default::Default for vtkSmoothErrorMetric { @@ -80620,12 +44862,8 @@ impl Drop for vtkSmoothErrorMetric { #[test] fn test_vtkSmoothErrorMetric_create_drop() { let obj = vtkSmoothErrorMetric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSmoothErrorMetric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// provides a method for sorting field data /// @@ -80655,22 +44893,13 @@ fn test_vtkSmoothErrorMetric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSortFieldData(*mut core::ffi::c_void); impl vtkSortFieldData { - /// Creates a new [vtkSortFieldData] wrapped inside `vtkNew` + /// Creates a new [vtkSortFieldData] via `vtkSortFieldData::New()` #[doc(alias = "vtkSortFieldData")] pub fn new() -> Self { unsafe extern "C" { fn vtkSortFieldData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSortFieldData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSortFieldData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSortFieldData_get_ptr(self.0) } + Self(unsafe { vtkSortFieldData_new() }) } } impl std::default::Default for vtkSortFieldData { @@ -80690,12 +44919,8 @@ impl Drop for vtkSortFieldData { #[test] fn test_vtkSortFieldData_create_drop() { let obj = vtkSortFieldData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSortFieldData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a sphere /// @@ -80707,22 +44932,13 @@ fn test_vtkSortFieldData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSphere(*mut core::ffi::c_void); impl vtkSphere { - /// Creates a new [vtkSphere] wrapped inside `vtkNew` + /// Creates a new [vtkSphere] via `vtkSphere::New()` #[doc(alias = "vtkSphere")] pub fn new() -> Self { unsafe extern "C" { fn vtkSphere_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSphere_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSphere_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSphere_get_ptr(self.0) } + Self(unsafe { vtkSphere_new() }) } } impl std::default::Default for vtkSphere { @@ -80742,12 +44958,8 @@ impl Drop for vtkSphere { #[test] fn test_vtkSphere_create_drop() { let obj = vtkSphere::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSphere(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a set of spheres /// @@ -80766,22 +44978,13 @@ fn test_vtkSphere_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSpheres(*mut core::ffi::c_void); impl vtkSpheres { - /// Creates a new [vtkSpheres] wrapped inside `vtkNew` + /// Creates a new [vtkSpheres] via `vtkSpheres::New()` #[doc(alias = "vtkSpheres")] pub fn new() -> Self { unsafe extern "C" { fn vtkSpheres_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSpheres_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSpheres_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSpheres_get_ptr(self.0) } + Self(unsafe { vtkSpheres_new() }) } } impl std::default::Default for vtkSpheres { @@ -80801,12 +45004,8 @@ impl Drop for vtkSpheres { #[test] fn test_vtkSpheres_create_drop() { let obj = vtkSpheres::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSpheres(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// object represents upward pointers from points /// @@ -80836,22 +45035,13 @@ fn test_vtkSpheres_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStaticCellLinks(*mut core::ffi::c_void); impl vtkStaticCellLinks { - /// Creates a new [vtkStaticCellLinks] wrapped inside `vtkNew` + /// Creates a new [vtkStaticCellLinks] via `vtkStaticCellLinks::New()` #[doc(alias = "vtkStaticCellLinks")] pub fn new() -> Self { unsafe extern "C" { fn vtkStaticCellLinks_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStaticCellLinks_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStaticCellLinks_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStaticCellLinks_get_ptr(self.0) } + Self(unsafe { vtkStaticCellLinks_new() }) } } impl std::default::Default for vtkStaticCellLinks { @@ -80871,12 +45061,8 @@ impl Drop for vtkStaticCellLinks { #[test] fn test_vtkStaticCellLinks_create_drop() { let obj = vtkStaticCellLinks::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStaticCellLinks(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// perform fast cell location operations /// @@ -80903,22 +45089,13 @@ fn test_vtkStaticCellLinks_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStaticCellLocator(*mut core::ffi::c_void); impl vtkStaticCellLocator { - /// Creates a new [vtkStaticCellLocator] wrapped inside `vtkNew` + /// Creates a new [vtkStaticCellLocator] via `vtkStaticCellLocator::New()` #[doc(alias = "vtkStaticCellLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkStaticCellLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStaticCellLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStaticCellLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStaticCellLocator_get_ptr(self.0) } + Self(unsafe { vtkStaticCellLocator_new() }) } } impl std::default::Default for vtkStaticCellLocator { @@ -80938,12 +45115,8 @@ impl Drop for vtkStaticCellLocator { #[test] fn test_vtkStaticCellLocator_create_drop() { let obj = vtkStaticCellLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStaticCellLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// quickly locate points in 3-space /// @@ -80980,22 +45153,13 @@ fn test_vtkStaticCellLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStaticPointLocator(*mut core::ffi::c_void); impl vtkStaticPointLocator { - /// Creates a new [vtkStaticPointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkStaticPointLocator] via `vtkStaticPointLocator::New()` #[doc(alias = "vtkStaticPointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkStaticPointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStaticPointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStaticPointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStaticPointLocator_get_ptr(self.0) } + Self(unsafe { vtkStaticPointLocator_new() }) } } impl std::default::Default for vtkStaticPointLocator { @@ -81015,12 +45179,8 @@ impl Drop for vtkStaticPointLocator { #[test] fn test_vtkStaticPointLocator_create_drop() { let obj = vtkStaticPointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStaticPointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// quickly locate points in 2-space /// @@ -81063,22 +45223,13 @@ fn test_vtkStaticPointLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStaticPointLocator2D(*mut core::ffi::c_void); impl vtkStaticPointLocator2D { - /// Creates a new [vtkStaticPointLocator2D] wrapped inside `vtkNew` + /// Creates a new [vtkStaticPointLocator2D] via `vtkStaticPointLocator2D::New()` #[doc(alias = "vtkStaticPointLocator2D")] pub fn new() -> Self { unsafe extern "C" { fn vtkStaticPointLocator2D_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStaticPointLocator2D_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStaticPointLocator2D_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStaticPointLocator2D_get_ptr(self.0) } + Self(unsafe { vtkStaticPointLocator2D_new() }) } } impl std::default::Default for vtkStaticPointLocator2D { @@ -81098,12 +45249,8 @@ impl Drop for vtkStaticPointLocator2D { #[test] fn test_vtkStaticPointLocator2D_create_drop() { let obj = vtkStaticPointLocator2D::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStaticPointLocator2D(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// helper class to aid working with structured /// @@ -81116,22 +45263,13 @@ fn test_vtkStaticPointLocator2D_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStructuredExtent(*mut core::ffi::c_void); impl vtkStructuredExtent { - /// Creates a new [vtkStructuredExtent] wrapped inside `vtkNew` + /// Creates a new [vtkStructuredExtent] via `vtkStructuredExtent::New()` #[doc(alias = "vtkStructuredExtent")] pub fn new() -> Self { unsafe extern "C" { fn vtkStructuredExtent_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStructuredExtent_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStructuredExtent_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStructuredExtent_get_ptr(self.0) } + Self(unsafe { vtkStructuredExtent_new() }) } } impl std::default::Default for vtkStructuredExtent { @@ -81151,12 +45289,8 @@ impl Drop for vtkStructuredExtent { #[test] fn test_vtkStructuredExtent_create_drop() { let obj = vtkStructuredExtent::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStructuredExtent(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// topologically regular array of data /// @@ -81185,22 +45319,13 @@ fn test_vtkStructuredExtent_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStructuredGrid(*mut core::ffi::c_void); impl vtkStructuredGrid { - /// Creates a new [vtkStructuredGrid] wrapped inside `vtkNew` + /// Creates a new [vtkStructuredGrid] via `vtkStructuredGrid::New()` #[doc(alias = "vtkStructuredGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkStructuredGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStructuredGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStructuredGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStructuredGrid_get_ptr(self.0) } + Self(unsafe { vtkStructuredGrid_new() }) } } impl std::default::Default for vtkStructuredGrid { @@ -81220,12 +45345,8 @@ impl Drop for vtkStructuredGrid { #[test] fn test_vtkStructuredGrid_create_drop() { let obj = vtkStructuredGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStructuredGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A subclass of ImageData. /// @@ -81241,22 +45362,13 @@ fn test_vtkStructuredGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStructuredPoints(*mut core::ffi::c_void); impl vtkStructuredPoints { - /// Creates a new [vtkStructuredPoints] wrapped inside `vtkNew` + /// Creates a new [vtkStructuredPoints] via `vtkStructuredPoints::New()` #[doc(alias = "vtkStructuredPoints")] pub fn new() -> Self { unsafe extern "C" { fn vtkStructuredPoints_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStructuredPoints_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStructuredPoints_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStructuredPoints_get_ptr(self.0) } + Self(unsafe { vtkStructuredPoints_new() }) } } impl std::default::Default for vtkStructuredPoints { @@ -81276,12 +45388,8 @@ impl Drop for vtkStructuredPoints { #[test] fn test_vtkStructuredPoints_create_drop() { let obj = vtkStructuredPoints::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStructuredPoints(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of structured points data objects /// @@ -81292,22 +45400,13 @@ fn test_vtkStructuredPoints_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStructuredPointsCollection(*mut core::ffi::c_void); impl vtkStructuredPointsCollection { - /// Creates a new [vtkStructuredPointsCollection] wrapped inside `vtkNew` + /// Creates a new [vtkStructuredPointsCollection] via `vtkStructuredPointsCollection::New()` #[doc(alias = "vtkStructuredPointsCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkStructuredPointsCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStructuredPointsCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStructuredPointsCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStructuredPointsCollection_get_ptr(self.0) } + Self(unsafe { vtkStructuredPointsCollection_new() }) } } impl std::default::Default for vtkStructuredPointsCollection { @@ -81327,12 +45426,8 @@ impl Drop for vtkStructuredPointsCollection { #[test] fn test_vtkStructuredPointsCollection_create_drop() { let obj = vtkStructuredPointsCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStructuredPointsCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a Superquadric /// @@ -81360,22 +45455,13 @@ fn test_vtkStructuredPointsCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSuperquadric(*mut core::ffi::c_void); impl vtkSuperquadric { - /// Creates a new [vtkSuperquadric] wrapped inside `vtkNew` + /// Creates a new [vtkSuperquadric] via `vtkSuperquadric::New()` #[doc(alias = "vtkSuperquadric")] pub fn new() -> Self { unsafe extern "C" { fn vtkSuperquadric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSuperquadric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSuperquadric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSuperquadric_get_ptr(self.0) } + Self(unsafe { vtkSuperquadric_new() }) } } impl std::default::Default for vtkSuperquadric { @@ -81395,12 +45481,8 @@ impl Drop for vtkSuperquadric { #[test] fn test_vtkSuperquadric_create_drop() { let obj = vtkSuperquadric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSuperquadric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A table, which contains similar-typed columns of data /// @@ -81433,20 +45515,13 @@ fn test_vtkSuperquadric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTable(*mut core::ffi::c_void); impl vtkTable { - /// Creates a new [vtkTable] wrapped inside `vtkNew` + /// Creates a new [vtkTable] via `vtkTable::New()` #[doc(alias = "vtkTable")] pub fn new() -> Self { unsafe extern "C" { fn vtkTable_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTable_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTable_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkTable_get_ptr(self.0) } + Self(unsafe { vtkTable_new() }) } } impl std::default::Default for vtkTable { @@ -81466,12 +45541,8 @@ impl Drop for vtkTable { #[test] fn test_vtkTable_create_drop() { let obj = vtkTable::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTable(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell that represents a tetrahedron /// @@ -81488,20 +45559,13 @@ fn test_vtkTable_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTetra(*mut core::ffi::c_void); impl vtkTetra { - /// Creates a new [vtkTetra] wrapped inside `vtkNew` + /// Creates a new [vtkTetra] via `vtkTetra::New()` #[doc(alias = "vtkTetra")] pub fn new() -> Self { unsafe extern "C" { fn vtkTetra_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTetra_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTetra_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkTetra_get_ptr(self.0) } + Self(unsafe { vtkTetra_new() }) } } impl std::default::Default for vtkTetra { @@ -81521,12 +45585,8 @@ impl Drop for vtkTetra { #[test] fn test_vtkTetra_create_drop() { let obj = vtkTetra::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTetra(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A rooted tree data structure. /// @@ -81554,20 +45614,13 @@ fn test_vtkTetra_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTree(*mut core::ffi::c_void); impl vtkTree { - /// Creates a new [vtkTree] wrapped inside `vtkNew` + /// Creates a new [vtkTree] via `vtkTree::New()` #[doc(alias = "vtkTree")] pub fn new() -> Self { unsafe extern "C" { fn vtkTree_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTree_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTree_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkTree_get_ptr(self.0) } + Self(unsafe { vtkTree_new() }) } } impl std::default::Default for vtkTree { @@ -81587,12 +45640,8 @@ impl Drop for vtkTree { #[test] fn test_vtkTree_create_drop() { let obj = vtkTree::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTree(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// breadth first search iterator through a vtkTree /// @@ -81609,22 +45658,13 @@ fn test_vtkTree_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTreeBFSIterator(*mut core::ffi::c_void); impl vtkTreeBFSIterator { - /// Creates a new [vtkTreeBFSIterator] wrapped inside `vtkNew` + /// Creates a new [vtkTreeBFSIterator] via `vtkTreeBFSIterator::New()` #[doc(alias = "vtkTreeBFSIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkTreeBFSIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTreeBFSIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTreeBFSIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTreeBFSIterator_get_ptr(self.0) } + Self(unsafe { vtkTreeBFSIterator_new() }) } } impl std::default::Default for vtkTreeBFSIterator { @@ -81644,12 +45684,8 @@ impl Drop for vtkTreeBFSIterator { #[test] fn test_vtkTreeBFSIterator_create_drop() { let obj = vtkTreeBFSIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTreeBFSIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// depth first iterator through a vtkGraph /// @@ -81669,22 +45705,13 @@ fn test_vtkTreeBFSIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTreeDFSIterator(*mut core::ffi::c_void); impl vtkTreeDFSIterator { - /// Creates a new [vtkTreeDFSIterator] wrapped inside `vtkNew` + /// Creates a new [vtkTreeDFSIterator] via `vtkTreeDFSIterator::New()` #[doc(alias = "vtkTreeDFSIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkTreeDFSIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTreeDFSIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTreeDFSIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTreeDFSIterator_get_ptr(self.0) } + Self(unsafe { vtkTreeDFSIterator_new() }) } } impl std::default::Default for vtkTreeDFSIterator { @@ -81704,12 +45731,8 @@ impl Drop for vtkTreeDFSIterator { #[test] fn test_vtkTreeDFSIterator_create_drop() { let obj = vtkTreeDFSIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTreeDFSIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 27-node isoparametric hexahedron /// @@ -81767,22 +45790,13 @@ fn test_vtkTreeDFSIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTriQuadraticHexahedron(*mut core::ffi::c_void); impl vtkTriQuadraticHexahedron { - /// Creates a new [vtkTriQuadraticHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkTriQuadraticHexahedron] via `vtkTriQuadraticHexahedron::New()` #[doc(alias = "vtkTriQuadraticHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkTriQuadraticHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTriQuadraticHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTriQuadraticHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTriQuadraticHexahedron_get_ptr(self.0) } + Self(unsafe { vtkTriQuadraticHexahedron_new() }) } } impl std::default::Default for vtkTriQuadraticHexahedron { @@ -81802,12 +45816,8 @@ impl Drop for vtkTriQuadraticHexahedron { #[test] fn test_vtkTriQuadraticHexahedron_create_drop() { let obj = vtkTriQuadraticHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTriQuadraticHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 13-node isoparametric pyramid /// @@ -81884,22 +45894,13 @@ fn test_vtkTriQuadraticHexahedron_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTriQuadraticPyramid(*mut core::ffi::c_void); impl vtkTriQuadraticPyramid { - /// Creates a new [vtkTriQuadraticPyramid] wrapped inside `vtkNew` + /// Creates a new [vtkTriQuadraticPyramid] via `vtkTriQuadraticPyramid::New()` #[doc(alias = "vtkTriQuadraticPyramid")] pub fn new() -> Self { unsafe extern "C" { fn vtkTriQuadraticPyramid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTriQuadraticPyramid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTriQuadraticPyramid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTriQuadraticPyramid_get_ptr(self.0) } + Self(unsafe { vtkTriQuadraticPyramid_new() }) } } impl std::default::Default for vtkTriQuadraticPyramid { @@ -81919,12 +45920,8 @@ impl Drop for vtkTriQuadraticPyramid { #[test] fn test_vtkTriQuadraticPyramid_create_drop() { let obj = vtkTriQuadraticPyramid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTriQuadraticPyramid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a triangle /// @@ -81934,22 +45931,13 @@ fn test_vtkTriQuadraticPyramid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTriangle(*mut core::ffi::c_void); impl vtkTriangle { - /// Creates a new [vtkTriangle] wrapped inside `vtkNew` + /// Creates a new [vtkTriangle] via `vtkTriangle::New()` #[doc(alias = "vtkTriangle")] pub fn new() -> Self { unsafe extern "C" { fn vtkTriangle_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTriangle_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTriangle_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTriangle_get_ptr(self.0) } + Self(unsafe { vtkTriangle_new() }) } } impl std::default::Default for vtkTriangle { @@ -81969,12 +45957,8 @@ impl Drop for vtkTriangle { #[test] fn test_vtkTriangle_create_drop() { let obj = vtkTriangle::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTriangle(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a triangle strip /// @@ -81988,22 +45972,13 @@ fn test_vtkTriangle_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTriangleStrip(*mut core::ffi::c_void); impl vtkTriangleStrip { - /// Creates a new [vtkTriangleStrip] wrapped inside `vtkNew` + /// Creates a new [vtkTriangleStrip] via `vtkTriangleStrip::New()` #[doc(alias = "vtkTriangleStrip")] pub fn new() -> Self { unsafe extern "C" { fn vtkTriangleStrip_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTriangleStrip_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTriangleStrip_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTriangleStrip_get_ptr(self.0) } + Self(unsafe { vtkTriangleStrip_new() }) } } impl std::default::Default for vtkTriangleStrip { @@ -82023,12 +45998,8 @@ impl Drop for vtkTriangleStrip { #[test] fn test_vtkTriangleStrip_create_drop() { let obj = vtkTriangleStrip::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTriangleStrip(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// An undirected graph. /// @@ -82052,22 +46023,13 @@ fn test_vtkTriangleStrip_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUndirectedGraph(*mut core::ffi::c_void); impl vtkUndirectedGraph { - /// Creates a new [vtkUndirectedGraph] wrapped inside `vtkNew` + /// Creates a new [vtkUndirectedGraph] via `vtkUndirectedGraph::New()` #[doc(alias = "vtkUndirectedGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkUndirectedGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUndirectedGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUndirectedGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUndirectedGraph_get_ptr(self.0) } + Self(unsafe { vtkUndirectedGraph_new() }) } } impl std::default::Default for vtkUndirectedGraph { @@ -82087,12 +46049,8 @@ impl Drop for vtkUndirectedGraph { #[test] fn test_vtkUndirectedGraph_create_drop() { let obj = vtkUndirectedGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUndirectedGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// image data with blanking /// @@ -82102,22 +46060,13 @@ fn test_vtkUndirectedGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUniformGrid(*mut core::ffi::c_void); impl vtkUniformGrid { - /// Creates a new [vtkUniformGrid] wrapped inside `vtkNew` + /// Creates a new [vtkUniformGrid] via `vtkUniformGrid::New()` #[doc(alias = "vtkUniformGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformGrid_get_ptr(self.0) } + Self(unsafe { vtkUniformGrid_new() }) } } impl std::default::Default for vtkUniformGrid { @@ -82137,33 +46086,20 @@ impl Drop for vtkUniformGrid { #[test] fn test_vtkUniformGrid_create_drop() { let obj = vtkUniformGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkUniformGridAMR(*mut core::ffi::c_void); impl vtkUniformGridAMR { - /// Creates a new [vtkUniformGridAMR] wrapped inside `vtkNew` + /// Creates a new [vtkUniformGridAMR] via `vtkUniformGridAMR::New()` #[doc(alias = "vtkUniformGridAMR")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformGridAMR_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformGridAMR_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformGridAMR_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformGridAMR_get_ptr(self.0) } + Self(unsafe { vtkUniformGridAMR_new() }) } } impl std::default::Default for vtkUniformGridAMR { @@ -82183,12 +46119,8 @@ impl Drop for vtkUniformGridAMR { #[test] fn test_vtkUniformGridAMR_create_drop() { let obj = vtkUniformGridAMR::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformGridAMR(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// subclass of vtkCompositeDataIterator /// @@ -82196,22 +46128,13 @@ fn test_vtkUniformGridAMR_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUniformGridAMRDataIterator(*mut core::ffi::c_void); impl vtkUniformGridAMRDataIterator { - /// Creates a new [vtkUniformGridAMRDataIterator] wrapped inside `vtkNew` + /// Creates a new [vtkUniformGridAMRDataIterator] via `vtkUniformGridAMRDataIterator::New()` #[doc(alias = "vtkUniformGridAMRDataIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformGridAMRDataIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformGridAMRDataIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformGridAMRDataIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformGridAMRDataIterator_get_ptr(self.0) } + Self(unsafe { vtkUniformGridAMRDataIterator_new() }) } } impl std::default::Default for vtkUniformGridAMRDataIterator { @@ -82231,12 +46154,8 @@ impl Drop for vtkUniformGridAMRDataIterator { #[test] fn test_vtkUniformGridAMRDataIterator_create_drop() { let obj = vtkUniformGridAMRDataIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformGridAMRDataIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A specifalized type of vtkHyperTreeGrid for the case /// @@ -82253,22 +46172,13 @@ fn test_vtkUniformGridAMRDataIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUniformHyperTreeGrid(*mut core::ffi::c_void); impl vtkUniformHyperTreeGrid { - /// Creates a new [vtkUniformHyperTreeGrid] wrapped inside `vtkNew` + /// Creates a new [vtkUniformHyperTreeGrid] via `vtkUniformHyperTreeGrid::New()` #[doc(alias = "vtkUniformHyperTreeGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformHyperTreeGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformHyperTreeGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformHyperTreeGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformHyperTreeGrid_get_ptr(self.0) } + Self(unsafe { vtkUniformHyperTreeGrid_new() }) } } impl std::default::Default for vtkUniformHyperTreeGrid { @@ -82288,12 +46198,8 @@ impl Drop for vtkUniformHyperTreeGrid { #[test] fn test_vtkUniformHyperTreeGrid_create_drop() { let obj = vtkUniformHyperTreeGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformHyperTreeGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dataset represents arbitrary combinations of /// @@ -82308,22 +46214,13 @@ fn test_vtkUniformHyperTreeGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnstructuredGrid(*mut core::ffi::c_void); impl vtkUnstructuredGrid { - /// Creates a new [vtkUnstructuredGrid] wrapped inside `vtkNew` + /// Creates a new [vtkUnstructuredGrid] via `vtkUnstructuredGrid::New()` #[doc(alias = "vtkUnstructuredGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnstructuredGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnstructuredGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnstructuredGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnstructuredGrid_get_ptr(self.0) } + Self(unsafe { vtkUnstructuredGrid_new() }) } } impl std::default::Default for vtkUnstructuredGrid { @@ -82343,12 +46240,8 @@ impl Drop for vtkUnstructuredGrid { #[test] fn test_vtkUnstructuredGrid_create_drop() { let obj = vtkUnstructuredGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnstructuredGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Implementation of vtkCellIterator /// @@ -82356,22 +46249,13 @@ fn test_vtkUnstructuredGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnstructuredGridCellIterator(*mut core::ffi::c_void); impl vtkUnstructuredGridCellIterator { - /// Creates a new [vtkUnstructuredGridCellIterator] wrapped inside `vtkNew` + /// Creates a new [vtkUnstructuredGridCellIterator] via `vtkUnstructuredGridCellIterator::New()` #[doc(alias = "vtkUnstructuredGridCellIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnstructuredGridCellIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnstructuredGridCellIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnstructuredGridCellIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnstructuredGridCellIterator_get_ptr(self.0) } + Self(unsafe { vtkUnstructuredGridCellIterator_new() }) } } impl std::default::Default for vtkUnstructuredGridCellIterator { @@ -82391,12 +46275,8 @@ impl Drop for vtkUnstructuredGridCellIterator { #[test] fn test_vtkUnstructuredGridCellIterator_create_drop() { let obj = vtkUnstructuredGridCellIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnstructuredGridCellIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a 3D point /// @@ -82405,22 +46285,13 @@ fn test_vtkUnstructuredGridCellIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVertex(*mut core::ffi::c_void); impl vtkVertex { - /// Creates a new [vtkVertex] wrapped inside `vtkNew` + /// Creates a new [vtkVertex] via `vtkVertex::New()` #[doc(alias = "vtkVertex")] pub fn new() -> Self { unsafe extern "C" { fn vtkVertex_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVertex_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVertex_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkVertex_get_ptr(self.0) } + Self(unsafe { vtkVertex_new() }) } } impl std::default::Default for vtkVertex { @@ -82440,12 +46311,8 @@ impl Drop for vtkVertex { #[test] fn test_vtkVertex_create_drop() { let obj = vtkVertex::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVertex(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates all vertices in a graph. /// @@ -82461,22 +46328,13 @@ fn test_vtkVertex_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVertexListIterator(*mut core::ffi::c_void); impl vtkVertexListIterator { - /// Creates a new [vtkVertexListIterator] wrapped inside `vtkNew` + /// Creates a new [vtkVertexListIterator] via `vtkVertexListIterator::New()` #[doc(alias = "vtkVertexListIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkVertexListIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVertexListIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVertexListIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkVertexListIterator_get_ptr(self.0) } + Self(unsafe { vtkVertexListIterator_new() }) } } impl std::default::Default for vtkVertexListIterator { @@ -82496,12 +46354,8 @@ impl Drop for vtkVertexListIterator { #[test] fn test_vtkVertexListIterator_create_drop() { let obj = vtkVertexListIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVertexListIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a 3D orthogonal parallelepiped /// @@ -82516,20 +46370,13 @@ fn test_vtkVertexListIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVoxel(*mut core::ffi::c_void); impl vtkVoxel { - /// Creates a new [vtkVoxel] wrapped inside `vtkNew` + /// Creates a new [vtkVoxel] via `vtkVoxel::New()` #[doc(alias = "vtkVoxel")] pub fn new() -> Self { unsafe extern "C" { fn vtkVoxel_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVoxel_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVoxel_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkVoxel_get_ptr(self.0) } + Self(unsafe { vtkVoxel_new() }) } } impl std::default::Default for vtkVoxel { @@ -82549,12 +46396,8 @@ impl Drop for vtkVoxel { #[test] fn test_vtkVoxel_create_drop() { let obj = vtkVoxel::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVoxel(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell that represents a linear wedge /// @@ -82572,20 +46415,13 @@ fn test_vtkVoxel_create_drop() { #[allow(non_camel_case_types)] pub struct vtkWedge(*mut core::ffi::c_void); impl vtkWedge { - /// Creates a new [vtkWedge] wrapped inside `vtkNew` + /// Creates a new [vtkWedge] via `vtkWedge::New()` #[doc(alias = "vtkWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkWedge_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkWedge_get_ptr(self.0) } + Self(unsafe { vtkWedge_new() }) } } impl std::default::Default for vtkWedge { @@ -82605,12 +46441,8 @@ impl Drop for vtkWedge { #[test] fn test_vtkWedge_create_drop() { let obj = vtkWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Represents an XML element and those nested inside. /// @@ -82625,22 +46457,13 @@ fn test_vtkWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkXMLDataElement(*mut core::ffi::c_void); impl vtkXMLDataElement { - /// Creates a new [vtkXMLDataElement] wrapped inside `vtkNew` + /// Creates a new [vtkXMLDataElement] via `vtkXMLDataElement::New()` #[doc(alias = "vtkXMLDataElement")] pub fn new() -> Self { unsafe extern "C" { fn vtkXMLDataElement_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkXMLDataElement_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkXMLDataElement_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkXMLDataElement_get_ptr(self.0) } + Self(unsafe { vtkXMLDataElement_new() }) } } impl std::default::Default for vtkXMLDataElement { @@ -82660,10 +46483,6 @@ impl Drop for vtkXMLDataElement { #[test] fn test_vtkXMLDataElement_create_drop() { let obj = vtkXMLDataElement::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkXMLDataElement(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonExecutionModel.rs b/vtk-rs-9.1/src/vtkCommonExecutionModel.rs index 3fd1d99..a92bc78 100644 --- a/vtk-rs-9.1/src/vtkCommonExecutionModel.rs +++ b/vtk-rs-9.1/src/vtkCommonExecutionModel.rs @@ -11,20 +11,6 @@ pub trait VtkAlgorithm { inInfo: *mut core::ffi::c_void, outInfo: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inInfo: *mut core::ffi::c_void, - outInfo: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn compute_pipeline_m_time( - &mut self, - request: *mut core::ffi::c_void, - inInfoVec: *mut core::ffi::c_void, - outInfoVec: *mut core::ffi::c_void, - requestFromOutputPort: core::ffi::c_int, - mtime: core::ffi::c_ulong, - ) -> core::ffi::c_int; fn modify_request( &mut self, request: *mut core::ffi::c_void, @@ -57,8 +43,7 @@ pub trait VtkAlgorithm { ) -> (); fn get_progress_shift(&mut self) -> core::ffi::c_double; fn get_progress_scale(&mut self) -> core::ffi::c_double; - fn set_progress_text(&mut self, ptext: core::ffi::c_char) -> (); - fn get_progress_text(&mut self) -> *mut core::ffi::c_char; + fn set_progress_text(&mut self, ptext: &str) -> (); fn get_error_code(&mut self) -> core::ffi::c_ulong; fn input_is_optional(&mut self) -> *mut core::ffi::c_void; fn input_is_repeatable(&mut self) -> *mut core::ffi::c_void; @@ -75,28 +60,7 @@ pub trait VtkAlgorithm { port: core::ffi::c_int, connection: core::ffi::c_int, fieldAssociation: core::ffi::c_int, - name: core::ffi::c_char, - ) -> (); - fn set_input_array_to_process( - &mut self, - idx: core::ffi::c_int, - port: core::ffi::c_int, - connection: core::ffi::c_int, - fieldAssociation: core::ffi::c_int, - fieldAttributeType: core::ffi::c_int, - ) -> (); - fn set_input_array_to_process( - &mut self, - idx: core::ffi::c_int, - info: *mut core::ffi::c_void, - ) -> (); - fn set_input_array_to_process( - &mut self, - idx: core::ffi::c_int, - port: core::ffi::c_int, - connection: core::ffi::c_int, - fieldAssociation: core::ffi::c_char, - attributeTypeorName: core::ffi::c_char, + name: &str, ) -> (); fn get_input_array_information( &mut self, @@ -117,38 +81,28 @@ pub trait VtkAlgorithm { port: core::ffi::c_int, input: *mut core::ffi::c_void, ) -> (); - fn set_input_connection(&mut self, input: *mut core::ffi::c_void) -> (); fn add_input_connection( &mut self, port: core::ffi::c_int, input: *mut core::ffi::c_void, ) -> (); - fn add_input_connection(&mut self, input: *mut core::ffi::c_void) -> (); fn remove_input_connection( &mut self, port: core::ffi::c_int, input: *mut core::ffi::c_void, ) -> (); - fn remove_input_connection( - &mut self, - port: core::ffi::c_int, - idx: core::ffi::c_int, - ) -> (); fn remove_all_input_connections(&mut self, port: core::ffi::c_int) -> (); fn set_input_data_object( &mut self, port: core::ffi::c_int, data: *mut core::ffi::c_void, ) -> (); - fn set_input_data_object(&mut self, data: *mut core::ffi::c_void) -> (); fn add_input_data_object( &mut self, port: core::ffi::c_int, data: *mut core::ffi::c_void, ) -> (); - fn add_input_data_object(&mut self, data: *mut core::ffi::c_void) -> (); fn get_output_port(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_output_port(&mut self) -> *mut core::ffi::c_void; fn get_number_of_input_connections( &mut self, port: core::ffi::c_int, @@ -163,54 +117,23 @@ pub trait VtkAlgorithm { &mut self, port: core::ffi::c_int, index: core::ffi::c_int, - algPort: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_input_algorithm( - &mut self, - port: core::ffi::c_int, - index: core::ffi::c_int, + algPort: &mut core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get_input_algorithm(&mut self) -> *mut core::ffi::c_void; fn get_input_executive( &mut self, port: core::ffi::c_int, index: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get_input_executive(&mut self) -> *mut core::ffi::c_void; fn get_input_information( &mut self, port: core::ffi::c_int, index: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get_input_information(&mut self) -> *mut core::ffi::c_void; fn get_output_information( &mut self, port: core::ffi::c_int, ) -> *mut core::ffi::c_void; fn update(&mut self, port: core::ffi::c_int) -> (); - fn update(&mut self) -> (); - fn update( - &mut self, - port: core::ffi::c_int, - requests: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn update(&mut self, requests: *mut core::ffi::c_void) -> core::ffi::c_int; - fn update_piece( - &mut self, - piece: core::ffi::c_int, - numPieces: core::ffi::c_int, - ghostLevels: core::ffi::c_int, - extents: core::ffi::c_int, - ) -> core::ffi::c_int; - fn update_extent(&mut self, extents: core::ffi::c_int) -> core::ffi::c_int; - fn update_time_step( - &mut self, - time: core::ffi::c_double, - piece: core::ffi::c_int, - numPieces: core::ffi::c_int, - ghostLevels: core::ffi::c_int, - extents: core::ffi::c_int, - ) -> core::ffi::c_int; fn update_information(&mut self) -> (); fn update_data_object(&mut self) -> (); fn propagate_update_extent(&mut self) -> (); @@ -218,8 +141,8 @@ pub trait VtkAlgorithm { fn convert_total_input_to_port_connection( &mut self, ind: core::ffi::c_int, - port: core::ffi::c_int, - conn: core::ffi::c_int, + port: &mut core::ffi::c_int, + conn: &mut core::ffi::c_int, ) -> (); fn set_release_data_flag(&mut self, p0: core::ffi::c_int) -> (); fn get_release_data_flag(&mut self) -> core::ffi::c_int; @@ -230,48 +153,10 @@ pub trait VtkAlgorithm { pinfo: *mut core::ffi::c_void, output: *mut core::ffi::c_void, ) -> core::ffi::c_int; - fn update_extent_is_empty( - &mut self, - pinfo: *mut core::ffi::c_void, - extentType: core::ffi::c_int, - ) -> core::ffi::c_int; fn set_default_executive_prototype(&mut self, proto: *mut core::ffi::c_void) -> (); - fn get_update_extent(&mut self) -> *mut core::ffi::c_int; - fn get_update_extent(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_int; - fn get_update_extent( - &mut self, - x0: core::ffi::c_int, - x1: core::ffi::c_int, - y0: core::ffi::c_int, - y1: core::ffi::c_int, - z0: core::ffi::c_int, - z1: core::ffi::c_int, - ) -> (); - fn get_update_extent( - &mut self, - port: core::ffi::c_int, - x0: core::ffi::c_int, - x1: core::ffi::c_int, - y0: core::ffi::c_int, - y1: core::ffi::c_int, - z0: core::ffi::c_int, - z1: core::ffi::c_int, - ) -> (); - fn get_update_extent(&mut self, extent: core::ffi::c_int) -> (); - fn get_update_extent( - &mut self, - port: core::ffi::c_int, - extent: core::ffi::c_int, - ) -> (); fn get_update_piece(&mut self) -> core::ffi::c_int; - fn get_update_piece(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; fn get_update_number_of_pieces(&mut self) -> core::ffi::c_int; - fn get_update_number_of_pieces( - &mut self, - port: core::ffi::c_int, - ) -> core::ffi::c_int; fn get_update_ghost_level(&mut self) -> core::ffi::c_int; - fn get_update_ghost_level(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; fn set_progress_observer(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_progress_observer(&mut self) -> *mut core::ffi::c_void; } @@ -284,57 +169,33 @@ pub trait VtkAlgorithmOutput { fn get_producer(&mut self) -> *mut core::ffi::c_void; fn set_producer(&mut self, producer: *mut core::ffi::c_void) -> (); } -pub trait VtkAnnotationLayersAlgorithm: VtkAlgorithm { +pub trait VtkAnnotationLayersAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> (); } -pub trait VtkArrayDataAlgorithm: VtkAlgorithm { +pub trait VtkArrayDataAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> (); } -pub trait VtkCachedStreamingDemandDrivenPipeline: VtkStreamingDemandDrivenPipeline + VtkDemandDrivenPipeline + VtkExecutive { +pub trait VtkCachedStreamingDemandDrivenPipeline { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn set_cache_size(&mut self, size: core::ffi::c_int) -> (); fn get_cache_size(&mut self) -> core::ffi::c_int; } -pub trait VtkCastToConcrete: VtkDataSetAlgorithm + VtkAlgorithm { +pub trait VtkCastToConcrete { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkCompositeDataPipeline: VtkStreamingDemandDrivenPipeline + VtkDemandDrivenPipeline + VtkExecutive { +pub trait VtkCompositeDataPipeline { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -342,58 +203,33 @@ pub trait VtkCompositeDataPipeline: VtkStreamingDemandDrivenPipeline + VtkDemand &mut self, port: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get_composite_input_data( - &mut self, - port: core::ffi::c_int, - index: core::ffi::c_int, - inInfoVec: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; fn load_requested_blocks(&mut self) -> *mut core::ffi::c_void; fn composite_data_meta_data(&mut self) -> *mut core::ffi::c_void; fn update_composite_indices(&mut self) -> *mut core::ffi::c_void; fn block_amount_of_detail(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkCompositeDataSetAlgorithm: VtkAlgorithm { +pub trait VtkCompositeDataSetAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; } -pub trait VtkDataObjectAlgorithm: VtkAlgorithm { +pub trait VtkDataObjectAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_input(&mut self) -> *mut core::ffi::c_void; - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } -pub trait VtkDataSetAlgorithm: VtkAlgorithm { +pub trait VtkDataSetAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_input(&mut self) -> *mut core::ffi::c_void; fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void; @@ -402,38 +238,12 @@ pub trait VtkDataSetAlgorithm: VtkAlgorithm { fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; } -pub trait VtkDemandDrivenPipeline: VtkExecutive { +pub trait VtkDemandDrivenPipeline { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inInfo: *mut core::ffi::c_void, - outInfo: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn compute_pipeline_m_time( - &mut self, - request: *mut core::ffi::c_void, - inInfoVec: *mut core::ffi::c_void, - outInfoVec: *mut core::ffi::c_void, - requestFromOutputPort: core::ffi::c_int, - mtime: core::ffi::c_ulong, - ) -> core::ffi::c_int; fn get_pipeline_m_time(&mut self) -> core::ffi::c_ulong; fn set_release_data_flag( &mut self, @@ -450,28 +260,16 @@ pub trait VtkDemandDrivenPipeline: VtkExecutive { fn request_data_not_generated(&mut self) -> *mut core::ffi::c_void; fn release_data(&mut self) -> *mut core::ffi::c_void; fn data_not_generated(&mut self) -> *mut core::ffi::c_void; - fn new_data_object(&mut self, type_: core::ffi::c_char) -> *mut core::ffi::c_void; + fn new_data_object(&mut self, type_: &str) -> *mut core::ffi::c_void; } -pub trait VtkDirectedGraphAlgorithm: VtkAlgorithm { +pub trait VtkDirectedGraphAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> (); } -pub trait VtkEnsembleSource: VtkAlgorithm { +pub trait VtkEnsembleSource { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -488,23 +286,8 @@ pub trait VtkExecutive { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_algorithm(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inInfo: *mut core::ffi::c_void, - outInfo: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - fn compute_pipeline_m_time( - &mut self, - request: *mut core::ffi::c_void, - inInfoVec: *mut core::ffi::c_void, - outInfoVec: *mut core::ffi::c_void, - requestFromOutputPort: core::ffi::c_int, - mtime: core::ffi::c_ulong, - ) -> core::ffi::c_int; fn update_information(&mut self) -> core::ffi::c_int; fn update(&mut self) -> core::ffi::c_int; - fn update(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; fn get_number_of_input_ports(&mut self) -> core::ffi::c_int; fn get_number_of_output_ports(&mut self) -> core::ffi::c_int; fn get_number_of_input_connections( @@ -515,17 +298,11 @@ pub trait VtkExecutive { &mut self, port: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get_output_information(&mut self) -> *mut core::ffi::c_void; fn get_input_information( &mut self, port: core::ffi::c_int, connection: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get_input_information( - &mut self, - port: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn get_input_information(&mut self) -> *mut &mut vtkInformationVector; fn get_input_executive( &mut self, port: core::ffi::c_int, @@ -538,23 +315,11 @@ pub trait VtkExecutive { p1: *mut core::ffi::c_void, info: *mut core::ffi::c_void, ) -> (); - fn set_output_data( - &mut self, - port: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> (); - fn get_input_data( - &mut self, - port: core::ffi::c_int, - connection: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_input_data( &mut self, port: core::ffi::c_int, connection: core::ffi::c_int, - inInfoVec: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; - fn set_shared_input_information(&mut self, inInfoVec: *mut core::ffi::c_void) -> (); fn set_shared_output_information( &mut self, outInfoVec: *mut core::ffi::c_void, @@ -568,37 +333,20 @@ pub trait VtkExecutive { fn algorithm_direction(&mut self) -> *mut core::ffi::c_void; fn forward_direction(&mut self) -> *mut core::ffi::c_void; fn keys_to_copy(&mut self) -> *mut core::ffi::c_void; - fn call_algorithm( - &mut self, - request: *mut core::ffi::c_void, - direction: core::ffi::c_int, - inInfo: *mut core::ffi::c_void, - outInfo: *mut core::ffi::c_void, - ) -> core::ffi::c_int; } -pub trait VtkExplicitStructuredGridAlgorithm: VtkAlgorithm { +pub trait VtkExplicitStructuredGridAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_input(&mut self) -> *mut core::ffi::c_void; - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_explicit_structured_grid_input( &mut self, port: core::ffi::c_int, ) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } pub trait VtkExtentRCBPartitioner { fn new(&mut self) -> *mut core::ffi::c_void; @@ -614,7 +362,6 @@ pub trait VtkExtentRCBPartitioner { kmin: core::ffi::c_int, kmax: core::ffi::c_int, ) -> (); - fn set_global_extent(&mut self, ext: core::ffi::c_int) -> (); fn set_duplicate_nodes(&mut self, _arg: core::ffi::c_int) -> (); fn get_duplicate_nodes(&mut self) -> core::ffi::c_int; fn duplicate_nodes_on(&mut self) -> (); @@ -623,11 +370,6 @@ pub trait VtkExtentRCBPartitioner { fn get_number_of_ghost_layers(&mut self) -> core::ffi::c_int; fn get_num_extents(&mut self) -> core::ffi::c_int; fn partition(&mut self) -> (); - fn get_partition_extent( - &mut self, - idx: core::ffi::c_int, - ext: core::ffi::c_int, - ) -> (); } pub trait VtkExtentSplitter { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -644,12 +386,6 @@ pub trait VtkExtentSplitter { z0: core::ffi::c_int, z1: core::ffi::c_int, ) -> (); - fn add_extent_source( - &mut self, - id: core::ffi::c_int, - priority: core::ffi::c_int, - extent: core::ffi::c_int, - ) -> (); fn remove_extent_source(&mut self, id: core::ffi::c_int) -> (); fn remove_all_extent_sources(&mut self) -> (); fn add_extent( @@ -661,15 +397,8 @@ pub trait VtkExtentSplitter { z0: core::ffi::c_int, z1: core::ffi::c_int, ) -> (); - fn add_extent(&mut self, extent: core::ffi::c_int) -> (); fn compute_sub_extents(&mut self) -> core::ffi::c_int; fn get_number_of_sub_extents(&mut self) -> core::ffi::c_int; - fn get_sub_extent(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_int; - fn get_sub_extent( - &mut self, - index: core::ffi::c_int, - extent: core::ffi::c_int, - ) -> (); fn get_sub_extent_source(&mut self, index: core::ffi::c_int) -> core::ffi::c_int; fn get_point_mode(&mut self) -> core::ffi::c_int; fn set_point_mode(&mut self, _arg: core::ffi::c_int) -> (); @@ -689,18 +418,6 @@ pub trait VtkExtentTranslator { _arg5: core::ffi::c_int, _arg6: core::ffi::c_int, ) -> (); - fn set_whole_extent(&mut self, _arg: core::ffi::c_int) -> (); - fn get_whole_extent(&mut self) -> *mut core::ffi::c_int; - fn get_whole_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> (); - fn get_whole_extent(&mut self, _arg: core::ffi::c_int) -> (); fn set_extent( &mut self, _arg1: core::ffi::c_int, @@ -710,18 +427,6 @@ pub trait VtkExtentTranslator { _arg5: core::ffi::c_int, _arg6: core::ffi::c_int, ) -> (); - fn set_extent(&mut self, _arg: core::ffi::c_int) -> (); - fn get_extent(&mut self) -> *mut core::ffi::c_int; - fn get_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> (); - fn get_extent(&mut self, _arg: core::ffi::c_int) -> (); fn set_piece(&mut self, _arg: core::ffi::c_int) -> (); fn get_piece(&mut self) -> core::ffi::c_int; fn set_number_of_pieces(&mut self, _arg: core::ffi::c_int) -> (); @@ -730,115 +435,52 @@ pub trait VtkExtentTranslator { fn get_ghost_level(&mut self) -> core::ffi::c_int; fn piece_to_extent(&mut self) -> core::ffi::c_int; fn piece_to_extent_by_points(&mut self) -> core::ffi::c_int; - fn piece_to_extent_thread_safe( - &mut self, - piece: core::ffi::c_int, - numPieces: core::ffi::c_int, - ghostLevel: core::ffi::c_int, - wholeExtent: core::ffi::c_int, - resultExtent: core::ffi::c_int, - splitMode: core::ffi::c_int, - byPoints: core::ffi::c_int, - ) -> core::ffi::c_int; fn set_split_mode_to_block(&mut self) -> (); fn set_split_mode_to_x_slab(&mut self) -> (); fn set_split_mode_to_y_slab(&mut self) -> (); fn set_split_mode_to_z_slab(&mut self) -> (); fn get_split_mode(&mut self) -> core::ffi::c_int; - fn set_split_path( - &mut self, - len: core::ffi::c_int, - splitpath: core::ffi::c_int, - ) -> (); fn update_split_mode(&mut self) -> *mut core::ffi::c_void; } pub trait VtkFilteringInformationKeyManager { fn register(&mut self, key: *mut core::ffi::c_void) -> (); } -pub trait VtkGraphAlgorithm: VtkAlgorithm { +pub trait VtkGraphAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> (); } -pub trait VtkHierarchicalBoxDataSetAlgorithm: VtkAlgorithm { +pub trait VtkHierarchicalBoxDataSetAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; } -pub trait VtkHyperTreeGridAlgorithm: VtkAlgorithm { +pub trait VtkHyperTreeGridAlgorithm { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_hyper_tree_grid_output(&mut self) -> *mut core::ffi::c_void; - fn get_hyper_tree_grid_output( - &mut self, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; - fn get_poly_data_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; - fn get_unstructured_grid_output( - &mut self, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } -pub trait VtkImageAlgorithm: VtkAlgorithm { +pub trait VtkImageAlgorithm { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_input(&mut self) -> *mut core::ffi::c_void; fn get_image_data_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } -pub trait VtkImageInPlaceFilter: VtkImageAlgorithm + VtkAlgorithm { +pub trait VtkImageInPlaceFilter { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; } @@ -846,12 +488,12 @@ pub trait VtkImageProgressIterator { fn next_span(&mut self) -> (); fn is_at_end(&mut self) -> core::ffi::c_int; } -pub trait VtkImageToStructuredGrid: VtkStructuredGridAlgorithm + VtkAlgorithm { +pub trait VtkImageToStructuredGrid { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkImageToStructuredPoints: VtkImageAlgorithm + VtkAlgorithm { +pub trait VtkImageToStructuredPoints { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -862,11 +504,7 @@ pub trait VtkImageToStructuredPoints: VtkImageAlgorithm + VtkAlgorithm { pub trait VtkInformationDataObjectMetaDataKey { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; fn copy_default_information( &mut self, request: *mut core::ffi::c_void, @@ -877,11 +515,7 @@ pub trait VtkInformationDataObjectMetaDataKey { pub trait VtkInformationExecutivePortKey { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; fn set( &mut self, info: *mut core::ffi::c_void, @@ -894,7 +528,7 @@ pub trait VtkInformationExecutivePortKey { &mut self, info: *mut core::ffi::c_void, executive: *mut core::ffi::c_void, - port: core::ffi::c_int, + port: &mut core::ffi::c_int, ) -> (); fn shallow_copy( &mut self, @@ -905,11 +539,7 @@ pub trait VtkInformationExecutivePortKey { pub trait VtkInformationExecutivePortVectorKey { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; fn append( &mut self, info: *mut core::ffi::c_void, @@ -922,21 +552,6 @@ pub trait VtkInformationExecutivePortVectorKey { executive: *mut core::ffi::c_void, port: core::ffi::c_int, ) -> (); - fn set( - &mut self, - info: *mut core::ffi::c_void, - executives: *mut core::ffi::c_void, - ports: core::ffi::c_int, - length: core::ffi::c_int, - ) -> (); - fn get_executives(&mut self, info: *mut core::ffi::c_void) -> *mut &mut vtkExecutive; - fn get_ports(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_int; - fn get( - &mut self, - info: *mut core::ffi::c_void, - executives: *mut core::ffi::c_void, - ports: core::ffi::c_int, - ) -> (); fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; fn shallow_copy( &mut self, @@ -947,11 +562,7 @@ pub trait VtkInformationExecutivePortVectorKey { pub trait VtkInformationIntegerRequestKey { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn make_key( - &mut self, - name: core::ffi::c_char, - location: core::ffi::c_char, - ) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; fn need_to_execute( &mut self, pipelineInfo: *mut core::ffi::c_void, @@ -970,69 +581,49 @@ pub trait VtkInformationIntegerRequestKey { toInfo: *mut core::ffi::c_void, ) -> (); } -pub trait VtkMoleculeAlgorithm: VtkAlgorithm { +pub trait VtkMoleculeAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_input(&mut self) -> *mut core::ffi::c_void; - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_molecule_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } -pub trait VtkMultiBlockDataSetAlgorithm: VtkAlgorithm { +pub trait VtkMultiBlockDataSetAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; } -pub trait VtkMultiTimeStepAlgorithm: VtkAlgorithm { +pub trait VtkMultiTimeStepAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkNonOverlappingAMRAlgorithm: VtkUniformGridAMRAlgorithm + VtkAlgorithm { +pub trait VtkNonOverlappingAMRAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; } -pub trait VtkOverlappingAMRAlgorithm: VtkUniformGridAMRAlgorithm + VtkAlgorithm { +pub trait VtkOverlappingAMRAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; } -pub trait VtkParallelReader: VtkReaderAlgorithm + VtkAlgorithm { +pub trait VtkParallelReader { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn add_file_name(&mut self, fname: core::ffi::c_char) -> (); + fn add_file_name(&mut self, fname: &str) -> (); fn clear_file_names(&mut self) -> (); fn get_number_of_file_names(&mut self) -> core::ffi::c_int; - fn get_file_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char; - fn get_current_file_name(&mut self) -> *const core::ffi::c_char; + fn get_file_name(&mut self, i: core::ffi::c_int) -> &str; + fn get_current_file_name(&mut self) -> &str; fn read_meta_data(&mut self, metadata: *mut core::ffi::c_void) -> core::ffi::c_int; fn read_mesh( &mut self, @@ -1059,24 +650,21 @@ pub trait VtkParallelReader: VtkReaderAlgorithm + VtkAlgorithm { output: *mut core::ffi::c_void, ) -> core::ffi::c_int; } -pub trait VtkPartitionedDataSetAlgorithm: VtkAlgorithm { +pub trait VtkPartitionedDataSetAlgorithm { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; } -pub trait VtkPartitionedDataSetCollectionAlgorithm: VtkAlgorithm { +pub trait VtkPartitionedDataSetCollectionAlgorithm { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; } -pub trait VtkPassInputTypeAlgorithm: VtkAlgorithm { +pub trait VtkPassInputTypeAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void; fn get_image_data_output(&mut self) -> *mut core::ffi::c_void; @@ -1088,37 +676,19 @@ pub trait VtkPassInputTypeAlgorithm: VtkAlgorithm { fn get_table_output(&mut self) -> *mut core::ffi::c_void; fn get_input(&mut self) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; } -pub trait VtkPiecewiseFunctionAlgorithm: VtkAlgorithm { +pub trait VtkPiecewiseFunctionAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_input(&mut self) -> *mut core::ffi::c_void; - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } -pub trait VtkPiecewiseFunctionShiftScale: VtkPiecewiseFunctionAlgorithm + VtkAlgorithm { +pub trait VtkPiecewiseFunctionShiftScale { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -1131,51 +701,28 @@ pub trait VtkPiecewiseFunctionShiftScale: VtkPiecewiseFunctionAlgorithm + VtkAlg fn get_value_shift(&mut self) -> core::ffi::c_double; fn get_value_scale(&mut self) -> core::ffi::c_double; } -pub trait VtkPointSetAlgorithm: VtkAlgorithm { +pub trait VtkPointSetAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void; fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn get_input(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; } -pub trait VtkPolyDataAlgorithm: VtkAlgorithm { +pub trait VtkPolyDataAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_input(&mut self) -> *mut core::ffi::c_void; - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_poly_data_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } pub trait VtkProgressObserver { fn new(&mut self) -> *mut core::ffi::c_void; @@ -1184,15 +731,9 @@ pub trait VtkProgressObserver { fn update_progress(&mut self, amount: core::ffi::c_double) -> (); fn get_progress(&mut self) -> core::ffi::c_double; } -pub trait VtkReaderAlgorithm: VtkAlgorithm { +pub trait VtkReaderAlgorithm { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inInfo: *mut core::ffi::c_void, - outInfo: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn create_output( &mut self, currentOutput: *mut core::ffi::c_void, @@ -1228,36 +769,26 @@ pub trait VtkReaderAlgorithm: VtkAlgorithm { output: *mut core::ffi::c_void, ) -> core::ffi::c_int; } -pub trait VtkReaderExecutive: VtkStreamingDemandDrivenPipeline + VtkDemandDrivenPipeline + VtkExecutive { +pub trait VtkReaderExecutive { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkRectilinearGridAlgorithm: VtkAlgorithm { +pub trait VtkRectilinearGridAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_input(&mut self) -> *mut core::ffi::c_void; - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_rectilinear_grid_input( &mut self, port: core::ffi::c_int, ) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } -pub trait VtkSMPProgressObserver: VtkProgressObserver { +pub trait VtkSMPProgressObserver { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -1277,7 +808,7 @@ pub trait VtkScalarTree { fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> (); fn get_next_cell( &mut self, - cellId: core::ffi::c_uchar, + cellId: &mut core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellScalars: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; @@ -1285,44 +816,27 @@ pub trait VtkScalarTree { fn get_number_of_cell_batches( &mut self, scalarValue: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn get_cell_batch( - &mut self, - batchNum: core::ffi::c_uchar, - numCells: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } -pub trait VtkSelectionAlgorithm: VtkAlgorithm { +pub trait VtkSelectionAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> (); } -pub trait VtkSimpleImageToImageFilter: VtkImageAlgorithm + VtkAlgorithm { +pub trait VtkSimpleImageToImageFilter { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkSimpleReader: VtkReaderAlgorithm + VtkAlgorithm { +pub trait VtkSimpleReader { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn add_file_name(&mut self, fname: core::ffi::c_char) -> (); + fn add_file_name(&mut self, fname: &str) -> (); fn clear_file_names(&mut self) -> (); fn get_number_of_file_names(&mut self) -> core::ffi::c_int; - fn get_file_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char; - fn get_current_file_name(&mut self) -> *const core::ffi::c_char; + fn get_file_name(&mut self, i: core::ffi::c_int) -> &str; + fn get_current_file_name(&mut self) -> &str; fn read_time_dependent_meta_data( &mut self, timestep: core::ffi::c_int, @@ -1375,7 +889,7 @@ pub trait VtkSimpleReader: VtkReaderAlgorithm + VtkAlgorithm { output: *mut core::ffi::c_void, ) -> core::ffi::c_int; } -pub trait VtkSimpleScalarTree: VtkScalarTree { +pub trait VtkSimpleScalarTree { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -1393,21 +907,16 @@ pub trait VtkSimpleScalarTree: VtkScalarTree { fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> (); fn get_next_cell( &mut self, - cellId: core::ffi::c_uchar, + cellId: &mut core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellScalars: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; fn get_number_of_cell_batches( &mut self, scalarValue: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn get_cell_batch( - &mut self, - batchNum: core::ffi::c_uchar, - numCells: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } -pub trait VtkSpanSpace: VtkScalarTree { +pub trait VtkSpanSpace { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -1416,17 +925,14 @@ pub trait VtkSpanSpace: VtkScalarTree { _arg1: core::ffi::c_double, _arg2: core::ffi::c_double, ) -> (); - fn set_scalar_range(&mut self, _arg: core::ffi::c_double) -> (); - fn get_scalar_range(&mut self) -> *mut core::ffi::c_double; - fn get_scalar_range(&mut self, data: core::ffi::c_double) -> (); fn set_compute_scalar_range(&mut self, _arg: core::ffi::c_int) -> (); fn get_compute_scalar_range(&mut self) -> core::ffi::c_int; fn compute_scalar_range_on(&mut self) -> (); fn compute_scalar_range_off(&mut self) -> (); - fn set_resolution(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_resolution_min_value(&mut self) -> core::ffi::c_uchar; - fn get_resolution_max_value(&mut self) -> core::ffi::c_uchar; - fn get_resolution(&mut self) -> core::ffi::c_uchar; + fn set_resolution(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_longlong; + fn get_resolution_max_value(&mut self) -> core::ffi::c_longlong; + fn get_resolution(&mut self) -> core::ffi::c_longlong; fn set_compute_resolution(&mut self, _arg: core::ffi::c_int) -> (); fn get_compute_resolution(&mut self) -> core::ffi::c_int; fn compute_resolution_on(&mut self) -> (); @@ -1440,23 +946,18 @@ pub trait VtkSpanSpace: VtkScalarTree { fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> (); fn get_next_cell( &mut self, - cellId: core::ffi::c_uchar, + cellId: &mut core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellScalars: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; fn get_number_of_cell_batches( &mut self, scalarValue: core::ffi::c_double, - ) -> core::ffi::c_uchar; - fn get_cell_batch( - &mut self, - batchNum: core::ffi::c_uchar, - numCells: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn set_batch_size(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_batch_size_min_value(&mut self) -> core::ffi::c_uchar; - fn get_batch_size_max_value(&mut self) -> core::ffi::c_uchar; - fn get_batch_size(&mut self) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; + fn set_batch_size(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_batch_size_min_value(&mut self) -> core::ffi::c_longlong; + fn get_batch_size_max_value(&mut self) -> core::ffi::c_longlong; + fn get_batch_size(&mut self) -> core::ffi::c_longlong; } pub trait VtkSphereTree { fn new(&mut self) -> *mut core::ffi::c_void; @@ -1465,45 +966,10 @@ pub trait VtkSphereTree { fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_data_set(&mut self) -> *mut core::ffi::c_void; fn build(&mut self) -> (); - fn build(&mut self, input: *mut core::ffi::c_void) -> (); fn set_build_hierarchy(&mut self, _arg: bool) -> (); fn get_build_hierarchy(&mut self) -> bool; fn build_hierarchy_on(&mut self) -> (); fn build_hierarchy_off(&mut self) -> (); - fn select_point( - &mut self, - point: core::ffi::c_double, - numSelected: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn select_line( - &mut self, - origin: core::ffi::c_double, - ray: core::ffi::c_double, - numSelected: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn select_plane( - &mut self, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - numSelected: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - fn select_point( - &mut self, - point: core::ffi::c_double, - cellIds: *mut core::ffi::c_void, - ) -> (); - fn select_line( - &mut self, - origin: core::ffi::c_double, - ray: core::ffi::c_double, - cellIds: *mut core::ffi::c_void, - ) -> (); - fn select_plane( - &mut self, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - cellIds: *mut core::ffi::c_void, - ) -> (); fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); fn get_resolution_min_value(&mut self) -> core::ffi::c_int; fn get_resolution_max_value(&mut self) -> core::ffi::c_int; @@ -1513,24 +979,13 @@ pub trait VtkSphereTree { fn get_max_level_max_value(&mut self) -> core::ffi::c_int; fn get_max_level(&mut self) -> core::ffi::c_int; fn get_number_of_levels(&mut self) -> core::ffi::c_int; - fn get_cell_spheres(&mut self) -> *const core::ffi::c_double; - fn get_tree_spheres( - &mut self, - level: core::ffi::c_int, - numSpheres: core::ffi::c_uchar, - ) -> *const core::ffi::c_double; } -pub trait VtkStreamingDemandDrivenPipeline: VtkDemandDrivenPipeline + VtkExecutive { +pub trait VtkStreamingDemandDrivenPipeline { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn update(&mut self) -> core::ffi::c_int; fn update_whole_extent(&mut self) -> core::ffi::c_int; - fn update( - &mut self, - port: core::ffi::c_int, - requests: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn propagate_update_extent( &mut self, outputPort: core::ffi::c_int, @@ -1540,17 +995,6 @@ pub trait VtkStreamingDemandDrivenPipeline: VtkDemandDrivenPipeline + VtkExecuti &mut self, outputPort: core::ffi::c_int, ) -> core::ffi::c_int; - fn set_whole_extent( - &mut self, - p0: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> core::ffi::c_int; - fn get_whole_extent( - &mut self, - p0: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> (); - fn get_whole_extent(&mut self, p0: *mut core::ffi::c_void) -> *mut core::ffi::c_int; fn set_request_exact_extent( &mut self, port: core::ffi::c_int, @@ -1575,12 +1019,6 @@ pub trait VtkStreamingDemandDrivenPipeline: VtkDemandDrivenPipeline + VtkExecuti fn update_time_step(&mut self) -> *mut core::ffi::c_void; fn time_dependent_information(&mut self) -> *mut core::ffi::c_void; fn bounds(&mut self) -> *mut core::ffi::c_void; - fn get_update_extent( - &mut self, - p0: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> (); - fn get_update_extent(&mut self, p0: *mut core::ffi::c_void) -> *mut core::ffi::c_int; fn get_update_piece(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int; fn get_update_number_of_pieces( &mut self, @@ -1588,74 +1026,35 @@ pub trait VtkStreamingDemandDrivenPipeline: VtkDemandDrivenPipeline + VtkExecuti ) -> core::ffi::c_int; fn get_update_ghost_level(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int; } -pub trait VtkStructuredGridAlgorithm: VtkAlgorithm { +pub trait VtkStructuredGridAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_input(&mut self) -> *mut core::ffi::c_void; - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; fn get_structured_grid_input( &mut self, port: core::ffi::c_int, ) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } -pub trait VtkTableAlgorithm: VtkAlgorithm { +pub trait VtkTableAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> (); } -pub trait VtkThreadedCompositeDataPipeline: VtkCompositeDataPipeline + VtkStreamingDemandDrivenPipeline + VtkDemandDrivenPipeline + VtkExecutive { +pub trait VtkThreadedCompositeDataPipeline { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkThreadedImageAlgorithm: VtkImageAlgorithm + VtkAlgorithm { +pub trait VtkThreadedImageAlgorithm { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn threaded_request_data( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - inData: *mut core::ffi::c_void, - outData: *mut core::ffi::c_void, - extent: core::ffi::c_int, - threadId: core::ffi::c_int, - ) -> (); - fn threaded_execute( - &mut self, - inData: *mut core::ffi::c_void, - outData: *mut core::ffi::c_void, - extent: core::ffi::c_int, - threadId: core::ffi::c_int, - ) -> (); fn get_enable_smp(&mut self) -> bool; fn set_enable_smp(&mut self, _arg: bool) -> (); fn set_global_default_enable_smp(&mut self, enable: bool) -> (); @@ -1666,17 +1065,8 @@ pub trait VtkThreadedImageAlgorithm: VtkImageAlgorithm + VtkAlgorithm { _arg2: core::ffi::c_int, _arg3: core::ffi::c_int, ) -> (); - fn set_minimum_piece_size(&mut self, _arg: core::ffi::c_int) -> (); - fn get_minimum_piece_size(&mut self) -> *mut core::ffi::c_int; - fn get_minimum_piece_size( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - ) -> (); - fn get_minimum_piece_size(&mut self, _arg: core::ffi::c_int) -> (); - fn set_desired_bytes_per_piece(&mut self, _arg: core::ffi::c_uchar) -> (); - fn get_desired_bytes_per_piece(&mut self) -> core::ffi::c_uchar; + fn set_desired_bytes_per_piece(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_desired_bytes_per_piece(&mut self) -> core::ffi::c_longlong; fn set_split_mode(&mut self, _arg: core::ffi::c_int) -> (); fn get_split_mode_min_value(&mut self) -> core::ffi::c_int; fn get_split_mode_max_value(&mut self) -> core::ffi::c_int; @@ -1688,48 +1078,23 @@ pub trait VtkThreadedImageAlgorithm: VtkImageAlgorithm + VtkAlgorithm { fn get_number_of_threads_min_value(&mut self) -> core::ffi::c_int; fn get_number_of_threads_max_value(&mut self) -> core::ffi::c_int; fn get_number_of_threads(&mut self) -> core::ffi::c_int; - fn split_extent( - &mut self, - splitExt: core::ffi::c_int, - startExt: core::ffi::c_int, - num: core::ffi::c_int, - total: core::ffi::c_int, - ) -> core::ffi::c_int; } -pub trait VtkTreeAlgorithm: VtkAlgorithm { +pub trait VtkTreeAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> (); } -pub trait VtkTrivialConsumer: VtkAlgorithm { +pub trait VtkTrivialConsumer { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkTrivialProducer: VtkAlgorithm { +pub trait VtkTrivialProducer { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn set_output(&mut self, output: *mut core::ffi::c_void) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; fn set_whole_extent( @@ -1741,59 +1106,27 @@ pub trait VtkTrivialProducer: VtkAlgorithm { _arg5: core::ffi::c_int, _arg6: core::ffi::c_int, ) -> (); - fn set_whole_extent(&mut self, _arg: core::ffi::c_int) -> (); - fn get_whole_extent(&mut self) -> *mut core::ffi::c_int; - fn get_whole_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> (); - fn get_whole_extent(&mut self, _arg: core::ffi::c_int) -> (); fn fill_output_data_information( &mut self, output: *mut core::ffi::c_void, outInfo: *mut core::ffi::c_void, ) -> (); } -pub trait VtkUndirectedGraphAlgorithm: VtkAlgorithm { +pub trait VtkUndirectedGraphAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> (); } -pub trait VtkUniformGridAMRAlgorithm: VtkAlgorithm { +pub trait VtkUniformGridAMRAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; } -pub trait VtkUniformGridPartitioner: VtkMultiBlockDataSetAlgorithm + VtkAlgorithm { +pub trait VtkUniformGridPartitioner { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -1806,47 +1139,28 @@ pub trait VtkUniformGridPartitioner: VtkMultiBlockDataSetAlgorithm + VtkAlgorith fn duplicate_nodes_on(&mut self) -> (); fn duplicate_nodes_off(&mut self) -> (); } -pub trait VtkUnstructuredGridAlgorithm: VtkAlgorithm { +pub trait VtkUnstructuredGridAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; - fn get_input(&mut self) -> *mut core::ffi::c_void; fn get_unstructured_grid_input( &mut self, port: core::ffi::c_int, ) -> *mut core::ffi::c_void; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } -pub trait VtkUnstructuredGridBaseAlgorithm: VtkAlgorithm { +pub trait VtkUnstructuredGridBaseAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_output(&mut self) -> *mut core::ffi::c_void; - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn set_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); - fn add_input_data(&mut self, p0: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); } impl VtkAlgorithm for vtkAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -1915,51 +1229,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_process_request(self.0, request, inInfo, outInfo) } } - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inInfo: *mut core::ffi::c_void, - outInfo: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_process_request( - sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inInfo: *mut core::ffi::c_void, - outInfo: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_algorithm_process_request(self.0, request, inInfo, outInfo) } - } - fn compute_pipeline_m_time( - &mut self, - request: *mut core::ffi::c_void, - inInfoVec: *mut core::ffi::c_void, - outInfoVec: *mut core::ffi::c_void, - requestFromOutputPort: core::ffi::c_int, - mtime: core::ffi::c_ulong, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_compute_pipeline_m_time( - sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inInfoVec: *mut core::ffi::c_void, - outInfoVec: *mut core::ffi::c_void, - requestFromOutputPort: core::ffi::c_int, - mtime: core::ffi::c_ulong, - ) -> core::ffi::c_int; - } - unsafe { - vtk_algorithm_compute_pipeline_m_time( - self.0, - request, - inInfoVec, - outInfoVec, - requestFromOutputPort, - mtime, - ) - } - } fn modify_request( &mut self, request: *mut core::ffi::c_void, @@ -2125,22 +1394,15 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_get_progress_scale(self.0) } } - fn set_progress_text(&mut self, ptext: core::ffi::c_char) -> () { + fn set_progress_text(&mut self, ptext: &str) -> () { + let c_ptext = std::ffi::CString::new(ptext).expect("CString::new failed"); unsafe extern "C" { fn vtk_algorithm_set_progress_text( sself: *mut core::ffi::c_void, - ptext: core::ffi::c_char, + ptext: *const core::ffi::c_char, ); } - unsafe { vtk_algorithm_set_progress_text(self.0, ptext) } - } - fn get_progress_text(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_algorithm_get_progress_text( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_algorithm_get_progress_text(self.0) } + unsafe { vtk_algorithm_set_progress_text(self.0, c_ptext.as_ptr()) } } fn get_error_code(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { @@ -2228,37 +1490,9 @@ impl VtkAlgorithm for vtkAlgorithm { port: core::ffi::c_int, connection: core::ffi::c_int, fieldAssociation: core::ffi::c_int, - name: core::ffi::c_char, - ) -> () { - unsafe extern "C" { - fn vtk_algorithm_set_input_array_to_process( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_int, - port: core::ffi::c_int, - connection: core::ffi::c_int, - fieldAssociation: core::ffi::c_int, - name: core::ffi::c_char, - ); - } - unsafe { - vtk_algorithm_set_input_array_to_process( - self.0, - idx, - port, - connection, - fieldAssociation, - name, - ) - } - } - fn set_input_array_to_process( - &mut self, - idx: core::ffi::c_int, - port: core::ffi::c_int, - connection: core::ffi::c_int, - fieldAssociation: core::ffi::c_int, - fieldAttributeType: core::ffi::c_int, + name: &str, ) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_algorithm_set_input_array_to_process( sself: *mut core::ffi::c_void, @@ -2266,50 +1500,7 @@ impl VtkAlgorithm for vtkAlgorithm { port: core::ffi::c_int, connection: core::ffi::c_int, fieldAssociation: core::ffi::c_int, - fieldAttributeType: core::ffi::c_int, - ); - } - unsafe { - vtk_algorithm_set_input_array_to_process( - self.0, - idx, - port, - connection, - fieldAssociation, - fieldAttributeType, - ) - } - } - fn set_input_array_to_process( - &mut self, - idx: core::ffi::c_int, - info: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_algorithm_set_input_array_to_process( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_int, - info: *mut core::ffi::c_void, - ); - } - unsafe { vtk_algorithm_set_input_array_to_process(self.0, idx, info) } - } - fn set_input_array_to_process( - &mut self, - idx: core::ffi::c_int, - port: core::ffi::c_int, - connection: core::ffi::c_int, - fieldAssociation: core::ffi::c_char, - attributeTypeorName: core::ffi::c_char, - ) -> () { - unsafe extern "C" { - fn vtk_algorithm_set_input_array_to_process( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_int, - port: core::ffi::c_int, - connection: core::ffi::c_int, - fieldAssociation: core::ffi::c_char, - attributeTypeorName: core::ffi::c_char, + name: *const core::ffi::c_char, ); } unsafe { @@ -2319,7 +1510,7 @@ impl VtkAlgorithm for vtkAlgorithm { port, connection, fieldAssociation, - attributeTypeorName, + c_name.as_ptr(), ) } } @@ -2381,15 +1572,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_set_input_connection(self.0, port, input) } } - fn set_input_connection(&mut self, input: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_algorithm_set_input_connection( - sself: *mut core::ffi::c_void, - input: *mut core::ffi::c_void, - ); - } - unsafe { vtk_algorithm_set_input_connection(self.0, input) } - } fn add_input_connection( &mut self, port: core::ffi::c_int, @@ -2404,15 +1586,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_add_input_connection(self.0, port, input) } } - fn add_input_connection(&mut self, input: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_algorithm_add_input_connection( - sself: *mut core::ffi::c_void, - input: *mut core::ffi::c_void, - ); - } - unsafe { vtk_algorithm_add_input_connection(self.0, input) } - } fn remove_input_connection( &mut self, port: core::ffi::c_int, @@ -2427,28 +1600,14 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_remove_input_connection(self.0, port, input) } } - fn remove_input_connection( - &mut self, - port: core::ffi::c_int, - idx: core::ffi::c_int, - ) -> () { + fn remove_all_input_connections(&mut self, port: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_algorithm_remove_input_connection( + fn vtk_algorithm_remove_all_input_connections( sself: *mut core::ffi::c_void, port: core::ffi::c_int, - idx: core::ffi::c_int, ); } - unsafe { vtk_algorithm_remove_input_connection(self.0, port, idx) } - } - fn remove_all_input_connections(&mut self, port: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_algorithm_remove_all_input_connections( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ); - } - unsafe { vtk_algorithm_remove_all_input_connections(self.0, port) } + unsafe { vtk_algorithm_remove_all_input_connections(self.0, port) } } fn set_input_data_object( &mut self, @@ -2464,15 +1623,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_set_input_data_object(self.0, port, data) } } - fn set_input_data_object(&mut self, data: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_algorithm_set_input_data_object( - sself: *mut core::ffi::c_void, - data: *mut core::ffi::c_void, - ); - } - unsafe { vtk_algorithm_set_input_data_object(self.0, data) } - } fn add_input_data_object( &mut self, port: core::ffi::c_int, @@ -2487,15 +1637,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_add_input_data_object(self.0, port, data) } } - fn add_input_data_object(&mut self, data: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_algorithm_add_input_data_object( - sself: *mut core::ffi::c_void, - data: *mut core::ffi::c_void, - ); - } - unsafe { vtk_algorithm_add_input_data_object(self.0, data) } - } fn get_output_port(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_algorithm_get_output_port( @@ -2505,14 +1646,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_get_output_port(self.0, index) } } - fn get_output_port(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_algorithm_get_output_port( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_algorithm_get_output_port(self.0) } - } fn get_number_of_input_connections( &mut self, port: core::ffi::c_int, @@ -2551,40 +1684,18 @@ impl VtkAlgorithm for vtkAlgorithm { &mut self, port: core::ffi::c_int, index: core::ffi::c_int, - algPort: core::ffi::c_int, + algPort: &mut core::ffi::c_int, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_algorithm_get_input_algorithm( sself: *mut core::ffi::c_void, port: core::ffi::c_int, index: core::ffi::c_int, - algPort: core::ffi::c_int, + algPort: &mut core::ffi::c_int, ) -> *mut core::ffi::c_void; } unsafe { vtk_algorithm_get_input_algorithm(self.0, port, index, algPort) } } - fn get_input_algorithm( - &mut self, - port: core::ffi::c_int, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_algorithm_get_input_algorithm( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_algorithm_get_input_algorithm(self.0, port, index) } - } - fn get_input_algorithm(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_algorithm_get_input_algorithm( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_algorithm_get_input_algorithm(self.0) } - } fn get_input_executive( &mut self, port: core::ffi::c_int, @@ -2599,14 +1710,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_get_input_executive(self.0, port, index) } } - fn get_input_executive(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_algorithm_get_input_executive( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_algorithm_get_input_executive(self.0) } - } fn get_input_information( &mut self, port: core::ffi::c_int, @@ -2621,14 +1724,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_get_input_information(self.0, port, index) } } - fn get_input_information(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_algorithm_get_input_information( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_algorithm_get_input_information(self.0) } - } fn get_output_information( &mut self, port: core::ffi::c_int, @@ -2650,93 +1745,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_update(self.0, port) } } - fn update(&mut self) -> () { - unsafe extern "C" { - fn vtk_algorithm_update(sself: *mut core::ffi::c_void); - } - unsafe { vtk_algorithm_update(self.0) } - } - fn update( - &mut self, - port: core::ffi::c_int, - requests: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_update( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - requests: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_algorithm_update(self.0, port, requests) } - } - fn update(&mut self, requests: *mut core::ffi::c_void) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_update( - sself: *mut core::ffi::c_void, - requests: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_algorithm_update(self.0, requests) } - } - fn update_piece( - &mut self, - piece: core::ffi::c_int, - numPieces: core::ffi::c_int, - ghostLevels: core::ffi::c_int, - extents: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_update_piece( - sself: *mut core::ffi::c_void, - piece: core::ffi::c_int, - numPieces: core::ffi::c_int, - ghostLevels: core::ffi::c_int, - extents: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_algorithm_update_piece(self.0, piece, numPieces, ghostLevels, extents) - } - } - fn update_extent(&mut self, extents: core::ffi::c_int) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_update_extent( - sself: *mut core::ffi::c_void, - extents: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_algorithm_update_extent(self.0, extents) } - } - fn update_time_step( - &mut self, - time: core::ffi::c_double, - piece: core::ffi::c_int, - numPieces: core::ffi::c_int, - ghostLevels: core::ffi::c_int, - extents: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_update_time_step( - sself: *mut core::ffi::c_void, - time: core::ffi::c_double, - piece: core::ffi::c_int, - numPieces: core::ffi::c_int, - ghostLevels: core::ffi::c_int, - extents: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_algorithm_update_time_step( - self.0, - time, - piece, - numPieces, - ghostLevels, - extents, - ) - } - } fn update_information(&mut self) -> () { unsafe extern "C" { fn vtk_algorithm_update_information(sself: *mut core::ffi::c_void); @@ -2764,15 +1772,15 @@ impl VtkAlgorithm for vtkAlgorithm { fn convert_total_input_to_port_connection( &mut self, ind: core::ffi::c_int, - port: core::ffi::c_int, - conn: core::ffi::c_int, + port: &mut core::ffi::c_int, + conn: &mut core::ffi::c_int, ) -> () { unsafe extern "C" { fn vtk_algorithm_convert_total_input_to_port_connection( sself: *mut core::ffi::c_void, ind: core::ffi::c_int, - port: core::ffi::c_int, - conn: core::ffi::c_int, + port: &mut core::ffi::c_int, + conn: &mut core::ffi::c_int, ); } unsafe { @@ -2822,20 +1830,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_update_extent_is_empty(self.0, pinfo, output) } } - fn update_extent_is_empty( - &mut self, - pinfo: *mut core::ffi::c_void, - extentType: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_update_extent_is_empty( - sself: *mut core::ffi::c_void, - pinfo: *mut core::ffi::c_void, - extentType: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_algorithm_update_extent_is_empty(self.0, pinfo, extentType) } - } fn set_default_executive_prototype(&mut self, proto: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_algorithm_set_default_executive_prototype( @@ -2845,92 +1839,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_set_default_executive_prototype(self.0, proto) } } - fn get_update_extent(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_get_update_extent( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_algorithm_get_update_extent(self.0) } - } - fn get_update_extent(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_get_update_extent( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_algorithm_get_update_extent(self.0, port) } - } - fn get_update_extent( - &mut self, - x0: core::ffi::c_int, - x1: core::ffi::c_int, - y0: core::ffi::c_int, - y1: core::ffi::c_int, - z0: core::ffi::c_int, - z1: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_algorithm_get_update_extent( - sself: *mut core::ffi::c_void, - x0: core::ffi::c_int, - x1: core::ffi::c_int, - y0: core::ffi::c_int, - y1: core::ffi::c_int, - z0: core::ffi::c_int, - z1: core::ffi::c_int, - ); - } - unsafe { vtk_algorithm_get_update_extent(self.0, x0, x1, y0, y1, z0, z1) } - } - fn get_update_extent( - &mut self, - port: core::ffi::c_int, - x0: core::ffi::c_int, - x1: core::ffi::c_int, - y0: core::ffi::c_int, - y1: core::ffi::c_int, - z0: core::ffi::c_int, - z1: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_algorithm_get_update_extent( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - x0: core::ffi::c_int, - x1: core::ffi::c_int, - y0: core::ffi::c_int, - y1: core::ffi::c_int, - z0: core::ffi::c_int, - z1: core::ffi::c_int, - ); - } - unsafe { vtk_algorithm_get_update_extent(self.0, port, x0, x1, y0, y1, z0, z1) } - } - fn get_update_extent(&mut self, extent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_algorithm_get_update_extent( - sself: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_algorithm_get_update_extent(self.0, extent) } - } - fn get_update_extent( - &mut self, - port: core::ffi::c_int, - extent: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_algorithm_get_update_extent( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_algorithm_get_update_extent(self.0, port, extent) } - } fn get_update_piece(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_algorithm_get_update_piece( @@ -2939,15 +1847,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_get_update_piece(self.0) } } - fn get_update_piece(&mut self, port: core::ffi::c_int) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_get_update_piece( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_algorithm_get_update_piece(self.0, port) } - } fn get_update_number_of_pieces(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_algorithm_get_update_number_of_pieces( @@ -2956,18 +1855,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_get_update_number_of_pieces(self.0) } } - fn get_update_number_of_pieces( - &mut self, - port: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_get_update_number_of_pieces( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_algorithm_get_update_number_of_pieces(self.0, port) } - } fn get_update_ghost_level(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_algorithm_get_update_ghost_level( @@ -2976,15 +1863,6 @@ impl VtkAlgorithm for vtkAlgorithm { } unsafe { vtk_algorithm_get_update_ghost_level(self.0) } } - fn get_update_ghost_level(&mut self, port: core::ffi::c_int) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_algorithm_get_update_ghost_level( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_algorithm_get_update_ghost_level(self.0, port) } - } fn set_progress_observer(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_algorithm_set_progress_observer( @@ -3090,22 +1968,6 @@ impl VtkAnnotationLayersAlgorithm for vtkAnnotationLayersAlgorithm { } unsafe { vtk_annotation_layers_algorithm_new_instance(self.0) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_annotation_layers_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_annotation_layers_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_output(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_annotation_layers_algorithm_get_output( @@ -3114,15 +1976,6 @@ impl VtkAnnotationLayersAlgorithm for vtkAnnotationLayersAlgorithm { } unsafe { vtk_annotation_layers_algorithm_get_output(self.0) } } - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_annotation_layers_algorithm_get_output( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_annotation_layers_algorithm_get_output(self.0, index) } - } fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_annotation_layers_algorithm_set_input_data( @@ -3132,20 +1985,6 @@ impl VtkAnnotationLayersAlgorithm for vtkAnnotationLayersAlgorithm { } unsafe { vtk_annotation_layers_algorithm_set_input_data(self.0, obj) } } - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_annotation_layers_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ); - } - unsafe { vtk_annotation_layers_algorithm_set_input_data(self.0, index, obj) } - } } impl VtkArrayDataAlgorithm for vtkArrayDataAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -3173,22 +2012,6 @@ impl VtkArrayDataAlgorithm for vtkArrayDataAlgorithm { } unsafe { vtk_array_data_algorithm_new_instance(self.0) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_array_data_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_array_data_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_output(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_array_data_algorithm_get_output( @@ -3197,15 +2020,6 @@ impl VtkArrayDataAlgorithm for vtkArrayDataAlgorithm { } unsafe { vtk_array_data_algorithm_get_output(self.0) } } - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_array_data_algorithm_get_output( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_array_data_algorithm_get_output(self.0, index) } - } fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_array_data_algorithm_set_input_data( @@ -3215,20 +2029,6 @@ impl VtkArrayDataAlgorithm for vtkArrayDataAlgorithm { } unsafe { vtk_array_data_algorithm_set_input_data(self.0, obj) } } - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_array_data_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ); - } - unsafe { vtk_array_data_algorithm_set_input_data(self.0, index, obj) } - } } impl VtkCachedStreamingDemandDrivenPipeline for vtkCachedStreamingDemandDrivenPipeline { fn new(&mut self) -> *mut core::ffi::c_void { @@ -3341,29 +2141,6 @@ impl VtkCompositeDataPipeline for vtkCompositeDataPipeline { } unsafe { vtk_composite_data_pipeline_get_composite_output_data(self.0, port) } } - fn get_composite_input_data( - &mut self, - port: core::ffi::c_int, - index: core::ffi::c_int, - inInfoVec: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_composite_data_pipeline_get_composite_input_data( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - index: core::ffi::c_int, - inInfoVec: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { - vtk_composite_data_pipeline_get_composite_input_data( - self.0, - port, - index, - inInfoVec, - ) - } - } fn load_requested_blocks(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_composite_data_pipeline_load_requested_blocks( @@ -3431,15 +2208,6 @@ impl VtkCompositeDataSetAlgorithm for vtkCompositeDataSetAlgorithm { } unsafe { vtk_composite_data_set_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_composite_data_set_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_composite_data_set_algorithm_get_output(self.0, p0) } - } fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_composite_data_set_algorithm_set_input_data( @@ -3449,43 +2217,6 @@ impl VtkCompositeDataSetAlgorithm for vtkCompositeDataSetAlgorithm { } unsafe { vtk_composite_data_set_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_composite_data_set_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_composite_data_set_algorithm_set_input_data(self.0, p0, p1) } - } - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_composite_data_set_algorithm_process_request( - sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_composite_data_set_algorithm_process_request( - self.0, - request, - inputVector, - outputVector, - ) - } - } } impl VtkDataObjectAlgorithm for vtkDataObjectAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -3521,15 +2252,6 @@ impl VtkDataObjectAlgorithm for vtkDataObjectAlgorithm { } unsafe { vtk_data_object_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_object_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_object_algorithm_get_output(self.0, p0) } - } fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_data_object_algorithm_set_output( @@ -3539,22 +2261,6 @@ impl VtkDataObjectAlgorithm for vtkDataObjectAlgorithm { } unsafe { vtk_data_object_algorithm_set_output(self.0, d) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_data_object_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_data_object_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_input(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_data_object_algorithm_get_input( @@ -3563,15 +2269,6 @@ impl VtkDataObjectAlgorithm for vtkDataObjectAlgorithm { } unsafe { vtk_data_object_algorithm_get_input(self.0) } } - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_object_algorithm_get_input( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_object_algorithm_get_input(self.0, port) } - } fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_data_object_algorithm_set_input_data( @@ -3581,20 +2278,6 @@ impl VtkDataObjectAlgorithm for vtkDataObjectAlgorithm { } unsafe { vtk_data_object_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_data_object_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_object_algorithm_set_input_data(self.0, p0, p1) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_data_object_algorithm_add_input_data( @@ -3604,20 +2287,6 @@ impl VtkDataObjectAlgorithm for vtkDataObjectAlgorithm { } unsafe { vtk_data_object_algorithm_add_input_data(self.0, p0) } } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_data_object_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_object_algorithm_add_input_data(self.0, p0, p1) } - } } impl VtkDataSetAlgorithm for vtkDataSetAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -3653,15 +2322,6 @@ impl VtkDataSetAlgorithm for vtkDataSetAlgorithm { } unsafe { vtk_data_set_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_data_set_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_data_set_algorithm_get_output(self.0, p0) } - } fn get_input(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_data_set_algorithm_get_input( @@ -3727,111 +2387,14 @@ impl VtkDataSetAlgorithm for vtkDataSetAlgorithm { } unsafe { vtk_data_set_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_set_algorithm_set_input_data(self.0, p0, p1) } - } - fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_data_set_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_set_algorithm_set_input_data(self.0, p0) } - } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_set_algorithm_set_input_data(self.0, p0, p1) } - } - fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_data_set_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_set_algorithm_add_input_data(self.0, p0) } - } - fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_data_set_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_set_algorithm_add_input_data(self.0, p0) } - } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_set_algorithm_add_input_data(self.0, p0, p1) } - } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_data_set_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_data_set_algorithm_add_input_data(self.0, p0, p1) } - } - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int { + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_data_set_algorithm_process_request( + fn vtk_data_set_algorithm_add_input_data( sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_data_set_algorithm_process_request( - self.0, - request, - inputVector, - outputVector, - ) + p0: *mut core::ffi::c_void, + ); } + unsafe { vtk_data_set_algorithm_add_input_data(self.0, p0) } } } impl VtkDemandDrivenPipeline for vtkDemandDrivenPipeline { @@ -3860,53 +2423,6 @@ impl VtkDemandDrivenPipeline for vtkDemandDrivenPipeline { } unsafe { vtk_demand_driven_pipeline_new_instance(self.0) } } - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inInfo: *mut core::ffi::c_void, - outInfo: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_demand_driven_pipeline_process_request( - sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inInfo: *mut core::ffi::c_void, - outInfo: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_demand_driven_pipeline_process_request(self.0, request, inInfo, outInfo) - } - } - fn compute_pipeline_m_time( - &mut self, - request: *mut core::ffi::c_void, - inInfoVec: *mut core::ffi::c_void, - outInfoVec: *mut core::ffi::c_void, - requestFromOutputPort: core::ffi::c_int, - mtime: core::ffi::c_ulong, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_demand_driven_pipeline_compute_pipeline_m_time( - sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inInfoVec: *mut core::ffi::c_void, - outInfoVec: *mut core::ffi::c_void, - requestFromOutputPort: core::ffi::c_int, - mtime: core::ffi::c_ulong, - ) -> core::ffi::c_int; - } - unsafe { - vtk_demand_driven_pipeline_compute_pipeline_m_time( - self.0, - request, - inInfoVec, - outInfoVec, - requestFromOutputPort, - mtime, - ) - } - } fn get_pipeline_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { fn vtk_demand_driven_pipeline_get_pipeline_m_time( @@ -4011,14 +2527,15 @@ impl VtkDemandDrivenPipeline for vtkDemandDrivenPipeline { } unsafe { vtk_demand_driven_pipeline_data_not_generated(self.0) } } - fn new_data_object(&mut self, type_: core::ffi::c_char) -> *mut core::ffi::c_void { + fn new_data_object(&mut self, type_: &str) -> *mut core::ffi::c_void { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); unsafe extern "C" { fn vtk_demand_driven_pipeline_new_data_object( sself: *mut core::ffi::c_void, - type_: core::ffi::c_char, + type_: *const core::ffi::c_char, ) -> *mut core::ffi::c_void; } - unsafe { vtk_demand_driven_pipeline_new_data_object(self.0, type_) } + unsafe { vtk_demand_driven_pipeline_new_data_object(self.0, c_type.as_ptr()) } } } impl VtkDirectedGraphAlgorithm for vtkDirectedGraphAlgorithm { @@ -4047,22 +2564,6 @@ impl VtkDirectedGraphAlgorithm for vtkDirectedGraphAlgorithm { } unsafe { vtk_directed_graph_algorithm_new_instance(self.0) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_directed_graph_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_directed_graph_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_output(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_directed_graph_algorithm_get_output( @@ -4071,15 +2572,6 @@ impl VtkDirectedGraphAlgorithm for vtkDirectedGraphAlgorithm { } unsafe { vtk_directed_graph_algorithm_get_output(self.0) } } - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_directed_graph_algorithm_get_output( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_directed_graph_algorithm_get_output(self.0, index) } - } fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_directed_graph_algorithm_set_input_data( @@ -4089,20 +2581,6 @@ impl VtkDirectedGraphAlgorithm for vtkDirectedGraphAlgorithm { } unsafe { vtk_directed_graph_algorithm_set_input_data(self.0, obj) } } - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_directed_graph_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ); - } - unsafe { vtk_directed_graph_algorithm_set_input_data(self.0, index, obj) } - } } impl VtkEnsembleSource for vtkEnsembleSource { fn new(&mut self) -> *mut core::ffi::c_void { @@ -4230,15 +2708,6 @@ impl VtkExplicitStructuredGridAlgorithm for vtkExplicitStructuredGridAlgorithm { } unsafe { vtk_explicit_structured_grid_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_explicit_structured_grid_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_explicit_structured_grid_algorithm_get_output(self.0, p0) } - } fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_explicit_structured_grid_algorithm_set_output( @@ -4248,24 +2717,6 @@ impl VtkExplicitStructuredGridAlgorithm for vtkExplicitStructuredGridAlgorithm { } unsafe { vtk_explicit_structured_grid_algorithm_set_output(self.0, d) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_explicit_structured_grid_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_explicit_structured_grid_algorithm_process_request(self.0, p0, p1, p2) - } - } fn get_input(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_explicit_structured_grid_algorithm_get_input( @@ -4274,15 +2725,6 @@ impl VtkExplicitStructuredGridAlgorithm for vtkExplicitStructuredGridAlgorithm { } unsafe { vtk_explicit_structured_grid_algorithm_get_input(self.0) } } - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_explicit_structured_grid_algorithm_get_input( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_explicit_structured_grid_algorithm_get_input(self.0, port) } - } fn get_explicit_structured_grid_input( &mut self, port: core::ffi::c_int, @@ -4309,20 +2751,6 @@ impl VtkExplicitStructuredGridAlgorithm for vtkExplicitStructuredGridAlgorithm { } unsafe { vtk_explicit_structured_grid_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_explicit_structured_grid_algorithm_set_input_data(self.0, p0, p1) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_explicit_structured_grid_algorithm_add_input_data( @@ -4332,20 +2760,6 @@ impl VtkExplicitStructuredGridAlgorithm for vtkExplicitStructuredGridAlgorithm { } unsafe { vtk_explicit_structured_grid_algorithm_add_input_data(self.0, p0) } } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_explicit_structured_grid_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_explicit_structured_grid_algorithm_add_input_data(self.0, p0, p1) } - } } impl VtkExtentRCBPartitioner for vtkExtentRCBPartitioner { fn new(&mut self) -> *mut core::ffi::c_void { @@ -4414,15 +2828,6 @@ impl VtkExtentRCBPartitioner for vtkExtentRCBPartitioner { ) } } - fn set_global_extent(&mut self, ext: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_extent_rcb_partitioner_set_global_extent( - sself: *mut core::ffi::c_void, - ext: core::ffi::c_int, - ); - } - unsafe { vtk_extent_rcb_partitioner_set_global_extent(self.0, ext) } - } fn set_duplicate_nodes(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_extent_rcb_partitioner_set_duplicate_nodes( @@ -4487,20 +2892,6 @@ impl VtkExtentRCBPartitioner for vtkExtentRCBPartitioner { } unsafe { vtk_extent_rcb_partitioner_partition(self.0) } } - fn get_partition_extent( - &mut self, - idx: core::ffi::c_int, - ext: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_extent_rcb_partitioner_get_partition_extent( - sself: *mut core::ffi::c_void, - idx: core::ffi::c_int, - ext: core::ffi::c_int, - ); - } - unsafe { vtk_extent_rcb_partitioner_get_partition_extent(self.0, idx, ext) } - } } impl VtkExtentSplitter for vtkExtentSplitter { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -4566,22 +2957,6 @@ impl VtkExtentSplitter for vtkExtentSplitter { ) } } - fn add_extent_source( - &mut self, - id: core::ffi::c_int, - priority: core::ffi::c_int, - extent: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_extent_splitter_add_extent_source( - sself: *mut core::ffi::c_void, - id: core::ffi::c_int, - priority: core::ffi::c_int, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_extent_splitter_add_extent_source(self.0, id, priority, extent) } - } fn remove_extent_source(&mut self, id: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_extent_splitter_remove_extent_source( @@ -4621,15 +2996,6 @@ impl VtkExtentSplitter for vtkExtentSplitter { } unsafe { vtk_extent_splitter_add_extent(self.0, x0, x1, y0, y1, z0, z1) } } - fn add_extent(&mut self, extent: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_extent_splitter_add_extent( - sself: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_extent_splitter_add_extent(self.0, extent) } - } fn compute_sub_extents(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_extent_splitter_compute_sub_extents( @@ -4646,29 +3012,6 @@ impl VtkExtentSplitter for vtkExtentSplitter { } unsafe { vtk_extent_splitter_get_number_of_sub_extents(self.0) } } - fn get_sub_extent(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_extent_splitter_get_sub_extent( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_extent_splitter_get_sub_extent(self.0, index) } - } - fn get_sub_extent( - &mut self, - index: core::ffi::c_int, - extent: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_extent_splitter_get_sub_extent( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - extent: core::ffi::c_int, - ); - } - unsafe { vtk_extent_splitter_get_sub_extent(self.0, index, extent) } - } fn get_sub_extent_source(&mut self, index: core::ffi::c_int) -> core::ffi::c_int { unsafe extern "C" { fn vtk_extent_splitter_get_sub_extent_source( @@ -4680,151 +3023,61 @@ impl VtkExtentSplitter for vtkExtentSplitter { } fn get_point_mode(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_extent_splitter_get_point_mode( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_extent_splitter_get_point_mode(self.0) } - } - fn set_point_mode(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_extent_splitter_set_point_mode( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_extent_splitter_set_point_mode(self.0, _arg) } - } - fn point_mode_on(&mut self) -> () { - unsafe extern "C" { - fn vtk_extent_splitter_point_mode_on(sself: *mut core::ffi::c_void); - } - unsafe { vtk_extent_splitter_point_mode_on(self.0) } - } - fn point_mode_off(&mut self) -> () { - unsafe extern "C" { - fn vtk_extent_splitter_point_mode_off(sself: *mut core::ffi::c_void); - } - unsafe { vtk_extent_splitter_point_mode_off(self.0) } - } -} -impl VtkExtentTranslator for vtkExtentTranslator { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_extent_translator_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_extent_translator_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_extent_translator_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_extent_translator_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_extent_translator_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_extent_translator_new_instance(self.0) } - } - fn set_whole_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_extent_translator_set_whole_extent( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ); - } - unsafe { - vtk_extent_translator_set_whole_extent( - self.0, - _arg1, - _arg2, - _arg3, - _arg4, - _arg5, - _arg6, - ) + fn vtk_extent_splitter_get_point_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; } + unsafe { vtk_extent_splitter_get_point_mode(self.0) } } - fn set_whole_extent(&mut self, _arg: core::ffi::c_int) -> () { + fn set_point_mode(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { - fn vtk_extent_translator_set_whole_extent( + fn vtk_extent_splitter_set_point_mode( sself: *mut core::ffi::c_void, _arg: core::ffi::c_int, ); } - unsafe { vtk_extent_translator_set_whole_extent(self.0, _arg) } + unsafe { vtk_extent_splitter_set_point_mode(self.0, _arg) } } - fn get_whole_extent(&mut self) -> *mut core::ffi::c_int { + fn point_mode_on(&mut self) -> () { unsafe extern "C" { - fn vtk_extent_translator_get_whole_extent( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; + fn vtk_extent_splitter_point_mode_on(sself: *mut core::ffi::c_void); } - unsafe { vtk_extent_translator_get_whole_extent(self.0) } + unsafe { vtk_extent_splitter_point_mode_on(self.0) } } - fn get_whole_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> () { + fn point_mode_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_point_mode_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_extent_splitter_point_mode_off(self.0) } + } +} +impl VtkExtentTranslator for vtkExtentTranslator { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_extent_translator_get_whole_extent( + fn vtk_extent_translator_new( sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ); + ) -> *mut core::ffi::c_void; } - unsafe { - vtk_extent_translator_get_whole_extent( - self.0, - _arg1, - _arg2, - _arg3, - _arg4, - _arg5, - _arg6, - ) + unsafe { vtk_extent_translator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_translator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } + unsafe { vtk_extent_translator_safe_down_cast(self.0, o) } } - fn get_whole_extent(&mut self, _arg: core::ffi::c_int) -> () { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_extent_translator_get_whole_extent( + fn vtk_extent_translator_new_instance( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); + ) -> *mut core::ffi::c_void; } - unsafe { vtk_extent_translator_get_whole_extent(self.0, _arg) } + unsafe { vtk_extent_translator_new_instance(self.0) } } - fn set_extent( + fn set_whole_extent( &mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int, @@ -4834,7 +3087,7 @@ impl VtkExtentTranslator for vtkExtentTranslator { _arg6: core::ffi::c_int, ) -> () { unsafe extern "C" { - fn vtk_extent_translator_set_extent( + fn vtk_extent_translator_set_whole_extent( sself: *mut core::ffi::c_void, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int, @@ -4845,7 +3098,7 @@ impl VtkExtentTranslator for vtkExtentTranslator { ); } unsafe { - vtk_extent_translator_set_extent( + vtk_extent_translator_set_whole_extent( self.0, _arg1, _arg2, @@ -4856,24 +3109,7 @@ impl VtkExtentTranslator for vtkExtentTranslator { ) } } - fn set_extent(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_extent_translator_set_extent( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_extent_translator_set_extent(self.0, _arg) } - } - fn get_extent(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_extent_translator_get_extent( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_extent_translator_get_extent(self.0) } - } - fn get_extent( + fn set_extent( &mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int, @@ -4883,7 +3119,7 @@ impl VtkExtentTranslator for vtkExtentTranslator { _arg6: core::ffi::c_int, ) -> () { unsafe extern "C" { - fn vtk_extent_translator_get_extent( + fn vtk_extent_translator_set_extent( sself: *mut core::ffi::c_void, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int, @@ -4894,7 +3130,7 @@ impl VtkExtentTranslator for vtkExtentTranslator { ); } unsafe { - vtk_extent_translator_get_extent( + vtk_extent_translator_set_extent( self.0, _arg1, _arg2, @@ -4905,15 +3141,6 @@ impl VtkExtentTranslator for vtkExtentTranslator { ) } } - fn get_extent(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_extent_translator_get_extent( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_extent_translator_get_extent(self.0, _arg) } - } fn set_piece(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_extent_translator_set_piece( @@ -4981,41 +3208,6 @@ impl VtkExtentTranslator for vtkExtentTranslator { } unsafe { vtk_extent_translator_piece_to_extent_by_points(self.0) } } - fn piece_to_extent_thread_safe( - &mut self, - piece: core::ffi::c_int, - numPieces: core::ffi::c_int, - ghostLevel: core::ffi::c_int, - wholeExtent: core::ffi::c_int, - resultExtent: core::ffi::c_int, - splitMode: core::ffi::c_int, - byPoints: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_extent_translator_piece_to_extent_thread_safe( - sself: *mut core::ffi::c_void, - piece: core::ffi::c_int, - numPieces: core::ffi::c_int, - ghostLevel: core::ffi::c_int, - wholeExtent: core::ffi::c_int, - resultExtent: core::ffi::c_int, - splitMode: core::ffi::c_int, - byPoints: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_extent_translator_piece_to_extent_thread_safe( - self.0, - piece, - numPieces, - ghostLevel, - wholeExtent, - resultExtent, - splitMode, - byPoints, - ) - } - } fn set_split_mode_to_block(&mut self) -> () { unsafe extern "C" { fn vtk_extent_translator_set_split_mode_to_block( @@ -5056,20 +3248,6 @@ impl VtkExtentTranslator for vtkExtentTranslator { } unsafe { vtk_extent_translator_get_split_mode(self.0) } } - fn set_split_path( - &mut self, - len: core::ffi::c_int, - splitpath: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_extent_translator_set_split_path( - sself: *mut core::ffi::c_void, - len: core::ffi::c_int, - splitpath: core::ffi::c_int, - ); - } - unsafe { vtk_extent_translator_set_split_path(self.0, len, splitpath) } - } fn update_split_mode(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_extent_translator_update_split_mode( @@ -5105,22 +3283,6 @@ impl VtkGraphAlgorithm for vtkGraphAlgorithm { } unsafe { vtk_graph_algorithm_new_instance(self.0) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_graph_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_graph_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_output(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_graph_algorithm_get_output( @@ -5129,15 +3291,6 @@ impl VtkGraphAlgorithm for vtkGraphAlgorithm { } unsafe { vtk_graph_algorithm_get_output(self.0) } } - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_graph_algorithm_get_output( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_graph_algorithm_get_output(self.0, index) } - } fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_graph_algorithm_set_input_data( @@ -5147,20 +3300,6 @@ impl VtkGraphAlgorithm for vtkGraphAlgorithm { } unsafe { vtk_graph_algorithm_set_input_data(self.0, obj) } } - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_graph_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ); - } - unsafe { vtk_graph_algorithm_set_input_data(self.0, index, obj) } - } } impl VtkHierarchicalBoxDataSetAlgorithm for vtkHierarchicalBoxDataSetAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -5196,15 +3335,6 @@ impl VtkHierarchicalBoxDataSetAlgorithm for vtkHierarchicalBoxDataSetAlgorithm { } unsafe { vtk_hierarchical_box_data_set_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_hierarchical_box_data_set_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_hierarchical_box_data_set_algorithm_get_output(self.0, p0) } - } fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_hierarchical_box_data_set_algorithm_set_input_data( @@ -5214,43 +3344,6 @@ impl VtkHierarchicalBoxDataSetAlgorithm for vtkHierarchicalBoxDataSetAlgorithm { } unsafe { vtk_hierarchical_box_data_set_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_hierarchical_box_data_set_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_hierarchical_box_data_set_algorithm_set_input_data(self.0, p0, p1) } - } - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_hierarchical_box_data_set_algorithm_process_request( - sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_hierarchical_box_data_set_algorithm_process_request( - self.0, - request, - inputVector, - outputVector, - ) - } - } } impl VtkImageToStructuredGrid for vtkImageToStructuredGrid { fn new(&mut self) -> *mut core::ffi::c_void { @@ -5365,15 +3458,6 @@ impl VtkMoleculeAlgorithm for vtkMoleculeAlgorithm { } unsafe { vtk_molecule_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_molecule_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_molecule_algorithm_get_output(self.0, p0) } - } fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_molecule_algorithm_set_output( @@ -5383,22 +3467,6 @@ impl VtkMoleculeAlgorithm for vtkMoleculeAlgorithm { } unsafe { vtk_molecule_algorithm_set_output(self.0, d) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_molecule_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_molecule_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_input(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_molecule_algorithm_get_input( @@ -5407,15 +3475,6 @@ impl VtkMoleculeAlgorithm for vtkMoleculeAlgorithm { } unsafe { vtk_molecule_algorithm_get_input(self.0) } } - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_molecule_algorithm_get_input( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_molecule_algorithm_get_input(self.0, port) } - } fn get_molecule_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_molecule_algorithm_get_molecule_input( @@ -5434,20 +3493,6 @@ impl VtkMoleculeAlgorithm for vtkMoleculeAlgorithm { } unsafe { vtk_molecule_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_molecule_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_molecule_algorithm_set_input_data(self.0, p0, p1) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_molecule_algorithm_add_input_data( @@ -5457,20 +3502,6 @@ impl VtkMoleculeAlgorithm for vtkMoleculeAlgorithm { } unsafe { vtk_molecule_algorithm_add_input_data(self.0, p0) } } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_molecule_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_molecule_algorithm_add_input_data(self.0, p0, p1) } - } } impl VtkMultiBlockDataSetAlgorithm for vtkMultiBlockDataSetAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -5506,15 +3537,6 @@ impl VtkMultiBlockDataSetAlgorithm for vtkMultiBlockDataSetAlgorithm { } unsafe { vtk_multi_block_data_set_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_multi_block_data_set_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_multi_block_data_set_algorithm_get_output(self.0, p0) } - } fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_multi_block_data_set_algorithm_set_input_data( @@ -5524,43 +3546,6 @@ impl VtkMultiBlockDataSetAlgorithm for vtkMultiBlockDataSetAlgorithm { } unsafe { vtk_multi_block_data_set_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_multi_block_data_set_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_multi_block_data_set_algorithm_set_input_data(self.0, p0, p1) } - } - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_multi_block_data_set_algorithm_process_request( - sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_multi_block_data_set_algorithm_process_request( - self.0, - request, - inputVector, - outputVector, - ) - } - } } impl VtkMultiTimeStepAlgorithm for vtkMultiTimeStepAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -5621,16 +3606,7 @@ impl VtkNonOverlappingAMRAlgorithm for vtkNonOverlappingAMRAlgorithm { sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_non_overlapping_amr_algorithm_get_output(self.0) } - } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_non_overlapping_amr_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_non_overlapping_amr_algorithm_get_output(self.0, p0) } + unsafe { vtk_non_overlapping_amr_algorithm_get_output(self.0) } } } impl VtkOverlappingAMRAlgorithm for vtkOverlappingAMRAlgorithm { @@ -5667,15 +3643,6 @@ impl VtkOverlappingAMRAlgorithm for vtkOverlappingAMRAlgorithm { } unsafe { vtk_overlapping_amr_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_overlapping_amr_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_overlapping_amr_algorithm_get_output(self.0, p0) } - } } impl VtkPassInputTypeAlgorithm for vtkPassInputTypeAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -5711,15 +3678,6 @@ impl VtkPassInputTypeAlgorithm for vtkPassInputTypeAlgorithm { } unsafe { vtk_pass_input_type_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_pass_input_type_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_pass_input_type_algorithm_get_output(self.0, p0) } - } fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_pass_input_type_algorithm_get_poly_data_output( @@ -5809,20 +3767,6 @@ impl VtkPassInputTypeAlgorithm for vtkPassInputTypeAlgorithm { } unsafe { vtk_pass_input_type_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_pass_input_type_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_pass_input_type_algorithm_set_input_data(self.0, p0, p1) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_pass_input_type_algorithm_add_input_data( @@ -5832,43 +3776,6 @@ impl VtkPassInputTypeAlgorithm for vtkPassInputTypeAlgorithm { } unsafe { vtk_pass_input_type_algorithm_add_input_data(self.0, p0) } } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_pass_input_type_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_pass_input_type_algorithm_add_input_data(self.0, p0, p1) } - } - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_pass_input_type_algorithm_process_request( - sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_pass_input_type_algorithm_process_request( - self.0, - request, - inputVector, - outputVector, - ) - } - } } impl VtkPiecewiseFunctionAlgorithm for vtkPiecewiseFunctionAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -5904,15 +3811,6 @@ impl VtkPiecewiseFunctionAlgorithm for vtkPiecewiseFunctionAlgorithm { } unsafe { vtk_piecewise_function_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_piecewise_function_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_piecewise_function_algorithm_get_output(self.0, p0) } - } fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_piecewise_function_algorithm_set_output( @@ -5922,22 +3820,6 @@ impl VtkPiecewiseFunctionAlgorithm for vtkPiecewiseFunctionAlgorithm { } unsafe { vtk_piecewise_function_algorithm_set_output(self.0, d) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_piecewise_function_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_piecewise_function_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_input(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_piecewise_function_algorithm_get_input( @@ -5946,15 +3828,6 @@ impl VtkPiecewiseFunctionAlgorithm for vtkPiecewiseFunctionAlgorithm { } unsafe { vtk_piecewise_function_algorithm_get_input(self.0) } } - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_piecewise_function_algorithm_get_input( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_piecewise_function_algorithm_get_input(self.0, port) } - } fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_piecewise_function_algorithm_set_input_data( @@ -5964,20 +3837,6 @@ impl VtkPiecewiseFunctionAlgorithm for vtkPiecewiseFunctionAlgorithm { } unsafe { vtk_piecewise_function_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_piecewise_function_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_piecewise_function_algorithm_set_input_data(self.0, p0, p1) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_piecewise_function_algorithm_add_input_data( @@ -5987,20 +3846,6 @@ impl VtkPiecewiseFunctionAlgorithm for vtkPiecewiseFunctionAlgorithm { } unsafe { vtk_piecewise_function_algorithm_add_input_data(self.0, p0) } } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_piecewise_function_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_piecewise_function_algorithm_add_input_data(self.0, p0, p1) } - } } impl VtkPiecewiseFunctionShiftScale for vtkPiecewiseFunctionShiftScale { fn new(&mut self) -> *mut core::ffi::c_void { @@ -6131,15 +3976,6 @@ impl VtkPointSetAlgorithm for vtkPointSetAlgorithm { } unsafe { vtk_point_set_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_point_set_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_point_set_algorithm_get_output(self.0, p0) } - } fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_point_set_algorithm_get_poly_data_output( @@ -6173,52 +4009,6 @@ impl VtkPointSetAlgorithm for vtkPointSetAlgorithm { } unsafe { vtk_point_set_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_point_set_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_point_set_algorithm_set_input_data(self.0, p0, p1) } - } - fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_point_set_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_point_set_algorithm_set_input_data(self.0, p0) } - } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_point_set_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_point_set_algorithm_set_input_data(self.0, p0, p1) } - } - fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_point_set_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ); - } - unsafe { vtk_point_set_algorithm_add_input_data(self.0, p0) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_point_set_algorithm_add_input_data( @@ -6228,34 +4018,6 @@ impl VtkPointSetAlgorithm for vtkPointSetAlgorithm { } unsafe { vtk_point_set_algorithm_add_input_data(self.0, p0) } } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_point_set_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_point_set_algorithm_add_input_data(self.0, p0, p1) } - } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_point_set_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_point_set_algorithm_add_input_data(self.0, p0, p1) } - } fn get_input(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_point_set_algorithm_get_input( @@ -6264,29 +4026,6 @@ impl VtkPointSetAlgorithm for vtkPointSetAlgorithm { } unsafe { vtk_point_set_algorithm_get_input(self.0) } } - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_point_set_algorithm_process_request( - sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_point_set_algorithm_process_request( - self.0, - request, - inputVector, - outputVector, - ) - } - } } impl VtkPolyDataAlgorithm for vtkPolyDataAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -6322,15 +4061,6 @@ impl VtkPolyDataAlgorithm for vtkPolyDataAlgorithm { } unsafe { vtk_poly_data_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_poly_data_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_poly_data_algorithm_get_output(self.0, p0) } - } fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_poly_data_algorithm_set_output( @@ -6340,22 +4070,6 @@ impl VtkPolyDataAlgorithm for vtkPolyDataAlgorithm { } unsafe { vtk_poly_data_algorithm_set_output(self.0, d) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_poly_data_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_poly_data_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_input(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_poly_data_algorithm_get_input( @@ -6364,15 +4078,6 @@ impl VtkPolyDataAlgorithm for vtkPolyDataAlgorithm { } unsafe { vtk_poly_data_algorithm_get_input(self.0) } } - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_poly_data_algorithm_get_input( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_poly_data_algorithm_get_input(self.0, port) } - } fn get_poly_data_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_poly_data_algorithm_get_poly_data_input( @@ -6391,20 +4096,6 @@ impl VtkPolyDataAlgorithm for vtkPolyDataAlgorithm { } unsafe { vtk_poly_data_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_poly_data_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_poly_data_algorithm_set_input_data(self.0, p0, p1) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_poly_data_algorithm_add_input_data( @@ -6414,20 +4105,6 @@ impl VtkPolyDataAlgorithm for vtkPolyDataAlgorithm { } unsafe { vtk_poly_data_algorithm_add_input_data(self.0, p0) } } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_poly_data_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_poly_data_algorithm_add_input_data(self.0, p0, p1) } - } } impl VtkProgressObserver for vtkProgressObserver { fn new(&mut self) -> *mut core::ffi::c_void { @@ -6534,15 +4211,6 @@ impl VtkRectilinearGridAlgorithm for vtkRectilinearGridAlgorithm { } unsafe { vtk_rectilinear_grid_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_rectilinear_grid_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_rectilinear_grid_algorithm_get_output(self.0, p0) } - } fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_rectilinear_grid_algorithm_set_output( @@ -6552,38 +4220,13 @@ impl VtkRectilinearGridAlgorithm for vtkRectilinearGridAlgorithm { } unsafe { vtk_rectilinear_grid_algorithm_set_output(self.0, d) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_rectilinear_grid_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_rectilinear_grid_algorithm_process_request(self.0, p0, p1, p2) } - } - fn get_input(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_rectilinear_grid_algorithm_get_input( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_rectilinear_grid_algorithm_get_input(self.0) } - } - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + fn get_input(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_rectilinear_grid_algorithm_get_input( sself: *mut core::ffi::c_void, - port: core::ffi::c_int, ) -> *mut core::ffi::c_void; } - unsafe { vtk_rectilinear_grid_algorithm_get_input(self.0, port) } + unsafe { vtk_rectilinear_grid_algorithm_get_input(self.0) } } fn get_rectilinear_grid_input( &mut self, @@ -6608,20 +4251,6 @@ impl VtkRectilinearGridAlgorithm for vtkRectilinearGridAlgorithm { } unsafe { vtk_rectilinear_grid_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_rectilinear_grid_algorithm_set_input_data(self.0, p0, p1) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_rectilinear_grid_algorithm_add_input_data( @@ -6631,20 +4260,6 @@ impl VtkRectilinearGridAlgorithm for vtkRectilinearGridAlgorithm { } unsafe { vtk_rectilinear_grid_algorithm_add_input_data(self.0, p0) } } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_rectilinear_grid_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_rectilinear_grid_algorithm_add_input_data(self.0, p0, p1) } - } } impl VtkSMPProgressObserver for vtkSMPProgressObserver { fn new(&mut self) -> *mut core::ffi::c_void { @@ -6716,22 +4331,6 @@ impl VtkSelectionAlgorithm for vtkSelectionAlgorithm { } unsafe { vtk_selection_algorithm_new_instance(self.0) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_selection_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_selection_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_output(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_selection_algorithm_get_output( @@ -6740,15 +4339,6 @@ impl VtkSelectionAlgorithm for vtkSelectionAlgorithm { } unsafe { vtk_selection_algorithm_get_output(self.0) } } - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_selection_algorithm_get_output( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_selection_algorithm_get_output(self.0, index) } - } fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_selection_algorithm_set_input_data( @@ -6758,20 +4348,6 @@ impl VtkSelectionAlgorithm for vtkSelectionAlgorithm { } unsafe { vtk_selection_algorithm_set_input_data(self.0, obj) } } - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_selection_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ); - } - unsafe { vtk_selection_algorithm_set_input_data(self.0, index, obj) } - } } impl VtkSimpleScalarTree for vtkSimpleScalarTree { fn new(&mut self) -> *mut core::ffi::c_void { @@ -6896,14 +4472,14 @@ impl VtkSimpleScalarTree for vtkSimpleScalarTree { } fn get_next_cell( &mut self, - cellId: core::ffi::c_uchar, + cellId: &mut core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellScalars: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_simple_scalar_tree_get_next_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: &mut core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellScalars: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; @@ -6915,29 +4491,15 @@ impl VtkSimpleScalarTree for vtkSimpleScalarTree { fn get_number_of_cell_batches( &mut self, scalarValue: core::ffi::c_double, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_simple_scalar_tree_get_number_of_cell_batches( sself: *mut core::ffi::c_void, scalarValue: core::ffi::c_double, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_simple_scalar_tree_get_number_of_cell_batches(self.0, scalarValue) } } - fn get_cell_batch( - &mut self, - batchNum: core::ffi::c_uchar, - numCells: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_simple_scalar_tree_get_cell_batch( - sself: *mut core::ffi::c_void, - batchNum: core::ffi::c_uchar, - numCells: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_simple_scalar_tree_get_cell_batch(self.0, batchNum, numCells) } - } } impl VtkSpanSpace for vtkSpanSpace { fn new(&mut self) -> *mut core::ffi::c_void { @@ -6979,32 +4541,6 @@ impl VtkSpanSpace for vtkSpanSpace { } unsafe { vtk_span_space_set_scalar_range(self.0, _arg1, _arg2) } } - fn set_scalar_range(&mut self, _arg: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_span_space_set_scalar_range( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_double, - ); - } - unsafe { vtk_span_space_set_scalar_range(self.0, _arg) } - } - fn get_scalar_range(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_span_space_get_scalar_range( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_span_space_get_scalar_range(self.0) } - } - fn get_scalar_range(&mut self, data: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_span_space_get_scalar_range( - sself: *mut core::ffi::c_void, - data: core::ffi::c_double, - ); - } - unsafe { vtk_span_space_get_scalar_range(self.0, data) } - } fn set_compute_scalar_range(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_span_space_set_compute_scalar_range( @@ -7034,36 +4570,36 @@ impl VtkSpanSpace for vtkSpanSpace { } unsafe { vtk_span_space_compute_scalar_range_off(self.0) } } - fn set_resolution(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_resolution(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_span_space_set_resolution( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_span_space_set_resolution(self.0, _arg) } } - fn get_resolution_min_value(&mut self) -> core::ffi::c_uchar { + fn get_resolution_min_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_span_space_get_resolution_min_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_span_space_get_resolution_min_value(self.0) } } - fn get_resolution_max_value(&mut self) -> core::ffi::c_uchar { + fn get_resolution_max_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_span_space_get_resolution_max_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_span_space_get_resolution_max_value(self.0) } } - fn get_resolution(&mut self) -> core::ffi::c_uchar { + fn get_resolution(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_span_space_get_resolution( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_span_space_get_resolution(self.0) } } @@ -7152,14 +4688,14 @@ impl VtkSpanSpace for vtkSpanSpace { } fn get_next_cell( &mut self, - cellId: core::ffi::c_uchar, + cellId: &mut core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellScalars: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_span_space_get_next_cell( sself: *mut core::ffi::c_void, - cellId: core::ffi::c_uchar, + cellId: &mut core::ffi::c_longlong, ptIds: *mut core::ffi::c_void, cellScalars: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; @@ -7169,59 +4705,45 @@ impl VtkSpanSpace for vtkSpanSpace { fn get_number_of_cell_batches( &mut self, scalarValue: core::ffi::c_double, - ) -> core::ffi::c_uchar { + ) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_span_space_get_number_of_cell_batches( sself: *mut core::ffi::c_void, scalarValue: core::ffi::c_double, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_span_space_get_number_of_cell_batches(self.0, scalarValue) } } - fn get_cell_batch( - &mut self, - batchNum: core::ffi::c_uchar, - numCells: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_span_space_get_cell_batch( - sself: *mut core::ffi::c_void, - batchNum: core::ffi::c_uchar, - numCells: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_span_space_get_cell_batch(self.0, batchNum, numCells) } - } - fn set_batch_size(&mut self, _arg: core::ffi::c_uchar) -> () { + fn set_batch_size(&mut self, _arg: core::ffi::c_longlong) -> () { unsafe extern "C" { fn vtk_span_space_set_batch_size( sself: *mut core::ffi::c_void, - _arg: core::ffi::c_uchar, + _arg: core::ffi::c_longlong, ); } unsafe { vtk_span_space_set_batch_size(self.0, _arg) } } - fn get_batch_size_min_value(&mut self) -> core::ffi::c_uchar { + fn get_batch_size_min_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_span_space_get_batch_size_min_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_span_space_get_batch_size_min_value(self.0) } } - fn get_batch_size_max_value(&mut self) -> core::ffi::c_uchar { + fn get_batch_size_max_value(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_span_space_get_batch_size_max_value( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_span_space_get_batch_size_max_value(self.0) } } - fn get_batch_size(&mut self) -> core::ffi::c_uchar { + fn get_batch_size(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_span_space_get_batch_size( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_span_space_get_batch_size(self.0) } } @@ -7275,15 +4797,6 @@ impl VtkSphereTree for vtkSphereTree { } unsafe { vtk_sphere_tree_build(self.0) } } - fn build(&mut self, input: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_sphere_tree_build( - sself: *mut core::ffi::c_void, - input: *mut core::ffi::c_void, - ); - } - unsafe { vtk_sphere_tree_build(self.0, input) } - } fn set_build_hierarchy(&mut self, _arg: bool) -> () { unsafe extern "C" { fn vtk_sphere_tree_set_build_hierarchy( @@ -7313,98 +4826,6 @@ impl VtkSphereTree for vtkSphereTree { } unsafe { vtk_sphere_tree_build_hierarchy_off(self.0) } } - fn select_point( - &mut self, - point: core::ffi::c_double, - numSelected: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_sphere_tree_select_point( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - numSelected: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_sphere_tree_select_point(self.0, point, numSelected) } - } - fn select_line( - &mut self, - origin: core::ffi::c_double, - ray: core::ffi::c_double, - numSelected: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_sphere_tree_select_line( - sself: *mut core::ffi::c_void, - origin: core::ffi::c_double, - ray: core::ffi::c_double, - numSelected: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_sphere_tree_select_line(self.0, origin, ray, numSelected) } - } - fn select_plane( - &mut self, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - numSelected: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar { - unsafe extern "C" { - fn vtk_sphere_tree_select_plane( - sself: *mut core::ffi::c_void, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - numSelected: core::ffi::c_uchar, - ) -> *const core::ffi::c_uchar; - } - unsafe { vtk_sphere_tree_select_plane(self.0, origin, normal, numSelected) } - } - fn select_point( - &mut self, - point: core::ffi::c_double, - cellIds: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_sphere_tree_select_point( - sself: *mut core::ffi::c_void, - point: core::ffi::c_double, - cellIds: *mut core::ffi::c_void, - ); - } - unsafe { vtk_sphere_tree_select_point(self.0, point, cellIds) } - } - fn select_line( - &mut self, - origin: core::ffi::c_double, - ray: core::ffi::c_double, - cellIds: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_sphere_tree_select_line( - sself: *mut core::ffi::c_void, - origin: core::ffi::c_double, - ray: core::ffi::c_double, - cellIds: *mut core::ffi::c_void, - ); - } - unsafe { vtk_sphere_tree_select_line(self.0, origin, ray, cellIds) } - } - fn select_plane( - &mut self, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - cellIds: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_sphere_tree_select_plane( - sself: *mut core::ffi::c_void, - origin: core::ffi::c_double, - normal: core::ffi::c_double, - cellIds: *mut core::ffi::c_void, - ); - } - unsafe { vtk_sphere_tree_select_plane(self.0, origin, normal, cellIds) } - } fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_sphere_tree_set_resolution( @@ -7479,28 +4900,6 @@ impl VtkSphereTree for vtkSphereTree { } unsafe { vtk_sphere_tree_get_number_of_levels(self.0) } } - fn get_cell_spheres(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_sphere_tree_get_cell_spheres( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_sphere_tree_get_cell_spheres(self.0) } - } - fn get_tree_spheres( - &mut self, - level: core::ffi::c_int, - numSpheres: core::ffi::c_uchar, - ) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_sphere_tree_get_tree_spheres( - sself: *mut core::ffi::c_void, - level: core::ffi::c_int, - numSpheres: core::ffi::c_uchar, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_sphere_tree_get_tree_spheres(self.0, level, numSpheres) } - } } impl VtkStreamingDemandDrivenPipeline for vtkStreamingDemandDrivenPipeline { fn new(&mut self) -> *mut core::ffi::c_void { @@ -7544,20 +4943,6 @@ impl VtkStreamingDemandDrivenPipeline for vtkStreamingDemandDrivenPipeline { } unsafe { vtk_streaming_demand_driven_pipeline_update_whole_extent(self.0) } } - fn update( - &mut self, - port: core::ffi::c_int, - requests: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_streaming_demand_driven_pipeline_update( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - requests: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_streaming_demand_driven_pipeline_update(self.0, port, requests) } - } fn propagate_update_extent( &mut self, outputPort: core::ffi::c_int, @@ -7603,47 +4988,6 @@ impl VtkStreamingDemandDrivenPipeline for vtkStreamingDemandDrivenPipeline { ) } } - fn set_whole_extent( - &mut self, - p0: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_streaming_demand_driven_pipeline_set_whole_extent( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_streaming_demand_driven_pipeline_set_whole_extent(self.0, p0, extent) - } - } - fn get_whole_extent( - &mut self, - p0: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_streaming_demand_driven_pipeline_get_whole_extent( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ); - } - unsafe { - vtk_streaming_demand_driven_pipeline_get_whole_extent(self.0, p0, extent) - } - } - fn get_whole_extent(&mut self, p0: *mut core::ffi::c_void) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_streaming_demand_driven_pipeline_get_whole_extent( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_streaming_demand_driven_pipeline_get_whole_extent(self.0, p0) } - } fn set_request_exact_extent( &mut self, port: core::ffi::c_int, @@ -7829,34 +5173,6 @@ impl VtkStreamingDemandDrivenPipeline for vtkStreamingDemandDrivenPipeline { } unsafe { vtk_streaming_demand_driven_pipeline_bounds(self.0) } } - fn get_update_extent( - &mut self, - p0: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_streaming_demand_driven_pipeline_get_update_extent( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - extent: core::ffi::c_int, - ); - } - unsafe { - vtk_streaming_demand_driven_pipeline_get_update_extent(self.0, p0, extent) - } - } - fn get_update_extent( - &mut self, - p0: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_streaming_demand_driven_pipeline_get_update_extent( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_streaming_demand_driven_pipeline_get_update_extent(self.0, p0) } - } fn get_update_piece(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int { unsafe extern "C" { fn vtk_streaming_demand_driven_pipeline_get_update_piece( @@ -7929,15 +5245,6 @@ impl VtkStructuredGridAlgorithm for vtkStructuredGridAlgorithm { } unsafe { vtk_structured_grid_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_structured_grid_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_structured_grid_algorithm_get_output(self.0, p0) } - } fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_structured_grid_algorithm_set_output( @@ -7947,22 +5254,6 @@ impl VtkStructuredGridAlgorithm for vtkStructuredGridAlgorithm { } unsafe { vtk_structured_grid_algorithm_set_output(self.0, d) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_structured_grid_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_structured_grid_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_input(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_structured_grid_algorithm_get_input( @@ -7971,15 +5262,6 @@ impl VtkStructuredGridAlgorithm for vtkStructuredGridAlgorithm { } unsafe { vtk_structured_grid_algorithm_get_input(self.0) } } - fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_structured_grid_algorithm_get_input( - sself: *mut core::ffi::c_void, - port: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_structured_grid_algorithm_get_input(self.0, port) } - } fn get_structured_grid_input( &mut self, port: core::ffi::c_int, @@ -8001,20 +5283,6 @@ impl VtkStructuredGridAlgorithm for vtkStructuredGridAlgorithm { } unsafe { vtk_structured_grid_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_structured_grid_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_structured_grid_algorithm_set_input_data(self.0, p0, p1) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_structured_grid_algorithm_add_input_data( @@ -8024,20 +5292,6 @@ impl VtkStructuredGridAlgorithm for vtkStructuredGridAlgorithm { } unsafe { vtk_structured_grid_algorithm_add_input_data(self.0, p0) } } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_structured_grid_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_structured_grid_algorithm_add_input_data(self.0, p0, p1) } - } } impl VtkTableAlgorithm for vtkTableAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -8057,46 +5311,21 @@ impl VtkTableAlgorithm for vtkTableAlgorithm { } unsafe { vtk_table_algorithm_safe_down_cast(self.0, o) } } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_table_algorithm_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_table_algorithm_new_instance(self.0) } - } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_table_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_table_algorithm_process_request(self.0, p0, p1, p2) } - } - fn get_output(&mut self) -> *mut core::ffi::c_void { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_table_algorithm_get_output( + fn vtk_table_algorithm_new_instance( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_table_algorithm_get_output(self.0) } + unsafe { vtk_table_algorithm_new_instance(self.0) } } - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + fn get_output(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_table_algorithm_get_output( sself: *mut core::ffi::c_void, - index: core::ffi::c_int, ) -> *mut core::ffi::c_void; } - unsafe { vtk_table_algorithm_get_output(self.0, index) } + unsafe { vtk_table_algorithm_get_output(self.0) } } fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { @@ -8107,20 +5336,6 @@ impl VtkTableAlgorithm for vtkTableAlgorithm { } unsafe { vtk_table_algorithm_set_input_data(self.0, obj) } } - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_table_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ); - } - unsafe { vtk_table_algorithm_set_input_data(self.0, index, obj) } - } } impl VtkThreadedCompositeDataPipeline for vtkThreadedCompositeDataPipeline { fn new(&mut self) -> *mut core::ffi::c_void { @@ -8175,22 +5390,6 @@ impl VtkTreeAlgorithm for vtkTreeAlgorithm { } unsafe { vtk_tree_algorithm_new_instance(self.0) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_tree_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_tree_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_output(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_tree_algorithm_get_output( @@ -8199,15 +5398,6 @@ impl VtkTreeAlgorithm for vtkTreeAlgorithm { } unsafe { vtk_tree_algorithm_get_output(self.0) } } - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_tree_algorithm_get_output( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_tree_algorithm_get_output(self.0, index) } - } fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_tree_algorithm_set_input_data( @@ -8217,20 +5407,6 @@ impl VtkTreeAlgorithm for vtkTreeAlgorithm { } unsafe { vtk_tree_algorithm_set_input_data(self.0, obj) } } - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_tree_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ); - } - unsafe { vtk_tree_algorithm_set_input_data(self.0, index, obj) } - } } impl VtkTrivialConsumer for vtkTrivialConsumer { fn new(&mut self) -> *mut core::ffi::c_void { @@ -8285,22 +5461,6 @@ impl VtkTrivialProducer for vtkTrivialProducer { } unsafe { vtk_trivial_producer_new_instance(self.0) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_trivial_producer_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_trivial_producer_process_request(self.0, p0, p1, p2) } - } fn set_output(&mut self, output: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_trivial_producer_set_output( @@ -8350,64 +5510,6 @@ impl VtkTrivialProducer for vtkTrivialProducer { ) } } - fn set_whole_extent(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_trivial_producer_set_whole_extent( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_trivial_producer_set_whole_extent(self.0, _arg) } - } - fn get_whole_extent(&mut self) -> *mut core::ffi::c_int { - unsafe extern "C" { - fn vtk_trivial_producer_get_whole_extent( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_int; - } - unsafe { vtk_trivial_producer_get_whole_extent(self.0) } - } - fn get_whole_extent( - &mut self, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_trivial_producer_get_whole_extent( - sself: *mut core::ffi::c_void, - _arg1: core::ffi::c_int, - _arg2: core::ffi::c_int, - _arg3: core::ffi::c_int, - _arg4: core::ffi::c_int, - _arg5: core::ffi::c_int, - _arg6: core::ffi::c_int, - ); - } - unsafe { - vtk_trivial_producer_get_whole_extent( - self.0, - _arg1, - _arg2, - _arg3, - _arg4, - _arg5, - _arg6, - ) - } - } - fn get_whole_extent(&mut self, _arg: core::ffi::c_int) -> () { - unsafe extern "C" { - fn vtk_trivial_producer_get_whole_extent( - sself: *mut core::ffi::c_void, - _arg: core::ffi::c_int, - ); - } - unsafe { vtk_trivial_producer_get_whole_extent(self.0, _arg) } - } fn fill_output_data_information( &mut self, output: *mut core::ffi::c_void, @@ -8451,22 +5553,6 @@ impl VtkUndirectedGraphAlgorithm for vtkUndirectedGraphAlgorithm { } unsafe { vtk_undirected_graph_algorithm_new_instance(self.0) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_undirected_graph_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_undirected_graph_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_output(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_undirected_graph_algorithm_get_output( @@ -8475,15 +5561,6 @@ impl VtkUndirectedGraphAlgorithm for vtkUndirectedGraphAlgorithm { } unsafe { vtk_undirected_graph_algorithm_get_output(self.0) } } - fn get_output(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_undirected_graph_algorithm_get_output( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_undirected_graph_algorithm_get_output(self.0, index) } - } fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_undirected_graph_algorithm_set_input_data( @@ -8493,20 +5570,6 @@ impl VtkUndirectedGraphAlgorithm for vtkUndirectedGraphAlgorithm { } unsafe { vtk_undirected_graph_algorithm_set_input_data(self.0, obj) } } - fn set_input_data( - &mut self, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_undirected_graph_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - index: core::ffi::c_int, - obj: *mut core::ffi::c_void, - ); - } - unsafe { vtk_undirected_graph_algorithm_set_input_data(self.0, index, obj) } - } } impl VtkUniformGridAMRAlgorithm for vtkUniformGridAMRAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -8542,15 +5605,6 @@ impl VtkUniformGridAMRAlgorithm for vtkUniformGridAMRAlgorithm { } unsafe { vtk_uniform_grid_amr_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_uniform_grid_amr_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_uniform_grid_amr_algorithm_get_output(self.0, p0) } - } fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_uniform_grid_amr_algorithm_set_input_data( @@ -8560,43 +5614,6 @@ impl VtkUniformGridAMRAlgorithm for vtkUniformGridAMRAlgorithm { } unsafe { vtk_uniform_grid_amr_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_uniform_grid_amr_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_uniform_grid_amr_algorithm_set_input_data(self.0, p0, p1) } - } - fn process_request( - &mut self, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_uniform_grid_amr_algorithm_process_request( - sself: *mut core::ffi::c_void, - request: *mut core::ffi::c_void, - inputVector: *mut core::ffi::c_void, - outputVector: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_uniform_grid_amr_algorithm_process_request( - self.0, - request, - inputVector, - outputVector, - ) - } - } } impl VtkUniformGridPartitioner for vtkUniformGridPartitioner { fn new(&mut self) -> *mut core::ffi::c_void { @@ -8726,15 +5743,6 @@ impl VtkUnstructuredGridAlgorithm for vtkUnstructuredGridAlgorithm { } unsafe { vtk_unstructured_grid_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_unstructured_grid_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_unstructured_grid_algorithm_get_output(self.0, p0) } - } fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_unstructured_grid_algorithm_set_output( @@ -8744,22 +5752,6 @@ impl VtkUnstructuredGridAlgorithm for vtkUnstructuredGridAlgorithm { } unsafe { vtk_unstructured_grid_algorithm_set_output(self.0, d) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_unstructured_grid_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_unstructured_grid_algorithm_process_request(self.0, p0, p1, p2) } - } fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_unstructured_grid_algorithm_get_input( @@ -8769,14 +5761,6 @@ impl VtkUnstructuredGridAlgorithm for vtkUnstructuredGridAlgorithm { } unsafe { vtk_unstructured_grid_algorithm_get_input(self.0, port) } } - fn get_input(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_unstructured_grid_algorithm_get_input( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_unstructured_grid_algorithm_get_input(self.0) } - } fn get_unstructured_grid_input( &mut self, port: core::ffi::c_int, @@ -8800,20 +5784,6 @@ impl VtkUnstructuredGridAlgorithm for vtkUnstructuredGridAlgorithm { } unsafe { vtk_unstructured_grid_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_unstructured_grid_algorithm_set_input_data(self.0, p0, p1) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_unstructured_grid_algorithm_add_input_data( @@ -8823,20 +5793,6 @@ impl VtkUnstructuredGridAlgorithm for vtkUnstructuredGridAlgorithm { } unsafe { vtk_unstructured_grid_algorithm_add_input_data(self.0, p0) } } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_unstructured_grid_algorithm_add_input_data(self.0, p0, p1) } - } } impl VtkUnstructuredGridBaseAlgorithm for vtkUnstructuredGridBaseAlgorithm { fn new(&mut self) -> *mut core::ffi::c_void { @@ -8872,15 +5828,6 @@ impl VtkUnstructuredGridBaseAlgorithm for vtkUnstructuredGridBaseAlgorithm { } unsafe { vtk_unstructured_grid_base_algorithm_get_output(self.0) } } - fn get_output(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_unstructured_grid_base_algorithm_get_output( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_unstructured_grid_base_algorithm_get_output(self.0, p0) } - } fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_unstructured_grid_base_algorithm_set_output( @@ -8890,24 +5837,6 @@ impl VtkUnstructuredGridBaseAlgorithm for vtkUnstructuredGridBaseAlgorithm { } unsafe { vtk_unstructured_grid_base_algorithm_set_output(self.0, d) } } - fn process_request( - &mut self, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_unstructured_grid_base_algorithm_process_request( - sself: *mut core::ffi::c_void, - p0: *mut core::ffi::c_void, - p1: *mut core::ffi::c_void, - p2: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { - vtk_unstructured_grid_base_algorithm_process_request(self.0, p0, p1, p2) - } - } fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_unstructured_grid_base_algorithm_set_input_data( @@ -8917,20 +5846,6 @@ impl VtkUnstructuredGridBaseAlgorithm for vtkUnstructuredGridBaseAlgorithm { } unsafe { vtk_unstructured_grid_base_algorithm_set_input_data(self.0, p0) } } - fn set_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_base_algorithm_set_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_unstructured_grid_base_algorithm_set_input_data(self.0, p0, p1) } - } fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_unstructured_grid_base_algorithm_add_input_data( @@ -8938,21 +5853,7 @@ impl VtkUnstructuredGridBaseAlgorithm for vtkUnstructuredGridBaseAlgorithm { p0: *mut core::ffi::c_void, ); } - unsafe { vtk_unstructured_grid_base_algorithm_add_input_data(self.0, p0) } - } - fn add_input_data( - &mut self, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_unstructured_grid_base_algorithm_add_input_data( - sself: *mut core::ffi::c_void, - p0: core::ffi::c_int, - p1: *mut core::ffi::c_void, - ); - } - unsafe { vtk_unstructured_grid_base_algorithm_add_input_data(self.0, p0, p1) } + unsafe { vtk_unstructured_grid_base_algorithm_add_input_data(self.0, p0) } } } /// Superclass for all sources, filters, and sinks in VTK. @@ -8972,22 +5873,13 @@ impl VtkUnstructuredGridBaseAlgorithm for vtkUnstructuredGridBaseAlgorithm { #[allow(non_camel_case_types)] pub struct vtkAlgorithm(*mut core::ffi::c_void); impl vtkAlgorithm { - /// Creates a new [vtkAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkAlgorithm] via `vtkAlgorithm::New()` #[doc(alias = "vtkAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkAlgorithm_new() }) } } impl std::default::Default for vtkAlgorithm { @@ -9007,12 +5899,8 @@ impl Drop for vtkAlgorithm { #[test] fn test_vtkAlgorithm_create_drop() { let obj = vtkAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Proxy object to connect input/output ports. /// @@ -9027,22 +5915,13 @@ fn test_vtkAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAlgorithmOutput(*mut core::ffi::c_void); impl vtkAlgorithmOutput { - /// Creates a new [vtkAlgorithmOutput] wrapped inside `vtkNew` + /// Creates a new [vtkAlgorithmOutput] via `vtkAlgorithmOutput::New()` #[doc(alias = "vtkAlgorithmOutput")] pub fn new() -> Self { unsafe extern "C" { fn vtkAlgorithmOutput_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAlgorithmOutput_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAlgorithmOutput_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAlgorithmOutput_get_ptr(self.0) } + Self(unsafe { vtkAlgorithmOutput_new() }) } } impl std::default::Default for vtkAlgorithmOutput { @@ -9062,12 +5941,8 @@ impl Drop for vtkAlgorithmOutput { #[test] fn test_vtkAlgorithmOutput_create_drop() { let obj = vtkAlgorithmOutput::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAlgorithmOutput(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only vtkAnnotationLayers as output /// @@ -9087,22 +5962,13 @@ fn test_vtkAlgorithmOutput_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAnnotationLayersAlgorithm(*mut core::ffi::c_void); impl vtkAnnotationLayersAlgorithm { - /// Creates a new [vtkAnnotationLayersAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkAnnotationLayersAlgorithm] via `vtkAnnotationLayersAlgorithm::New()` #[doc(alias = "vtkAnnotationLayersAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkAnnotationLayersAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAnnotationLayersAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAnnotationLayersAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAnnotationLayersAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkAnnotationLayersAlgorithm_new() }) } } impl std::default::Default for vtkAnnotationLayersAlgorithm { @@ -9122,12 +5988,8 @@ impl Drop for vtkAnnotationLayersAlgorithm { #[test] fn test_vtkAnnotationLayersAlgorithm_create_drop() { let obj = vtkAnnotationLayersAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAnnotationLayersAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce /// @@ -9149,22 +6011,13 @@ fn test_vtkAnnotationLayersAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkArrayDataAlgorithm(*mut core::ffi::c_void); impl vtkArrayDataAlgorithm { - /// Creates a new [vtkArrayDataAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkArrayDataAlgorithm] via `vtkArrayDataAlgorithm::New()` #[doc(alias = "vtkArrayDataAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkArrayDataAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkArrayDataAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkArrayDataAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkArrayDataAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkArrayDataAlgorithm_new() }) } } impl std::default::Default for vtkArrayDataAlgorithm { @@ -9184,34 +6037,21 @@ impl Drop for vtkArrayDataAlgorithm { #[test] fn test_vtkArrayDataAlgorithm_create_drop() { let obj = vtkArrayDataAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkArrayDataAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// vtkCachedStreamingDemandDrivenPipeline #[allow(non_camel_case_types)] pub struct vtkCachedStreamingDemandDrivenPipeline(*mut core::ffi::c_void); impl vtkCachedStreamingDemandDrivenPipeline { - /// Creates a new [vtkCachedStreamingDemandDrivenPipeline] wrapped inside `vtkNew` + /// Creates a new [vtkCachedStreamingDemandDrivenPipeline] via `vtkCachedStreamingDemandDrivenPipeline::New()` #[doc(alias = "vtkCachedStreamingDemandDrivenPipeline")] pub fn new() -> Self { unsafe extern "C" { fn vtkCachedStreamingDemandDrivenPipeline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCachedStreamingDemandDrivenPipeline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCachedStreamingDemandDrivenPipeline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCachedStreamingDemandDrivenPipeline_get_ptr(self.0) } + Self(unsafe { vtkCachedStreamingDemandDrivenPipeline_new() }) } } impl std::default::Default for vtkCachedStreamingDemandDrivenPipeline { @@ -9233,12 +6073,8 @@ impl Drop for vtkCachedStreamingDemandDrivenPipeline { #[test] fn test_vtkCachedStreamingDemandDrivenPipeline_create_drop() { let obj = vtkCachedStreamingDemandDrivenPipeline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCachedStreamingDemandDrivenPipeline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// works around type-checking limitations /// @@ -9266,22 +6102,13 @@ fn test_vtkCachedStreamingDemandDrivenPipeline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCastToConcrete(*mut core::ffi::c_void); impl vtkCastToConcrete { - /// Creates a new [vtkCastToConcrete] wrapped inside `vtkNew` + /// Creates a new [vtkCastToConcrete] via `vtkCastToConcrete::New()` #[doc(alias = "vtkCastToConcrete")] pub fn new() -> Self { unsafe extern "C" { fn vtkCastToConcrete_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCastToConcrete_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCastToConcrete_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCastToConcrete_get_ptr(self.0) } + Self(unsafe { vtkCastToConcrete_new() }) } } impl std::default::Default for vtkCastToConcrete { @@ -9301,12 +6128,8 @@ impl Drop for vtkCastToConcrete { #[test] fn test_vtkCastToConcrete_create_drop() { let obj = vtkCastToConcrete::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCastToConcrete(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Executive supporting composite datasets. /// @@ -9337,22 +6160,13 @@ fn test_vtkCastToConcrete_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCompositeDataPipeline(*mut core::ffi::c_void); impl vtkCompositeDataPipeline { - /// Creates a new [vtkCompositeDataPipeline] wrapped inside `vtkNew` + /// Creates a new [vtkCompositeDataPipeline] via `vtkCompositeDataPipeline::New()` #[doc(alias = "vtkCompositeDataPipeline")] pub fn new() -> Self { unsafe extern "C" { fn vtkCompositeDataPipeline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCompositeDataPipeline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCompositeDataPipeline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCompositeDataPipeline_get_ptr(self.0) } + Self(unsafe { vtkCompositeDataPipeline_new() }) } } impl std::default::Default for vtkCompositeDataPipeline { @@ -9372,12 +6186,8 @@ impl Drop for vtkCompositeDataPipeline { #[test] fn test_vtkCompositeDataPipeline_create_drop() { let obj = vtkCompositeDataPipeline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCompositeDataPipeline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only vtkCompositeDataSet as output /// @@ -9388,22 +6198,13 @@ fn test_vtkCompositeDataPipeline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCompositeDataSetAlgorithm(*mut core::ffi::c_void); impl vtkCompositeDataSetAlgorithm { - /// Creates a new [vtkCompositeDataSetAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkCompositeDataSetAlgorithm] via `vtkCompositeDataSetAlgorithm::New()` #[doc(alias = "vtkCompositeDataSetAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkCompositeDataSetAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCompositeDataSetAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCompositeDataSetAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCompositeDataSetAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkCompositeDataSetAlgorithm_new() }) } } impl std::default::Default for vtkCompositeDataSetAlgorithm { @@ -9423,12 +6224,8 @@ impl Drop for vtkCompositeDataSetAlgorithm { #[test] fn test_vtkCompositeDataSetAlgorithm_create_drop() { let obj = vtkCompositeDataSetAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCompositeDataSetAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only data object as output /// @@ -9448,22 +6245,13 @@ fn test_vtkCompositeDataSetAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataObjectAlgorithm(*mut core::ffi::c_void); impl vtkDataObjectAlgorithm { - /// Creates a new [vtkDataObjectAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkDataObjectAlgorithm] via `vtkDataObjectAlgorithm::New()` #[doc(alias = "vtkDataObjectAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataObjectAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataObjectAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataObjectAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataObjectAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkDataObjectAlgorithm_new() }) } } impl std::default::Default for vtkDataObjectAlgorithm { @@ -9483,12 +6271,8 @@ impl Drop for vtkDataObjectAlgorithm { #[test] fn test_vtkDataObjectAlgorithm_create_drop() { let obj = vtkDataObjectAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataObjectAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce output of the same type as input /// @@ -9509,22 +6293,13 @@ fn test_vtkDataObjectAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataSetAlgorithm(*mut core::ffi::c_void); impl vtkDataSetAlgorithm { - /// Creates a new [vtkDataSetAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkDataSetAlgorithm] via `vtkDataSetAlgorithm::New()` #[doc(alias = "vtkDataSetAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataSetAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataSetAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataSetAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataSetAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkDataSetAlgorithm_new() }) } } impl std::default::Default for vtkDataSetAlgorithm { @@ -9544,12 +6319,8 @@ impl Drop for vtkDataSetAlgorithm { #[test] fn test_vtkDataSetAlgorithm_create_drop() { let obj = vtkDataSetAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataSetAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Executive supporting on-demand execution. /// @@ -9560,22 +6331,13 @@ fn test_vtkDataSetAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDemandDrivenPipeline(*mut core::ffi::c_void); impl vtkDemandDrivenPipeline { - /// Creates a new [vtkDemandDrivenPipeline] wrapped inside `vtkNew` + /// Creates a new [vtkDemandDrivenPipeline] via `vtkDemandDrivenPipeline::New()` #[doc(alias = "vtkDemandDrivenPipeline")] pub fn new() -> Self { unsafe extern "C" { fn vtkDemandDrivenPipeline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDemandDrivenPipeline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDemandDrivenPipeline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDemandDrivenPipeline_get_ptr(self.0) } + Self(unsafe { vtkDemandDrivenPipeline_new() }) } } impl std::default::Default for vtkDemandDrivenPipeline { @@ -9595,12 +6357,8 @@ impl Drop for vtkDemandDrivenPipeline { #[test] fn test_vtkDemandDrivenPipeline_create_drop() { let obj = vtkDemandDrivenPipeline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDemandDrivenPipeline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only directed graph as output /// @@ -9625,22 +6383,13 @@ fn test_vtkDemandDrivenPipeline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDirectedGraphAlgorithm(*mut core::ffi::c_void); impl vtkDirectedGraphAlgorithm { - /// Creates a new [vtkDirectedGraphAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkDirectedGraphAlgorithm] via `vtkDirectedGraphAlgorithm::New()` #[doc(alias = "vtkDirectedGraphAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkDirectedGraphAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDirectedGraphAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDirectedGraphAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDirectedGraphAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkDirectedGraphAlgorithm_new() }) } } impl std::default::Default for vtkDirectedGraphAlgorithm { @@ -9660,12 +6409,8 @@ impl Drop for vtkDirectedGraphAlgorithm { #[test] fn test_vtkDirectedGraphAlgorithm_create_drop() { let obj = vtkDirectedGraphAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDirectedGraphAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// source that manages dataset ensembles /// @@ -9679,22 +6424,13 @@ fn test_vtkDirectedGraphAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkEnsembleSource(*mut core::ffi::c_void); impl vtkEnsembleSource { - /// Creates a new [vtkEnsembleSource] wrapped inside `vtkNew` + /// Creates a new [vtkEnsembleSource] via `vtkEnsembleSource::New()` #[doc(alias = "vtkEnsembleSource")] pub fn new() -> Self { unsafe extern "C" { fn vtkEnsembleSource_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEnsembleSource_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEnsembleSource_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEnsembleSource_get_ptr(self.0) } + Self(unsafe { vtkEnsembleSource_new() }) } } impl std::default::Default for vtkEnsembleSource { @@ -9714,12 +6450,8 @@ impl Drop for vtkEnsembleSource { #[test] fn test_vtkEnsembleSource_create_drop() { let obj = vtkEnsembleSource::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEnsembleSource(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only /// @@ -9727,22 +6459,13 @@ fn test_vtkEnsembleSource_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExplicitStructuredGridAlgorithm(*mut core::ffi::c_void); impl vtkExplicitStructuredGridAlgorithm { - /// Creates a new [vtkExplicitStructuredGridAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkExplicitStructuredGridAlgorithm] via `vtkExplicitStructuredGridAlgorithm::New()` #[doc(alias = "vtkExplicitStructuredGridAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkExplicitStructuredGridAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExplicitStructuredGridAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExplicitStructuredGridAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExplicitStructuredGridAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkExplicitStructuredGridAlgorithm_new() }) } } impl std::default::Default for vtkExplicitStructuredGridAlgorithm { @@ -9764,12 +6487,8 @@ impl Drop for vtkExplicitStructuredGridAlgorithm { #[test] fn test_vtkExplicitStructuredGridAlgorithm_create_drop() { let obj = vtkExplicitStructuredGridAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExplicitStructuredGridAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// This method partitions a global extent to N partitions where N is a user /// @@ -9777,22 +6496,13 @@ fn test_vtkExplicitStructuredGridAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExtentRCBPartitioner(*mut core::ffi::c_void); impl vtkExtentRCBPartitioner { - /// Creates a new [vtkExtentRCBPartitioner] wrapped inside `vtkNew` + /// Creates a new [vtkExtentRCBPartitioner] via `vtkExtentRCBPartitioner::New()` #[doc(alias = "vtkExtentRCBPartitioner")] pub fn new() -> Self { unsafe extern "C" { fn vtkExtentRCBPartitioner_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExtentRCBPartitioner_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExtentRCBPartitioner_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExtentRCBPartitioner_get_ptr(self.0) } + Self(unsafe { vtkExtentRCBPartitioner_new() }) } } impl std::default::Default for vtkExtentRCBPartitioner { @@ -9812,12 +6522,8 @@ impl Drop for vtkExtentRCBPartitioner { #[test] fn test_vtkExtentRCBPartitioner_create_drop() { let obj = vtkExtentRCBPartitioner::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExtentRCBPartitioner(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Split an extent across other extents. /// @@ -9833,22 +6539,13 @@ fn test_vtkExtentRCBPartitioner_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExtentSplitter(*mut core::ffi::c_void); impl vtkExtentSplitter { - /// Creates a new [vtkExtentSplitter] wrapped inside `vtkNew` + /// Creates a new [vtkExtentSplitter] via `vtkExtentSplitter::New()` #[doc(alias = "vtkExtentSplitter")] pub fn new() -> Self { unsafe extern "C" { fn vtkExtentSplitter_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExtentSplitter_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExtentSplitter_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExtentSplitter_get_ptr(self.0) } + Self(unsafe { vtkExtentSplitter_new() }) } } impl std::default::Default for vtkExtentSplitter { @@ -9868,12 +6565,8 @@ impl Drop for vtkExtentSplitter { #[test] fn test_vtkExtentSplitter_create_drop() { let obj = vtkExtentSplitter::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExtentSplitter(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generates a structured extent from unstructured. /// @@ -9885,22 +6578,13 @@ fn test_vtkExtentSplitter_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExtentTranslator(*mut core::ffi::c_void); impl vtkExtentTranslator { - /// Creates a new [vtkExtentTranslator] wrapped inside `vtkNew` + /// Creates a new [vtkExtentTranslator] via `vtkExtentTranslator::New()` #[doc(alias = "vtkExtentTranslator")] pub fn new() -> Self { unsafe extern "C" { fn vtkExtentTranslator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExtentTranslator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExtentTranslator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExtentTranslator_get_ptr(self.0) } + Self(unsafe { vtkExtentTranslator_new() }) } } impl std::default::Default for vtkExtentTranslator { @@ -9920,12 +6604,8 @@ impl Drop for vtkExtentTranslator { #[test] fn test_vtkExtentTranslator_create_drop() { let obj = vtkExtentTranslator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExtentTranslator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only graph as output /// @@ -9949,22 +6629,13 @@ fn test_vtkExtentTranslator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGraphAlgorithm(*mut core::ffi::c_void); impl vtkGraphAlgorithm { - /// Creates a new [vtkGraphAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkGraphAlgorithm] via `vtkGraphAlgorithm::New()` #[doc(alias = "vtkGraphAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkGraphAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGraphAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGraphAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGraphAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkGraphAlgorithm_new() }) } } impl std::default::Default for vtkGraphAlgorithm { @@ -9984,12 +6655,8 @@ impl Drop for vtkGraphAlgorithm { #[test] fn test_vtkGraphAlgorithm_create_drop() { let obj = vtkGraphAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGraphAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// superclass for algorithms that /// @@ -10001,22 +6668,13 @@ fn test_vtkGraphAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHierarchicalBoxDataSetAlgorithm(*mut core::ffi::c_void); impl vtkHierarchicalBoxDataSetAlgorithm { - /// Creates a new [vtkHierarchicalBoxDataSetAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkHierarchicalBoxDataSetAlgorithm] via `vtkHierarchicalBoxDataSetAlgorithm::New()` #[doc(alias = "vtkHierarchicalBoxDataSetAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkHierarchicalBoxDataSetAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHierarchicalBoxDataSetAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHierarchicalBoxDataSetAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHierarchicalBoxDataSetAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkHierarchicalBoxDataSetAlgorithm_new() }) } } impl std::default::Default for vtkHierarchicalBoxDataSetAlgorithm { @@ -10038,12 +6696,8 @@ impl Drop for vtkHierarchicalBoxDataSetAlgorithm { #[test] fn test_vtkHierarchicalBoxDataSetAlgorithm_create_drop() { let obj = vtkHierarchicalBoxDataSetAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHierarchicalBoxDataSetAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// a structured grid instance. @@ -10054,22 +6708,13 @@ fn test_vtkHierarchicalBoxDataSetAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImageToStructuredGrid(*mut core::ffi::c_void); impl vtkImageToStructuredGrid { - /// Creates a new [vtkImageToStructuredGrid] wrapped inside `vtkNew` + /// Creates a new [vtkImageToStructuredGrid] via `vtkImageToStructuredGrid::New()` #[doc(alias = "vtkImageToStructuredGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkImageToStructuredGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImageToStructuredGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImageToStructuredGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImageToStructuredGrid_get_ptr(self.0) } + Self(unsafe { vtkImageToStructuredGrid_new() }) } } impl std::default::Default for vtkImageToStructuredGrid { @@ -10089,12 +6734,8 @@ impl Drop for vtkImageToStructuredGrid { #[test] fn test_vtkImageToStructuredGrid_create_drop() { let obj = vtkImageToStructuredGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImageToStructuredGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Attaches image pipeline to VTK. /// @@ -10108,22 +6749,13 @@ fn test_vtkImageToStructuredGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImageToStructuredPoints(*mut core::ffi::c_void); impl vtkImageToStructuredPoints { - /// Creates a new [vtkImageToStructuredPoints] wrapped inside `vtkNew` + /// Creates a new [vtkImageToStructuredPoints] via `vtkImageToStructuredPoints::New()` #[doc(alias = "vtkImageToStructuredPoints")] pub fn new() -> Self { unsafe extern "C" { fn vtkImageToStructuredPoints_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImageToStructuredPoints_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImageToStructuredPoints_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImageToStructuredPoints_get_ptr(self.0) } + Self(unsafe { vtkImageToStructuredPoints_new() }) } } impl std::default::Default for vtkImageToStructuredPoints { @@ -10143,12 +6775,8 @@ impl Drop for vtkImageToStructuredPoints { #[test] fn test_vtkImageToStructuredPoints_create_drop() { let obj = vtkImageToStructuredPoints::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImageToStructuredPoints(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that operate on /// @@ -10168,22 +6796,13 @@ fn test_vtkImageToStructuredPoints_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMoleculeAlgorithm(*mut core::ffi::c_void); impl vtkMoleculeAlgorithm { - /// Creates a new [vtkMoleculeAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkMoleculeAlgorithm] via `vtkMoleculeAlgorithm::New()` #[doc(alias = "vtkMoleculeAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkMoleculeAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMoleculeAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMoleculeAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMoleculeAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkMoleculeAlgorithm_new() }) } } impl std::default::Default for vtkMoleculeAlgorithm { @@ -10203,12 +6822,8 @@ impl Drop for vtkMoleculeAlgorithm { #[test] fn test_vtkMoleculeAlgorithm_create_drop() { let obj = vtkMoleculeAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMoleculeAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only vtkMultiBlockDataSet as output /// @@ -10219,22 +6834,13 @@ fn test_vtkMoleculeAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMultiBlockDataSetAlgorithm(*mut core::ffi::c_void); impl vtkMultiBlockDataSetAlgorithm { - /// Creates a new [vtkMultiBlockDataSetAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkMultiBlockDataSetAlgorithm] via `vtkMultiBlockDataSetAlgorithm::New()` #[doc(alias = "vtkMultiBlockDataSetAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkMultiBlockDataSetAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMultiBlockDataSetAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMultiBlockDataSetAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMultiBlockDataSetAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkMultiBlockDataSetAlgorithm_new() }) } } impl std::default::Default for vtkMultiBlockDataSetAlgorithm { @@ -10254,12 +6860,8 @@ impl Drop for vtkMultiBlockDataSetAlgorithm { #[test] fn test_vtkMultiBlockDataSetAlgorithm_create_drop() { let obj = vtkMultiBlockDataSetAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMultiBlockDataSetAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that would like to make multiple time requests /// @@ -10284,22 +6886,13 @@ fn test_vtkMultiBlockDataSetAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMultiTimeStepAlgorithm(*mut core::ffi::c_void); impl vtkMultiTimeStepAlgorithm { - /// Creates a new [vtkMultiTimeStepAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkMultiTimeStepAlgorithm] via `vtkMultiTimeStepAlgorithm::New()` #[doc(alias = "vtkMultiTimeStepAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkMultiTimeStepAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMultiTimeStepAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMultiTimeStepAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMultiTimeStepAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkMultiTimeStepAlgorithm_new() }) } } impl std::default::Default for vtkMultiTimeStepAlgorithm { @@ -10319,34 +6912,21 @@ impl Drop for vtkMultiTimeStepAlgorithm { #[test] fn test_vtkMultiTimeStepAlgorithm_create_drop() { let obj = vtkMultiTimeStepAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMultiTimeStepAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// produce vtkNonOverlappingAMR as output. #[allow(non_camel_case_types)] pub struct vtkNonOverlappingAMRAlgorithm(*mut core::ffi::c_void); impl vtkNonOverlappingAMRAlgorithm { - /// Creates a new [vtkNonOverlappingAMRAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkNonOverlappingAMRAlgorithm] via `vtkNonOverlappingAMRAlgorithm::New()` #[doc(alias = "vtkNonOverlappingAMRAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkNonOverlappingAMRAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkNonOverlappingAMRAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkNonOverlappingAMRAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkNonOverlappingAMRAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkNonOverlappingAMRAlgorithm_new() }) } } impl std::default::Default for vtkNonOverlappingAMRAlgorithm { @@ -10366,12 +6946,8 @@ impl Drop for vtkNonOverlappingAMRAlgorithm { #[test] fn test_vtkNonOverlappingAMRAlgorithm_create_drop() { let obj = vtkNonOverlappingAMRAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkNonOverlappingAMRAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A base class for all algorithms that take as input vtkOverlappingAMR and /// @@ -10379,22 +6955,13 @@ fn test_vtkNonOverlappingAMRAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOverlappingAMRAlgorithm(*mut core::ffi::c_void); impl vtkOverlappingAMRAlgorithm { - /// Creates a new [vtkOverlappingAMRAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkOverlappingAMRAlgorithm] via `vtkOverlappingAMRAlgorithm::New()` #[doc(alias = "vtkOverlappingAMRAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkOverlappingAMRAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOverlappingAMRAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOverlappingAMRAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOverlappingAMRAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkOverlappingAMRAlgorithm_new() }) } } impl std::default::Default for vtkOverlappingAMRAlgorithm { @@ -10414,12 +6981,8 @@ impl Drop for vtkOverlappingAMRAlgorithm { #[test] fn test_vtkOverlappingAMRAlgorithm_create_drop() { let obj = vtkOverlappingAMRAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOverlappingAMRAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce output of the same type as input /// @@ -10440,22 +7003,13 @@ fn test_vtkOverlappingAMRAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPassInputTypeAlgorithm(*mut core::ffi::c_void); impl vtkPassInputTypeAlgorithm { - /// Creates a new [vtkPassInputTypeAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkPassInputTypeAlgorithm] via `vtkPassInputTypeAlgorithm::New()` #[doc(alias = "vtkPassInputTypeAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkPassInputTypeAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPassInputTypeAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPassInputTypeAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPassInputTypeAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkPassInputTypeAlgorithm_new() }) } } impl std::default::Default for vtkPassInputTypeAlgorithm { @@ -10475,12 +7029,8 @@ impl Drop for vtkPassInputTypeAlgorithm { #[test] fn test_vtkPassInputTypeAlgorithm_create_drop() { let obj = vtkPassInputTypeAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPassInputTypeAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only piecewise function as output /// @@ -10500,22 +7050,13 @@ fn test_vtkPassInputTypeAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPiecewiseFunctionAlgorithm(*mut core::ffi::c_void); impl vtkPiecewiseFunctionAlgorithm { - /// Creates a new [vtkPiecewiseFunctionAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkPiecewiseFunctionAlgorithm] via `vtkPiecewiseFunctionAlgorithm::New()` #[doc(alias = "vtkPiecewiseFunctionAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkPiecewiseFunctionAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPiecewiseFunctionAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPiecewiseFunctionAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPiecewiseFunctionAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkPiecewiseFunctionAlgorithm_new() }) } } impl std::default::Default for vtkPiecewiseFunctionAlgorithm { @@ -10535,33 +7076,20 @@ impl Drop for vtkPiecewiseFunctionAlgorithm { #[test] fn test_vtkPiecewiseFunctionAlgorithm_create_drop() { let obj = vtkPiecewiseFunctionAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPiecewiseFunctionAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkPiecewiseFunctionShiftScale(*mut core::ffi::c_void); impl vtkPiecewiseFunctionShiftScale { - /// Creates a new [vtkPiecewiseFunctionShiftScale] wrapped inside `vtkNew` + /// Creates a new [vtkPiecewiseFunctionShiftScale] via `vtkPiecewiseFunctionShiftScale::New()` #[doc(alias = "vtkPiecewiseFunctionShiftScale")] pub fn new() -> Self { unsafe extern "C" { fn vtkPiecewiseFunctionShiftScale_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPiecewiseFunctionShiftScale_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPiecewiseFunctionShiftScale_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPiecewiseFunctionShiftScale_get_ptr(self.0) } + Self(unsafe { vtkPiecewiseFunctionShiftScale_new() }) } } impl std::default::Default for vtkPiecewiseFunctionShiftScale { @@ -10581,12 +7109,8 @@ impl Drop for vtkPiecewiseFunctionShiftScale { #[test] fn test_vtkPiecewiseFunctionShiftScale_create_drop() { let obj = vtkPiecewiseFunctionShiftScale::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPiecewiseFunctionShiftScale(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce output of the same type as input /// @@ -10605,22 +7129,13 @@ fn test_vtkPiecewiseFunctionShiftScale_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPointSetAlgorithm(*mut core::ffi::c_void); impl vtkPointSetAlgorithm { - /// Creates a new [vtkPointSetAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkPointSetAlgorithm] via `vtkPointSetAlgorithm::New()` #[doc(alias = "vtkPointSetAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointSetAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointSetAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointSetAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointSetAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkPointSetAlgorithm_new() }) } } impl std::default::Default for vtkPointSetAlgorithm { @@ -10640,12 +7155,8 @@ impl Drop for vtkPointSetAlgorithm { #[test] fn test_vtkPointSetAlgorithm_create_drop() { let obj = vtkPointSetAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointSetAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only polydata as output /// @@ -10663,22 +7174,13 @@ fn test_vtkPointSetAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyDataAlgorithm(*mut core::ffi::c_void); impl vtkPolyDataAlgorithm { - /// Creates a new [vtkPolyDataAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkPolyDataAlgorithm] via `vtkPolyDataAlgorithm::New()` #[doc(alias = "vtkPolyDataAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyDataAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyDataAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyDataAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyDataAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkPolyDataAlgorithm_new() }) } } impl std::default::Default for vtkPolyDataAlgorithm { @@ -10698,12 +7200,8 @@ impl Drop for vtkPolyDataAlgorithm { #[test] fn test_vtkPolyDataAlgorithm_create_drop() { let obj = vtkPolyDataAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyDataAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Basic class to optionally replace vtkAlgorithm progress functionality. /// @@ -10720,22 +7218,13 @@ fn test_vtkPolyDataAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkProgressObserver(*mut core::ffi::c_void); impl vtkProgressObserver { - /// Creates a new [vtkProgressObserver] wrapped inside `vtkNew` + /// Creates a new [vtkProgressObserver] via `vtkProgressObserver::New()` #[doc(alias = "vtkProgressObserver")] pub fn new() -> Self { unsafe extern "C" { fn vtkProgressObserver_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkProgressObserver_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkProgressObserver_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkProgressObserver_get_ptr(self.0) } + Self(unsafe { vtkProgressObserver_new() }) } } impl std::default::Default for vtkProgressObserver { @@ -10755,12 +7244,8 @@ impl Drop for vtkProgressObserver { #[test] fn test_vtkProgressObserver_create_drop() { let obj = vtkProgressObserver::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkProgressObserver(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Executive that works with vtkReaderAlgorithm and subclasses. /// @@ -10780,22 +7265,13 @@ fn test_vtkProgressObserver_create_drop() { #[allow(non_camel_case_types)] pub struct vtkReaderExecutive(*mut core::ffi::c_void); impl vtkReaderExecutive { - /// Creates a new [vtkReaderExecutive] wrapped inside `vtkNew` + /// Creates a new [vtkReaderExecutive] via `vtkReaderExecutive::New()` #[doc(alias = "vtkReaderExecutive")] pub fn new() -> Self { unsafe extern "C" { fn vtkReaderExecutive_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkReaderExecutive_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkReaderExecutive_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkReaderExecutive_get_ptr(self.0) } + Self(unsafe { vtkReaderExecutive_new() }) } } impl std::default::Default for vtkReaderExecutive { @@ -10815,12 +7291,8 @@ impl Drop for vtkReaderExecutive { #[test] fn test_vtkReaderExecutive_create_drop() { let obj = vtkReaderExecutive::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkReaderExecutive(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only rectilinear grid as output /// @@ -10840,22 +7312,13 @@ fn test_vtkReaderExecutive_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRectilinearGridAlgorithm(*mut core::ffi::c_void); impl vtkRectilinearGridAlgorithm { - /// Creates a new [vtkRectilinearGridAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkRectilinearGridAlgorithm] via `vtkRectilinearGridAlgorithm::New()` #[doc(alias = "vtkRectilinearGridAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkRectilinearGridAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRectilinearGridAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRectilinearGridAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRectilinearGridAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkRectilinearGridAlgorithm_new() }) } } impl std::default::Default for vtkRectilinearGridAlgorithm { @@ -10875,12 +7338,8 @@ impl Drop for vtkRectilinearGridAlgorithm { #[test] fn test_vtkRectilinearGridAlgorithm_create_drop() { let obj = vtkRectilinearGridAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRectilinearGridAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Progress observer that is thread safe /// @@ -10894,22 +7353,13 @@ fn test_vtkRectilinearGridAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSMPProgressObserver(*mut core::ffi::c_void); impl vtkSMPProgressObserver { - /// Creates a new [vtkSMPProgressObserver] wrapped inside `vtkNew` + /// Creates a new [vtkSMPProgressObserver] via `vtkSMPProgressObserver::New()` #[doc(alias = "vtkSMPProgressObserver")] pub fn new() -> Self { unsafe extern "C" { fn vtkSMPProgressObserver_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSMPProgressObserver_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSMPProgressObserver_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSMPProgressObserver_get_ptr(self.0) } + Self(unsafe { vtkSMPProgressObserver_new() }) } } impl std::default::Default for vtkSMPProgressObserver { @@ -10929,12 +7379,8 @@ impl Drop for vtkSMPProgressObserver { #[test] fn test_vtkSMPProgressObserver_create_drop() { let obj = vtkSMPProgressObserver::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSMPProgressObserver(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only Selection as output /// @@ -10958,22 +7404,13 @@ fn test_vtkSMPProgressObserver_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSelectionAlgorithm(*mut core::ffi::c_void); impl vtkSelectionAlgorithm { - /// Creates a new [vtkSelectionAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkSelectionAlgorithm] via `vtkSelectionAlgorithm::New()` #[doc(alias = "vtkSelectionAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkSelectionAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSelectionAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSelectionAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSelectionAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkSelectionAlgorithm_new() }) } } impl std::default::Default for vtkSelectionAlgorithm { @@ -10993,12 +7430,8 @@ impl Drop for vtkSelectionAlgorithm { #[test] fn test_vtkSelectionAlgorithm_create_drop() { let obj = vtkSelectionAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSelectionAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// organize data according to scalar values (used to accelerate contouring operations) /// @@ -11032,22 +7465,13 @@ fn test_vtkSelectionAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSimpleScalarTree(*mut core::ffi::c_void); impl vtkSimpleScalarTree { - /// Creates a new [vtkSimpleScalarTree] wrapped inside `vtkNew` + /// Creates a new [vtkSimpleScalarTree] via `vtkSimpleScalarTree::New()` #[doc(alias = "vtkSimpleScalarTree")] pub fn new() -> Self { unsafe extern "C" { fn vtkSimpleScalarTree_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSimpleScalarTree_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSimpleScalarTree_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSimpleScalarTree_get_ptr(self.0) } + Self(unsafe { vtkSimpleScalarTree_new() }) } } impl std::default::Default for vtkSimpleScalarTree { @@ -11067,12 +7491,8 @@ impl Drop for vtkSimpleScalarTree { #[test] fn test_vtkSimpleScalarTree_create_drop() { let obj = vtkSimpleScalarTree::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSimpleScalarTree(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// organize data according to scalar span space /// @@ -11098,22 +7518,13 @@ fn test_vtkSimpleScalarTree_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSpanSpace(*mut core::ffi::c_void); impl vtkSpanSpace { - /// Creates a new [vtkSpanSpace] wrapped inside `vtkNew` + /// Creates a new [vtkSpanSpace] via `vtkSpanSpace::New()` #[doc(alias = "vtkSpanSpace")] pub fn new() -> Self { unsafe extern "C" { fn vtkSpanSpace_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSpanSpace_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSpanSpace_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSpanSpace_get_ptr(self.0) } + Self(unsafe { vtkSpanSpace_new() }) } } impl std::default::Default for vtkSpanSpace { @@ -11133,12 +7544,8 @@ impl Drop for vtkSpanSpace { #[test] fn test_vtkSpanSpace_create_drop() { let obj = vtkSpanSpace::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSpanSpace(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// class to build and traverse sphere trees /// @@ -11174,22 +7581,13 @@ fn test_vtkSpanSpace_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSphereTree(*mut core::ffi::c_void); impl vtkSphereTree { - /// Creates a new [vtkSphereTree] wrapped inside `vtkNew` + /// Creates a new [vtkSphereTree] via `vtkSphereTree::New()` #[doc(alias = "vtkSphereTree")] pub fn new() -> Self { unsafe extern "C" { fn vtkSphereTree_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSphereTree_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSphereTree_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSphereTree_get_ptr(self.0) } + Self(unsafe { vtkSphereTree_new() }) } } impl std::default::Default for vtkSphereTree { @@ -11209,12 +7607,8 @@ impl Drop for vtkSphereTree { #[test] fn test_vtkSphereTree_create_drop() { let obj = vtkSphereTree::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSphereTree(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Executive supporting partial updates. /// @@ -11227,22 +7621,13 @@ fn test_vtkSphereTree_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStreamingDemandDrivenPipeline(*mut core::ffi::c_void); impl vtkStreamingDemandDrivenPipeline { - /// Creates a new [vtkStreamingDemandDrivenPipeline] wrapped inside `vtkNew` + /// Creates a new [vtkStreamingDemandDrivenPipeline] via `vtkStreamingDemandDrivenPipeline::New()` #[doc(alias = "vtkStreamingDemandDrivenPipeline")] pub fn new() -> Self { unsafe extern "C" { fn vtkStreamingDemandDrivenPipeline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStreamingDemandDrivenPipeline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStreamingDemandDrivenPipeline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStreamingDemandDrivenPipeline_get_ptr(self.0) } + Self(unsafe { vtkStreamingDemandDrivenPipeline_new() }) } } impl std::default::Default for vtkStreamingDemandDrivenPipeline { @@ -11264,12 +7649,8 @@ impl Drop for vtkStreamingDemandDrivenPipeline { #[test] fn test_vtkStreamingDemandDrivenPipeline_create_drop() { let obj = vtkStreamingDemandDrivenPipeline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStreamingDemandDrivenPipeline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only structured grid as output /// @@ -11287,22 +7668,13 @@ fn test_vtkStreamingDemandDrivenPipeline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStructuredGridAlgorithm(*mut core::ffi::c_void); impl vtkStructuredGridAlgorithm { - /// Creates a new [vtkStructuredGridAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkStructuredGridAlgorithm] via `vtkStructuredGridAlgorithm::New()` #[doc(alias = "vtkStructuredGridAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkStructuredGridAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStructuredGridAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStructuredGridAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStructuredGridAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkStructuredGridAlgorithm_new() }) } } impl std::default::Default for vtkStructuredGridAlgorithm { @@ -11322,12 +7694,8 @@ impl Drop for vtkStructuredGridAlgorithm { #[test] fn test_vtkStructuredGridAlgorithm_create_drop() { let obj = vtkStructuredGridAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStructuredGridAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only vtkTables as output /// @@ -11348,22 +7716,13 @@ fn test_vtkStructuredGridAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTableAlgorithm(*mut core::ffi::c_void); impl vtkTableAlgorithm { - /// Creates a new [vtkTableAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkTableAlgorithm] via `vtkTableAlgorithm::New()` #[doc(alias = "vtkTableAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkTableAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTableAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTableAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTableAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkTableAlgorithm_new() }) } } impl std::default::Default for vtkTableAlgorithm { @@ -11383,12 +7742,8 @@ impl Drop for vtkTableAlgorithm { #[test] fn test_vtkTableAlgorithm_create_drop() { let obj = vtkTableAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTableAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Executive that works in parallel /// @@ -11403,22 +7758,13 @@ fn test_vtkTableAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkThreadedCompositeDataPipeline(*mut core::ffi::c_void); impl vtkThreadedCompositeDataPipeline { - /// Creates a new [vtkThreadedCompositeDataPipeline] wrapped inside `vtkNew` + /// Creates a new [vtkThreadedCompositeDataPipeline] via `vtkThreadedCompositeDataPipeline::New()` #[doc(alias = "vtkThreadedCompositeDataPipeline")] pub fn new() -> Self { unsafe extern "C" { fn vtkThreadedCompositeDataPipeline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkThreadedCompositeDataPipeline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkThreadedCompositeDataPipeline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkThreadedCompositeDataPipeline_get_ptr(self.0) } + Self(unsafe { vtkThreadedCompositeDataPipeline_new() }) } } impl std::default::Default for vtkThreadedCompositeDataPipeline { @@ -11440,12 +7786,8 @@ impl Drop for vtkThreadedCompositeDataPipeline { #[test] fn test_vtkThreadedCompositeDataPipeline_create_drop() { let obj = vtkThreadedCompositeDataPipeline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkThreadedCompositeDataPipeline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only Tree as output /// @@ -11463,22 +7805,13 @@ fn test_vtkThreadedCompositeDataPipeline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTreeAlgorithm(*mut core::ffi::c_void); impl vtkTreeAlgorithm { - /// Creates a new [vtkTreeAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkTreeAlgorithm] via `vtkTreeAlgorithm::New()` #[doc(alias = "vtkTreeAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkTreeAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTreeAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTreeAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTreeAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkTreeAlgorithm_new() }) } } impl std::default::Default for vtkTreeAlgorithm { @@ -11498,12 +7831,8 @@ impl Drop for vtkTreeAlgorithm { #[test] fn test_vtkTreeAlgorithm_create_drop() { let obj = vtkTreeAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTreeAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Consumer to consume data off of a pipeline. /// @@ -11515,22 +7844,13 @@ fn test_vtkTreeAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTrivialConsumer(*mut core::ffi::c_void); impl vtkTrivialConsumer { - /// Creates a new [vtkTrivialConsumer] wrapped inside `vtkNew` + /// Creates a new [vtkTrivialConsumer] via `vtkTrivialConsumer::New()` #[doc(alias = "vtkTrivialConsumer")] pub fn new() -> Self { unsafe extern "C" { fn vtkTrivialConsumer_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTrivialConsumer_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTrivialConsumer_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTrivialConsumer_get_ptr(self.0) } + Self(unsafe { vtkTrivialConsumer_new() }) } } impl std::default::Default for vtkTrivialConsumer { @@ -11550,12 +7870,8 @@ impl Drop for vtkTrivialConsumer { #[test] fn test_vtkTrivialConsumer_create_drop() { let obj = vtkTrivialConsumer::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTrivialConsumer(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Producer for stand-alone data objects. /// @@ -11568,22 +7884,13 @@ fn test_vtkTrivialConsumer_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTrivialProducer(*mut core::ffi::c_void); impl vtkTrivialProducer { - /// Creates a new [vtkTrivialProducer] wrapped inside `vtkNew` + /// Creates a new [vtkTrivialProducer] via `vtkTrivialProducer::New()` #[doc(alias = "vtkTrivialProducer")] pub fn new() -> Self { unsafe extern "C" { fn vtkTrivialProducer_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTrivialProducer_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTrivialProducer_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTrivialProducer_get_ptr(self.0) } + Self(unsafe { vtkTrivialProducer_new() }) } } impl std::default::Default for vtkTrivialProducer { @@ -11603,12 +7910,8 @@ impl Drop for vtkTrivialProducer { #[test] fn test_vtkTrivialProducer_create_drop() { let obj = vtkTrivialProducer::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTrivialProducer(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce undirected graph as output /// @@ -11630,22 +7933,13 @@ fn test_vtkTrivialProducer_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUndirectedGraphAlgorithm(*mut core::ffi::c_void); impl vtkUndirectedGraphAlgorithm { - /// Creates a new [vtkUndirectedGraphAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkUndirectedGraphAlgorithm] via `vtkUndirectedGraphAlgorithm::New()` #[doc(alias = "vtkUndirectedGraphAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkUndirectedGraphAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUndirectedGraphAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUndirectedGraphAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUndirectedGraphAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkUndirectedGraphAlgorithm_new() }) } } impl std::default::Default for vtkUndirectedGraphAlgorithm { @@ -11665,12 +7959,8 @@ impl Drop for vtkUndirectedGraphAlgorithm { #[test] fn test_vtkUndirectedGraphAlgorithm_create_drop() { let obj = vtkUndirectedGraphAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUndirectedGraphAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// vtkUniformGridAMR as output. @@ -11681,22 +7971,13 @@ fn test_vtkUndirectedGraphAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUniformGridAMRAlgorithm(*mut core::ffi::c_void); impl vtkUniformGridAMRAlgorithm { - /// Creates a new [vtkUniformGridAMRAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkUniformGridAMRAlgorithm] via `vtkUniformGridAMRAlgorithm::New()` #[doc(alias = "vtkUniformGridAMRAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformGridAMRAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformGridAMRAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformGridAMRAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformGridAMRAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkUniformGridAMRAlgorithm_new() }) } } impl std::default::Default for vtkUniformGridAMRAlgorithm { @@ -11716,12 +7997,8 @@ impl Drop for vtkUniformGridAMRAlgorithm { #[test] fn test_vtkUniformGridAMRAlgorithm_create_drop() { let obj = vtkUniformGridAMRAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformGridAMRAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// A concrete implementation of vtkMultiBlockDataSetAlgorithm that provides @@ -11734,22 +8011,13 @@ fn test_vtkUniformGridAMRAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUniformGridPartitioner(*mut core::ffi::c_void); impl vtkUniformGridPartitioner { - /// Creates a new [vtkUniformGridPartitioner] wrapped inside `vtkNew` + /// Creates a new [vtkUniformGridPartitioner] via `vtkUniformGridPartitioner::New()` #[doc(alias = "vtkUniformGridPartitioner")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformGridPartitioner_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformGridPartitioner_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformGridPartitioner_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformGridPartitioner_get_ptr(self.0) } + Self(unsafe { vtkUniformGridPartitioner_new() }) } } impl std::default::Default for vtkUniformGridPartitioner { @@ -11769,12 +8037,8 @@ impl Drop for vtkUniformGridPartitioner { #[test] fn test_vtkUniformGridPartitioner_create_drop() { let obj = vtkUniformGridPartitioner::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformGridPartitioner(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only unstructured grid as output /// @@ -11792,22 +8056,13 @@ fn test_vtkUniformGridPartitioner_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnstructuredGridAlgorithm(*mut core::ffi::c_void); impl vtkUnstructuredGridAlgorithm { - /// Creates a new [vtkUnstructuredGridAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkUnstructuredGridAlgorithm] via `vtkUnstructuredGridAlgorithm::New()` #[doc(alias = "vtkUnstructuredGridAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnstructuredGridAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnstructuredGridAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnstructuredGridAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnstructuredGridAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkUnstructuredGridAlgorithm_new() }) } } impl std::default::Default for vtkUnstructuredGridAlgorithm { @@ -11827,12 +8082,8 @@ impl Drop for vtkUnstructuredGridAlgorithm { #[test] fn test_vtkUnstructuredGridAlgorithm_create_drop() { let obj = vtkUnstructuredGridAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnstructuredGridAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that /// @@ -11849,22 +8100,13 @@ fn test_vtkUnstructuredGridAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnstructuredGridBaseAlgorithm(*mut core::ffi::c_void); impl vtkUnstructuredGridBaseAlgorithm { - /// Creates a new [vtkUnstructuredGridBaseAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkUnstructuredGridBaseAlgorithm] via `vtkUnstructuredGridBaseAlgorithm::New()` #[doc(alias = "vtkUnstructuredGridBaseAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnstructuredGridBaseAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnstructuredGridBaseAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnstructuredGridBaseAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnstructuredGridBaseAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkUnstructuredGridBaseAlgorithm_new() }) } } impl std::default::Default for vtkUnstructuredGridBaseAlgorithm { @@ -11886,10 +8128,6 @@ impl Drop for vtkUnstructuredGridBaseAlgorithm { #[test] fn test_vtkUnstructuredGridBaseAlgorithm_create_drop() { let obj = vtkUnstructuredGridBaseAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnstructuredGridBaseAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonMath.rs b/vtk-rs-9.1/src/vtkCommonMath.rs index 01ed117..3910274 100644 --- a/vtk-rs-9.1/src/vtkCommonMath.rs +++ b/vtk-rs-9.1/src/vtkCommonMath.rs @@ -2,33 +2,12 @@ pub trait VtkAmoebaMinimizer { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn set_function(&mut self, f: *mut core::ffi::c_void, arg: ()) -> (); fn set_function_arg_delete(&mut self, f: *mut core::ffi::c_void) -> (); - fn set_parameter_value( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_double, - ) -> (); - fn set_parameter_value( - &mut self, - i: core::ffi::c_int, - value: core::ffi::c_double, - ) -> (); - fn set_parameter_scale( - &mut self, - name: core::ffi::c_char, - scale: core::ffi::c_double, - ) -> (); - fn get_parameter_scale(&mut self, name: core::ffi::c_char) -> core::ffi::c_double; - fn set_parameter_scale( - &mut self, - i: core::ffi::c_int, - scale: core::ffi::c_double, - ) -> (); - fn get_parameter_scale(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; - fn get_parameter_value(&mut self, name: core::ffi::c_char) -> core::ffi::c_double; - fn get_parameter_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; - fn get_parameter_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char; + fn set_parameter_value(&mut self, name: &str, value: core::ffi::c_double) -> (); + fn set_parameter_scale(&mut self, name: &str, scale: core::ffi::c_double) -> (); + fn get_parameter_scale(&mut self, name: &str) -> core::ffi::c_double; + fn get_parameter_value(&mut self, name: &str) -> core::ffi::c_double; + fn get_parameter_name(&mut self, i: core::ffi::c_int) -> &str; fn get_number_of_parameters(&mut self) -> core::ffi::c_int; fn initialize(&mut self) -> (); fn minimize(&mut self) -> (); @@ -57,23 +36,6 @@ pub trait VtkFFT { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn fft(&mut self, in_: Vec) -> Vec; - fn fft(&mut self, in_: Vec) -> Vec; - fn r_fft(&mut self, in_: Vec) -> Vec; - fn i_fft(&mut self, in_: Vec) -> Vec; - fn ir_fft(&mut self, in_: Vec) -> Vec; - fn abs(&mut self, in_: kiss_fft_cpx) -> core::ffi::c_double; - fn squared_abs(&mut self, in_: kiss_fft_cpx) -> core::ffi::c_double; - fn fft_freq( - &mut self, - windowLength: core::ffi::c_int, - sampleSpacing: core::ffi::c_double, - ) -> Vec; - fn r_fft_freq( - &mut self, - windowLength: core::ffi::c_int, - sampleSpacing: core::ffi::c_double, - ) -> Vec; fn hanning_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; fn bartlett_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; fn sine_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; @@ -83,115 +45,12 @@ pub trait VtkFFT { pub trait VtkFunctionSet { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn function_values( - &mut self, - x: core::ffi::c_double, - f: core::ffi::c_double, - ) -> core::ffi::c_int; - fn function_values( - &mut self, - x: core::ffi::c_double, - f: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; fn get_number_of_functions(&mut self) -> core::ffi::c_int; fn get_number_of_independent_variables(&mut self) -> core::ffi::c_int; } pub trait VtkInitialValueProblemSolver { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - ) -> core::ffi::c_int; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - dxprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - ) -> core::ffi::c_int; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - dxprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - delTActual: core::ffi::c_double, - minStep: core::ffi::c_double, - maxStep: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - ) -> core::ffi::c_int; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - delTActual: core::ffi::c_double, - minStep: core::ffi::c_double, - maxStep: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - dxprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - delTActual: core::ffi::c_double, - minStep: core::ffi::c_double, - maxStep: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - ) -> core::ffi::c_int; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - dxprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - delTActual: core::ffi::c_double, - minStep: core::ffi::c_double, - maxStep: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; fn set_function_set(&mut self, fset: *mut core::ffi::c_void) -> (); fn get_function_set(&mut self) -> *mut core::ffi::c_void; fn is_adaptive(&mut self) -> core::ffi::c_int; @@ -201,81 +60,26 @@ pub trait VtkMatrix3x3 { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn deep_copy(&mut self, source: *mut core::ffi::c_void) -> (); - fn deep_copy( - &mut self, - elements: core::ffi::c_double, - source: *mut core::ffi::c_void, - ) -> (); - fn deep_copy( - &mut self, - elements: core::ffi::c_double, - newElements: core::ffi::c_double, - ) -> (); - fn deep_copy(&mut self, elements: core::ffi::c_double) -> (); fn zero(&mut self) -> (); - fn zero(&mut self, elements: core::ffi::c_double) -> (); fn identity(&mut self) -> (); - fn identity(&mut self, elements: core::ffi::c_double) -> (); fn invert(&mut self, in_: *mut core::ffi::c_void, out: *mut core::ffi::c_void) -> (); - fn invert(&mut self) -> (); - fn invert( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> (); fn transpose( &mut self, in_: *mut core::ffi::c_void, out: *mut core::ffi::c_void, ) -> (); - fn transpose(&mut self) -> (); - fn transpose( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> (); - fn multiply_point(&mut self, in_: core::ffi::c_float, out: core::ffi::c_float) -> (); - fn multiply_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn multiply_point( - &mut self, - elements: core::ffi::c_double, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn multiply_point( - &mut self, - elements: core::ffi::c_double, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); fn multiply_3_x_3( &mut self, a: *mut core::ffi::c_void, b: *mut core::ffi::c_void, c: *mut core::ffi::c_void, ) -> (); - fn multiply_3_x_3( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ) -> (); fn adjoint( &mut self, in_: *mut core::ffi::c_void, out: *mut core::ffi::c_void, ) -> (); - fn adjoint( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> (); fn determinant(&mut self) -> core::ffi::c_double; - fn determinant(&mut self, elements: core::ffi::c_double) -> core::ffi::c_double; fn set_element( &mut self, i: core::ffi::c_int, @@ -288,104 +92,15 @@ pub trait VtkMatrix3x3 { j: core::ffi::c_int, ) -> core::ffi::c_double; fn is_identity(&mut self) -> bool; - fn get_data(&mut self) -> *mut core::ffi::c_double; - fn get_data(&mut self) -> *const core::ffi::c_double; } pub trait VtkMatrix4x4 { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn deep_copy(&mut self, source: vtkMatrix4x4) -> (); - fn deep_copy( - &mut self, - destination: core::ffi::c_double, - source: vtkMatrix4x4, - ) -> (); - fn deep_copy( - &mut self, - destination: core::ffi::c_double, - source: core::ffi::c_double, - ) -> (); - fn deep_copy(&mut self, elements: core::ffi::c_double) -> (); fn zero(&mut self) -> (); - fn zero(&mut self, elements: core::ffi::c_double) -> (); fn identity(&mut self) -> (); - fn identity(&mut self, elements: core::ffi::c_double) -> (); fn is_identity(&mut self) -> bool; - fn invert(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> (); - fn invert(&mut self) -> (); - fn invert( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> (); - fn transpose(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> (); - fn transpose(&mut self) -> (); - fn transpose( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> (); - fn multiply_point(&mut self, in_: core::ffi::c_float, out: core::ffi::c_float) -> (); - fn multiply_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn multiply_point( - &mut self, - elements: core::ffi::c_double, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn multiply_point( - &mut self, - elements: core::ffi::c_double, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn multiply_point(&mut self, in_: core::ffi::c_float) -> *mut core::ffi::c_float; - fn multiply_point(&mut self, in_: core::ffi::c_double) -> *mut core::ffi::c_double; - fn multiply_float_point( - &mut self, - in_: core::ffi::c_float, - ) -> *mut core::ffi::c_float; - fn multiply_double_point( - &mut self, - in_: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn multiply_4_x_4( - &mut self, - a: vtkMatrix4x4, - b: vtkMatrix4x4, - c: *mut core::ffi::c_void, - ) -> (); - fn multiply_4_x_4( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ) -> (); - fn multiply_4_x_4( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_float, - ) -> (); - fn multiply_and_transpose_4_x_4( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_float, - ) -> (); - fn adjoint(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> (); - fn adjoint( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> (); fn determinant(&mut self) -> core::ffi::c_double; - fn determinant(&mut self, elements: core::ffi::c_double) -> core::ffi::c_double; fn set_element( &mut self, i: core::ffi::c_int, @@ -397,183 +112,21 @@ pub trait VtkMatrix4x4 { i: core::ffi::c_int, j: core::ffi::c_int, ) -> core::ffi::c_double; - fn get_data(&mut self) -> *mut core::ffi::c_double; - fn get_data(&mut self) -> *const core::ffi::c_double; } pub trait VtkPolynomialSolversUnivariate { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn habicht_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - ) -> core::ffi::c_int; - fn habicht_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - ) -> core::ffi::c_int; - fn habicht_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - divideGCD: bool, - ) -> core::ffi::c_int; - fn sturm_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - ) -> core::ffi::c_int; - fn sturm_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - ) -> core::ffi::c_int; - fn sturm_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - divideGCD: bool, - ) -> core::ffi::c_int; - fn filter_roots( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - upperBnds: core::ffi::c_double, - rootcount: core::ffi::c_int, - diameter: core::ffi::c_double, - ) -> core::ffi::c_int; - fn lin_bairstow_solve( - &mut self, - c: core::ffi::c_double, - d: core::ffi::c_int, - r: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_int; - fn ferrari_solve( - &mut self, - c: core::ffi::c_double, - r: core::ffi::c_double, - m: core::ffi::c_int, - tol: core::ffi::c_double, - ) -> core::ffi::c_int; - fn tartaglia_cardan_solve( - &mut self, - c: core::ffi::c_double, - r: core::ffi::c_double, - m: core::ffi::c_int, - tol: core::ffi::c_double, - ) -> core::ffi::c_int; - fn solve_cubic( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn solve_quadratic( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn solve_linear( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn solve_cubic( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - r1: core::ffi::c_double, - r2: core::ffi::c_double, - r3: core::ffi::c_double, - num_roots: core::ffi::c_int, - ) -> core::ffi::c_int; - fn solve_quadratic( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - r1: core::ffi::c_double, - r2: core::ffi::c_double, - num_roots: core::ffi::c_int, - ) -> core::ffi::c_int; - fn solve_quadratic( - &mut self, - c: core::ffi::c_double, - r: core::ffi::c_double, - m: core::ffi::c_int, - ) -> core::ffi::c_int; - fn solve_linear( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - r1: core::ffi::c_double, - num_roots: core::ffi::c_int, - ) -> core::ffi::c_int; fn set_division_tolerance(&mut self, tol: core::ffi::c_double) -> (); fn get_division_tolerance(&mut self) -> core::ffi::c_double; } -pub trait VtkQuaternion: VtkTuple { - fn squared_norm(&mut self) -> *mut core::ffi::c_void; - fn norm(&mut self) -> *mut core::ffi::c_void; +pub trait VtkQuaternion { fn to_identity(&mut self) -> (); - fn normalize(&mut self) -> *mut core::ffi::c_void; fn conjugate(&mut self) -> (); fn invert(&mut self) -> (); fn to_unit_log(&mut self) -> (); fn to_unit_exp(&mut self) -> (); fn normalize_with_angle_in_degrees(&mut self) -> (); - fn set(&mut self, w: T, x: T, y: T, z: T) -> (); - fn set(&mut self, quat: *mut core::ffi::c_void) -> (); - fn get(&mut self, quat: *mut core::ffi::c_void) -> (); - fn set_w(&mut self, w: T) -> (); - fn get_w(&mut self) -> T; - fn set_x(&mut self, x: T) -> (); - fn get_x(&mut self) -> T; - fn set_y(&mut self, y: T) -> (); - fn get_y(&mut self) -> T; - fn set_z(&mut self, z: T) -> (); - fn get_z(&mut self) -> T; - fn get_rotation_angle_and_axis( - &mut self, - axis: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - fn set_rotation_angle_and_axis( - &mut self, - angle: *mut core::ffi::c_void, - axis: *mut core::ffi::c_void, - ) -> (); - fn set_rotation_angle_and_axis(&mut self, angle: T, x: T, y: T, z: T) -> (); - fn to_matrix_3_x_3(&mut self, A: *mut core::ffi::c_void) -> (); - fn from_matrix_3_x_3(&mut self, A: T) -> (); } pub trait VtkQuaternionInterpolator { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -583,19 +136,7 @@ pub trait VtkQuaternionInterpolator { fn get_minimum_t(&mut self) -> core::ffi::c_double; fn get_maximum_t(&mut self) -> core::ffi::c_double; fn initialize(&mut self) -> (); - fn add_quaternion(&mut self, t: core::ffi::c_double, q: vtkQuaterniond) -> (); - fn add_quaternion(&mut self, t: core::ffi::c_double, q: core::ffi::c_double) -> (); fn remove_quaternion(&mut self, t: core::ffi::c_double) -> (); - fn interpolate_quaternion( - &mut self, - t: core::ffi::c_double, - q: *mut core::ffi::c_void, - ) -> (); - fn interpolate_quaternion( - &mut self, - t: core::ffi::c_double, - q: core::ffi::c_double, - ) -> (); fn get_search_method(&mut self) -> core::ffi::c_int; fn set_search_method(&mut self, type_: core::ffi::c_int) -> (); fn set_interpolation_type(&mut self, _arg: core::ffi::c_int) -> (); @@ -605,187 +146,78 @@ pub trait VtkQuaternionInterpolator { fn set_interpolation_type_to_linear(&mut self) -> (); fn set_interpolation_type_to_spline(&mut self) -> (); } -pub trait VtkQuaterniond: VtkQuaternion + VtkTuple { - fn identity(&mut self) -> *mut core::ffi::c_void; - fn normalized(&mut self) -> *mut core::ffi::c_void; - fn conjugated(&mut self) -> *mut core::ffi::c_void; - fn inverse(&mut self) -> *mut core::ffi::c_void; - fn unit_log(&mut self) -> *mut core::ffi::c_void; - fn unit_exp(&mut self) -> *mut core::ffi::c_void; - fn normalized_with_angle_in_degrees(&mut self) -> *mut core::ffi::c_void; - fn slerp( - &mut self, - t: core::ffi::c_double, - q: vtkQuaterniond, - ) -> *mut core::ffi::c_void; - fn inner_point( - &mut self, - q1: vtkQuaterniond, - q2: vtkQuaterniond, - ) -> *mut core::ffi::c_void; +pub trait VtkQuaterniond { fn squared_norm(&mut self) -> core::ffi::c_double; fn norm(&mut self) -> core::ffi::c_double; fn normalize(&mut self) -> core::ffi::c_double; fn set( &mut self, - w: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, + w: &core::ffi::c_double, + x: &core::ffi::c_double, + y: &core::ffi::c_double, + z: &core::ffi::c_double, ) -> (); - fn set(&mut self, quat: core::ffi::c_double) -> (); - fn get(&mut self, quat: core::ffi::c_double) -> (); - fn set_w(&mut self, w: core::ffi::c_double) -> (); + fn set_w(&mut self, w: &core::ffi::c_double) -> (); fn get_w(&mut self) -> core::ffi::c_double; - fn set_x(&mut self, x: core::ffi::c_double) -> (); + fn set_x(&mut self, x: &core::ffi::c_double) -> (); fn get_x(&mut self) -> core::ffi::c_double; - fn set_y(&mut self, y: core::ffi::c_double) -> (); + fn set_y(&mut self, y: &core::ffi::c_double) -> (); fn get_y(&mut self) -> core::ffi::c_double; - fn set_z(&mut self, z: core::ffi::c_double) -> (); + fn set_z(&mut self, z: &core::ffi::c_double) -> (); fn get_z(&mut self) -> core::ffi::c_double; - fn get_rotation_angle_and_axis( - &mut self, - axis: core::ffi::c_double, - ) -> core::ffi::c_double; - fn set_rotation_angle_and_axis( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_double, - ) -> (); fn set_rotation_angle_and_axis( &mut self, - angle: core::ffi::c_double, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, + angle: &core::ffi::c_double, + x: &core::ffi::c_double, + y: &core::ffi::c_double, + z: &core::ffi::c_double, ) -> (); - fn to_matrix_3_x_3(&mut self, A: core::ffi::c_double) -> (); - fn from_matrix_3_x_3(&mut self, A: core::ffi::c_double) -> (); - fn get_data(&mut self) -> *mut core::ffi::c_double; - fn get_data(&mut self) -> *const core::ffi::c_double; } -pub trait VtkQuaternionf: VtkQuaternion + VtkTuple { - fn identity(&mut self) -> *mut core::ffi::c_void; - fn normalized(&mut self) -> *mut core::ffi::c_void; - fn conjugated(&mut self) -> *mut core::ffi::c_void; - fn inverse(&mut self) -> *mut core::ffi::c_void; - fn unit_log(&mut self) -> *mut core::ffi::c_void; - fn unit_exp(&mut self) -> *mut core::ffi::c_void; - fn normalized_with_angle_in_degrees(&mut self) -> *mut core::ffi::c_void; - fn slerp( - &mut self, - t: core::ffi::c_float, - q: vtkQuaternionf, - ) -> *mut core::ffi::c_void; - fn inner_point( - &mut self, - q1: vtkQuaternionf, - q2: vtkQuaternionf, - ) -> *mut core::ffi::c_void; +pub trait VtkQuaternionf { fn squared_norm(&mut self) -> core::ffi::c_float; fn norm(&mut self) -> core::ffi::c_float; fn normalize(&mut self) -> core::ffi::c_float; fn set( &mut self, - w: core::ffi::c_float, - x: core::ffi::c_float, - y: core::ffi::c_float, - z: core::ffi::c_float, + w: &core::ffi::c_float, + x: &core::ffi::c_float, + y: &core::ffi::c_float, + z: &core::ffi::c_float, ) -> (); - fn set(&mut self, quat: core::ffi::c_float) -> (); - fn get(&mut self, quat: core::ffi::c_float) -> (); - fn set_w(&mut self, w: core::ffi::c_float) -> (); + fn set_w(&mut self, w: &core::ffi::c_float) -> (); fn get_w(&mut self) -> core::ffi::c_float; - fn set_x(&mut self, x: core::ffi::c_float) -> (); + fn set_x(&mut self, x: &core::ffi::c_float) -> (); fn get_x(&mut self) -> core::ffi::c_float; - fn set_y(&mut self, y: core::ffi::c_float) -> (); + fn set_y(&mut self, y: &core::ffi::c_float) -> (); fn get_y(&mut self) -> core::ffi::c_float; - fn set_z(&mut self, z: core::ffi::c_float) -> (); + fn set_z(&mut self, z: &core::ffi::c_float) -> (); fn get_z(&mut self) -> core::ffi::c_float; - fn get_rotation_angle_and_axis( - &mut self, - axis: core::ffi::c_float, - ) -> core::ffi::c_float; - fn set_rotation_angle_and_axis( - &mut self, - angle: core::ffi::c_float, - axis: core::ffi::c_float, - ) -> (); fn set_rotation_angle_and_axis( &mut self, - angle: core::ffi::c_float, - x: core::ffi::c_float, - y: core::ffi::c_float, - z: core::ffi::c_float, + angle: &core::ffi::c_float, + x: &core::ffi::c_float, + y: &core::ffi::c_float, + z: &core::ffi::c_float, ) -> (); - fn to_matrix_3_x_3(&mut self, A: core::ffi::c_float) -> (); - fn from_matrix_3_x_3(&mut self, A: core::ffi::c_float) -> (); - fn get_data(&mut self) -> *mut core::ffi::c_float; - fn get_data(&mut self) -> *const core::ffi::c_float; } -pub trait VtkRungeKutta2: VtkInitialValueProblemSolver { +pub trait VtkRungeKutta2 { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; } -pub trait VtkRungeKutta4: VtkInitialValueProblemSolver { +pub trait VtkRungeKutta4 { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; } -pub trait VtkRungeKutta45: VtkInitialValueProblemSolver { +pub trait VtkRungeKutta45 { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - dxprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - delTActual: core::ffi::c_double, - minStep: core::ffi::c_double, - maxStep: core::ffi::c_double, - maxError: core::ffi::c_double, - estErr: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; } pub trait VtkTuple { fn get_size(&mut self) -> core::ffi::c_int; fn get_data(&mut self) -> *mut core::ffi::c_void; - fn get_data(&mut self) -> *const T; } impl VtkAmoebaMinimizer for vtkAmoebaMinimizer { fn new(&mut self) -> *mut core::ffi::c_void { @@ -813,16 +245,6 @@ impl VtkAmoebaMinimizer for vtkAmoebaMinimizer { } unsafe { vtk_amoeba_minimizer_new_instance(self.0) } } - fn set_function(&mut self, f: *mut core::ffi::c_void, arg: ()) -> () { - unsafe extern "C" { - fn vtk_amoeba_minimizer_set_function( - sself: *mut core::ffi::c_void, - f: *mut core::ffi::c_void, - arg: (), - ); - } - unsafe { vtk_amoeba_minimizer_set_function(self.0, f, arg) } - } fn set_function_arg_delete(&mut self, f: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_amoeba_minimizer_set_function_arg_delete( @@ -832,106 +254,64 @@ impl VtkAmoebaMinimizer for vtkAmoebaMinimizer { } unsafe { vtk_amoeba_minimizer_set_function_arg_delete(self.0, f) } } - fn set_parameter_value( - &mut self, - name: core::ffi::c_char, - value: core::ffi::c_double, - ) -> () { + fn set_parameter_value(&mut self, name: &str, value: core::ffi::c_double) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_amoeba_minimizer_set_parameter_value( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, value: core::ffi::c_double, ); } - unsafe { vtk_amoeba_minimizer_set_parameter_value(self.0, name, value) } - } - fn set_parameter_value( - &mut self, - i: core::ffi::c_int, - value: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_amoeba_minimizer_set_parameter_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - value: core::ffi::c_double, - ); + unsafe { + vtk_amoeba_minimizer_set_parameter_value(self.0, c_name.as_ptr(), value) } - unsafe { vtk_amoeba_minimizer_set_parameter_value(self.0, i, value) } } - fn set_parameter_scale( - &mut self, - name: core::ffi::c_char, - scale: core::ffi::c_double, - ) -> () { + fn set_parameter_scale(&mut self, name: &str, scale: core::ffi::c_double) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_amoeba_minimizer_set_parameter_scale( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, scale: core::ffi::c_double, ); } - unsafe { vtk_amoeba_minimizer_set_parameter_scale(self.0, name, scale) } - } - fn get_parameter_scale(&mut self, name: core::ffi::c_char) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_amoeba_minimizer_get_parameter_scale( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> core::ffi::c_double; - } - unsafe { vtk_amoeba_minimizer_get_parameter_scale(self.0, name) } - } - fn set_parameter_scale( - &mut self, - i: core::ffi::c_int, - scale: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_amoeba_minimizer_set_parameter_scale( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - scale: core::ffi::c_double, - ); + unsafe { + vtk_amoeba_minimizer_set_parameter_scale(self.0, c_name.as_ptr(), scale) } - unsafe { vtk_amoeba_minimizer_set_parameter_scale(self.0, i, scale) } } - fn get_parameter_scale(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { + fn get_parameter_scale(&mut self, name: &str) -> core::ffi::c_double { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_amoeba_minimizer_get_parameter_scale( sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> core::ffi::c_double; - } - unsafe { vtk_amoeba_minimizer_get_parameter_scale(self.0, i) } - } - fn get_parameter_value(&mut self, name: core::ffi::c_char) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_amoeba_minimizer_get_parameter_value( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_double; } - unsafe { vtk_amoeba_minimizer_get_parameter_value(self.0, name) } + unsafe { vtk_amoeba_minimizer_get_parameter_scale(self.0, c_name.as_ptr()) } } - fn get_parameter_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { + fn get_parameter_value(&mut self, name: &str) -> core::ffi::c_double { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_amoeba_minimizer_get_parameter_value( sself: *mut core::ffi::c_void, - i: core::ffi::c_int, + name: *const core::ffi::c_char, ) -> core::ffi::c_double; } - unsafe { vtk_amoeba_minimizer_get_parameter_value(self.0, i) } + unsafe { vtk_amoeba_minimizer_get_parameter_value(self.0, c_name.as_ptr()) } } - fn get_parameter_name(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char { + fn get_parameter_name(&mut self, i: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_amoeba_minimizer_get_parameter_name( sself: *mut core::ffi::c_void, i: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_amoeba_minimizer_get_parameter_name(self.0, i) } + let ptr = unsafe { vtk_amoeba_minimizer_get_parameter_name(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn get_number_of_parameters(&mut self) -> core::ffi::c_int { unsafe extern "C" { @@ -1142,97 +522,6 @@ impl VtkFFT for vtkFFT { } unsafe { vtk_fft_new_instance(self.0) } } - fn fft(&mut self, in_: Vec) -> Vec { - unsafe extern "C" { - fn vtk_fft_fft( - sself: *mut core::ffi::c_void, - in_: Vec, - ) -> Vec; - } - unsafe { vtk_fft_fft(self.0, in_) } - } - fn fft(&mut self, in_: Vec) -> Vec { - unsafe extern "C" { - fn vtk_fft_fft( - sself: *mut core::ffi::c_void, - in_: Vec, - ) -> Vec; - } - unsafe { vtk_fft_fft(self.0, in_) } - } - fn r_fft(&mut self, in_: Vec) -> Vec { - unsafe extern "C" { - fn vtk_fft_r_fft( - sself: *mut core::ffi::c_void, - in_: Vec, - ) -> Vec; - } - unsafe { vtk_fft_r_fft(self.0, in_) } - } - fn i_fft(&mut self, in_: Vec) -> Vec { - unsafe extern "C" { - fn vtk_fft_i_fft( - sself: *mut core::ffi::c_void, - in_: Vec, - ) -> Vec; - } - unsafe { vtk_fft_i_fft(self.0, in_) } - } - fn ir_fft(&mut self, in_: Vec) -> Vec { - unsafe extern "C" { - fn vtk_fft_ir_fft( - sself: *mut core::ffi::c_void, - in_: Vec, - ) -> Vec; - } - unsafe { vtk_fft_ir_fft(self.0, in_) } - } - fn abs(&mut self, in_: kiss_fft_cpx) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_fft_abs( - sself: *mut core::ffi::c_void, - in_: kiss_fft_cpx, - ) -> core::ffi::c_double; - } - unsafe { vtk_fft_abs(self.0, in_) } - } - fn squared_abs(&mut self, in_: kiss_fft_cpx) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_fft_squared_abs( - sself: *mut core::ffi::c_void, - in_: kiss_fft_cpx, - ) -> core::ffi::c_double; - } - unsafe { vtk_fft_squared_abs(self.0, in_) } - } - fn fft_freq( - &mut self, - windowLength: core::ffi::c_int, - sampleSpacing: core::ffi::c_double, - ) -> Vec { - unsafe extern "C" { - fn vtk_fft_fft_freq( - sself: *mut core::ffi::c_void, - windowLength: core::ffi::c_int, - sampleSpacing: core::ffi::c_double, - ) -> Vec; - } - unsafe { vtk_fft_fft_freq(self.0, windowLength, sampleSpacing) } - } - fn r_fft_freq( - &mut self, - windowLength: core::ffi::c_int, - sampleSpacing: core::ffi::c_double, - ) -> Vec { - unsafe extern "C" { - fn vtk_fft_r_fft_freq( - sself: *mut core::ffi::c_void, - windowLength: core::ffi::c_int, - sampleSpacing: core::ffi::c_double, - ) -> Vec; - } - unsafe { vtk_fft_r_fft_freq(self.0, windowLength, sampleSpacing) } - } fn hanning_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { unsafe extern "C" { fn vtk_fft_hanning_generator( @@ -1319,73 +608,18 @@ impl VtkMatrix3x3 for vtkMatrix3x3 { } unsafe { vtk_matrix_3_x_3_deep_copy(self.0, source) } } - fn deep_copy( - &mut self, - elements: core::ffi::c_double, - source: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_deep_copy( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - source: *mut core::ffi::c_void, - ); - } - unsafe { vtk_matrix_3_x_3_deep_copy(self.0, elements, source) } - } - fn deep_copy( - &mut self, - elements: core::ffi::c_double, - newElements: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_deep_copy( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - newElements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_deep_copy(self.0, elements, newElements) } - } - fn deep_copy(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_deep_copy( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_deep_copy(self.0, elements) } - } fn zero(&mut self) -> () { unsafe extern "C" { fn vtk_matrix_3_x_3_zero(sself: *mut core::ffi::c_void); } unsafe { vtk_matrix_3_x_3_zero(self.0) } } - fn zero(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_zero( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_zero(self.0, elements) } - } fn identity(&mut self) -> () { unsafe extern "C" { fn vtk_matrix_3_x_3_identity(sself: *mut core::ffi::c_void); } unsafe { vtk_matrix_3_x_3_identity(self.0) } } - fn identity(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_identity( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_identity(self.0, elements) } - } fn invert( &mut self, in_: *mut core::ffi::c_void, @@ -1400,26 +634,6 @@ impl VtkMatrix3x3 for vtkMatrix3x3 { } unsafe { vtk_matrix_3_x_3_invert(self.0, in_, out) } } - fn invert(&mut self) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_invert(sself: *mut core::ffi::c_void); - } - unsafe { vtk_matrix_3_x_3_invert(self.0) } - } - fn invert( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_invert( - sself: *mut core::ffi::c_void, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_invert(self.0, inElements, outElements) } - } fn transpose( &mut self, in_: *mut core::ffi::c_void, @@ -1434,86 +648,6 @@ impl VtkMatrix3x3 for vtkMatrix3x3 { } unsafe { vtk_matrix_3_x_3_transpose(self.0, in_, out) } } - fn transpose(&mut self) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_transpose(sself: *mut core::ffi::c_void); - } - unsafe { vtk_matrix_3_x_3_transpose(self.0) } - } - fn transpose( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_transpose( - sself: *mut core::ffi::c_void, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_transpose(self.0, inElements, outElements) } - } - fn multiply_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_multiply_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ); - } - unsafe { vtk_matrix_3_x_3_multiply_point(self.0, in_, out) } - } - fn multiply_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_multiply_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_multiply_point(self.0, in_, out) } - } - fn multiply_point( - &mut self, - elements: core::ffi::c_double, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_multiply_point( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ); - } - unsafe { vtk_matrix_3_x_3_multiply_point(self.0, elements, in_, out) } - } - fn multiply_point( - &mut self, - elements: core::ffi::c_double, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_multiply_point( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_multiply_point(self.0, elements, in_, out) } - } fn multiply_3_x_3( &mut self, a: *mut core::ffi::c_void, @@ -1530,22 +664,6 @@ impl VtkMatrix3x3 for vtkMatrix3x3 { } unsafe { vtk_matrix_3_x_3_multiply_3_x_3(self.0, a, b, c) } } - fn multiply_3_x_3( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_multiply_3_x_3( - sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_multiply_3_x_3(self.0, a, b, c) } - } fn adjoint( &mut self, in_: *mut core::ffi::c_void, @@ -1554,470 +672,19 @@ impl VtkMatrix3x3 for vtkMatrix3x3 { unsafe extern "C" { fn vtk_matrix_3_x_3_adjoint( sself: *mut core::ffi::c_void, - in_: *mut core::ffi::c_void, - out: *mut core::ffi::c_void, - ); - } - unsafe { vtk_matrix_3_x_3_adjoint(self.0, in_, out) } - } - fn adjoint( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_adjoint( - sself: *mut core::ffi::c_void, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_adjoint(self.0, inElements, outElements) } - } - fn determinant(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_matrix_3_x_3_determinant( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_matrix_3_x_3_determinant(self.0) } - } - fn determinant(&mut self, elements: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_matrix_3_x_3_determinant( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ) -> core::ffi::c_double; - } - unsafe { vtk_matrix_3_x_3_determinant(self.0, elements) } - } - fn set_element( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - value: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_3_x_3_set_element( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - value: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_3_x_3_set_element(self.0, i, j, value) } - } - fn get_element( - &mut self, - i: core::ffi::c_int, - j: core::ffi::c_int, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_matrix_3_x_3_get_element( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - j: core::ffi::c_int, - ) -> core::ffi::c_double; - } - unsafe { vtk_matrix_3_x_3_get_element(self.0, i, j) } - } - fn is_identity(&mut self) -> bool { - unsafe extern "C" { - fn vtk_matrix_3_x_3_is_identity(sself: *mut core::ffi::c_void) -> bool; - } - unsafe { vtk_matrix_3_x_3_is_identity(self.0) } - } - fn get_data(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_matrix_3_x_3_get_data( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_matrix_3_x_3_get_data(self.0) } - } - fn get_data(&mut self) -> *const core::ffi::c_double { - unsafe extern "C" { - fn vtk_matrix_3_x_3_get_data( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; - } - unsafe { vtk_matrix_3_x_3_get_data(self.0) } - } -} -impl VtkMatrix4x4 for vtkMatrix4x4 { - fn new(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_matrix_4_x_4_new( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_matrix_4_x_4_new(self.0) } - } - fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_matrix_4_x_4_safe_down_cast( - sself: *mut core::ffi::c_void, - o: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_matrix_4_x_4_safe_down_cast(self.0, o) } - } - fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_matrix_4_x_4_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_matrix_4_x_4_new_instance(self.0) } - } - fn deep_copy(&mut self, source: vtkMatrix4x4) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_deep_copy( - sself: *mut core::ffi::c_void, - source: vtkMatrix4x4, - ); - } - unsafe { vtk_matrix_4_x_4_deep_copy(self.0, source) } - } - fn deep_copy( - &mut self, - destination: core::ffi::c_double, - source: vtkMatrix4x4, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_deep_copy( - sself: *mut core::ffi::c_void, - destination: core::ffi::c_double, - source: vtkMatrix4x4, - ); - } - unsafe { vtk_matrix_4_x_4_deep_copy(self.0, destination, source) } - } - fn deep_copy( - &mut self, - destination: core::ffi::c_double, - source: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_deep_copy( - sself: *mut core::ffi::c_void, - destination: core::ffi::c_double, - source: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_4_x_4_deep_copy(self.0, destination, source) } - } - fn deep_copy(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_deep_copy( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_4_x_4_deep_copy(self.0, elements) } - } - fn zero(&mut self) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_zero(sself: *mut core::ffi::c_void); - } - unsafe { vtk_matrix_4_x_4_zero(self.0) } - } - fn zero(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_zero( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_4_x_4_zero(self.0, elements) } - } - fn identity(&mut self) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_identity(sself: *mut core::ffi::c_void); - } - unsafe { vtk_matrix_4_x_4_identity(self.0) } - } - fn identity(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_identity( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_4_x_4_identity(self.0, elements) } - } - fn is_identity(&mut self) -> bool { - unsafe extern "C" { - fn vtk_matrix_4_x_4_is_identity(sself: *mut core::ffi::c_void) -> bool; - } - unsafe { vtk_matrix_4_x_4_is_identity(self.0) } - } - fn invert(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_invert( - sself: *mut core::ffi::c_void, - in_: vtkMatrix4x4, - out: *mut core::ffi::c_void, - ); - } - unsafe { vtk_matrix_4_x_4_invert(self.0, in_, out) } - } - fn invert(&mut self) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_invert(sself: *mut core::ffi::c_void); - } - unsafe { vtk_matrix_4_x_4_invert(self.0) } - } - fn invert( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_invert( - sself: *mut core::ffi::c_void, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_4_x_4_invert(self.0, inElements, outElements) } - } - fn transpose(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_transpose( - sself: *mut core::ffi::c_void, - in_: vtkMatrix4x4, - out: *mut core::ffi::c_void, - ); - } - unsafe { vtk_matrix_4_x_4_transpose(self.0, in_, out) } - } - fn transpose(&mut self) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_transpose(sself: *mut core::ffi::c_void); - } - unsafe { vtk_matrix_4_x_4_transpose(self.0) } - } - fn transpose( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_transpose( - sself: *mut core::ffi::c_void, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_4_x_4_transpose(self.0, inElements, outElements) } - } - fn multiply_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ); - } - unsafe { vtk_matrix_4_x_4_multiply_point(self.0, in_, out) } - } - fn multiply_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_4_x_4_multiply_point(self.0, in_, out) } - } - fn multiply_point( - &mut self, - elements: core::ffi::c_double, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_point( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ); - } - unsafe { vtk_matrix_4_x_4_multiply_point(self.0, elements, in_, out) } - } - fn multiply_point( - &mut self, - elements: core::ffi::c_double, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_point( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_4_x_4_multiply_point(self.0, elements, in_, out) } - } - fn multiply_point(&mut self, in_: core::ffi::c_float) -> *mut core::ffi::c_float { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_float, - ) -> *mut core::ffi::c_float; - } - unsafe { vtk_matrix_4_x_4_multiply_point(self.0, in_) } - } - fn multiply_point(&mut self, in_: core::ffi::c_double) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_matrix_4_x_4_multiply_point(self.0, in_) } - } - fn multiply_float_point( - &mut self, - in_: core::ffi::c_float, - ) -> *mut core::ffi::c_float { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_float_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_float, - ) -> *mut core::ffi::c_float; - } - unsafe { vtk_matrix_4_x_4_multiply_float_point(self.0, in_) } - } - fn multiply_double_point( - &mut self, - in_: core::ffi::c_double, - ) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_double_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_matrix_4_x_4_multiply_double_point(self.0, in_) } - } - fn multiply_4_x_4( - &mut self, - a: vtkMatrix4x4, - b: vtkMatrix4x4, - c: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_4_x_4( - sself: *mut core::ffi::c_void, - a: vtkMatrix4x4, - b: vtkMatrix4x4, - c: *mut core::ffi::c_void, - ); - } - unsafe { vtk_matrix_4_x_4_multiply_4_x_4(self.0, a, b, c) } - } - fn multiply_4_x_4( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_4_x_4( - sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_double, - ); - } - unsafe { vtk_matrix_4_x_4_multiply_4_x_4(self.0, a, b, c) } - } - fn multiply_4_x_4( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_4_x_4( - sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_float, - ); - } - unsafe { vtk_matrix_4_x_4_multiply_4_x_4(self.0, a, b, c) } - } - fn multiply_and_transpose_4_x_4( - &mut self, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_multiply_and_transpose_4_x_4( - sself: *mut core::ffi::c_void, - a: core::ffi::c_double, - b: core::ffi::c_double, - c: core::ffi::c_float, - ); - } - unsafe { vtk_matrix_4_x_4_multiply_and_transpose_4_x_4(self.0, a, b, c) } - } - fn adjoint(&mut self, in_: vtkMatrix4x4, out: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_adjoint( - sself: *mut core::ffi::c_void, - in_: vtkMatrix4x4, - out: *mut core::ffi::c_void, - ); - } - unsafe { vtk_matrix_4_x_4_adjoint(self.0, in_, out) } - } - fn adjoint( - &mut self, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_matrix_4_x_4_adjoint( - sself: *mut core::ffi::c_void, - inElements: core::ffi::c_double, - outElements: core::ffi::c_double, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, ); } - unsafe { vtk_matrix_4_x_4_adjoint(self.0, inElements, outElements) } + unsafe { vtk_matrix_3_x_3_adjoint(self.0, in_, out) } } fn determinant(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_matrix_4_x_4_determinant( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_matrix_4_x_4_determinant(self.0) } - } - fn determinant(&mut self, elements: core::ffi::c_double) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_matrix_4_x_4_determinant( + fn vtk_matrix_3_x_3_determinant( sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, ) -> core::ffi::c_double; } - unsafe { vtk_matrix_4_x_4_determinant(self.0, elements) } + unsafe { vtk_matrix_3_x_3_determinant(self.0) } } fn set_element( &mut self, @@ -2026,14 +693,14 @@ impl VtkMatrix4x4 for vtkMatrix4x4 { value: core::ffi::c_double, ) -> () { unsafe extern "C" { - fn vtk_matrix_4_x_4_set_element( + fn vtk_matrix_3_x_3_set_element( sself: *mut core::ffi::c_void, i: core::ffi::c_int, j: core::ffi::c_int, value: core::ffi::c_double, ); } - unsafe { vtk_matrix_4_x_4_set_element(self.0, i, j, value) } + unsafe { vtk_matrix_3_x_3_set_element(self.0, i, j, value) } } fn get_element( &mut self, @@ -2041,501 +708,129 @@ impl VtkMatrix4x4 for vtkMatrix4x4 { j: core::ffi::c_int, ) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_matrix_4_x_4_get_element( + fn vtk_matrix_3_x_3_get_element( sself: *mut core::ffi::c_void, i: core::ffi::c_int, j: core::ffi::c_int, ) -> core::ffi::c_double; } - unsafe { vtk_matrix_4_x_4_get_element(self.0, i, j) } - } - fn get_data(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_matrix_4_x_4_get_data( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_matrix_4_x_4_get_data(self.0) } + unsafe { vtk_matrix_3_x_3_get_element(self.0, i, j) } } - fn get_data(&mut self) -> *const core::ffi::c_double { + fn is_identity(&mut self) -> bool { unsafe extern "C" { - fn vtk_matrix_4_x_4_get_data( - sself: *mut core::ffi::c_void, - ) -> *const core::ffi::c_double; + fn vtk_matrix_3_x_3_is_identity(sself: *mut core::ffi::c_void) -> bool; } - unsafe { vtk_matrix_4_x_4_get_data(self.0) } + unsafe { vtk_matrix_3_x_3_is_identity(self.0) } } } -impl VtkPolynomialSolversUnivariate for vtkPolynomialSolversUnivariate { +impl VtkMatrix4x4 for vtkMatrix4x4 { fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_new( + fn vtk_matrix_4_x_4_new( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_polynomial_solvers_univariate_new(self.0) } + unsafe { vtk_matrix_4_x_4_new(self.0) } } fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_safe_down_cast( + fn vtk_matrix_4_x_4_safe_down_cast( sself: *mut core::ffi::c_void, o: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_polynomial_solvers_univariate_safe_down_cast(self.0, o) } + unsafe { vtk_matrix_4_x_4_safe_down_cast(self.0, o) } } fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_new_instance( + fn vtk_matrix_4_x_4_new_instance( sself: *mut core::ffi::c_void, ) -> *mut core::ffi::c_void; } - unsafe { vtk_polynomial_solvers_univariate_new_instance(self.0) } - } - fn habicht_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_habicht_bisection_solve( - sself: *mut core::ffi::c_void, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_habicht_bisection_solve( - self.0, - P, - d, - a, - upperBnds, - tol, - ) - } + unsafe { vtk_matrix_4_x_4_new_instance(self.0) } } - fn habicht_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_habicht_bisection_solve( - sself: *mut core::ffi::c_void, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_habicht_bisection_solve( - self.0, - P, - d, - a, - upperBnds, - tol, - intervalType, - ) - } - } - fn habicht_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - divideGCD: bool, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_habicht_bisection_solve( - sself: *mut core::ffi::c_void, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - divideGCD: bool, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_habicht_bisection_solve( - self.0, - P, - d, - a, - upperBnds, - tol, - intervalType, - divideGCD, - ) - } - } - fn sturm_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_sturm_bisection_solve( - sself: *mut core::ffi::c_void, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_sturm_bisection_solve( - self.0, - P, - d, - a, - upperBnds, - tol, - ) + fn zero(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_zero(sself: *mut core::ffi::c_void); } + unsafe { vtk_matrix_4_x_4_zero(self.0) } } - fn sturm_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_sturm_bisection_solve( - sself: *mut core::ffi::c_void, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_sturm_bisection_solve( - self.0, - P, - d, - a, - upperBnds, - tol, - intervalType, - ) - } - } - fn sturm_bisection_solve( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - divideGCD: bool, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_sturm_bisection_solve( - sself: *mut core::ffi::c_void, - P: core::ffi::c_double, - d: core::ffi::c_int, - a: core::ffi::c_double, - upperBnds: core::ffi::c_double, - tol: core::ffi::c_double, - intervalType: core::ffi::c_int, - divideGCD: bool, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_sturm_bisection_solve( - self.0, - P, - d, - a, - upperBnds, - tol, - intervalType, - divideGCD, - ) - } - } - fn filter_roots( - &mut self, - P: core::ffi::c_double, - d: core::ffi::c_int, - upperBnds: core::ffi::c_double, - rootcount: core::ffi::c_int, - diameter: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_filter_roots( - sself: *mut core::ffi::c_void, - P: core::ffi::c_double, - d: core::ffi::c_int, - upperBnds: core::ffi::c_double, - rootcount: core::ffi::c_int, - diameter: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_filter_roots( - self.0, - P, - d, - upperBnds, - rootcount, - diameter, - ) + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_identity(sself: *mut core::ffi::c_void); } + unsafe { vtk_matrix_4_x_4_identity(self.0) } } - fn lin_bairstow_solve( - &mut self, - c: core::ffi::c_double, - d: core::ffi::c_int, - r: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_lin_bairstow_solve( - sself: *mut core::ffi::c_void, - c: core::ffi::c_double, - d: core::ffi::c_int, - r: core::ffi::c_double, - tolerance: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_lin_bairstow_solve( - self.0, - c, - d, - r, - tolerance, - ) + fn is_identity(&mut self) -> bool { + unsafe extern "C" { + fn vtk_matrix_4_x_4_is_identity(sself: *mut core::ffi::c_void) -> bool; } + unsafe { vtk_matrix_4_x_4_is_identity(self.0) } } - fn ferrari_solve( - &mut self, - c: core::ffi::c_double, - r: core::ffi::c_double, - m: core::ffi::c_int, - tol: core::ffi::c_double, - ) -> core::ffi::c_int { + fn determinant(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_ferrari_solve( + fn vtk_matrix_4_x_4_determinant( sself: *mut core::ffi::c_void, - c: core::ffi::c_double, - r: core::ffi::c_double, - m: core::ffi::c_int, - tol: core::ffi::c_double, - ) -> core::ffi::c_int; + ) -> core::ffi::c_double; } - unsafe { vtk_polynomial_solvers_univariate_ferrari_solve(self.0, c, r, m, tol) } + unsafe { vtk_matrix_4_x_4_determinant(self.0) } } - fn tartaglia_cardan_solve( + fn set_element( &mut self, - c: core::ffi::c_double, - r: core::ffi::c_double, - m: core::ffi::c_int, - tol: core::ffi::c_double, - ) -> core::ffi::c_int { + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_tartaglia_cardan_solve( + fn vtk_matrix_4_x_4_set_element( sself: *mut core::ffi::c_void, - c: core::ffi::c_double, - r: core::ffi::c_double, - m: core::ffi::c_int, - tol: core::ffi::c_double, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_tartaglia_cardan_solve( - self.0, - c, - r, - m, - tol, - ) + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ); } + unsafe { vtk_matrix_4_x_4_set_element(self.0, i, j, value) } } - fn solve_cubic( + fn get_element( &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - ) -> *mut core::ffi::c_double { + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_solve_cubic( + fn vtk_matrix_4_x_4_get_element( sself: *mut core::ffi::c_void, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - ) -> *mut core::ffi::c_double; + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double; } - unsafe { vtk_polynomial_solvers_univariate_solve_cubic(self.0, c0, c1, c2, c3) } + unsafe { vtk_matrix_4_x_4_get_element(self.0, i, j) } } - fn solve_quadratic( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - ) -> *mut core::ffi::c_double { +} +impl VtkPolynomialSolversUnivariate for vtkPolynomialSolversUnivariate { + fn new(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_solve_quadratic( + fn vtk_polynomial_solvers_univariate_new( sself: *mut core::ffi::c_void, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - ) -> *mut core::ffi::c_double; + ) -> *mut core::ffi::c_void; } - unsafe { vtk_polynomial_solvers_univariate_solve_quadratic(self.0, c0, c1, c2) } + unsafe { vtk_polynomial_solvers_univariate_new(self.0) } } - fn solve_linear( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - ) -> *mut core::ffi::c_double { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_solve_linear( + fn vtk_polynomial_solvers_univariate_safe_down_cast( sself: *mut core::ffi::c_void, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - ) -> *mut core::ffi::c_double; + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_polynomial_solvers_univariate_solve_linear(self.0, c0, c1) } + unsafe { vtk_polynomial_solvers_univariate_safe_down_cast(self.0, o) } } - fn solve_cubic( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - r1: core::ffi::c_double, - r2: core::ffi::c_double, - r3: core::ffi::c_double, - num_roots: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_solve_cubic( - sself: *mut core::ffi::c_void, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - c3: core::ffi::c_double, - r1: core::ffi::c_double, - r2: core::ffi::c_double, - r3: core::ffi::c_double, - num_roots: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_solve_cubic( - self.0, - c0, - c1, - c2, - c3, - r1, - r2, - r3, - num_roots, - ) - } - } - fn solve_quadratic( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - r1: core::ffi::c_double, - r2: core::ffi::c_double, - num_roots: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_solve_quadratic( - sself: *mut core::ffi::c_void, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - c2: core::ffi::c_double, - r1: core::ffi::c_double, - r2: core::ffi::c_double, - num_roots: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_solve_quadratic( - self.0, - c0, - c1, - c2, - r1, - r2, - num_roots, - ) - } - } - fn solve_quadratic( - &mut self, - c: core::ffi::c_double, - r: core::ffi::c_double, - m: core::ffi::c_int, - ) -> core::ffi::c_int { + fn new_instance(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_solve_quadratic( + fn vtk_polynomial_solvers_univariate_new_instance( sself: *mut core::ffi::c_void, - c: core::ffi::c_double, - r: core::ffi::c_double, - m: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { vtk_polynomial_solvers_univariate_solve_quadratic(self.0, c, r, m) } - } - fn solve_linear( - &mut self, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - r1: core::ffi::c_double, - num_roots: core::ffi::c_int, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_polynomial_solvers_univariate_solve_linear( - sself: *mut core::ffi::c_void, - c0: core::ffi::c_double, - c1: core::ffi::c_double, - r1: core::ffi::c_double, - num_roots: core::ffi::c_int, - ) -> core::ffi::c_int; - } - unsafe { - vtk_polynomial_solvers_univariate_solve_linear(self.0, c0, c1, r1, num_roots) + ) -> *mut core::ffi::c_void; } + unsafe { vtk_polynomial_solvers_univariate_new_instance(self.0) } } fn set_division_tolerance(&mut self, tol: core::ffi::c_double) -> () { unsafe extern "C" { @@ -2611,26 +906,6 @@ impl VtkQuaternionInterpolator for vtkQuaternionInterpolator { } unsafe { vtk_quaternion_interpolator_initialize(self.0) } } - fn add_quaternion(&mut self, t: core::ffi::c_double, q: vtkQuaterniond) -> () { - unsafe extern "C" { - fn vtk_quaternion_interpolator_add_quaternion( - sself: *mut core::ffi::c_void, - t: core::ffi::c_double, - q: vtkQuaterniond, - ); - } - unsafe { vtk_quaternion_interpolator_add_quaternion(self.0, t, q) } - } - fn add_quaternion(&mut self, t: core::ffi::c_double, q: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_quaternion_interpolator_add_quaternion( - sself: *mut core::ffi::c_void, - t: core::ffi::c_double, - q: core::ffi::c_double, - ); - } - unsafe { vtk_quaternion_interpolator_add_quaternion(self.0, t, q) } - } fn remove_quaternion(&mut self, t: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_quaternion_interpolator_remove_quaternion( @@ -2640,34 +915,6 @@ impl VtkQuaternionInterpolator for vtkQuaternionInterpolator { } unsafe { vtk_quaternion_interpolator_remove_quaternion(self.0, t) } } - fn interpolate_quaternion( - &mut self, - t: core::ffi::c_double, - q: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_quaternion_interpolator_interpolate_quaternion( - sself: *mut core::ffi::c_void, - t: core::ffi::c_double, - q: *mut core::ffi::c_void, - ); - } - unsafe { vtk_quaternion_interpolator_interpolate_quaternion(self.0, t, q) } - } - fn interpolate_quaternion( - &mut self, - t: core::ffi::c_double, - q: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_quaternion_interpolator_interpolate_quaternion( - sself: *mut core::ffi::c_void, - t: core::ffi::c_double, - q: core::ffi::c_double, - ); - } - unsafe { vtk_quaternion_interpolator_interpolate_quaternion(self.0, t, q) } - } fn get_search_method(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_quaternion_interpolator_get_search_method( @@ -2761,41 +1008,6 @@ impl VtkRungeKutta2 for vtkRungeKutta2 { } unsafe { vtk_runge_kutta_2_new(self.0) } } - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_runge_kutta_2_compute_next_step( - sself: *mut core::ffi::c_void, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; - } - unsafe { - vtk_runge_kutta_2_compute_next_step( - self.0, - xprev, - xnext, - t, - delT, - maxError, - error, - userData, - ) - } - } } impl VtkRungeKutta4 for vtkRungeKutta4 { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -2823,41 +1035,6 @@ impl VtkRungeKutta4 for vtkRungeKutta4 { } unsafe { vtk_runge_kutta_4_new(self.0) } } - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_runge_kutta_4_compute_next_step( - sself: *mut core::ffi::c_void, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; - } - unsafe { - vtk_runge_kutta_4_compute_next_step( - self.0, - xprev, - xnext, - t, - delT, - maxError, - error, - userData, - ) - } - } } impl VtkRungeKutta45 for vtkRungeKutta45 { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -2885,88 +1062,6 @@ impl VtkRungeKutta45 for vtkRungeKutta45 { } unsafe { vtk_runge_kutta_45_new(self.0) } } - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_runge_kutta_45_compute_next_step( - sself: *mut core::ffi::c_void, - xprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - maxError: core::ffi::c_double, - error: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; - } - unsafe { - vtk_runge_kutta_45_compute_next_step( - self.0, - xprev, - xnext, - t, - delT, - maxError, - error, - userData, - ) - } - } - fn compute_next_step( - &mut self, - xprev: core::ffi::c_double, - dxprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - delTActual: core::ffi::c_double, - minStep: core::ffi::c_double, - maxStep: core::ffi::c_double, - maxError: core::ffi::c_double, - estErr: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_runge_kutta_45_compute_next_step( - sself: *mut core::ffi::c_void, - xprev: core::ffi::c_double, - dxprev: core::ffi::c_double, - xnext: core::ffi::c_double, - t: core::ffi::c_double, - delT: core::ffi::c_double, - delTActual: core::ffi::c_double, - minStep: core::ffi::c_double, - maxStep: core::ffi::c_double, - maxError: core::ffi::c_double, - estErr: core::ffi::c_double, - userData: (), - ) -> core::ffi::c_int; - } - unsafe { - vtk_runge_kutta_45_compute_next_step( - self.0, - xprev, - dxprev, - xnext, - t, - delT, - delTActual, - minStep, - maxStep, - maxError, - estErr, - userData, - ) - } - } } /// nonlinear optimization with a simplex /// @@ -2982,22 +1077,13 @@ impl VtkRungeKutta45 for vtkRungeKutta45 { #[allow(non_camel_case_types)] pub struct vtkAmoebaMinimizer(*mut core::ffi::c_void); impl vtkAmoebaMinimizer { - /// Creates a new [vtkAmoebaMinimizer] wrapped inside `vtkNew` + /// Creates a new [vtkAmoebaMinimizer] via `vtkAmoebaMinimizer::New()` #[doc(alias = "vtkAmoebaMinimizer")] pub fn new() -> Self { unsafe extern "C" { fn vtkAmoebaMinimizer_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAmoebaMinimizer_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAmoebaMinimizer_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAmoebaMinimizer_get_ptr(self.0) } + Self(unsafe { vtkAmoebaMinimizer_new() }) } } impl std::default::Default for vtkAmoebaMinimizer { @@ -3017,12 +1103,8 @@ impl Drop for vtkAmoebaMinimizer { #[test] fn test_vtkAmoebaMinimizer_create_drop() { let obj = vtkAmoebaMinimizer::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAmoebaMinimizer(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// perform Discrete Fourier Transforms /// @@ -3038,20 +1120,13 @@ fn test_vtkAmoebaMinimizer_create_drop() { #[allow(non_camel_case_types)] pub struct vtkFFT(*mut core::ffi::c_void); impl vtkFFT { - /// Creates a new [vtkFFT] wrapped inside `vtkNew` + /// Creates a new [vtkFFT] via `vtkFFT::New()` #[doc(alias = "vtkFFT")] pub fn new() -> Self { unsafe extern "C" { fn vtkFFT_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkFFT_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkFFT_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkFFT_get_ptr(self.0) } + Self(unsafe { vtkFFT_new() }) } } impl std::default::Default for vtkFFT { @@ -3071,12 +1146,8 @@ impl Drop for vtkFFT { #[test] fn test_vtkFFT_create_drop() { let obj = vtkFFT::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkFFT(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate 3x3 transformation matrices /// @@ -3090,22 +1161,13 @@ fn test_vtkFFT_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMatrix3x3(*mut core::ffi::c_void); impl vtkMatrix3x3 { - /// Creates a new [vtkMatrix3x3] wrapped inside `vtkNew` + /// Creates a new [vtkMatrix3x3] via `vtkMatrix3x3::New()` #[doc(alias = "vtkMatrix3x3")] pub fn new() -> Self { unsafe extern "C" { fn vtkMatrix3x3_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMatrix3x3_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMatrix3x3_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMatrix3x3_get_ptr(self.0) } + Self(unsafe { vtkMatrix3x3_new() }) } } impl std::default::Default for vtkMatrix3x3 { @@ -3125,12 +1187,8 @@ impl Drop for vtkMatrix3x3 { #[test] fn test_vtkMatrix3x3_create_drop() { let obj = vtkMatrix3x3::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMatrix3x3(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate 4x4 transformation matrices /// @@ -3146,22 +1204,13 @@ fn test_vtkMatrix3x3_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMatrix4x4(*mut core::ffi::c_void); impl vtkMatrix4x4 { - /// Creates a new [vtkMatrix4x4] wrapped inside `vtkNew` + /// Creates a new [vtkMatrix4x4] via `vtkMatrix4x4::New()` #[doc(alias = "vtkMatrix4x4")] pub fn new() -> Self { unsafe extern "C" { fn vtkMatrix4x4_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMatrix4x4_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMatrix4x4_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMatrix4x4_get_ptr(self.0) } + Self(unsafe { vtkMatrix4x4_new() }) } } impl std::default::Default for vtkMatrix4x4 { @@ -3181,12 +1230,8 @@ impl Drop for vtkMatrix4x4 { #[test] fn test_vtkMatrix4x4_create_drop() { let obj = vtkMatrix4x4::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMatrix4x4(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// polynomial solvers /// @@ -3212,22 +1257,13 @@ fn test_vtkMatrix4x4_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolynomialSolversUnivariate(*mut core::ffi::c_void); impl vtkPolynomialSolversUnivariate { - /// Creates a new [vtkPolynomialSolversUnivariate] wrapped inside `vtkNew` + /// Creates a new [vtkPolynomialSolversUnivariate] via `vtkPolynomialSolversUnivariate::New()` #[doc(alias = "vtkPolynomialSolversUnivariate")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolynomialSolversUnivariate_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolynomialSolversUnivariate_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolynomialSolversUnivariate_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolynomialSolversUnivariate_get_ptr(self.0) } + Self(unsafe { vtkPolynomialSolversUnivariate_new() }) } } impl std::default::Default for vtkPolynomialSolversUnivariate { @@ -3247,12 +1283,8 @@ impl Drop for vtkPolynomialSolversUnivariate { #[test] fn test_vtkPolynomialSolversUnivariate_create_drop() { let obj = vtkPolynomialSolversUnivariate::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolynomialSolversUnivariate(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// interpolate a quaternion /// @@ -3294,22 +1326,13 @@ fn test_vtkPolynomialSolversUnivariate_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuaternionInterpolator(*mut core::ffi::c_void); impl vtkQuaternionInterpolator { - /// Creates a new [vtkQuaternionInterpolator] wrapped inside `vtkNew` + /// Creates a new [vtkQuaternionInterpolator] via `vtkQuaternionInterpolator::New()` #[doc(alias = "vtkQuaternionInterpolator")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuaternionInterpolator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuaternionInterpolator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuaternionInterpolator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuaternionInterpolator_get_ptr(self.0) } + Self(unsafe { vtkQuaternionInterpolator_new() }) } } impl std::default::Default for vtkQuaternionInterpolator { @@ -3329,12 +1352,8 @@ impl Drop for vtkQuaternionInterpolator { #[test] fn test_vtkQuaternionInterpolator_create_drop() { let obj = vtkQuaternionInterpolator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuaternionInterpolator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Integrate an initial value problem using 2nd /// @@ -3350,22 +1369,13 @@ fn test_vtkQuaternionInterpolator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRungeKutta2(*mut core::ffi::c_void); impl vtkRungeKutta2 { - /// Creates a new [vtkRungeKutta2] wrapped inside `vtkNew` + /// Creates a new [vtkRungeKutta2] via `vtkRungeKutta2::New()` #[doc(alias = "vtkRungeKutta2")] pub fn new() -> Self { unsafe extern "C" { fn vtkRungeKutta2_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRungeKutta2_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRungeKutta2_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRungeKutta2_get_ptr(self.0) } + Self(unsafe { vtkRungeKutta2_new() }) } } impl std::default::Default for vtkRungeKutta2 { @@ -3385,12 +1395,8 @@ impl Drop for vtkRungeKutta2 { #[test] fn test_vtkRungeKutta2_create_drop() { let obj = vtkRungeKutta2::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRungeKutta2(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Integrate an initial value problem using 4th /// @@ -3406,22 +1412,13 @@ fn test_vtkRungeKutta2_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRungeKutta4(*mut core::ffi::c_void); impl vtkRungeKutta4 { - /// Creates a new [vtkRungeKutta4] wrapped inside `vtkNew` + /// Creates a new [vtkRungeKutta4] via `vtkRungeKutta4::New()` #[doc(alias = "vtkRungeKutta4")] pub fn new() -> Self { unsafe extern "C" { fn vtkRungeKutta4_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRungeKutta4_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRungeKutta4_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRungeKutta4_get_ptr(self.0) } + Self(unsafe { vtkRungeKutta4_new() }) } } impl std::default::Default for vtkRungeKutta4 { @@ -3441,12 +1438,8 @@ impl Drop for vtkRungeKutta4 { #[test] fn test_vtkRungeKutta4_create_drop() { let obj = vtkRungeKutta4::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRungeKutta4(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Integrate an initial value problem using 5th /// @@ -3468,22 +1461,13 @@ fn test_vtkRungeKutta4_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRungeKutta45(*mut core::ffi::c_void); impl vtkRungeKutta45 { - /// Creates a new [vtkRungeKutta45] wrapped inside `vtkNew` + /// Creates a new [vtkRungeKutta45] via `vtkRungeKutta45::New()` #[doc(alias = "vtkRungeKutta45")] pub fn new() -> Self { unsafe extern "C" { fn vtkRungeKutta45_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRungeKutta45_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRungeKutta45_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRungeKutta45_get_ptr(self.0) } + Self(unsafe { vtkRungeKutta45_new() }) } } impl std::default::Default for vtkRungeKutta45 { @@ -3503,10 +1487,6 @@ impl Drop for vtkRungeKutta45 { #[test] fn test_vtkRungeKutta45_create_drop() { let obj = vtkRungeKutta45::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRungeKutta45(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonMisc.rs b/vtk-rs-9.1/src/vtkCommonMisc.rs index 63eea59..e786c47 100644 --- a/vtk-rs-9.1/src/vtkCommonMisc.rs +++ b/vtk-rs-9.1/src/vtkCommonMisc.rs @@ -4,15 +4,8 @@ pub trait VtkContourValues { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn set_value(&mut self, i: core::ffi::c_int, value: core::ffi::c_double) -> (); fn get_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; - fn get_values(&mut self) -> *mut core::ffi::c_double; - fn get_values(&mut self, contourValues: core::ffi::c_double) -> (); fn set_number_of_contours(&mut self, number: core::ffi::c_int) -> (); fn get_number_of_contours(&mut self) -> core::ffi::c_int; - fn generate_values( - &mut self, - numContours: core::ffi::c_int, - range: core::ffi::c_double, - ) -> (); fn generate_values( &mut self, numContours: core::ffi::c_int, @@ -22,14 +15,8 @@ pub trait VtkContourValues { fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); } pub trait VtkErrorCode { - fn get_string_from_error_code( - &mut self, - error: core::ffi::c_ulong, - ) -> *const core::ffi::c_char; - fn get_error_code_from_string( - &mut self, - error: core::ffi::c_char, - ) -> core::ffi::c_ulong; + fn get_string_from_error_code(&mut self, error: core::ffi::c_ulong) -> &str; + fn get_error_code_from_string(&mut self, error: &str) -> core::ffi::c_ulong; fn get_last_system_error(&mut self) -> core::ffi::c_ulong; } pub trait VtkExprTkFunctionParser { @@ -37,77 +24,30 @@ pub trait VtkExprTkFunctionParser { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_m_time(&mut self) -> core::ffi::c_ulong; - fn set_function(&mut self, function: core::ffi::c_char) -> (); - fn get_function(&mut self) -> *const core::ffi::c_char; + fn set_function(&mut self, function: &str) -> (); + fn get_function(&mut self) -> &str; fn is_scalar_result(&mut self) -> core::ffi::c_int; fn is_vector_result(&mut self) -> core::ffi::c_int; fn get_scalar_result(&mut self) -> core::ffi::c_double; - fn get_vector_result(&mut self) -> *mut core::ffi::c_double; - fn get_vector_result(&mut self, result: core::ffi::c_double) -> (); fn set_scalar_variable_value( &mut self, variableName: &str, value: core::ffi::c_double, ) -> (); - fn set_scalar_variable_value( - &mut self, - i: core::ffi::c_int, - value: core::ffi::c_double, - ) -> (); fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double; - fn get_scalar_variable_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; - fn set_vector_variable_value( - &mut self, - variableName: &str, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ) -> (); fn set_vector_variable_value( &mut self, variableName: &str, - values: core::ffi::c_double, - ) -> (); - fn set_vector_variable_value( - &mut self, - i: core::ffi::c_int, xValue: core::ffi::c_double, yValue: core::ffi::c_double, zValue: core::ffi::c_double, ) -> (); - fn set_vector_variable_value( - &mut self, - i: core::ffi::c_int, - values: core::ffi::c_double, - ) -> (); - fn get_vector_variable_value( - &mut self, - variableName: &str, - ) -> *mut core::ffi::c_double; - fn get_vector_variable_value( - &mut self, - variableName: &str, - value: core::ffi::c_double, - ) -> (); - fn get_vector_variable_value( - &mut self, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_double; - fn get_vector_variable_value( - &mut self, - i: core::ffi::c_int, - value: core::ffi::c_double, - ) -> (); fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int; fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int; fn get_number_of_vector_variables(&mut self) -> core::ffi::c_int; fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int; - fn get_scalar_variable_name(&mut self, i: core::ffi::c_int) -> &str; - fn get_vector_variable_name(&mut self, i: core::ffi::c_int) -> &str; fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool; - fn get_scalar_variable_needed(&mut self, variableName: &str) -> bool; fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool; - fn get_vector_variable_needed(&mut self, variableName: &str) -> bool; fn remove_all_variables(&mut self) -> (); fn remove_scalar_variables(&mut self) -> (); fn remove_vector_variables(&mut self) -> (); @@ -118,124 +58,37 @@ pub trait VtkExprTkFunctionParser { fn set_replacement_value(&mut self, _arg: core::ffi::c_double) -> (); fn get_replacement_value(&mut self) -> core::ffi::c_double; fn invalidate_function(&mut self) -> (); - fn sanitize_name(&mut self, name: core::ffi::c_char) -> &str; } pub trait VtkFunctionParser { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_m_time(&mut self) -> core::ffi::c_ulong; - fn set_function(&mut self, function: core::ffi::c_char) -> (); - fn get_function(&mut self) -> *mut core::ffi::c_char; + fn set_function(&mut self, function: &str) -> (); fn is_scalar_result(&mut self) -> core::ffi::c_int; fn is_vector_result(&mut self) -> core::ffi::c_int; fn get_scalar_result(&mut self) -> core::ffi::c_double; - fn get_vector_result(&mut self) -> *mut core::ffi::c_double; - fn get_vector_result(&mut self, result: core::ffi::c_double) -> (); - fn set_scalar_variable_value( - &mut self, - variableName: core::ffi::c_char, - value: core::ffi::c_double, - ) -> (); fn set_scalar_variable_value( &mut self, variableName: &str, value: core::ffi::c_double, ) -> (); - fn set_scalar_variable_value( - &mut self, - i: core::ffi::c_int, - value: core::ffi::c_double, - ) -> (); - fn get_scalar_variable_value( - &mut self, - variableName: core::ffi::c_char, - ) -> core::ffi::c_double; fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double; - fn get_scalar_variable_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; - fn set_vector_variable_value( - &mut self, - variableName: core::ffi::c_char, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ) -> (); - fn set_vector_variable_value( - &mut self, - variableName: &str, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ) -> (); - fn set_vector_variable_value( - &mut self, - variableName: core::ffi::c_char, - values: core::ffi::c_double, - ) -> (); fn set_vector_variable_value( &mut self, variableName: &str, - values: core::ffi::c_double, - ) -> (); - fn set_vector_variable_value( - &mut self, - i: core::ffi::c_int, xValue: core::ffi::c_double, yValue: core::ffi::c_double, zValue: core::ffi::c_double, ) -> (); - fn set_vector_variable_value( - &mut self, - i: core::ffi::c_int, - values: core::ffi::c_double, - ) -> (); - fn get_vector_variable_value( - &mut self, - variableName: core::ffi::c_char, - ) -> *mut core::ffi::c_double; - fn get_vector_variable_value( - &mut self, - variableName: &str, - ) -> *mut core::ffi::c_double; - fn get_vector_variable_value( - &mut self, - variableName: core::ffi::c_char, - value: core::ffi::c_double, - ) -> (); - fn get_vector_variable_value( - &mut self, - variableName: &str, - value: core::ffi::c_double, - ) -> (); - fn get_vector_variable_value( - &mut self, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_double; - fn get_vector_variable_value( - &mut self, - i: core::ffi::c_int, - value: core::ffi::c_double, - ) -> (); fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int; - fn get_scalar_variable_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int; fn get_number_of_vector_variables(&mut self) -> core::ffi::c_int; - fn get_vector_variable_index(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int; - fn get_scalar_variable_name( - &mut self, - i: core::ffi::c_int, - ) -> *const core::ffi::c_char; - fn get_vector_variable_name( - &mut self, - i: core::ffi::c_int, - ) -> *const core::ffi::c_char; + fn get_scalar_variable_name(&mut self, i: core::ffi::c_int) -> &str; + fn get_vector_variable_name(&mut self, i: core::ffi::c_int) -> &str; fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool; - fn get_scalar_variable_needed(&mut self, variableName: core::ffi::c_char) -> bool; - fn get_scalar_variable_needed(&mut self, variableName: &str) -> bool; fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool; - fn get_vector_variable_needed(&mut self, variableName: core::ffi::c_char) -> bool; - fn get_vector_variable_needed(&mut self, variableName: &str) -> bool; fn remove_all_variables(&mut self) -> (); fn remove_scalar_variables(&mut self) -> (); fn remove_vector_variables(&mut self) -> (); @@ -245,27 +98,19 @@ pub trait VtkFunctionParser { fn replace_invalid_values_off(&mut self) -> (); fn set_replacement_value(&mut self, _arg: core::ffi::c_double) -> (); fn get_replacement_value(&mut self) -> core::ffi::c_double; - fn check_expression( - &mut self, - pos: core::ffi::c_int, - error: core::ffi::c_char, - ) -> (); fn invalidate_function(&mut self) -> (); } pub trait VtkHeap { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn allocate_memory(&mut self, n: usize) -> *mut (); fn set_block_size(&mut self, p0: usize) -> (); fn get_block_size(&mut self) -> usize; fn get_number_of_blocks(&mut self) -> core::ffi::c_int; fn get_number_of_allocations(&mut self) -> core::ffi::c_int; fn reset(&mut self) -> (); - fn string_dup(&mut self, str: core::ffi::c_char) -> *mut core::ffi::c_char; } pub trait VtkPolygonBuilder { - fn insert_triangle(&mut self, abc: core::ffi::c_uchar) -> (); fn get_polygons(&mut self, polys: *mut core::ffi::c_void) -> (); fn reset(&mut self) -> (); } @@ -279,19 +124,6 @@ pub trait VtkResourceFileLocator { fn print_debug_information_off(&mut self) -> (); fn set_log_verbosity(&mut self, _arg: core::ffi::c_int) -> (); fn get_log_verbosity(&mut self) -> core::ffi::c_int; - fn locate(&mut self, anchor: &str, landmark: &str, defaultDir: &str) -> &str; - fn locate( - &mut self, - anchor: &str, - landmark_prefixes: Vec, - landmark: &str, - defaultDir: &str, - ) -> &str; - fn get_library_path_for_symbol_unix( - &mut self, - symbolname: core::ffi::c_char, - ) -> &str; - fn get_library_path_for_symbol_win_32(&mut self, fptr: ()) -> &str; } impl VtkContourValues for vtkContourValues { fn new(&mut self) -> *mut core::ffi::c_void { @@ -338,23 +170,6 @@ impl VtkContourValues for vtkContourValues { } unsafe { vtk_contour_values_get_value(self.0, i) } } - fn get_values(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_contour_values_get_values( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_contour_values_get_values(self.0) } - } - fn get_values(&mut self, contourValues: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_contour_values_get_values( - sself: *mut core::ffi::c_void, - contourValues: core::ffi::c_double, - ); - } - unsafe { vtk_contour_values_get_values(self.0, contourValues) } - } fn set_number_of_contours(&mut self, number: core::ffi::c_int) -> () { unsafe extern "C" { fn vtk_contour_values_set_number_of_contours( @@ -372,20 +187,6 @@ impl VtkContourValues for vtkContourValues { } unsafe { vtk_contour_values_get_number_of_contours(self.0) } } - fn generate_values( - &mut self, - numContours: core::ffi::c_int, - range: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_contour_values_generate_values( - sself: *mut core::ffi::c_void, - numContours: core::ffi::c_int, - range: core::ffi::c_double, - ); - } - unsafe { vtk_contour_values_generate_values(self.0, numContours, range) } - } fn generate_values( &mut self, numContours: core::ffi::c_int, @@ -448,22 +249,27 @@ impl VtkExprTkFunctionParser for vtkExprTkFunctionParser { } unsafe { vtk_expr_tk_function_parser_get_m_time(self.0) } } - fn set_function(&mut self, function: core::ffi::c_char) -> () { + fn set_function(&mut self, function: &str) -> () { + let c_function = std::ffi::CString::new(function).expect("CString::new failed"); unsafe extern "C" { fn vtk_expr_tk_function_parser_set_function( sself: *mut core::ffi::c_void, - function: core::ffi::c_char, + function: *const core::ffi::c_char, ); } - unsafe { vtk_expr_tk_function_parser_set_function(self.0, function) } + unsafe { vtk_expr_tk_function_parser_set_function(self.0, c_function.as_ptr()) } } - fn get_function(&mut self) -> *const core::ffi::c_char { + fn get_function(&mut self) -> &str { unsafe extern "C" { fn vtk_expr_tk_function_parser_get_function( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_expr_tk_function_parser_get_function(self.0) } + let ptr = unsafe { vtk_expr_tk_function_parser_get_function(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn is_scalar_result(&mut self) -> core::ffi::c_int { unsafe extern "C" { @@ -489,23 +295,6 @@ impl VtkExprTkFunctionParser for vtkExprTkFunctionParser { } unsafe { vtk_expr_tk_function_parser_get_scalar_result(self.0) } } - fn get_vector_result(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_vector_result( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_expr_tk_function_parser_get_vector_result(self.0) } - } - fn get_vector_result(&mut self, result: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_vector_result( - sself: *mut core::ffi::c_void, - result: core::ffi::c_double, - ); - } - unsafe { vtk_expr_tk_function_parser_get_vector_result(self.0, result) } - } fn set_scalar_variable_value( &mut self, variableName: &str, @@ -528,22 +317,6 @@ impl VtkExprTkFunctionParser for vtkExprTkFunctionParser { ) } } - fn set_scalar_variable_value( - &mut self, - i: core::ffi::c_int, - value: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_set_scalar_variable_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - value: core::ffi::c_double, - ); - } - unsafe { - vtk_expr_tk_function_parser_set_scalar_variable_value(self.0, i, value) - } - } fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double { let c_variableName = std::ffi::CString::new(variableName) .expect("CString::new failed"); @@ -560,15 +333,6 @@ impl VtkExprTkFunctionParser for vtkExprTkFunctionParser { ) } } - fn get_scalar_variable_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_scalar_variable_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> core::ffi::c_double; - } - unsafe { vtk_expr_tk_function_parser_get_scalar_variable_value(self.0, i) } - } fn set_vector_variable_value( &mut self, variableName: &str, @@ -597,139 +361,6 @@ impl VtkExprTkFunctionParser for vtkExprTkFunctionParser { ) } } - fn set_vector_variable_value( - &mut self, - variableName: &str, - values: core::ffi::c_double, - ) -> () { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_expr_tk_function_parser_set_vector_variable_value( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - values: core::ffi::c_double, - ); - } - unsafe { - vtk_expr_tk_function_parser_set_vector_variable_value( - self.0, - c_variableName.as_ptr(), - values, - ) - } - } - fn set_vector_variable_value( - &mut self, - i: core::ffi::c_int, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_set_vector_variable_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ); - } - unsafe { - vtk_expr_tk_function_parser_set_vector_variable_value( - self.0, - i, - xValue, - yValue, - zValue, - ) - } - } - fn set_vector_variable_value( - &mut self, - i: core::ffi::c_int, - values: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_set_vector_variable_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - values: core::ffi::c_double, - ); - } - unsafe { - vtk_expr_tk_function_parser_set_vector_variable_value(self.0, i, values) - } - } - fn get_vector_variable_value( - &mut self, - variableName: &str, - ) -> *mut core::ffi::c_double { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_vector_variable_value( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - ) -> *mut core::ffi::c_double; - } - unsafe { - vtk_expr_tk_function_parser_get_vector_variable_value( - self.0, - c_variableName.as_ptr(), - ) - } - } - fn get_vector_variable_value( - &mut self, - variableName: &str, - value: core::ffi::c_double, - ) -> () { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_vector_variable_value( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - value: core::ffi::c_double, - ); - } - unsafe { - vtk_expr_tk_function_parser_get_vector_variable_value( - self.0, - c_variableName.as_ptr(), - value, - ) - } - } - fn get_vector_variable_value( - &mut self, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_vector_variable_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_expr_tk_function_parser_get_vector_variable_value(self.0, i) } - } - fn get_vector_variable_value( - &mut self, - i: core::ffi::c_int, - value: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_vector_variable_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - value: core::ffi::c_double, - ); - } - unsafe { - vtk_expr_tk_function_parser_get_vector_variable_value(self.0, i, value) - } - } fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int { unsafe extern "C" { fn vtk_expr_tk_function_parser_get_number_of_scalar_variables( @@ -776,61 +407,15 @@ impl VtkExprTkFunctionParser for vtkExprTkFunctionParser { ) } } - fn get_scalar_variable_name(&mut self, i: core::ffi::c_int) -> &str { + fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool { unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_scalar_variable_name( + fn vtk_expr_tk_function_parser_get_scalar_variable_needed( sself: *mut core::ffi::c_void, i: core::ffi::c_int, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { - vtk_expr_tk_function_parser_get_scalar_variable_name(self.0, i) - }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } - fn get_vector_variable_name(&mut self, i: core::ffi::c_int) -> &str { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_vector_variable_name( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { - vtk_expr_tk_function_parser_get_vector_variable_name(self.0, i) - }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } - fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_scalar_variable_needed( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> bool; + ) -> bool; } unsafe { vtk_expr_tk_function_parser_get_scalar_variable_needed(self.0, i) } } - fn get_scalar_variable_needed(&mut self, variableName: &str) -> bool { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_scalar_variable_needed( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - ) -> bool; - } - unsafe { - vtk_expr_tk_function_parser_get_scalar_variable_needed( - self.0, - c_variableName.as_ptr(), - ) - } - } fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool { unsafe extern "C" { fn vtk_expr_tk_function_parser_get_vector_variable_needed( @@ -840,22 +425,6 @@ impl VtkExprTkFunctionParser for vtkExprTkFunctionParser { } unsafe { vtk_expr_tk_function_parser_get_vector_variable_needed(self.0, i) } } - fn get_vector_variable_needed(&mut self, variableName: &str) -> bool { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_expr_tk_function_parser_get_vector_variable_needed( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - ) -> bool; - } - unsafe { - vtk_expr_tk_function_parser_get_vector_variable_needed( - self.0, - c_variableName.as_ptr(), - ) - } - } fn remove_all_variables(&mut self) -> () { unsafe extern "C" { fn vtk_expr_tk_function_parser_remove_all_variables( @@ -938,19 +507,6 @@ impl VtkExprTkFunctionParser for vtkExprTkFunctionParser { } unsafe { vtk_expr_tk_function_parser_invalidate_function(self.0) } } - fn sanitize_name(&mut self, name: core::ffi::c_char) -> &str { - unsafe extern "C" { - fn vtk_expr_tk_function_parser_sanitize_name( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { vtk_expr_tk_function_parser_sanitize_name(self.0, name) }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } } impl VtkFunctionParser for vtkFunctionParser { fn new(&mut self) -> *mut core::ffi::c_void { @@ -971,348 +527,56 @@ impl VtkFunctionParser for vtkFunctionParser { unsafe { vtk_function_parser_safe_down_cast(self.0, o) } } fn new_instance(&mut self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_function_parser_new_instance( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_function_parser_new_instance(self.0) } - } - fn get_m_time(&mut self) -> core::ffi::c_ulong { - unsafe extern "C" { - fn vtk_function_parser_get_m_time( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_ulong; - } - unsafe { vtk_function_parser_get_m_time(self.0) } - } - fn set_function(&mut self, function: core::ffi::c_char) -> () { - unsafe extern "C" { - fn vtk_function_parser_set_function( - sself: *mut core::ffi::c_void, - function: core::ffi::c_char, - ); - } - unsafe { vtk_function_parser_set_function(self.0, function) } - } - fn get_function(&mut self) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_function_parser_get_function( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_function_parser_get_function(self.0) } - } - fn is_scalar_result(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_function_parser_is_scalar_result( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_function_parser_is_scalar_result(self.0) } - } - fn is_vector_result(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_function_parser_is_vector_result( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_function_parser_is_vector_result(self.0) } - } - fn get_scalar_result(&mut self) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_function_parser_get_scalar_result( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_double; - } - unsafe { vtk_function_parser_get_scalar_result(self.0) } - } - fn get_vector_result(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_function_parser_get_vector_result( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_function_parser_get_vector_result(self.0) } - } - fn get_vector_result(&mut self, result: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_function_parser_get_vector_result( - sself: *mut core::ffi::c_void, - result: core::ffi::c_double, - ); - } - unsafe { vtk_function_parser_get_vector_result(self.0, result) } - } - fn set_scalar_variable_value( - &mut self, - variableName: core::ffi::c_char, - value: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_function_parser_set_scalar_variable_value( - sself: *mut core::ffi::c_void, - variableName: core::ffi::c_char, - value: core::ffi::c_double, - ); - } - unsafe { - vtk_function_parser_set_scalar_variable_value(self.0, variableName, value) - } - } - fn set_scalar_variable_value( - &mut self, - variableName: &str, - value: core::ffi::c_double, - ) -> () { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_function_parser_set_scalar_variable_value( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - value: core::ffi::c_double, - ); - } - unsafe { - vtk_function_parser_set_scalar_variable_value( - self.0, - c_variableName.as_ptr(), - value, - ) - } - } - fn set_scalar_variable_value( - &mut self, - i: core::ffi::c_int, - value: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_function_parser_set_scalar_variable_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - value: core::ffi::c_double, - ); - } - unsafe { vtk_function_parser_set_scalar_variable_value(self.0, i, value) } - } - fn get_scalar_variable_value( - &mut self, - variableName: core::ffi::c_char, - ) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_function_parser_get_scalar_variable_value( - sself: *mut core::ffi::c_void, - variableName: core::ffi::c_char, - ) -> core::ffi::c_double; - } - unsafe { vtk_function_parser_get_scalar_variable_value(self.0, variableName) } - } - fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_function_parser_get_scalar_variable_value( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - ) -> core::ffi::c_double; - } - unsafe { - vtk_function_parser_get_scalar_variable_value( - self.0, - c_variableName.as_ptr(), - ) - } - } - fn get_scalar_variable_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { - unsafe extern "C" { - fn vtk_function_parser_get_scalar_variable_value( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> core::ffi::c_double; - } - unsafe { vtk_function_parser_get_scalar_variable_value(self.0, i) } - } - fn set_vector_variable_value( - &mut self, - variableName: core::ffi::c_char, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_function_parser_set_vector_variable_value( - sself: *mut core::ffi::c_void, - variableName: core::ffi::c_char, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ); - } - unsafe { - vtk_function_parser_set_vector_variable_value( - self.0, - variableName, - xValue, - yValue, - zValue, - ) - } - } - fn set_vector_variable_value( - &mut self, - variableName: &str, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ) -> () { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_function_parser_set_vector_variable_value( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ); - } - unsafe { - vtk_function_parser_set_vector_variable_value( - self.0, - c_variableName.as_ptr(), - xValue, - yValue, - zValue, - ) - } - } - fn set_vector_variable_value( - &mut self, - variableName: core::ffi::c_char, - values: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_function_parser_set_vector_variable_value( - sself: *mut core::ffi::c_void, - variableName: core::ffi::c_char, - values: core::ffi::c_double, - ); - } - unsafe { - vtk_function_parser_set_vector_variable_value(self.0, variableName, values) - } - } - fn set_vector_variable_value( - &mut self, - variableName: &str, - values: core::ffi::c_double, - ) -> () { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_function_parser_set_vector_variable_value( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - values: core::ffi::c_double, - ); - } - unsafe { - vtk_function_parser_set_vector_variable_value( - self.0, - c_variableName.as_ptr(), - values, - ) + unsafe extern "C" { + fn vtk_function_parser_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; } + unsafe { vtk_function_parser_new_instance(self.0) } } - fn set_vector_variable_value( - &mut self, - i: core::ffi::c_int, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ) -> () { + fn get_m_time(&mut self) -> core::ffi::c_ulong { unsafe extern "C" { - fn vtk_function_parser_set_vector_variable_value( + fn vtk_function_parser_get_m_time( sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - xValue: core::ffi::c_double, - yValue: core::ffi::c_double, - zValue: core::ffi::c_double, - ); - } - unsafe { - vtk_function_parser_set_vector_variable_value( - self.0, - i, - xValue, - yValue, - zValue, - ) + ) -> core::ffi::c_ulong; } + unsafe { vtk_function_parser_get_m_time(self.0) } } - fn set_vector_variable_value( - &mut self, - i: core::ffi::c_int, - values: core::ffi::c_double, - ) -> () { + fn set_function(&mut self, function: &str) -> () { + let c_function = std::ffi::CString::new(function).expect("CString::new failed"); unsafe extern "C" { - fn vtk_function_parser_set_vector_variable_value( + fn vtk_function_parser_set_function( sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - values: core::ffi::c_double, + function: *const core::ffi::c_char, ); } - unsafe { vtk_function_parser_set_vector_variable_value(self.0, i, values) } + unsafe { vtk_function_parser_set_function(self.0, c_function.as_ptr()) } } - fn get_vector_variable_value( - &mut self, - variableName: core::ffi::c_char, - ) -> *mut core::ffi::c_double { + fn is_scalar_result(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_function_parser_get_vector_variable_value( + fn vtk_function_parser_is_scalar_result( sself: *mut core::ffi::c_void, - variableName: core::ffi::c_char, - ) -> *mut core::ffi::c_double; + ) -> core::ffi::c_int; } - unsafe { vtk_function_parser_get_vector_variable_value(self.0, variableName) } + unsafe { vtk_function_parser_is_scalar_result(self.0) } } - fn get_vector_variable_value( - &mut self, - variableName: &str, - ) -> *mut core::ffi::c_double { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); + fn is_vector_result(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_function_parser_get_vector_variable_value( + fn vtk_function_parser_is_vector_result( sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - ) -> *mut core::ffi::c_double; - } - unsafe { - vtk_function_parser_get_vector_variable_value( - self.0, - c_variableName.as_ptr(), - ) + ) -> core::ffi::c_int; } + unsafe { vtk_function_parser_is_vector_result(self.0) } } - fn get_vector_variable_value( - &mut self, - variableName: core::ffi::c_char, - value: core::ffi::c_double, - ) -> () { + fn get_scalar_result(&mut self) -> core::ffi::c_double { unsafe extern "C" { - fn vtk_function_parser_get_vector_variable_value( + fn vtk_function_parser_get_scalar_result( sself: *mut core::ffi::c_void, - variableName: core::ffi::c_char, - value: core::ffi::c_double, - ); - } - unsafe { - vtk_function_parser_get_vector_variable_value(self.0, variableName, value) + ) -> core::ffi::c_double; } + unsafe { vtk_function_parser_get_scalar_result(self.0) } } - fn get_vector_variable_value( + fn set_scalar_variable_value( &mut self, variableName: &str, value: core::ffi::c_double, @@ -1320,45 +584,63 @@ impl VtkFunctionParser for vtkFunctionParser { let c_variableName = std::ffi::CString::new(variableName) .expect("CString::new failed"); unsafe extern "C" { - fn vtk_function_parser_get_vector_variable_value( + fn vtk_function_parser_set_scalar_variable_value( sself: *mut core::ffi::c_void, variableName: *const core::ffi::c_char, value: core::ffi::c_double, ); } unsafe { - vtk_function_parser_get_vector_variable_value( + vtk_function_parser_set_scalar_variable_value( self.0, c_variableName.as_ptr(), value, ) } } - fn get_vector_variable_value( - &mut self, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_double { + fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); unsafe extern "C" { - fn vtk_function_parser_get_vector_variable_value( + fn vtk_function_parser_get_scalar_variable_value( sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_double; + variableName: *const core::ffi::c_char, + ) -> core::ffi::c_double; + } + unsafe { + vtk_function_parser_get_scalar_variable_value( + self.0, + c_variableName.as_ptr(), + ) } - unsafe { vtk_function_parser_get_vector_variable_value(self.0, i) } } - fn get_vector_variable_value( + fn set_vector_variable_value( &mut self, - i: core::ffi::c_int, - value: core::ffi::c_double, + variableName: &str, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); unsafe extern "C" { - fn vtk_function_parser_get_vector_variable_value( + fn vtk_function_parser_set_vector_variable_value( sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - value: core::ffi::c_double, + variableName: *const core::ffi::c_char, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, ); } - unsafe { vtk_function_parser_get_vector_variable_value(self.0, i, value) } + unsafe { + vtk_function_parser_set_vector_variable_value( + self.0, + c_variableName.as_ptr(), + xValue, + yValue, + zValue, + ) + } } fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int { unsafe extern "C" { @@ -1368,18 +650,6 @@ impl VtkFunctionParser for vtkFunctionParser { } unsafe { vtk_function_parser_get_number_of_scalar_variables(self.0) } } - fn get_scalar_variable_index( - &mut self, - name: core::ffi::c_char, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_function_parser_get_scalar_variable_index( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { vtk_function_parser_get_scalar_variable_index(self.0, name) } - } fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int { let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { @@ -1398,18 +668,6 @@ impl VtkFunctionParser for vtkFunctionParser { } unsafe { vtk_function_parser_get_number_of_vector_variables(self.0) } } - fn get_vector_variable_index( - &mut self, - name: core::ffi::c_char, - ) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_function_parser_get_vector_variable_index( - sself: *mut core::ffi::c_void, - name: core::ffi::c_char, - ) -> core::ffi::c_int; - } - unsafe { vtk_function_parser_get_vector_variable_index(self.0, name) } - } fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int { let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { @@ -1420,29 +678,31 @@ impl VtkFunctionParser for vtkFunctionParser { } unsafe { vtk_function_parser_get_vector_variable_index(self.0, c_name.as_ptr()) } } - fn get_scalar_variable_name( - &mut self, - i: core::ffi::c_int, - ) -> *const core::ffi::c_char { + fn get_scalar_variable_name(&mut self, i: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_function_parser_get_scalar_variable_name( sself: *mut core::ffi::c_void, i: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_function_parser_get_scalar_variable_name(self.0, i) } + let ptr = unsafe { vtk_function_parser_get_scalar_variable_name(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn get_vector_variable_name( - &mut self, - i: core::ffi::c_int, - ) -> *const core::ffi::c_char { + fn get_vector_variable_name(&mut self, i: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_function_parser_get_vector_variable_name( sself: *mut core::ffi::c_void, i: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_function_parser_get_vector_variable_name(self.0, i) } + let ptr = unsafe { vtk_function_parser_get_vector_variable_name(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool { unsafe extern "C" { @@ -1453,31 +713,6 @@ impl VtkFunctionParser for vtkFunctionParser { } unsafe { vtk_function_parser_get_scalar_variable_needed(self.0, i) } } - fn get_scalar_variable_needed(&mut self, variableName: core::ffi::c_char) -> bool { - unsafe extern "C" { - fn vtk_function_parser_get_scalar_variable_needed( - sself: *mut core::ffi::c_void, - variableName: core::ffi::c_char, - ) -> bool; - } - unsafe { vtk_function_parser_get_scalar_variable_needed(self.0, variableName) } - } - fn get_scalar_variable_needed(&mut self, variableName: &str) -> bool { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_function_parser_get_scalar_variable_needed( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - ) -> bool; - } - unsafe { - vtk_function_parser_get_scalar_variable_needed( - self.0, - c_variableName.as_ptr(), - ) - } - } fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool { unsafe extern "C" { fn vtk_function_parser_get_vector_variable_needed( @@ -1487,31 +722,6 @@ impl VtkFunctionParser for vtkFunctionParser { } unsafe { vtk_function_parser_get_vector_variable_needed(self.0, i) } } - fn get_vector_variable_needed(&mut self, variableName: core::ffi::c_char) -> bool { - unsafe extern "C" { - fn vtk_function_parser_get_vector_variable_needed( - sself: *mut core::ffi::c_void, - variableName: core::ffi::c_char, - ) -> bool; - } - unsafe { vtk_function_parser_get_vector_variable_needed(self.0, variableName) } - } - fn get_vector_variable_needed(&mut self, variableName: &str) -> bool { - let c_variableName = std::ffi::CString::new(variableName) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_function_parser_get_vector_variable_needed( - sself: *mut core::ffi::c_void, - variableName: *const core::ffi::c_char, - ) -> bool; - } - unsafe { - vtk_function_parser_get_vector_variable_needed( - self.0, - c_variableName.as_ptr(), - ) - } - } fn remove_all_variables(&mut self) -> () { unsafe extern "C" { fn vtk_function_parser_remove_all_variables(sself: *mut core::ffi::c_void); @@ -1584,20 +794,6 @@ impl VtkFunctionParser for vtkFunctionParser { } unsafe { vtk_function_parser_get_replacement_value(self.0) } } - fn check_expression( - &mut self, - pos: core::ffi::c_int, - error: core::ffi::c_char, - ) -> () { - unsafe extern "C" { - fn vtk_function_parser_check_expression( - sself: *mut core::ffi::c_void, - pos: core::ffi::c_int, - error: core::ffi::c_char, - ); - } - unsafe { vtk_function_parser_check_expression(self.0, pos, error) } - } fn invalidate_function(&mut self) -> () { unsafe extern "C" { fn vtk_function_parser_invalidate_function(sself: *mut core::ffi::c_void); @@ -1629,15 +825,6 @@ impl VtkHeap for vtkHeap { } unsafe { vtk_heap_new_instance(self.0) } } - fn allocate_memory(&mut self, n: usize) -> *mut () { - unsafe extern "C" { - fn vtk_heap_allocate_memory( - sself: *mut core::ffi::c_void, - n: usize, - ) -> *mut (); - } - unsafe { vtk_heap_allocate_memory(self.0, n) } - } fn set_block_size(&mut self, p0: usize) -> () { unsafe extern "C" { fn vtk_heap_set_block_size(sself: *mut core::ffi::c_void, p0: usize); @@ -1672,15 +859,6 @@ impl VtkHeap for vtkHeap { } unsafe { vtk_heap_reset(self.0) } } - fn string_dup(&mut self, str: core::ffi::c_char) -> *mut core::ffi::c_char { - unsafe extern "C" { - fn vtk_heap_string_dup( - sself: *mut core::ffi::c_void, - str: core::ffi::c_char, - ) -> *mut core::ffi::c_char; - } - unsafe { vtk_heap_string_dup(self.0, str) } - } } impl VtkResourceFileLocator for vtkResourceFileLocator { fn new(&mut self) -> *mut core::ffi::c_void { @@ -1758,102 +936,6 @@ impl VtkResourceFileLocator for vtkResourceFileLocator { } unsafe { vtk_resource_file_locator_get_log_verbosity(self.0) } } - fn locate(&mut self, anchor: &str, landmark: &str, defaultDir: &str) -> &str { - let c_anchor = std::ffi::CString::new(anchor).expect("CString::new failed"); - let c_landmark = std::ffi::CString::new(landmark).expect("CString::new failed"); - let c_defaultDir = std::ffi::CString::new(defaultDir) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_resource_file_locator_locate( - sself: *mut core::ffi::c_void, - anchor: *const core::ffi::c_char, - landmark: *const core::ffi::c_char, - defaultDir: *const core::ffi::c_char, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { - vtk_resource_file_locator_locate( - self.0, - c_anchor.as_ptr(), - c_landmark.as_ptr(), - c_defaultDir.as_ptr(), - ) - }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } - fn locate( - &mut self, - anchor: &str, - landmark_prefixes: Vec, - landmark: &str, - defaultDir: &str, - ) -> &str { - let c_anchor = std::ffi::CString::new(anchor).expect("CString::new failed"); - let c_landmark = std::ffi::CString::new(landmark).expect("CString::new failed"); - let c_defaultDir = std::ffi::CString::new(defaultDir) - .expect("CString::new failed"); - unsafe extern "C" { - fn vtk_resource_file_locator_locate( - sself: *mut core::ffi::c_void, - anchor: *const core::ffi::c_char, - landmark_prefixes: Vec, - landmark: *const core::ffi::c_char, - defaultDir: *const core::ffi::c_char, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { - vtk_resource_file_locator_locate( - self.0, - c_anchor.as_ptr(), - landmark_prefixes, - c_landmark.as_ptr(), - c_defaultDir.as_ptr(), - ) - }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } - fn get_library_path_for_symbol_unix( - &mut self, - symbolname: core::ffi::c_char, - ) -> &str { - unsafe extern "C" { - fn vtk_resource_file_locator_get_library_path_for_symbol_unix( - sself: *mut core::ffi::c_void, - symbolname: core::ffi::c_char, - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { - vtk_resource_file_locator_get_library_path_for_symbol_unix( - self.0, - symbolname, - ) - }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } - fn get_library_path_for_symbol_win_32(&mut self, fptr: ()) -> &str { - unsafe extern "C" { - fn vtk_resource_file_locator_get_library_path_for_symbol_win_32( - sself: *mut core::ffi::c_void, - fptr: (), - ) -> *const core::ffi::c_char; - } - let ptr = unsafe { - vtk_resource_file_locator_get_library_path_for_symbol_win_32(self.0, fptr) - }; - if ptr.is_null() { - return ""; - } - unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } - } } /// helper object to manage setting and generating contour values /// @@ -1867,22 +949,13 @@ impl VtkResourceFileLocator for vtkResourceFileLocator { #[allow(non_camel_case_types)] pub struct vtkContourValues(*mut core::ffi::c_void); impl vtkContourValues { - /// Creates a new [vtkContourValues] wrapped inside `vtkNew` + /// Creates a new [vtkContourValues] via `vtkContourValues::New()` #[doc(alias = "vtkContourValues")] pub fn new() -> Self { unsafe extern "C" { fn vtkContourValues_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkContourValues_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkContourValues_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkContourValues_get_ptr(self.0) } + Self(unsafe { vtkContourValues_new() }) } } impl std::default::Default for vtkContourValues { @@ -1902,12 +975,8 @@ impl Drop for vtkContourValues { #[test] fn test_vtkContourValues_create_drop() { let obj = vtkContourValues::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkContourValues(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Parse and evaluate a mathematical expression /// @@ -1928,22 +997,13 @@ fn test_vtkContourValues_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExprTkFunctionParser(*mut core::ffi::c_void); impl vtkExprTkFunctionParser { - /// Creates a new [vtkExprTkFunctionParser] wrapped inside `vtkNew` + /// Creates a new [vtkExprTkFunctionParser] via `vtkExprTkFunctionParser::New()` #[doc(alias = "vtkExprTkFunctionParser")] pub fn new() -> Self { unsafe extern "C" { fn vtkExprTkFunctionParser_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExprTkFunctionParser_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExprTkFunctionParser_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExprTkFunctionParser_get_ptr(self.0) } + Self(unsafe { vtkExprTkFunctionParser_new() }) } } impl std::default::Default for vtkExprTkFunctionParser { @@ -1963,12 +1023,8 @@ impl Drop for vtkExprTkFunctionParser { #[test] fn test_vtkExprTkFunctionParser_create_drop() { let obj = vtkExprTkFunctionParser::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExprTkFunctionParser(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Parse and evaluate a mathematical expression /// @@ -2001,22 +1057,13 @@ fn test_vtkExprTkFunctionParser_create_drop() { #[allow(non_camel_case_types)] pub struct vtkFunctionParser(*mut core::ffi::c_void); impl vtkFunctionParser { - /// Creates a new [vtkFunctionParser] wrapped inside `vtkNew` + /// Creates a new [vtkFunctionParser] via `vtkFunctionParser::New()` #[doc(alias = "vtkFunctionParser")] pub fn new() -> Self { unsafe extern "C" { fn vtkFunctionParser_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkFunctionParser_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkFunctionParser_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkFunctionParser_get_ptr(self.0) } + Self(unsafe { vtkFunctionParser_new() }) } } impl std::default::Default for vtkFunctionParser { @@ -2036,12 +1083,8 @@ impl Drop for vtkFunctionParser { #[test] fn test_vtkFunctionParser_create_drop() { let obj = vtkFunctionParser::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkFunctionParser(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// replacement for malloc/free and new/delete /// @@ -2073,20 +1116,13 @@ fn test_vtkFunctionParser_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHeap(*mut core::ffi::c_void); impl vtkHeap { - /// Creates a new [vtkHeap] wrapped inside `vtkNew` + /// Creates a new [vtkHeap] via `vtkHeap::New()` #[doc(alias = "vtkHeap")] pub fn new() -> Self { unsafe extern "C" { fn vtkHeap_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHeap_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHeap_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkHeap_get_ptr(self.0) } + Self(unsafe { vtkHeap_new() }) } } impl std::default::Default for vtkHeap { @@ -2106,12 +1142,8 @@ impl Drop for vtkHeap { #[test] fn test_vtkHeap_create_drop() { let obj = vtkHeap::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHeap(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// utility to locate resource files. /// @@ -2130,22 +1162,13 @@ fn test_vtkHeap_create_drop() { #[allow(non_camel_case_types)] pub struct vtkResourceFileLocator(*mut core::ffi::c_void); impl vtkResourceFileLocator { - /// Creates a new [vtkResourceFileLocator] wrapped inside `vtkNew` + /// Creates a new [vtkResourceFileLocator] via `vtkResourceFileLocator::New()` #[doc(alias = "vtkResourceFileLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkResourceFileLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkResourceFileLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkResourceFileLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkResourceFileLocator_get_ptr(self.0) } + Self(unsafe { vtkResourceFileLocator_new() }) } } impl std::default::Default for vtkResourceFileLocator { @@ -2165,10 +1188,6 @@ impl Drop for vtkResourceFileLocator { #[test] fn test_vtkResourceFileLocator_create_drop() { let obj = vtkResourceFileLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkResourceFileLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonSystem.rs b/vtk-rs-9.1/src/vtkCommonSystem.rs index 4342946..cd10a48 100644 --- a/vtk-rs-9.1/src/vtkCommonSystem.rs +++ b/vtk-rs-9.1/src/vtkCommonSystem.rs @@ -1,10 +1,10 @@ -pub trait VtkClientSocket: VtkSocket { +pub trait VtkClientSocket { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn connect_to_server( &mut self, - hostname: core::ffi::c_char, + hostname: &str, port: core::ffi::c_int, ) -> core::ffi::c_int; fn get_connecting_side(&mut self) -> bool; @@ -13,23 +13,14 @@ pub trait VtkDirectory { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; - fn open(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int; - fn get_number_of_files(&mut self) -> core::ffi::c_uchar; - fn get_file(&mut self, index: core::ffi::c_uchar) -> *const core::ffi::c_char; - fn file_is_directory(&mut self, name: core::ffi::c_char) -> core::ffi::c_int; + fn open(&mut self, dir: &str) -> core::ffi::c_int; + fn get_number_of_files(&mut self) -> core::ffi::c_longlong; + fn get_file(&mut self, index: core::ffi::c_longlong) -> &str; + fn file_is_directory(&mut self, name: &str) -> core::ffi::c_int; fn get_files(&mut self) -> *mut core::ffi::c_void; - fn get_current_working_directory( - &mut self, - buf: core::ffi::c_char, - len: core::ffi::c_uint, - ) -> *const core::ffi::c_char; - fn make_directory(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int; - fn delete_directory(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int; - fn rename( - &mut self, - oldname: core::ffi::c_char, - newname: core::ffi::c_char, - ) -> core::ffi::c_int; + fn make_directory(&mut self, dir: &str) -> core::ffi::c_int; + fn delete_directory(&mut self, dir: &str) -> core::ffi::c_int; + fn rename(&mut self, oldname: &str, newname: &str) -> core::ffi::c_int; } pub trait VtkExecutableRunner { fn new(&mut self) -> *mut core::ffi::c_void; @@ -42,13 +33,13 @@ pub trait VtkExecutableRunner { fn get_right_trim_result(&mut self) -> bool; fn right_trim_result_on(&mut self) -> (); fn right_trim_result_off(&mut self) -> (); - fn get_command(&mut self) -> *const core::ffi::c_char; - fn set_command(&mut self, arg: core::ffi::c_char) -> (); - fn get_std_out(&mut self) -> *const core::ffi::c_char; - fn get_std_err(&mut self) -> *const core::ffi::c_char; + fn get_command(&mut self) -> &str; + fn set_command(&mut self, arg: &str) -> (); + fn get_std_out(&mut self) -> &str; + fn get_std_err(&mut self) -> &str; fn get_return_value(&mut self) -> core::ffi::c_int; } -pub trait VtkServerSocket: VtkSocket { +pub trait VtkServerSocket { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -64,21 +55,7 @@ pub trait VtkSocket { fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_connected(&mut self) -> core::ffi::c_int; fn close_socket(&mut self) -> (); - fn send(&mut self, data: (), length: core::ffi::c_int) -> core::ffi::c_int; - fn receive( - &mut self, - data: (), - length: core::ffi::c_int, - readFully: core::ffi::c_int, - ) -> core::ffi::c_int; fn get_socket_descriptor(&mut self) -> core::ffi::c_int; - fn select_sockets( - &mut self, - sockets_to_select: core::ffi::c_int, - size: core::ffi::c_int, - msec: core::ffi::c_ulong, - selected_index: core::ffi::c_int, - ) -> core::ffi::c_int; } pub trait VtkSocketCollection { fn new(&mut self) -> *mut core::ffi::c_void; @@ -109,21 +86,20 @@ pub trait VtkTimerLog { fn logging_off(&mut self) -> (); fn set_max_entries(&mut self, a: core::ffi::c_int) -> (); fn get_max_entries(&mut self) -> core::ffi::c_int; - fn dump_log(&mut self, filename: core::ffi::c_char) -> (); - fn mark_start_event(&mut self, EventString: core::ffi::c_char) -> (); - fn mark_end_event(&mut self, EventString: core::ffi::c_char) -> (); + fn dump_log(&mut self, filename: &str) -> (); + fn mark_start_event(&mut self, EventString: &str) -> (); + fn mark_end_event(&mut self, EventString: &str) -> (); fn insert_timed_event( &mut self, - EventString: core::ffi::c_char, + EventString: &str, time: core::ffi::c_double, cpuTicks: core::ffi::c_int, ) -> (); fn get_number_of_events(&mut self) -> core::ffi::c_int; fn get_event_indent(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; fn get_event_wall_time(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; - fn get_event_string(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char; - fn get_event_type(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; - fn mark_event(&mut self, EventString: core::ffi::c_char) -> (); + fn get_event_string(&mut self, i: core::ffi::c_int) -> &str; + fn mark_event(&mut self, EventString: &str) -> (); fn reset_log(&mut self) -> (); fn cleanup_log(&mut self) -> (); fn get_universal_time(&mut self) -> core::ffi::c_double; @@ -160,17 +136,18 @@ impl VtkClientSocket for vtkClientSocket { } fn connect_to_server( &mut self, - hostname: core::ffi::c_char, + hostname: &str, port: core::ffi::c_int, ) -> core::ffi::c_int { + let c_hostname = std::ffi::CString::new(hostname).expect("CString::new failed"); unsafe extern "C" { fn vtk_client_socket_connect_to_server( sself: *mut core::ffi::c_void, - hostname: core::ffi::c_char, + hostname: *const core::ffi::c_char, port: core::ffi::c_int, ) -> core::ffi::c_int; } - unsafe { vtk_client_socket_connect_to_server(self.0, hostname, port) } + unsafe { vtk_client_socket_connect_to_server(self.0, c_hostname.as_ptr(), port) } } fn get_connecting_side(&mut self) -> bool { unsafe extern "C" { @@ -207,40 +184,46 @@ impl VtkDirectory for vtkDirectory { } unsafe { vtk_directory_new(self.0) } } - fn open(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int { + fn open(&mut self, dir: &str) -> core::ffi::c_int { + let c_dir = std::ffi::CString::new(dir).expect("CString::new failed"); unsafe extern "C" { fn vtk_directory_open( sself: *mut core::ffi::c_void, - dir: core::ffi::c_char, + dir: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_directory_open(self.0, dir) } + unsafe { vtk_directory_open(self.0, c_dir.as_ptr()) } } - fn get_number_of_files(&mut self) -> core::ffi::c_uchar { + fn get_number_of_files(&mut self) -> core::ffi::c_longlong { unsafe extern "C" { fn vtk_directory_get_number_of_files( sself: *mut core::ffi::c_void, - ) -> core::ffi::c_uchar; + ) -> core::ffi::c_longlong; } unsafe { vtk_directory_get_number_of_files(self.0) } } - fn get_file(&mut self, index: core::ffi::c_uchar) -> *const core::ffi::c_char { + fn get_file(&mut self, index: core::ffi::c_longlong) -> &str { unsafe extern "C" { fn vtk_directory_get_file( sself: *mut core::ffi::c_void, - index: core::ffi::c_uchar, + index: core::ffi::c_longlong, ) -> *const core::ffi::c_char; } - unsafe { vtk_directory_get_file(self.0, index) } + let ptr = unsafe { vtk_directory_get_file(self.0, index) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn file_is_directory(&mut self, name: core::ffi::c_char) -> core::ffi::c_int { + fn file_is_directory(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); unsafe extern "C" { fn vtk_directory_file_is_directory( sself: *mut core::ffi::c_void, - name: core::ffi::c_char, + name: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_directory_file_is_directory(self.0, name) } + unsafe { vtk_directory_file_is_directory(self.0, c_name.as_ptr()) } } fn get_files(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -250,51 +233,37 @@ impl VtkDirectory for vtkDirectory { } unsafe { vtk_directory_get_files(self.0) } } - fn get_current_working_directory( - &mut self, - buf: core::ffi::c_char, - len: core::ffi::c_uint, - ) -> *const core::ffi::c_char { - unsafe extern "C" { - fn vtk_directory_get_current_working_directory( - sself: *mut core::ffi::c_void, - buf: core::ffi::c_char, - len: core::ffi::c_uint, - ) -> *const core::ffi::c_char; - } - unsafe { vtk_directory_get_current_working_directory(self.0, buf, len) } - } - fn make_directory(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int { + fn make_directory(&mut self, dir: &str) -> core::ffi::c_int { + let c_dir = std::ffi::CString::new(dir).expect("CString::new failed"); unsafe extern "C" { fn vtk_directory_make_directory( sself: *mut core::ffi::c_void, - dir: core::ffi::c_char, + dir: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_directory_make_directory(self.0, dir) } + unsafe { vtk_directory_make_directory(self.0, c_dir.as_ptr()) } } - fn delete_directory(&mut self, dir: core::ffi::c_char) -> core::ffi::c_int { + fn delete_directory(&mut self, dir: &str) -> core::ffi::c_int { + let c_dir = std::ffi::CString::new(dir).expect("CString::new failed"); unsafe extern "C" { fn vtk_directory_delete_directory( sself: *mut core::ffi::c_void, - dir: core::ffi::c_char, + dir: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_directory_delete_directory(self.0, dir) } + unsafe { vtk_directory_delete_directory(self.0, c_dir.as_ptr()) } } - fn rename( - &mut self, - oldname: core::ffi::c_char, - newname: core::ffi::c_char, - ) -> core::ffi::c_int { + fn rename(&mut self, oldname: &str, newname: &str) -> core::ffi::c_int { + let c_oldname = std::ffi::CString::new(oldname).expect("CString::new failed"); + let c_newname = std::ffi::CString::new(newname).expect("CString::new failed"); unsafe extern "C" { fn vtk_directory_rename( sself: *mut core::ffi::c_void, - oldname: core::ffi::c_char, - newname: core::ffi::c_char, + oldname: *const core::ffi::c_char, + newname: *const core::ffi::c_char, ) -> core::ffi::c_int; } - unsafe { vtk_directory_rename(self.0, oldname, newname) } + unsafe { vtk_directory_rename(self.0, c_oldname.as_ptr(), c_newname.as_ptr()) } } } impl VtkExecutableRunner for vtkExecutableRunner { @@ -377,38 +346,51 @@ impl VtkExecutableRunner for vtkExecutableRunner { } unsafe { vtk_executable_runner_right_trim_result_off(self.0) } } - fn get_command(&mut self) -> *const core::ffi::c_char { + fn get_command(&mut self) -> &str { unsafe extern "C" { fn vtk_executable_runner_get_command( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_executable_runner_get_command(self.0) } + let ptr = unsafe { vtk_executable_runner_get_command(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn set_command(&mut self, arg: core::ffi::c_char) -> () { + fn set_command(&mut self, arg: &str) -> () { + let c_arg = std::ffi::CString::new(arg).expect("CString::new failed"); unsafe extern "C" { fn vtk_executable_runner_set_command( sself: *mut core::ffi::c_void, - arg: core::ffi::c_char, + arg: *const core::ffi::c_char, ); } - unsafe { vtk_executable_runner_set_command(self.0, arg) } + unsafe { vtk_executable_runner_set_command(self.0, c_arg.as_ptr()) } } - fn get_std_out(&mut self) -> *const core::ffi::c_char { + fn get_std_out(&mut self) -> &str { unsafe extern "C" { fn vtk_executable_runner_get_std_out( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_executable_runner_get_std_out(self.0) } + let ptr = unsafe { vtk_executable_runner_get_std_out(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn get_std_err(&mut self) -> *const core::ffi::c_char { + fn get_std_err(&mut self) -> &str { unsafe extern "C" { fn vtk_executable_runner_get_std_err( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_executable_runner_get_std_err(self.0) } + let ptr = unsafe { vtk_executable_runner_get_std_err(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn get_return_value(&mut self) -> core::ffi::c_int { unsafe extern "C" { @@ -671,48 +653,62 @@ impl VtkTimerLog for vtkTimerLog { } unsafe { vtk_timer_log_get_max_entries(self.0) } } - fn dump_log(&mut self, filename: core::ffi::c_char) -> () { + fn dump_log(&mut self, filename: &str) -> () { + let c_filename = std::ffi::CString::new(filename).expect("CString::new failed"); unsafe extern "C" { fn vtk_timer_log_dump_log( sself: *mut core::ffi::c_void, - filename: core::ffi::c_char, + filename: *const core::ffi::c_char, ); } - unsafe { vtk_timer_log_dump_log(self.0, filename) } + unsafe { vtk_timer_log_dump_log(self.0, c_filename.as_ptr()) } } - fn mark_start_event(&mut self, EventString: core::ffi::c_char) -> () { + fn mark_start_event(&mut self, EventString: &str) -> () { + let c_EventString = std::ffi::CString::new(EventString) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_timer_log_mark_start_event( sself: *mut core::ffi::c_void, - EventString: core::ffi::c_char, + EventString: *const core::ffi::c_char, ); } - unsafe { vtk_timer_log_mark_start_event(self.0, EventString) } + unsafe { vtk_timer_log_mark_start_event(self.0, c_EventString.as_ptr()) } } - fn mark_end_event(&mut self, EventString: core::ffi::c_char) -> () { + fn mark_end_event(&mut self, EventString: &str) -> () { + let c_EventString = std::ffi::CString::new(EventString) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_timer_log_mark_end_event( sself: *mut core::ffi::c_void, - EventString: core::ffi::c_char, + EventString: *const core::ffi::c_char, ); } - unsafe { vtk_timer_log_mark_end_event(self.0, EventString) } + unsafe { vtk_timer_log_mark_end_event(self.0, c_EventString.as_ptr()) } } fn insert_timed_event( &mut self, - EventString: core::ffi::c_char, + EventString: &str, time: core::ffi::c_double, cpuTicks: core::ffi::c_int, ) -> () { + let c_EventString = std::ffi::CString::new(EventString) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_timer_log_insert_timed_event( sself: *mut core::ffi::c_void, - EventString: core::ffi::c_char, + EventString: *const core::ffi::c_char, time: core::ffi::c_double, cpuTicks: core::ffi::c_int, ); } - unsafe { vtk_timer_log_insert_timed_event(self.0, EventString, time, cpuTicks) } + unsafe { + vtk_timer_log_insert_timed_event( + self.0, + c_EventString.as_ptr(), + time, + cpuTicks, + ) + } } fn get_number_of_events(&mut self) -> core::ffi::c_int { unsafe extern "C" { @@ -740,32 +736,29 @@ impl VtkTimerLog for vtkTimerLog { } unsafe { vtk_timer_log_get_event_wall_time(self.0, i) } } - fn get_event_string(&mut self, i: core::ffi::c_int) -> *const core::ffi::c_char { + fn get_event_string(&mut self, i: core::ffi::c_int) -> &str { unsafe extern "C" { fn vtk_timer_log_get_event_string( sself: *mut core::ffi::c_void, i: core::ffi::c_int, ) -> *const core::ffi::c_char; } - unsafe { vtk_timer_log_get_event_string(self.0, i) } - } - fn get_event_type(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_timer_log_get_event_type( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; + let ptr = unsafe { vtk_timer_log_get_event_string(self.0, i) }; + if ptr.is_null() { + return ""; } - unsafe { vtk_timer_log_get_event_type(self.0, i) } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } - fn mark_event(&mut self, EventString: core::ffi::c_char) -> () { + fn mark_event(&mut self, EventString: &str) -> () { + let c_EventString = std::ffi::CString::new(EventString) + .expect("CString::new failed"); unsafe extern "C" { fn vtk_timer_log_mark_event( sself: *mut core::ffi::c_void, - EventString: core::ffi::c_char, + EventString: *const core::ffi::c_char, ); } - unsafe { vtk_timer_log_mark_event(self.0, EventString) } + unsafe { vtk_timer_log_mark_event(self.0, c_EventString.as_ptr()) } } fn reset_log(&mut self) -> () { unsafe extern "C" { @@ -821,22 +814,13 @@ impl VtkTimerLog for vtkTimerLog { #[allow(non_camel_case_types)] pub struct vtkClientSocket(*mut core::ffi::c_void); impl vtkClientSocket { - /// Creates a new [vtkClientSocket] wrapped inside `vtkNew` + /// Creates a new [vtkClientSocket] via `vtkClientSocket::New()` #[doc(alias = "vtkClientSocket")] pub fn new() -> Self { unsafe extern "C" { fn vtkClientSocket_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkClientSocket_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkClientSocket_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkClientSocket_get_ptr(self.0) } + Self(unsafe { vtkClientSocket_new() }) } } impl std::default::Default for vtkClientSocket { @@ -856,12 +840,8 @@ impl Drop for vtkClientSocket { #[test] fn test_vtkClientSocket_create_drop() { let obj = vtkClientSocket::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkClientSocket(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// OS independent class for access and manipulation of system directories /// @@ -874,22 +854,13 @@ fn test_vtkClientSocket_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDirectory(*mut core::ffi::c_void); impl vtkDirectory { - /// Creates a new [vtkDirectory] wrapped inside `vtkNew` + /// Creates a new [vtkDirectory] via `vtkDirectory::New()` #[doc(alias = "vtkDirectory")] pub fn new() -> Self { unsafe extern "C" { fn vtkDirectory_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDirectory_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDirectory_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDirectory_get_ptr(self.0) } + Self(unsafe { vtkDirectory_new() }) } } impl std::default::Default for vtkDirectory { @@ -909,12 +880,8 @@ impl Drop for vtkDirectory { #[test] fn test_vtkDirectory_create_drop() { let obj = vtkDirectory::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDirectory(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Launch a process on the current machine and get its output /// @@ -924,22 +891,13 @@ fn test_vtkDirectory_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExecutableRunner(*mut core::ffi::c_void); impl vtkExecutableRunner { - /// Creates a new [vtkExecutableRunner] wrapped inside `vtkNew` + /// Creates a new [vtkExecutableRunner] via `vtkExecutableRunner::New()` #[doc(alias = "vtkExecutableRunner")] pub fn new() -> Self { unsafe extern "C" { fn vtkExecutableRunner_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExecutableRunner_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExecutableRunner_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExecutableRunner_get_ptr(self.0) } + Self(unsafe { vtkExecutableRunner_new() }) } } impl std::default::Default for vtkExecutableRunner { @@ -959,34 +917,21 @@ impl Drop for vtkExecutableRunner { #[test] fn test_vtkExecutableRunner_create_drop() { let obj = vtkExecutableRunner::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExecutableRunner(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Encapsulate a socket that accepts connections. /// #[allow(non_camel_case_types)] pub struct vtkServerSocket(*mut core::ffi::c_void); impl vtkServerSocket { - /// Creates a new [vtkServerSocket] wrapped inside `vtkNew` + /// Creates a new [vtkServerSocket] via `vtkServerSocket::New()` #[doc(alias = "vtkServerSocket")] pub fn new() -> Self { unsafe extern "C" { fn vtkServerSocket_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkServerSocket_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkServerSocket_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkServerSocket_get_ptr(self.0) } + Self(unsafe { vtkServerSocket_new() }) } } impl std::default::Default for vtkServerSocket { @@ -1006,12 +951,8 @@ impl Drop for vtkServerSocket { #[test] fn test_vtkServerSocket_create_drop() { let obj = vtkServerSocket::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkServerSocket(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a collection for sockets. /// @@ -1022,22 +963,13 @@ fn test_vtkServerSocket_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSocketCollection(*mut core::ffi::c_void); impl vtkSocketCollection { - /// Creates a new [vtkSocketCollection] wrapped inside `vtkNew` + /// Creates a new [vtkSocketCollection] via `vtkSocketCollection::New()` #[doc(alias = "vtkSocketCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkSocketCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSocketCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSocketCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSocketCollection_get_ptr(self.0) } + Self(unsafe { vtkSocketCollection_new() }) } } impl std::default::Default for vtkSocketCollection { @@ -1057,12 +989,8 @@ impl Drop for vtkSocketCollection { #[test] fn test_vtkSocketCollection_create_drop() { let obj = vtkSocketCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSocketCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A class for performing inter-thread messaging /// @@ -1072,22 +1000,13 @@ fn test_vtkSocketCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkThreadMessager(*mut core::ffi::c_void); impl vtkThreadMessager { - /// Creates a new [vtkThreadMessager] wrapped inside `vtkNew` + /// Creates a new [vtkThreadMessager] via `vtkThreadMessager::New()` #[doc(alias = "vtkThreadMessager")] pub fn new() -> Self { unsafe extern "C" { fn vtkThreadMessager_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkThreadMessager_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkThreadMessager_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkThreadMessager_get_ptr(self.0) } + Self(unsafe { vtkThreadMessager_new() }) } } impl std::default::Default for vtkThreadMessager { @@ -1107,12 +1026,8 @@ impl Drop for vtkThreadMessager { #[test] fn test_vtkThreadMessager_create_drop() { let obj = vtkThreadMessager::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkThreadMessager(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Timer support and logging /// @@ -1127,22 +1042,13 @@ fn test_vtkThreadMessager_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTimerLog(*mut core::ffi::c_void); impl vtkTimerLog { - /// Creates a new [vtkTimerLog] wrapped inside `vtkNew` + /// Creates a new [vtkTimerLog] via `vtkTimerLog::New()` #[doc(alias = "vtkTimerLog")] pub fn new() -> Self { unsafe extern "C" { fn vtkTimerLog_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTimerLog_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTimerLog_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTimerLog_get_ptr(self.0) } + Self(unsafe { vtkTimerLog_new() }) } } impl std::default::Default for vtkTimerLog { @@ -1162,10 +1068,6 @@ impl Drop for vtkTimerLog { #[test] fn test_vtkTimerLog_create_drop() { let obj = vtkTimerLog::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTimerLog(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonTransforms.rs b/vtk-rs-9.1/src/vtkCommonTransforms.rs index 09d247b..a1fb269 100644 --- a/vtk-rs-9.1/src/vtkCommonTransforms.rs +++ b/vtk-rs-9.1/src/vtkCommonTransforms.rs @@ -1,156 +1,28 @@ pub trait VtkAbstractTransform { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn transform_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn transform_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn transform_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_point( - &mut self, - point: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_float_point( - &mut self, - x: core::ffi::c_float, - y: core::ffi::c_float, - z: core::ffi::c_float, - ) -> *mut core::ffi::c_float; - fn transform_float_point( - &mut self, - point: core::ffi::c_float, - ) -> *mut core::ffi::c_float; - fn transform_double_point( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_double_point( - &mut self, - point: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_normal_at_point( - &mut self, - point: core::ffi::c_float, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn transform_normal_at_point( - &mut self, - point: core::ffi::c_double, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn transform_normal_at_point( - &mut self, - point: core::ffi::c_double, - normal: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_double_normal_at_point( - &mut self, - point: core::ffi::c_double, - normal: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_float_normal_at_point( - &mut self, - point: core::ffi::c_float, - normal: core::ffi::c_float, - ) -> *mut core::ffi::c_float; - fn transform_vector_at_point( - &mut self, - point: core::ffi::c_float, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn transform_vector_at_point( - &mut self, - point: core::ffi::c_double, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn transform_vector_at_point( - &mut self, - point: core::ffi::c_double, - vector: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_double_vector_at_point( - &mut self, - point: core::ffi::c_double, - vector: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_float_vector_at_point( - &mut self, - point: core::ffi::c_float, - vector: core::ffi::c_float, - ) -> *mut core::ffi::c_float; fn transform_points( &mut self, inPts: *mut core::ffi::c_void, outPts: *mut core::ffi::c_void, ) -> (); - fn transform_points_normals_vectors( - &mut self, - inPts: *mut core::ffi::c_void, - outPts: *mut core::ffi::c_void, - inNms: *mut core::ffi::c_void, - outNms: *mut core::ffi::c_void, - inVrs: *mut core::ffi::c_void, - outVrs: *mut core::ffi::c_void, - nOptionalVectors: core::ffi::c_int, - inVrsArr: *mut core::ffi::c_void, - outVrsArr: *mut core::ffi::c_void, - ) -> (); fn get_inverse(&mut self) -> *mut core::ffi::c_void; fn set_inverse(&mut self, transform: *mut core::ffi::c_void) -> (); fn inverse(&mut self) -> (); fn deep_copy(&mut self, p0: *mut core::ffi::c_void) -> (); fn update(&mut self) -> (); - fn internal_transform_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn internal_transform_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn internal_transform_derivative( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - derivative: core::ffi::c_float, - ) -> (); - fn internal_transform_derivative( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - derivative: core::ffi::c_double, - ) -> (); fn make_transform(&mut self) -> *mut core::ffi::c_void; fn circuit_check(&mut self, transform: *mut core::ffi::c_void) -> core::ffi::c_int; fn get_m_time(&mut self) -> core::ffi::c_ulong; fn un_register(&mut self, O: *mut core::ffi::c_void) -> (); } -pub trait VtkCylindricalTransform: VtkWarpTransform + VtkAbstractTransform { +pub trait VtkCylindricalTransform { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn make_transform(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkGeneralTransform: VtkAbstractTransform { +pub trait VtkGeneralTransform { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -162,8 +34,6 @@ pub trait VtkGeneralTransform: VtkAbstractTransform { y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn translate(&mut self, x: core::ffi::c_double) -> (); - fn translate(&mut self, x: core::ffi::c_float) -> (); fn rotate_wxyz( &mut self, angle: core::ffi::c_double, @@ -171,16 +41,6 @@ pub trait VtkGeneralTransform: VtkAbstractTransform { y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_double, - ) -> (); - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_float, - ) -> (); fn rotate_x(&mut self, angle: core::ffi::c_double) -> (); fn rotate_y(&mut self, angle: core::ffi::c_double) -> (); fn rotate_z(&mut self, angle: core::ffi::c_double) -> (); @@ -190,11 +50,7 @@ pub trait VtkGeneralTransform: VtkAbstractTransform { y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn scale(&mut self, s: core::ffi::c_double) -> (); - fn scale(&mut self, s: core::ffi::c_float) -> (); fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> (); - fn concatenate(&mut self, elements: core::ffi::c_double) -> (); - fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> (); fn pre_multiply(&mut self) -> (); fn post_multiply(&mut self) -> (); fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int; @@ -207,68 +63,23 @@ pub trait VtkGeneralTransform: VtkAbstractTransform { fn get_inverse_flag(&mut self) -> core::ffi::c_int; fn push(&mut self) -> (); fn pop(&mut self) -> (); - fn internal_transform_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn internal_transform_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn internal_transform_derivative( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - derivative: core::ffi::c_float, - ) -> (); - fn internal_transform_derivative( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - derivative: core::ffi::c_double, - ) -> (); fn make_transform(&mut self) -> *mut core::ffi::c_void; fn get_m_time(&mut self) -> core::ffi::c_ulong; } -pub trait VtkHomogeneousTransform: VtkAbstractTransform { +pub trait VtkHomogeneousTransform { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn get_matrix(&mut self, m: *mut core::ffi::c_void) -> (); - fn get_matrix(&mut self) -> *mut core::ffi::c_void; fn get_homogeneous_inverse(&mut self) -> *mut core::ffi::c_void; - fn internal_transform_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn internal_transform_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn internal_transform_derivative( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - derivative: core::ffi::c_float, - ) -> (); - fn internal_transform_derivative( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - derivative: core::ffi::c_double, - ) -> (); } -pub trait VtkIdentityTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstractTransform { +pub trait VtkIdentityTransform { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn inverse(&mut self) -> (); fn make_transform(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkLandmarkTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstractTransform { +pub trait VtkLandmarkTransform { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -281,94 +92,14 @@ pub trait VtkLandmarkTransform: VtkLinearTransform + VtkHomogeneousTransform + V fn set_mode_to_similarity(&mut self) -> (); fn set_mode_to_affine(&mut self) -> (); fn get_mode(&mut self) -> core::ffi::c_int; - fn get_mode_as_string(&mut self) -> *const core::ffi::c_char; + fn get_mode_as_string(&mut self) -> &str; fn inverse(&mut self) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; fn make_transform(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkLinearTransform: VtkHomogeneousTransform + VtkAbstractTransform { +pub trait VtkLinearTransform { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; - fn transform_normal( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn transform_normal( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn transform_normal( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_normal( - &mut self, - normal: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_float_normal( - &mut self, - x: core::ffi::c_float, - y: core::ffi::c_float, - z: core::ffi::c_float, - ) -> *mut core::ffi::c_float; - fn transform_float_normal( - &mut self, - normal: core::ffi::c_float, - ) -> *mut core::ffi::c_float; - fn transform_double_normal( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_double_normal( - &mut self, - normal: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_vector( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_vector( - &mut self, - normal: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_vector( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn transform_vector( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn transform_float_vector( - &mut self, - x: core::ffi::c_float, - y: core::ffi::c_float, - z: core::ffi::c_float, - ) -> *mut core::ffi::c_float; - fn transform_float_vector( - &mut self, - vec: core::ffi::c_float, - ) -> *mut core::ffi::c_float; - fn transform_double_vector( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> *mut core::ffi::c_double; - fn transform_double_vector( - &mut self, - vec: core::ffi::c_double, - ) -> *mut core::ffi::c_double; fn transform_normals( &mut self, inNms: *mut core::ffi::c_void, @@ -380,28 +111,8 @@ pub trait VtkLinearTransform: VtkHomogeneousTransform + VtkAbstractTransform { outVrs: *mut core::ffi::c_void, ) -> (); fn get_linear_inverse(&mut self) -> *mut core::ffi::c_void; - fn internal_transform_normal( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn internal_transform_normal( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn internal_transform_vector( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn internal_transform_vector( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); } -pub trait VtkMatrixToHomogeneousTransform: VtkHomogeneousTransform + VtkAbstractTransform { +pub trait VtkMatrixToHomogeneousTransform { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -411,7 +122,7 @@ pub trait VtkMatrixToHomogeneousTransform: VtkHomogeneousTransform + VtkAbstract fn get_m_time(&mut self) -> core::ffi::c_ulong; fn make_transform(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkMatrixToLinearTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstractTransform { +pub trait VtkMatrixToLinearTransform { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -421,7 +132,7 @@ pub trait VtkMatrixToLinearTransform: VtkLinearTransform + VtkHomogeneousTransfo fn get_m_time(&mut self) -> core::ffi::c_ulong; fn make_transform(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkPerspectiveTransform: VtkHomogeneousTransform + VtkAbstractTransform { +pub trait VtkPerspectiveTransform { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -481,12 +192,6 @@ pub trait VtkPerspectiveTransform: VtkHomogeneousTransform + VtkAbstractTransfor angle: core::ffi::c_double, focaldistance: core::ffi::c_double, ) -> (); - fn setup_camera( - &mut self, - position: core::ffi::c_double, - focalpoint: core::ffi::c_double, - viewup: core::ffi::c_double, - ) -> (); fn setup_camera( &mut self, p0: core::ffi::c_double, @@ -505,8 +210,6 @@ pub trait VtkPerspectiveTransform: VtkHomogeneousTransform + VtkAbstractTransfor y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn translate(&mut self, x: core::ffi::c_double) -> (); - fn translate(&mut self, x: core::ffi::c_float) -> (); fn rotate_wxyz( &mut self, angle: core::ffi::c_double, @@ -514,16 +217,6 @@ pub trait VtkPerspectiveTransform: VtkHomogeneousTransform + VtkAbstractTransfor y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_double, - ) -> (); - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_float, - ) -> (); fn rotate_x(&mut self, angle: core::ffi::c_double) -> (); fn rotate_y(&mut self, angle: core::ffi::c_double) -> (); fn rotate_z(&mut self, angle: core::ffi::c_double) -> (); @@ -533,13 +226,8 @@ pub trait VtkPerspectiveTransform: VtkHomogeneousTransform + VtkAbstractTransfor y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn scale(&mut self, s: core::ffi::c_double) -> (); - fn scale(&mut self, s: core::ffi::c_float) -> (); fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); - fn set_matrix(&mut self, elements: core::ffi::c_double) -> (); fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> (); - fn concatenate(&mut self, elements: core::ffi::c_double) -> (); - fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> (); fn pre_multiply(&mut self) -> (); fn post_multiply(&mut self) -> (); fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int; @@ -555,13 +243,13 @@ pub trait VtkPerspectiveTransform: VtkHomogeneousTransform + VtkAbstractTransfor fn make_transform(&mut self) -> *mut core::ffi::c_void; fn get_m_time(&mut self) -> core::ffi::c_ulong; } -pub trait VtkSphericalTransform: VtkWarpTransform + VtkAbstractTransform { +pub trait VtkSphericalTransform { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn make_transform(&mut self) -> *mut core::ffi::c_void; } -pub trait VtkThinPlateSplineTransform: VtkWarpTransform + VtkAbstractTransform { +pub trait VtkThinPlateSplineTransform { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn new(&mut self) -> *mut core::ffi::c_void; @@ -571,7 +259,7 @@ pub trait VtkThinPlateSplineTransform: VtkWarpTransform + VtkAbstractTransform { fn get_basis(&mut self) -> core::ffi::c_int; fn set_basis_to_r(&mut self) -> (); fn set_basis_to_r_2_log_r(&mut self) -> (); - fn get_basis_as_string(&mut self) -> *const core::ffi::c_char; + fn get_basis_as_string(&mut self) -> &str; fn set_basis_function(&mut self, U: *mut core::ffi::c_void) -> (); fn set_basis_derivative(&mut self, dUdr: *mut core::ffi::c_void) -> (); fn set_source_landmarks(&mut self, source: *mut core::ffi::c_void) -> (); @@ -585,7 +273,7 @@ pub trait VtkThinPlateSplineTransform: VtkWarpTransform + VtkAbstractTransform { fn regularize_bulk_transform_on(&mut self) -> (); fn regularize_bulk_transform_off(&mut self) -> (); } -pub trait VtkTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstractTransform { +pub trait VtkTransform { fn new(&mut self) -> *mut core::ffi::c_void; fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; @@ -597,8 +285,6 @@ pub trait VtkTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstra y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn translate(&mut self, x: core::ffi::c_double) -> (); - fn translate(&mut self, x: core::ffi::c_float) -> (); fn rotate_wxyz( &mut self, angle: core::ffi::c_double, @@ -606,16 +292,6 @@ pub trait VtkTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstra y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_double, - ) -> (); - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_float, - ) -> (); fn rotate_x(&mut self, angle: core::ffi::c_double) -> (); fn rotate_y(&mut self, angle: core::ffi::c_double) -> (); fn rotate_z(&mut self, angle: core::ffi::c_double) -> (); @@ -625,13 +301,8 @@ pub trait VtkTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstra y: core::ffi::c_double, z: core::ffi::c_double, ) -> (); - fn scale(&mut self, s: core::ffi::c_double) -> (); - fn scale(&mut self, s: core::ffi::c_float) -> (); fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); - fn set_matrix(&mut self, elements: core::ffi::c_double) -> (); fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> (); - fn concatenate(&mut self, elements: core::ffi::c_double) -> (); - fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> (); fn pre_multiply(&mut self) -> (); fn post_multiply(&mut self) -> (); fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int; @@ -639,23 +310,6 @@ pub trait VtkTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstra &mut self, i: core::ffi::c_int, ) -> *mut core::ffi::c_void; - fn get_orientation(&mut self, orient: core::ffi::c_double) -> (); - fn get_orientation(&mut self, orient: core::ffi::c_float) -> (); - fn get_orientation(&mut self) -> *mut core::ffi::c_double; - fn get_orientation( - &mut self, - orient: core::ffi::c_double, - matrix: *mut core::ffi::c_void, - ) -> (); - fn get_orientation_wxyz(&mut self, wxyz: core::ffi::c_double) -> (); - fn get_orientation_wxyz(&mut self, wxyz: core::ffi::c_float) -> (); - fn get_orientation_wxyz(&mut self) -> *mut core::ffi::c_double; - fn get_position(&mut self, pos: core::ffi::c_double) -> (); - fn get_position(&mut self, pos: core::ffi::c_float) -> (); - fn get_position(&mut self) -> *mut core::ffi::c_double; - fn get_scale(&mut self, scale: core::ffi::c_double) -> (); - fn get_scale(&mut self, scale: core::ffi::c_float) -> (); - fn get_scale(&mut self) -> *mut core::ffi::c_double; fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> (); fn get_transpose(&mut self, transpose: *mut core::ffi::c_void) -> (); fn set_input(&mut self, input: *mut core::ffi::c_void) -> (); @@ -665,12 +319,6 @@ pub trait VtkTransform: VtkLinearTransform + VtkHomogeneousTransform + VtkAbstra fn pop(&mut self) -> (); fn make_transform(&mut self) -> *mut core::ffi::c_void; fn get_m_time(&mut self) -> core::ffi::c_ulong; - fn multiply_point(&mut self, in_: core::ffi::c_float, out: core::ffi::c_float) -> (); - fn multiply_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); } pub trait VtkTransform2D { fn new(&mut self) -> *mut core::ffi::c_void; @@ -679,63 +327,13 @@ pub trait VtkTransform2D { fn identity(&mut self) -> (); fn inverse(&mut self) -> (); fn translate(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); - fn translate(&mut self, x: core::ffi::c_double) -> (); - fn translate(&mut self, x: core::ffi::c_float) -> (); fn rotate(&mut self, angle: core::ffi::c_double) -> (); fn scale(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); - fn scale(&mut self, s: core::ffi::c_double) -> (); - fn scale(&mut self, s: core::ffi::c_float) -> (); fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); - fn set_matrix(&mut self, elements: core::ffi::c_double) -> (); fn get_matrix(&mut self) -> *mut core::ffi::c_void; - fn get_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); - fn get_position(&mut self, pos: core::ffi::c_double) -> (); - fn get_position(&mut self, pos: core::ffi::c_float) -> (); - fn get_scale(&mut self, scale: core::ffi::c_double) -> (); - fn get_scale(&mut self, pos: core::ffi::c_float) -> (); fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> (); fn get_transpose(&mut self, transpose: *mut core::ffi::c_void) -> (); fn get_m_time(&mut self) -> core::ffi::c_ulong; - fn transform_points( - &mut self, - inPts: core::ffi::c_float, - outPts: core::ffi::c_float, - n: core::ffi::c_int, - ) -> (); - fn transform_points( - &mut self, - inPts: core::ffi::c_double, - outPts: core::ffi::c_double, - n: core::ffi::c_int, - ) -> (); - fn transform_points( - &mut self, - inPts: *mut core::ffi::c_void, - outPts: *mut core::ffi::c_void, - ) -> (); - fn inverse_transform_points( - &mut self, - inPts: core::ffi::c_float, - outPts: core::ffi::c_float, - n: core::ffi::c_int, - ) -> (); - fn inverse_transform_points( - &mut self, - inPts: core::ffi::c_double, - outPts: core::ffi::c_double, - n: core::ffi::c_int, - ) -> (); - fn inverse_transform_points( - &mut self, - inPts: *mut core::ffi::c_void, - outPts: *mut core::ffi::c_void, - ) -> (); - fn multiply_point(&mut self, in_: core::ffi::c_float, out: core::ffi::c_float) -> (); - fn multiply_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); } pub trait VtkTransformCollection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; @@ -743,13 +341,11 @@ pub trait VtkTransformCollection { fn new(&mut self) -> *mut core::ffi::c_void; fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); fn get_next_item(&mut self) -> *mut core::ffi::c_void; - fn get_next_transform(&mut self, cookie: ()) -> *mut core::ffi::c_void; } pub trait VtkTransformConcatenation { fn new(&mut self) -> *mut core::ffi::c_void; fn delete(&mut self) -> (); fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> (); - fn concatenate(&mut self, elements: core::ffi::c_double) -> (); fn set_pre_multiply_flag(&mut self, flag: core::ffi::c_int) -> (); fn get_pre_multiply_flag(&mut self) -> core::ffi::c_int; fn translate( @@ -784,14 +380,12 @@ pub trait VtkTransformConcatenation { pub trait VtkTransformConcatenationStack { fn new(&mut self) -> *mut core::ffi::c_void; fn delete(&mut self) -> (); - fn pop(&mut self, concat: *mut core::ffi::c_void) -> (); - fn push(&mut self, concat: *mut core::ffi::c_void) -> (); fn deep_copy(&mut self, stack: *mut core::ffi::c_void) -> (); } pub trait VtkTransformPair { fn swap_forward_inverse(&mut self) -> (); } -pub trait VtkWarpTransform: VtkAbstractTransform { +pub trait VtkWarpTransform { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; fn new_instance(&mut self) -> *mut core::ffi::c_void; fn inverse(&mut self) -> (); @@ -800,72 +394,6 @@ pub trait VtkWarpTransform: VtkAbstractTransform { fn get_inverse_tolerance(&mut self) -> core::ffi::c_double; fn set_inverse_iterations(&mut self, _arg: core::ffi::c_int) -> (); fn get_inverse_iterations(&mut self) -> core::ffi::c_int; - fn internal_transform_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn internal_transform_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn internal_transform_derivative( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - derivative: core::ffi::c_float, - ) -> (); - fn internal_transform_derivative( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - derivative: core::ffi::c_double, - ) -> (); - fn template_transform_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn template_transform_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn template_transform_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - derivative: core::ffi::c_float, - ) -> (); - fn template_transform_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - derivative: core::ffi::c_double, - ) -> (); - fn template_transform_inverse( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> (); - fn template_transform_inverse( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> (); - fn template_transform_inverse( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - derivative: core::ffi::c_float, - ) -> (); - fn template_transform_inverse( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - derivative: core::ffi::c_double, - ) -> (); } impl VtkCylindricalTransform for vtkCylindricalTransform { fn new(&mut self) -> *mut core::ffi::c_void { @@ -956,24 +484,6 @@ impl VtkGeneralTransform for vtkGeneralTransform { } unsafe { vtk_general_transform_translate(self.0, x, y, z) } } - fn translate(&mut self, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_general_transform_translate( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ); - } - unsafe { vtk_general_transform_translate(self.0, x) } - } - fn translate(&mut self, x: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_general_transform_translate( - sself: *mut core::ffi::c_void, - x: core::ffi::c_float, - ); - } - unsafe { vtk_general_transform_translate(self.0, x) } - } fn rotate_wxyz( &mut self, angle: core::ffi::c_double, @@ -992,34 +502,6 @@ impl VtkGeneralTransform for vtkGeneralTransform { } unsafe { vtk_general_transform_rotate_wxyz(self.0, angle, x, y, z) } } - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_general_transform_rotate_wxyz( - sself: *mut core::ffi::c_void, - angle: core::ffi::c_double, - axis: core::ffi::c_double, - ); - } - unsafe { vtk_general_transform_rotate_wxyz(self.0, angle, axis) } - } - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_general_transform_rotate_wxyz( - sself: *mut core::ffi::c_void, - angle: core::ffi::c_double, - axis: core::ffi::c_float, - ); - } - unsafe { vtk_general_transform_rotate_wxyz(self.0, angle, axis) } - } fn rotate_x(&mut self, angle: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_general_transform_rotate_x( @@ -1063,24 +545,6 @@ impl VtkGeneralTransform for vtkGeneralTransform { } unsafe { vtk_general_transform_scale(self.0, x, y, z) } } - fn scale(&mut self, s: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_general_transform_scale( - sself: *mut core::ffi::c_void, - s: core::ffi::c_double, - ); - } - unsafe { vtk_general_transform_scale(self.0, s) } - } - fn scale(&mut self, s: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_general_transform_scale( - sself: *mut core::ffi::c_void, - s: core::ffi::c_float, - ); - } - unsafe { vtk_general_transform_scale(self.0, s) } - } fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_general_transform_concatenate( @@ -1090,24 +554,6 @@ impl VtkGeneralTransform for vtkGeneralTransform { } unsafe { vtk_general_transform_concatenate(self.0, matrix) } } - fn concatenate(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_general_transform_concatenate( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_general_transform_concatenate(self.0, elements) } - } - fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_general_transform_concatenate( - sself: *mut core::ffi::c_void, - transform: *mut core::ffi::c_void, - ); - } - unsafe { vtk_general_transform_concatenate(self.0, transform) } - } fn pre_multiply(&mut self) -> () { unsafe extern "C" { fn vtk_general_transform_pre_multiply(sself: *mut core::ffi::c_void); @@ -1169,87 +615,13 @@ impl VtkGeneralTransform for vtkGeneralTransform { unsafe extern "C" { fn vtk_general_transform_push(sself: *mut core::ffi::c_void); } - unsafe { vtk_general_transform_push(self.0) } - } - fn pop(&mut self) -> () { - unsafe extern "C" { - fn vtk_general_transform_pop(sself: *mut core::ffi::c_void); - } - unsafe { vtk_general_transform_pop(self.0) } - } - fn internal_transform_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_general_transform_internal_transform_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ); - } - unsafe { vtk_general_transform_internal_transform_point(self.0, in_, out) } - } - fn internal_transform_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_general_transform_internal_transform_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ); - } - unsafe { vtk_general_transform_internal_transform_point(self.0, in_, out) } - } - fn internal_transform_derivative( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - derivative: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_general_transform_internal_transform_derivative( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_float, - out: core::ffi::c_float, - derivative: core::ffi::c_float, - ); - } - unsafe { - vtk_general_transform_internal_transform_derivative( - self.0, - in_, - out, - derivative, - ) - } - } - fn internal_transform_derivative( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - derivative: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_general_transform_internal_transform_derivative( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_double, - out: core::ffi::c_double, - derivative: core::ffi::c_double, - ); - } - unsafe { - vtk_general_transform_internal_transform_derivative( - self.0, - in_, - out, - derivative, - ) + unsafe { vtk_general_transform_push(self.0) } + } + fn pop(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_pop(sself: *mut core::ffi::c_void); } + unsafe { vtk_general_transform_pop(self.0) } } fn make_transform(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { @@ -1408,13 +780,17 @@ impl VtkLandmarkTransform for vtkLandmarkTransform { } unsafe { vtk_landmark_transform_get_mode(self.0) } } - fn get_mode_as_string(&mut self) -> *const core::ffi::c_char { + fn get_mode_as_string(&mut self) -> &str { unsafe extern "C" { fn vtk_landmark_transform_get_mode_as_string( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_landmark_transform_get_mode_as_string(self.0) } + let ptr = unsafe { vtk_landmark_transform_get_mode_as_string(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn inverse(&mut self) -> () { unsafe extern "C" { @@ -1781,24 +1157,6 @@ impl VtkPerspectiveTransform for vtkPerspectiveTransform { } unsafe { vtk_perspective_transform_stereo(self.0, angle, focaldistance) } } - fn setup_camera( - &mut self, - position: core::ffi::c_double, - focalpoint: core::ffi::c_double, - viewup: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_perspective_transform_setup_camera( - sself: *mut core::ffi::c_void, - position: core::ffi::c_double, - focalpoint: core::ffi::c_double, - viewup: core::ffi::c_double, - ); - } - unsafe { - vtk_perspective_transform_setup_camera(self.0, position, focalpoint, viewup) - } - } fn setup_camera( &mut self, p0: core::ffi::c_double, @@ -1856,24 +1214,6 @@ impl VtkPerspectiveTransform for vtkPerspectiveTransform { } unsafe { vtk_perspective_transform_translate(self.0, x, y, z) } } - fn translate(&mut self, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_perspective_transform_translate( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ); - } - unsafe { vtk_perspective_transform_translate(self.0, x) } - } - fn translate(&mut self, x: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_perspective_transform_translate( - sself: *mut core::ffi::c_void, - x: core::ffi::c_float, - ); - } - unsafe { vtk_perspective_transform_translate(self.0, x) } - } fn rotate_wxyz( &mut self, angle: core::ffi::c_double, @@ -1892,34 +1232,6 @@ impl VtkPerspectiveTransform for vtkPerspectiveTransform { } unsafe { vtk_perspective_transform_rotate_wxyz(self.0, angle, x, y, z) } } - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_perspective_transform_rotate_wxyz( - sself: *mut core::ffi::c_void, - angle: core::ffi::c_double, - axis: core::ffi::c_double, - ); - } - unsafe { vtk_perspective_transform_rotate_wxyz(self.0, angle, axis) } - } - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_perspective_transform_rotate_wxyz( - sself: *mut core::ffi::c_void, - angle: core::ffi::c_double, - axis: core::ffi::c_float, - ); - } - unsafe { vtk_perspective_transform_rotate_wxyz(self.0, angle, axis) } - } fn rotate_x(&mut self, angle: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_perspective_transform_rotate_x( @@ -1963,24 +1275,6 @@ impl VtkPerspectiveTransform for vtkPerspectiveTransform { } unsafe { vtk_perspective_transform_scale(self.0, x, y, z) } } - fn scale(&mut self, s: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_perspective_transform_scale( - sself: *mut core::ffi::c_void, - s: core::ffi::c_double, - ); - } - unsafe { vtk_perspective_transform_scale(self.0, s) } - } - fn scale(&mut self, s: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_perspective_transform_scale( - sself: *mut core::ffi::c_void, - s: core::ffi::c_float, - ); - } - unsafe { vtk_perspective_transform_scale(self.0, s) } - } fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_perspective_transform_set_matrix( @@ -1990,15 +1284,6 @@ impl VtkPerspectiveTransform for vtkPerspectiveTransform { } unsafe { vtk_perspective_transform_set_matrix(self.0, matrix) } } - fn set_matrix(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_perspective_transform_set_matrix( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_perspective_transform_set_matrix(self.0, elements) } - } fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_perspective_transform_concatenate( @@ -2008,24 +1293,6 @@ impl VtkPerspectiveTransform for vtkPerspectiveTransform { } unsafe { vtk_perspective_transform_concatenate(self.0, matrix) } } - fn concatenate(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_perspective_transform_concatenate( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_perspective_transform_concatenate(self.0, elements) } - } - fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_perspective_transform_concatenate( - sself: *mut core::ffi::c_void, - transform: *mut core::ffi::c_void, - ); - } - unsafe { vtk_perspective_transform_concatenate(self.0, transform) } - } fn pre_multiply(&mut self) -> () { unsafe extern "C" { fn vtk_perspective_transform_pre_multiply(sself: *mut core::ffi::c_void); @@ -2225,13 +1492,17 @@ impl VtkThinPlateSplineTransform for vtkThinPlateSplineTransform { } unsafe { vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(self.0) } } - fn get_basis_as_string(&mut self) -> *const core::ffi::c_char { + fn get_basis_as_string(&mut self) -> &str { unsafe extern "C" { fn vtk_thin_plate_spline_transform_get_basis_as_string( sself: *mut core::ffi::c_void, ) -> *const core::ffi::c_char; } - unsafe { vtk_thin_plate_spline_transform_get_basis_as_string(self.0) } + let ptr = unsafe { vtk_thin_plate_spline_transform_get_basis_as_string(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } } fn set_basis_function(&mut self, U: *mut core::ffi::c_void) -> () { unsafe extern "C" { @@ -2391,24 +1662,6 @@ impl VtkTransform for vtkTransform { } unsafe { vtk_transform_translate(self.0, x, y, z) } } - fn translate(&mut self, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_translate( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ); - } - unsafe { vtk_transform_translate(self.0, x) } - } - fn translate(&mut self, x: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_transform_translate( - sself: *mut core::ffi::c_void, - x: core::ffi::c_float, - ); - } - unsafe { vtk_transform_translate(self.0, x) } - } fn rotate_wxyz( &mut self, angle: core::ffi::c_double, @@ -2426,287 +1679,99 @@ impl VtkTransform for vtkTransform { ); } unsafe { vtk_transform_rotate_wxyz(self.0, angle, x, y, z) } - } - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_transform_rotate_wxyz( - sself: *mut core::ffi::c_void, - angle: core::ffi::c_double, - axis: core::ffi::c_double, - ); - } - unsafe { vtk_transform_rotate_wxyz(self.0, angle, axis) } - } - fn rotate_wxyz( - &mut self, - angle: core::ffi::c_double, - axis: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_transform_rotate_wxyz( - sself: *mut core::ffi::c_void, - angle: core::ffi::c_double, - axis: core::ffi::c_float, - ); - } - unsafe { vtk_transform_rotate_wxyz(self.0, angle, axis) } - } - fn rotate_x(&mut self, angle: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_rotate_x( - sself: *mut core::ffi::c_void, - angle: core::ffi::c_double, - ); - } - unsafe { vtk_transform_rotate_x(self.0, angle) } - } - fn rotate_y(&mut self, angle: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_rotate_y( - sself: *mut core::ffi::c_void, - angle: core::ffi::c_double, - ); - } - unsafe { vtk_transform_rotate_y(self.0, angle) } - } - fn rotate_z(&mut self, angle: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_rotate_z( - sself: *mut core::ffi::c_void, - angle: core::ffi::c_double, - ); - } - unsafe { vtk_transform_rotate_z(self.0, angle) } - } - fn scale( - &mut self, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_transform_scale( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - y: core::ffi::c_double, - z: core::ffi::c_double, - ); - } - unsafe { vtk_transform_scale(self.0, x, y, z) } - } - fn scale(&mut self, s: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_scale( - sself: *mut core::ffi::c_void, - s: core::ffi::c_double, - ); - } - unsafe { vtk_transform_scale(self.0, s) } - } - fn scale(&mut self, s: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_transform_scale(sself: *mut core::ffi::c_void, s: core::ffi::c_float); - } - unsafe { vtk_transform_scale(self.0, s) } - } - fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_transform_set_matrix( - sself: *mut core::ffi::c_void, - matrix: *mut core::ffi::c_void, - ); - } - unsafe { vtk_transform_set_matrix(self.0, matrix) } - } - fn set_matrix(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_set_matrix( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_transform_set_matrix(self.0, elements) } - } - fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_transform_concatenate( - sself: *mut core::ffi::c_void, - matrix: *mut core::ffi::c_void, - ); - } - unsafe { vtk_transform_concatenate(self.0, matrix) } - } - fn concatenate(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_concatenate( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_transform_concatenate(self.0, elements) } - } - fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_transform_concatenate( - sself: *mut core::ffi::c_void, - transform: *mut core::ffi::c_void, - ); - } - unsafe { vtk_transform_concatenate(self.0, transform) } - } - fn pre_multiply(&mut self) -> () { - unsafe extern "C" { - fn vtk_transform_pre_multiply(sself: *mut core::ffi::c_void); - } - unsafe { vtk_transform_pre_multiply(self.0) } - } - fn post_multiply(&mut self) -> () { - unsafe extern "C" { - fn vtk_transform_post_multiply(sself: *mut core::ffi::c_void); - } - unsafe { vtk_transform_post_multiply(self.0) } - } - fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int { - unsafe extern "C" { - fn vtk_transform_get_number_of_concatenated_transforms( - sself: *mut core::ffi::c_void, - ) -> core::ffi::c_int; - } - unsafe { vtk_transform_get_number_of_concatenated_transforms(self.0) } - } - fn get_concatenated_transform( - &mut self, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_transform_get_concatenated_transform( - sself: *mut core::ffi::c_void, - i: core::ffi::c_int, - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_transform_get_concatenated_transform(self.0, i) } - } - fn get_orientation(&mut self, orient: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_get_orientation( - sself: *mut core::ffi::c_void, - orient: core::ffi::c_double, - ); - } - unsafe { vtk_transform_get_orientation(self.0, orient) } - } - fn get_orientation(&mut self, orient: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_transform_get_orientation( - sself: *mut core::ffi::c_void, - orient: core::ffi::c_float, - ); - } - unsafe { vtk_transform_get_orientation(self.0, orient) } - } - fn get_orientation(&mut self) -> *mut core::ffi::c_double { - unsafe extern "C" { - fn vtk_transform_get_orientation( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; - } - unsafe { vtk_transform_get_orientation(self.0) } - } - fn get_orientation( - &mut self, - orient: core::ffi::c_double, - matrix: *mut core::ffi::c_void, - ) -> () { + } + fn rotate_x(&mut self, angle: core::ffi::c_double) -> () { unsafe extern "C" { - fn vtk_transform_get_orientation( + fn vtk_transform_rotate_x( sself: *mut core::ffi::c_void, - orient: core::ffi::c_double, - matrix: *mut core::ffi::c_void, + angle: core::ffi::c_double, ); } - unsafe { vtk_transform_get_orientation(self.0, orient, matrix) } + unsafe { vtk_transform_rotate_x(self.0, angle) } } - fn get_orientation_wxyz(&mut self, wxyz: core::ffi::c_double) -> () { + fn rotate_y(&mut self, angle: core::ffi::c_double) -> () { unsafe extern "C" { - fn vtk_transform_get_orientation_wxyz( + fn vtk_transform_rotate_y( sself: *mut core::ffi::c_void, - wxyz: core::ffi::c_double, + angle: core::ffi::c_double, ); } - unsafe { vtk_transform_get_orientation_wxyz(self.0, wxyz) } + unsafe { vtk_transform_rotate_y(self.0, angle) } } - fn get_orientation_wxyz(&mut self, wxyz: core::ffi::c_float) -> () { + fn rotate_z(&mut self, angle: core::ffi::c_double) -> () { unsafe extern "C" { - fn vtk_transform_get_orientation_wxyz( + fn vtk_transform_rotate_z( sself: *mut core::ffi::c_void, - wxyz: core::ffi::c_float, + angle: core::ffi::c_double, ); } - unsafe { vtk_transform_get_orientation_wxyz(self.0, wxyz) } + unsafe { vtk_transform_rotate_z(self.0, angle) } } - fn get_orientation_wxyz(&mut self) -> *mut core::ffi::c_double { + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { unsafe extern "C" { - fn vtk_transform_get_orientation_wxyz( + fn vtk_transform_scale( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); } - unsafe { vtk_transform_get_orientation_wxyz(self.0) } + unsafe { vtk_transform_scale(self.0, x, y, z) } } - fn get_position(&mut self, pos: core::ffi::c_double) -> () { + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_transform_get_position( + fn vtk_transform_set_matrix( sself: *mut core::ffi::c_void, - pos: core::ffi::c_double, + matrix: *mut core::ffi::c_void, ); } - unsafe { vtk_transform_get_position(self.0, pos) } + unsafe { vtk_transform_set_matrix(self.0, matrix) } } - fn get_position(&mut self, pos: core::ffi::c_float) -> () { + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> () { unsafe extern "C" { - fn vtk_transform_get_position( + fn vtk_transform_concatenate( sself: *mut core::ffi::c_void, - pos: core::ffi::c_float, + matrix: *mut core::ffi::c_void, ); } - unsafe { vtk_transform_get_position(self.0, pos) } + unsafe { vtk_transform_concatenate(self.0, matrix) } } - fn get_position(&mut self) -> *mut core::ffi::c_double { + fn pre_multiply(&mut self) -> () { unsafe extern "C" { - fn vtk_transform_get_position( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + fn vtk_transform_pre_multiply(sself: *mut core::ffi::c_void); } - unsafe { vtk_transform_get_position(self.0) } + unsafe { vtk_transform_pre_multiply(self.0) } } - fn get_scale(&mut self, scale: core::ffi::c_double) -> () { + fn post_multiply(&mut self) -> () { unsafe extern "C" { - fn vtk_transform_get_scale( - sself: *mut core::ffi::c_void, - scale: core::ffi::c_double, - ); + fn vtk_transform_post_multiply(sself: *mut core::ffi::c_void); } - unsafe { vtk_transform_get_scale(self.0, scale) } + unsafe { vtk_transform_post_multiply(self.0) } } - fn get_scale(&mut self, scale: core::ffi::c_float) -> () { + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int { unsafe extern "C" { - fn vtk_transform_get_scale( + fn vtk_transform_get_number_of_concatenated_transforms( sself: *mut core::ffi::c_void, - scale: core::ffi::c_float, - ); + ) -> core::ffi::c_int; } - unsafe { vtk_transform_get_scale(self.0, scale) } + unsafe { vtk_transform_get_number_of_concatenated_transforms(self.0) } } - fn get_scale(&mut self) -> *mut core::ffi::c_double { + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { unsafe extern "C" { - fn vtk_transform_get_scale( + fn vtk_transform_get_concatenated_transform( sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_double; + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; } - unsafe { vtk_transform_get_scale(self.0) } + unsafe { vtk_transform_get_concatenated_transform(self.0, i) } } fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> () { unsafe extern "C" { @@ -2779,34 +1844,6 @@ impl VtkTransform for vtkTransform { } unsafe { vtk_transform_get_m_time(self.0) } } - fn multiply_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_transform_multiply_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ); - } - unsafe { vtk_transform_multiply_point(self.0, in_, out) } - } - fn multiply_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_transform_multiply_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ); - } - unsafe { vtk_transform_multiply_point(self.0, in_, out) } - } } impl VtkTransform2D for vtkTransform2D { fn new(&mut self) -> *mut core::ffi::c_void { @@ -2856,24 +1893,6 @@ impl VtkTransform2D for vtkTransform2D { } unsafe { vtk_transform_2_d_translate(self.0, x, y) } } - fn translate(&mut self, x: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_translate( - sself: *mut core::ffi::c_void, - x: core::ffi::c_double, - ); - } - unsafe { vtk_transform_2_d_translate(self.0, x) } - } - fn translate(&mut self, x: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_translate( - sself: *mut core::ffi::c_void, - x: core::ffi::c_float, - ); - } - unsafe { vtk_transform_2_d_translate(self.0, x) } - } fn rotate(&mut self, angle: core::ffi::c_double) -> () { unsafe extern "C" { fn vtk_transform_2_d_rotate( @@ -2893,24 +1912,6 @@ impl VtkTransform2D for vtkTransform2D { } unsafe { vtk_transform_2_d_scale(self.0, x, y) } } - fn scale(&mut self, s: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_scale( - sself: *mut core::ffi::c_void, - s: core::ffi::c_double, - ); - } - unsafe { vtk_transform_2_d_scale(self.0, s) } - } - fn scale(&mut self, s: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_scale( - sself: *mut core::ffi::c_void, - s: core::ffi::c_float, - ); - } - unsafe { vtk_transform_2_d_scale(self.0, s) } - } fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_transform_2_d_set_matrix( @@ -2920,15 +1921,6 @@ impl VtkTransform2D for vtkTransform2D { } unsafe { vtk_transform_2_d_set_matrix(self.0, matrix) } } - fn set_matrix(&mut self, elements: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_set_matrix( - sself: *mut core::ffi::c_void, - elements: core::ffi::c_double, - ); - } - unsafe { vtk_transform_2_d_set_matrix(self.0, elements) } - } fn get_matrix(&mut self) -> *mut core::ffi::c_void { unsafe extern "C" { fn vtk_transform_2_d_get_matrix( @@ -2937,51 +1929,6 @@ impl VtkTransform2D for vtkTransform2D { } unsafe { vtk_transform_2_d_get_matrix(self.0) } } - fn get_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_get_matrix( - sself: *mut core::ffi::c_void, - matrix: *mut core::ffi::c_void, - ); - } - unsafe { vtk_transform_2_d_get_matrix(self.0, matrix) } - } - fn get_position(&mut self, pos: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_get_position( - sself: *mut core::ffi::c_void, - pos: core::ffi::c_double, - ); - } - unsafe { vtk_transform_2_d_get_position(self.0, pos) } - } - fn get_position(&mut self, pos: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_get_position( - sself: *mut core::ffi::c_void, - pos: core::ffi::c_float, - ); - } - unsafe { vtk_transform_2_d_get_position(self.0, pos) } - } - fn get_scale(&mut self, scale: core::ffi::c_double) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_get_scale( - sself: *mut core::ffi::c_void, - scale: core::ffi::c_double, - ); - } - unsafe { vtk_transform_2_d_get_scale(self.0, scale) } - } - fn get_scale(&mut self, pos: core::ffi::c_float) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_get_scale( - sself: *mut core::ffi::c_void, - pos: core::ffi::c_float, - ); - } - unsafe { vtk_transform_2_d_get_scale(self.0, pos) } - } fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> () { unsafe extern "C" { fn vtk_transform_2_d_get_inverse( @@ -3008,126 +1955,6 @@ impl VtkTransform2D for vtkTransform2D { } unsafe { vtk_transform_2_d_get_m_time(self.0) } } - fn transform_points( - &mut self, - inPts: core::ffi::c_float, - outPts: core::ffi::c_float, - n: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_transform_points( - sself: *mut core::ffi::c_void, - inPts: core::ffi::c_float, - outPts: core::ffi::c_float, - n: core::ffi::c_int, - ); - } - unsafe { vtk_transform_2_d_transform_points(self.0, inPts, outPts, n) } - } - fn transform_points( - &mut self, - inPts: core::ffi::c_double, - outPts: core::ffi::c_double, - n: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_transform_points( - sself: *mut core::ffi::c_void, - inPts: core::ffi::c_double, - outPts: core::ffi::c_double, - n: core::ffi::c_int, - ); - } - unsafe { vtk_transform_2_d_transform_points(self.0, inPts, outPts, n) } - } - fn transform_points( - &mut self, - inPts: *mut core::ffi::c_void, - outPts: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_transform_points( - sself: *mut core::ffi::c_void, - inPts: *mut core::ffi::c_void, - outPts: *mut core::ffi::c_void, - ); - } - unsafe { vtk_transform_2_d_transform_points(self.0, inPts, outPts) } - } - fn inverse_transform_points( - &mut self, - inPts: core::ffi::c_float, - outPts: core::ffi::c_float, - n: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_inverse_transform_points( - sself: *mut core::ffi::c_void, - inPts: core::ffi::c_float, - outPts: core::ffi::c_float, - n: core::ffi::c_int, - ); - } - unsafe { vtk_transform_2_d_inverse_transform_points(self.0, inPts, outPts, n) } - } - fn inverse_transform_points( - &mut self, - inPts: core::ffi::c_double, - outPts: core::ffi::c_double, - n: core::ffi::c_int, - ) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_inverse_transform_points( - sself: *mut core::ffi::c_void, - inPts: core::ffi::c_double, - outPts: core::ffi::c_double, - n: core::ffi::c_int, - ); - } - unsafe { vtk_transform_2_d_inverse_transform_points(self.0, inPts, outPts, n) } - } - fn inverse_transform_points( - &mut self, - inPts: *mut core::ffi::c_void, - outPts: *mut core::ffi::c_void, - ) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_inverse_transform_points( - sself: *mut core::ffi::c_void, - inPts: *mut core::ffi::c_void, - outPts: *mut core::ffi::c_void, - ); - } - unsafe { vtk_transform_2_d_inverse_transform_points(self.0, inPts, outPts) } - } - fn multiply_point( - &mut self, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_multiply_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_float, - out: core::ffi::c_float, - ); - } - unsafe { vtk_transform_2_d_multiply_point(self.0, in_, out) } - } - fn multiply_point( - &mut self, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ) -> () { - unsafe extern "C" { - fn vtk_transform_2_d_multiply_point( - sself: *mut core::ffi::c_void, - in_: core::ffi::c_double, - out: core::ffi::c_double, - ); - } - unsafe { vtk_transform_2_d_multiply_point(self.0, in_, out) } - } } impl VtkTransformCollection for vtkTransformCollection { fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { @@ -3172,15 +1999,6 @@ impl VtkTransformCollection for vtkTransformCollection { } unsafe { vtk_transform_collection_get_next_item(self.0) } } - fn get_next_transform(&mut self, cookie: ()) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtk_transform_collection_get_next_transform( - sself: *mut core::ffi::c_void, - cookie: (), - ) -> *mut core::ffi::c_void; - } - unsafe { vtk_transform_collection_get_next_transform(self.0, cookie) } - } } /// cylindrical to rectangular coords and back /// @@ -3198,22 +2016,13 @@ impl VtkTransformCollection for vtkTransformCollection { #[allow(non_camel_case_types)] pub struct vtkCylindricalTransform(*mut core::ffi::c_void); impl vtkCylindricalTransform { - /// Creates a new [vtkCylindricalTransform] wrapped inside `vtkNew` + /// Creates a new [vtkCylindricalTransform] via `vtkCylindricalTransform::New()` #[doc(alias = "vtkCylindricalTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkCylindricalTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCylindricalTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCylindricalTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCylindricalTransform_get_ptr(self.0) } + Self(unsafe { vtkCylindricalTransform_new() }) } } impl std::default::Default for vtkCylindricalTransform { @@ -3233,12 +2042,8 @@ impl Drop for vtkCylindricalTransform { #[test] fn test_vtkCylindricalTransform_create_drop() { let obj = vtkCylindricalTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCylindricalTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// allows operations on any transforms /// @@ -3254,22 +2059,13 @@ fn test_vtkCylindricalTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGeneralTransform(*mut core::ffi::c_void); impl vtkGeneralTransform { - /// Creates a new [vtkGeneralTransform] wrapped inside `vtkNew` + /// Creates a new [vtkGeneralTransform] via `vtkGeneralTransform::New()` #[doc(alias = "vtkGeneralTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkGeneralTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGeneralTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGeneralTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGeneralTransform_get_ptr(self.0) } + Self(unsafe { vtkGeneralTransform_new() }) } } impl std::default::Default for vtkGeneralTransform { @@ -3289,12 +2085,8 @@ impl Drop for vtkGeneralTransform { #[test] fn test_vtkGeneralTransform_create_drop() { let obj = vtkGeneralTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGeneralTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a transform that doesn't do anything /// @@ -3307,22 +2099,13 @@ fn test_vtkGeneralTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIdentityTransform(*mut core::ffi::c_void); impl vtkIdentityTransform { - /// Creates a new [vtkIdentityTransform] wrapped inside `vtkNew` + /// Creates a new [vtkIdentityTransform] via `vtkIdentityTransform::New()` #[doc(alias = "vtkIdentityTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkIdentityTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIdentityTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIdentityTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIdentityTransform_get_ptr(self.0) } + Self(unsafe { vtkIdentityTransform_new() }) } } impl std::default::Default for vtkIdentityTransform { @@ -3342,12 +2125,8 @@ impl Drop for vtkIdentityTransform { #[test] fn test_vtkIdentityTransform_create_drop() { let obj = vtkIdentityTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIdentityTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a linear transform specified by two corresponding point sets /// @@ -3366,22 +2145,13 @@ fn test_vtkIdentityTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLandmarkTransform(*mut core::ffi::c_void); impl vtkLandmarkTransform { - /// Creates a new [vtkLandmarkTransform] wrapped inside `vtkNew` + /// Creates a new [vtkLandmarkTransform] via `vtkLandmarkTransform::New()` #[doc(alias = "vtkLandmarkTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkLandmarkTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLandmarkTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLandmarkTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLandmarkTransform_get_ptr(self.0) } + Self(unsafe { vtkLandmarkTransform_new() }) } } impl std::default::Default for vtkLandmarkTransform { @@ -3401,12 +2171,8 @@ impl Drop for vtkLandmarkTransform { #[test] fn test_vtkLandmarkTransform_create_drop() { let obj = vtkLandmarkTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLandmarkTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// convert a matrix to a transform /// @@ -3421,22 +2187,13 @@ fn test_vtkLandmarkTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMatrixToHomogeneousTransform(*mut core::ffi::c_void); impl vtkMatrixToHomogeneousTransform { - /// Creates a new [vtkMatrixToHomogeneousTransform] wrapped inside `vtkNew` + /// Creates a new [vtkMatrixToHomogeneousTransform] via `vtkMatrixToHomogeneousTransform::New()` #[doc(alias = "vtkMatrixToHomogeneousTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkMatrixToHomogeneousTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMatrixToHomogeneousTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMatrixToHomogeneousTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMatrixToHomogeneousTransform_get_ptr(self.0) } + Self(unsafe { vtkMatrixToHomogeneousTransform_new() }) } } impl std::default::Default for vtkMatrixToHomogeneousTransform { @@ -3456,12 +2213,8 @@ impl Drop for vtkMatrixToHomogeneousTransform { #[test] fn test_vtkMatrixToHomogeneousTransform_create_drop() { let obj = vtkMatrixToHomogeneousTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMatrixToHomogeneousTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// convert a matrix to a transform /// @@ -3476,22 +2229,13 @@ fn test_vtkMatrixToHomogeneousTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMatrixToLinearTransform(*mut core::ffi::c_void); impl vtkMatrixToLinearTransform { - /// Creates a new [vtkMatrixToLinearTransform] wrapped inside `vtkNew` + /// Creates a new [vtkMatrixToLinearTransform] via `vtkMatrixToLinearTransform::New()` #[doc(alias = "vtkMatrixToLinearTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkMatrixToLinearTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMatrixToLinearTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMatrixToLinearTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMatrixToLinearTransform_get_ptr(self.0) } + Self(unsafe { vtkMatrixToLinearTransform_new() }) } } impl std::default::Default for vtkMatrixToLinearTransform { @@ -3511,12 +2255,8 @@ impl Drop for vtkMatrixToLinearTransform { #[test] fn test_vtkMatrixToLinearTransform_create_drop() { let obj = vtkMatrixToLinearTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMatrixToLinearTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// describes a 4x4 matrix transformation /// @@ -3547,22 +2287,13 @@ fn test_vtkMatrixToLinearTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPerspectiveTransform(*mut core::ffi::c_void); impl vtkPerspectiveTransform { - /// Creates a new [vtkPerspectiveTransform] wrapped inside `vtkNew` + /// Creates a new [vtkPerspectiveTransform] via `vtkPerspectiveTransform::New()` #[doc(alias = "vtkPerspectiveTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkPerspectiveTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPerspectiveTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPerspectiveTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPerspectiveTransform_get_ptr(self.0) } + Self(unsafe { vtkPerspectiveTransform_new() }) } } impl std::default::Default for vtkPerspectiveTransform { @@ -3582,12 +2313,8 @@ impl Drop for vtkPerspectiveTransform { #[test] fn test_vtkPerspectiveTransform_create_drop() { let obj = vtkPerspectiveTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPerspectiveTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// spherical to rectangular coords and back /// @@ -3606,22 +2333,13 @@ fn test_vtkPerspectiveTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSphericalTransform(*mut core::ffi::c_void); impl vtkSphericalTransform { - /// Creates a new [vtkSphericalTransform] wrapped inside `vtkNew` + /// Creates a new [vtkSphericalTransform] via `vtkSphericalTransform::New()` #[doc(alias = "vtkSphericalTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkSphericalTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSphericalTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSphericalTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSphericalTransform_get_ptr(self.0) } + Self(unsafe { vtkSphericalTransform_new() }) } } impl std::default::Default for vtkSphericalTransform { @@ -3641,12 +2359,8 @@ impl Drop for vtkSphericalTransform { #[test] fn test_vtkSphericalTransform_create_drop() { let obj = vtkSphericalTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSphericalTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a nonlinear warp transformation /// @@ -3673,22 +2387,13 @@ fn test_vtkSphericalTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkThinPlateSplineTransform(*mut core::ffi::c_void); impl vtkThinPlateSplineTransform { - /// Creates a new [vtkThinPlateSplineTransform] wrapped inside `vtkNew` + /// Creates a new [vtkThinPlateSplineTransform] via `vtkThinPlateSplineTransform::New()` #[doc(alias = "vtkThinPlateSplineTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkThinPlateSplineTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkThinPlateSplineTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkThinPlateSplineTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkThinPlateSplineTransform_get_ptr(self.0) } + Self(unsafe { vtkThinPlateSplineTransform_new() }) } } impl std::default::Default for vtkThinPlateSplineTransform { @@ -3708,12 +2413,8 @@ impl Drop for vtkThinPlateSplineTransform { #[test] fn test_vtkThinPlateSplineTransform_create_drop() { let obj = vtkThinPlateSplineTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkThinPlateSplineTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// describes linear transformations via a 4x4 matrix /// @@ -3745,22 +2446,13 @@ fn test_vtkThinPlateSplineTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTransform(*mut core::ffi::c_void); impl vtkTransform { - /// Creates a new [vtkTransform] wrapped inside `vtkNew` + /// Creates a new [vtkTransform] via `vtkTransform::New()` #[doc(alias = "vtkTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTransform_get_ptr(self.0) } + Self(unsafe { vtkTransform_new() }) } } impl std::default::Default for vtkTransform { @@ -3780,12 +2472,8 @@ impl Drop for vtkTransform { #[test] fn test_vtkTransform_create_drop() { let obj = vtkTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// describes linear transformations via a 3x3 matrix /// @@ -3806,22 +2494,13 @@ fn test_vtkTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTransform2D(*mut core::ffi::c_void); impl vtkTransform2D { - /// Creates a new [vtkTransform2D] wrapped inside `vtkNew` + /// Creates a new [vtkTransform2D] via `vtkTransform2D::New()` #[doc(alias = "vtkTransform2D")] pub fn new() -> Self { unsafe extern "C" { fn vtkTransform2D_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTransform2D_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTransform2D_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTransform2D_get_ptr(self.0) } + Self(unsafe { vtkTransform2D_new() }) } } impl std::default::Default for vtkTransform2D { @@ -3841,12 +2520,8 @@ impl Drop for vtkTransform2D { #[test] fn test_vtkTransform2D_create_drop() { let obj = vtkTransform2D::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTransform2D(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of transforms /// @@ -3860,22 +2535,13 @@ fn test_vtkTransform2D_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTransformCollection(*mut core::ffi::c_void); impl vtkTransformCollection { - /// Creates a new [vtkTransformCollection] wrapped inside `vtkNew` + /// Creates a new [vtkTransformCollection] via `vtkTransformCollection::New()` #[doc(alias = "vtkTransformCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkTransformCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTransformCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTransformCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTransformCollection_get_ptr(self.0) } + Self(unsafe { vtkTransformCollection_new() }) } } impl std::default::Default for vtkTransformCollection { @@ -3895,10 +2561,6 @@ impl Drop for vtkTransformCollection { #[test] fn test_vtkTransformCollection_create_drop() { let obj = vtkTransformCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTransformCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkFiltersSources.rs b/vtk-rs-9.1/src/vtkFiltersSources.rs new file mode 100644 index 0000000..3d3d6b6 --- /dev/null +++ b/vtk-rs-9.1/src/vtkFiltersSources.rs @@ -0,0 +1,10307 @@ +pub trait VtkArcSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_point_1( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_point_2( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_polar_vector( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_angle(&mut self, _arg: core::ffi::c_double) -> (); + fn get_angle_min_value(&mut self) -> core::ffi::c_double; + fn get_angle_max_value(&mut self) -> core::ffi::c_double; + fn get_angle(&mut self) -> core::ffi::c_double; + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_negative(&mut self, _arg: bool) -> (); + fn get_negative(&mut self) -> bool; + fn negative_on(&mut self) -> (); + fn negative_off(&mut self) -> (); + fn set_use_normal_and_angle(&mut self, _arg: bool) -> (); + fn get_use_normal_and_angle(&mut self) -> bool; + fn use_normal_and_angle_on(&mut self) -> (); + fn use_normal_and_angle_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkArrowSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_tip_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tip_length_min_value(&mut self) -> core::ffi::c_double; + fn get_tip_length_max_value(&mut self) -> core::ffi::c_double; + fn get_tip_length(&mut self) -> core::ffi::c_double; + fn set_tip_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tip_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_tip_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_tip_radius(&mut self) -> core::ffi::c_double; + fn set_tip_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_tip_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_tip_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_tip_resolution(&mut self) -> core::ffi::c_int; + fn set_shaft_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_shaft_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_shaft_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_shaft_radius(&mut self) -> core::ffi::c_double; + fn set_shaft_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_shaft_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_shaft_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_shaft_resolution(&mut self) -> core::ffi::c_int; + fn invert_on(&mut self) -> (); + fn invert_off(&mut self) -> (); + fn set_invert(&mut self, _arg: bool) -> (); + fn get_invert(&mut self) -> bool; + fn set_arrow_origin_to_default(&mut self) -> (); + fn set_arrow_origin_to_center(&mut self) -> (); +} +pub trait VtkButtonSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_texture_style(&mut self, _arg: core::ffi::c_int) -> (); + fn get_texture_style_min_value(&mut self) -> core::ffi::c_int; + fn get_texture_style_max_value(&mut self) -> core::ffi::c_int; + fn get_texture_style(&mut self) -> core::ffi::c_int; + fn set_texture_style_to_fit_image(&mut self) -> (); + fn set_texture_style_to_proportional(&mut self) -> (); + fn set_texture_dimensions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + ) -> (); + fn set_shoulder_texture_coordinate( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_two_sided(&mut self, _arg: core::ffi::c_int) -> (); + fn get_two_sided(&mut self) -> core::ffi::c_int; + fn two_sided_on(&mut self) -> (); + fn two_sided_off(&mut self) -> (); +} +pub trait VtkCapsuleSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_cylinder_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_cylinder_length_min_value(&mut self) -> core::ffi::c_double; + fn get_cylinder_length_max_value(&mut self) -> core::ffi::c_double; + fn get_cylinder_length(&mut self) -> core::ffi::c_double; + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution(&mut self) -> core::ffi::c_int; + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution(&mut self) -> core::ffi::c_int; + fn set_lat_long_tessellation(&mut self, _arg: core::ffi::c_int) -> (); + fn get_lat_long_tessellation(&mut self) -> core::ffi::c_int; + fn lat_long_tessellation_on(&mut self) -> (); + fn lat_long_tessellation_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkCellTypeSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_cell_type(&mut self, cellType: core::ffi::c_int) -> (); + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn set_cell_order(&mut self, _arg: core::ffi::c_int) -> (); + fn get_cell_order(&mut self) -> core::ffi::c_int; + fn set_complete_quadratic_simplicial_elements(&mut self, _arg: bool) -> (); + fn get_complete_quadratic_simplicial_elements(&mut self) -> bool; + fn complete_quadratic_simplicial_elements_on(&mut self) -> (); + fn complete_quadratic_simplicial_elements_off(&mut self) -> (); + fn set_polynomial_field_order(&mut self, _arg: core::ffi::c_int) -> (); + fn get_polynomial_field_order_min_value(&mut self) -> core::ffi::c_int; + fn get_polynomial_field_order_max_value(&mut self) -> core::ffi::c_int; + fn get_polynomial_field_order(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn set_output_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_precision_min_value(&mut self) -> core::ffi::c_int; + fn get_output_precision_max_value(&mut self) -> core::ffi::c_int; + fn get_output_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkConeSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_height(&mut self, _arg: core::ffi::c_double) -> (); + fn get_height_min_value(&mut self) -> core::ffi::c_double; + fn get_height_max_value(&mut self) -> core::ffi::c_double; + fn get_height(&mut self) -> core::ffi::c_double; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_direction( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_angle(&mut self, angle: core::ffi::c_double) -> (); + fn get_angle(&mut self) -> core::ffi::c_double; + fn set_capping(&mut self, _arg: core::ffi::c_int) -> (); + fn get_capping(&mut self) -> core::ffi::c_int; + fn capping_on(&mut self) -> (); + fn capping_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkCubeSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_x_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_x_length_min_value(&mut self) -> core::ffi::c_double; + fn get_x_length_max_value(&mut self) -> core::ffi::c_double; + fn get_x_length(&mut self) -> core::ffi::c_double; + fn set_y_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_y_length_min_value(&mut self) -> core::ffi::c_double; + fn get_y_length_max_value(&mut self) -> core::ffi::c_double; + fn get_y_length(&mut self) -> core::ffi::c_double; + fn set_z_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_z_length_min_value(&mut self) -> core::ffi::c_double; + fn get_z_length_max_value(&mut self) -> core::ffi::c_double; + fn get_z_length(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkCylinderSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_height(&mut self, _arg: core::ffi::c_double) -> (); + fn get_height_min_value(&mut self) -> core::ffi::c_double; + fn get_height_max_value(&mut self) -> core::ffi::c_double; + fn get_height(&mut self) -> core::ffi::c_double; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_capping(&mut self, _arg: core::ffi::c_int) -> (); + fn get_capping(&mut self) -> core::ffi::c_int; + fn capping_on(&mut self) -> (); + fn capping_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkDiagonalMatrixSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_array_type(&mut self) -> core::ffi::c_int; + fn set_array_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_extents(&mut self) -> core::ffi::c_longlong; + fn set_extents(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_diagonal(&mut self) -> core::ffi::c_double; + fn set_diagonal(&mut self, _arg: core::ffi::c_double) -> (); + fn get_super_diagonal(&mut self) -> core::ffi::c_double; + fn set_super_diagonal(&mut self, _arg: core::ffi::c_double) -> (); + fn get_sub_diagonal(&mut self) -> core::ffi::c_double; + fn set_sub_diagonal(&mut self, _arg: core::ffi::c_double) -> (); + fn set_row_label(&mut self, _arg: &str) -> (); + fn set_column_label(&mut self, _arg: &str) -> (); +} +pub trait VtkDiskSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_inner_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_inner_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_inner_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_inner_radius(&mut self) -> core::ffi::c_double; + fn set_outer_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_outer_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_outer_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_outer_radius(&mut self) -> core::ffi::c_double; + fn set_radial_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_radial_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_radial_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_radial_resolution(&mut self) -> core::ffi::c_int; + fn set_circumferential_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_circumferential_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_circumferential_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_circumferential_resolution(&mut self) -> core::ffi::c_int; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkEllipseArcSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_major_radius_vector( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_start_angle(&mut self, _arg: core::ffi::c_double) -> (); + fn get_start_angle_min_value(&mut self) -> core::ffi::c_double; + fn get_start_angle_max_value(&mut self) -> core::ffi::c_double; + fn get_start_angle(&mut self) -> core::ffi::c_double; + fn set_segment_angle(&mut self, _arg: core::ffi::c_double) -> (); + fn get_segment_angle_min_value(&mut self) -> core::ffi::c_double; + fn get_segment_angle_max_value(&mut self) -> core::ffi::c_double; + fn get_segment_angle(&mut self) -> core::ffi::c_double; + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_close(&mut self, _arg: bool) -> (); + fn get_close(&mut self) -> bool; + fn close_on(&mut self) -> (); + fn close_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; + fn set_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_ratio(&mut self) -> core::ffi::c_double; +} +pub trait VtkEllipticalButtonSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_width(&mut self, _arg: core::ffi::c_double) -> (); + fn get_width_min_value(&mut self) -> core::ffi::c_double; + fn get_width_max_value(&mut self) -> core::ffi::c_double; + fn get_width(&mut self) -> core::ffi::c_double; + fn set_height(&mut self, _arg: core::ffi::c_double) -> (); + fn get_height_min_value(&mut self) -> core::ffi::c_double; + fn get_height_max_value(&mut self) -> core::ffi::c_double; + fn get_height(&mut self) -> core::ffi::c_double; + fn set_depth(&mut self, _arg: core::ffi::c_double) -> (); + fn get_depth_min_value(&mut self) -> core::ffi::c_double; + fn get_depth_max_value(&mut self) -> core::ffi::c_double; + fn get_depth(&mut self) -> core::ffi::c_double; + fn set_circumferential_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_circumferential_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_circumferential_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_circumferential_resolution(&mut self) -> core::ffi::c_int; + fn set_texture_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_texture_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_texture_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_texture_resolution(&mut self) -> core::ffi::c_int; + fn set_shoulder_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_shoulder_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_shoulder_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_shoulder_resolution(&mut self) -> core::ffi::c_int; + fn set_radial_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radial_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_radial_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_radial_ratio(&mut self) -> core::ffi::c_double; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkFrustumSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_planes(&mut self) -> *mut core::ffi::c_void; + fn set_planes(&mut self, planes: *mut core::ffi::c_void) -> (); + fn get_show_lines(&mut self) -> bool; + fn set_show_lines(&mut self, _arg: bool) -> (); + fn show_lines_on(&mut self) -> (); + fn show_lines_off(&mut self) -> (); + fn get_lines_length(&mut self) -> core::ffi::c_double; + fn set_lines_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkGlyphSource2D { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_scale(&mut self, _arg: core::ffi::c_double) -> (); + fn get_scale_min_value(&mut self) -> core::ffi::c_double; + fn get_scale_max_value(&mut self) -> core::ffi::c_double; + fn get_scale(&mut self) -> core::ffi::c_double; + fn set_scale_2(&mut self, _arg: core::ffi::c_double) -> (); + fn get_scale_2_min_value(&mut self) -> core::ffi::c_double; + fn get_scale_2_max_value(&mut self) -> core::ffi::c_double; + fn get_scale_2(&mut self) -> core::ffi::c_double; + fn set_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_filled(&mut self, _arg: core::ffi::c_int) -> (); + fn get_filled(&mut self) -> core::ffi::c_int; + fn filled_on(&mut self) -> (); + fn filled_off(&mut self) -> (); + fn set_dash(&mut self, _arg: core::ffi::c_int) -> (); + fn get_dash(&mut self) -> core::ffi::c_int; + fn dash_on(&mut self) -> (); + fn dash_off(&mut self) -> (); + fn set_cross(&mut self, _arg: core::ffi::c_int) -> (); + fn get_cross(&mut self) -> core::ffi::c_int; + fn cross_on(&mut self) -> (); + fn cross_off(&mut self) -> (); + fn set_rotation_angle(&mut self, _arg: core::ffi::c_double) -> (); + fn get_rotation_angle(&mut self) -> core::ffi::c_double; + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_glyph_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_glyph_type_min_value(&mut self) -> core::ffi::c_int; + fn get_glyph_type_max_value(&mut self) -> core::ffi::c_int; + fn get_glyph_type(&mut self) -> core::ffi::c_int; + fn set_glyph_type_to_none(&mut self) -> (); + fn set_glyph_type_to_vertex(&mut self) -> (); + fn set_glyph_type_to_dash(&mut self) -> (); + fn set_glyph_type_to_cross(&mut self) -> (); + fn set_glyph_type_to_thick_cross(&mut self) -> (); + fn set_glyph_type_to_triangle(&mut self) -> (); + fn set_glyph_type_to_square(&mut self) -> (); + fn set_glyph_type_to_circle(&mut self) -> (); + fn set_glyph_type_to_diamond(&mut self) -> (); + fn set_glyph_type_to_arrow(&mut self) -> (); + fn set_glyph_type_to_thick_arrow(&mut self) -> (); + fn set_glyph_type_to_hooked_arrow(&mut self) -> (); + fn set_glyph_type_to_edge_arrow(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkGraphToPolyData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_edge_glyph_output(&mut self, _arg: bool) -> (); + fn get_edge_glyph_output(&mut self) -> bool; + fn edge_glyph_output_on(&mut self) -> (); + fn edge_glyph_output_off(&mut self) -> (); + fn set_edge_glyph_position(&mut self, _arg: core::ffi::c_double) -> (); + fn get_edge_glyph_position(&mut self) -> core::ffi::c_double; +} +pub trait VtkHandleSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_directional(&mut self, _arg: bool) -> (); + fn get_directional(&mut self) -> bool; + fn directional_on(&mut self) -> (); + fn directional_off(&mut self) -> (); + fn set_position( + &mut self, + xPos: core::ffi::c_double, + yPos: core::ffi::c_double, + zPos: core::ffi::c_double, + ) -> (); + fn set_direction( + &mut self, + xDir: core::ffi::c_double, + yDir: core::ffi::c_double, + zDir: core::ffi::c_double, + ) -> (); + fn set_size(&mut self, _arg: core::ffi::c_double) -> (); + fn get_size(&mut self) -> core::ffi::c_double; +} +pub trait VtkHyperTreeGridSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_maximum_level(&mut self) -> core::ffi::c_uint; + fn set_maximum_level(&mut self, levels: core::ffi::c_uint) -> (); + fn get_max_depth(&mut self) -> core::ffi::c_uint; + fn set_max_depth(&mut self, levels: core::ffi::c_uint) -> (); + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_grid_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_transposed_root_indexing(&mut self, _arg: bool) -> (); + fn get_transposed_root_indexing(&mut self) -> bool; + fn set_indexing_mode_to_kji(&mut self) -> (); + fn set_indexing_mode_to_ijk(&mut self) -> (); + fn get_orientation(&mut self) -> core::ffi::c_uint; + fn set_branch_factor(&mut self, _arg: core::ffi::c_uint) -> (); + fn get_branch_factor_min_value(&mut self) -> core::ffi::c_uint; + fn get_branch_factor_max_value(&mut self) -> core::ffi::c_uint; + fn get_branch_factor(&mut self) -> core::ffi::c_uint; + fn set_use_descriptor(&mut self, _arg: bool) -> (); + fn get_use_descriptor(&mut self) -> bool; + fn use_descriptor_on(&mut self) -> (); + fn use_descriptor_off(&mut self) -> (); + fn set_use_mask(&mut self, _arg: bool) -> (); + fn get_use_mask(&mut self) -> bool; + fn use_mask_on(&mut self) -> (); + fn use_mask_off(&mut self) -> (); + fn set_generate_interface_fields(&mut self, _arg: bool) -> (); + fn get_generate_interface_fields(&mut self) -> bool; + fn generate_interface_fields_on(&mut self) -> (); + fn generate_interface_fields_off(&mut self) -> (); + fn set_descriptor(&mut self, _arg: &str) -> (); + fn set_mask(&mut self, _arg: &str) -> (); + fn set_descriptor_bits(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_descriptor_bits(&mut self) -> *mut core::ffi::c_void; + fn set_level_zero_material_index(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_mask_bits(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_mask_bits(&mut self) -> *mut core::ffi::c_void; + fn set_quadric(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_quadric(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn convert_descriptor_string_to_bit_array( + &mut self, + p0: &str, + ) -> *mut core::ffi::c_void; + fn convert_mask_string_to_bit_array(&mut self, p0: &str) -> *mut core::ffi::c_void; +} +pub trait VtkLineSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_point_1( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_point_2( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_use_regular_refinement(&mut self, _arg: bool) -> (); + fn get_use_regular_refinement(&mut self) -> bool; + fn use_regular_refinement_on(&mut self) -> (); + fn use_regular_refinement_off(&mut self) -> (); + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_number_of_refinement_ratios(&mut self, p0: core::ffi::c_int) -> (); + fn set_refinement_ratio( + &mut self, + index: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_number_of_refinement_ratios(&mut self) -> core::ffi::c_int; + fn get_refinement_ratio(&mut self, index: core::ffi::c_int) -> core::ffi::c_double; + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkOutlineCornerFilter { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_corner_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_corner_factor_min_value(&mut self) -> core::ffi::c_double; + fn get_corner_factor_max_value(&mut self) -> core::ffi::c_double; + fn get_corner_factor(&mut self) -> core::ffi::c_double; +} +pub trait VtkOutlineCornerSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_corner_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_corner_factor_min_value(&mut self) -> core::ffi::c_double; + fn get_corner_factor_max_value(&mut self) -> core::ffi::c_double; + fn get_corner_factor(&mut self) -> core::ffi::c_double; +} +pub trait VtkOutlineSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_box_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_box_type(&mut self) -> core::ffi::c_int; + fn set_box_type_to_axis_aligned(&mut self) -> (); + fn set_box_type_to_oriented(&mut self) -> (); + fn set_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> (); + fn set_generate_faces(&mut self, _arg: core::ffi::c_int) -> (); + fn generate_faces_on(&mut self) -> (); + fn generate_faces_off(&mut self) -> (); + fn get_generate_faces(&mut self) -> core::ffi::c_int; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricFunctionSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_parametric_function(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_parametric_function(&mut self) -> *mut core::ffi::c_void; + fn set_u_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_u_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_u_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_u_resolution(&mut self) -> core::ffi::c_int; + fn set_v_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_v_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_v_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_v_resolution(&mut self) -> core::ffi::c_int; + fn set_w_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_w_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_w_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_w_resolution(&mut self) -> core::ffi::c_int; + fn generate_texture_coordinates_on(&mut self) -> (); + fn generate_texture_coordinates_off(&mut self) -> (); + fn set_generate_texture_coordinates(&mut self, _arg: core::ffi::c_int) -> (); + fn get_generate_texture_coordinates_min_value(&mut self) -> core::ffi::c_int; + fn get_generate_texture_coordinates_max_value(&mut self) -> core::ffi::c_int; + fn get_generate_texture_coordinates(&mut self) -> core::ffi::c_int; + fn generate_normals_on(&mut self) -> (); + fn generate_normals_off(&mut self) -> (); + fn set_generate_normals(&mut self, _arg: core::ffi::c_int) -> (); + fn get_generate_normals_min_value(&mut self) -> core::ffi::c_int; + fn get_generate_normals_max_value(&mut self) -> core::ffi::c_int; + fn get_generate_normals(&mut self) -> core::ffi::c_int; + fn set_scalar_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_scalar_mode_min_value(&mut self) -> core::ffi::c_int; + fn get_scalar_mode_max_value(&mut self) -> core::ffi::c_int; + fn get_scalar_mode(&mut self) -> core::ffi::c_int; + fn set_scalar_mode_to_none(&mut self) -> (); + fn set_scalar_mode_to_u(&mut self) -> (); + fn set_scalar_mode_to_v(&mut self) -> (); + fn set_scalar_mode_to_u_0(&mut self) -> (); + fn set_scalar_mode_to_v_0(&mut self) -> (); + fn set_scalar_mode_to_u_0_v_0(&mut self) -> (); + fn set_scalar_mode_to_modulus(&mut self) -> (); + fn set_scalar_mode_to_phase(&mut self) -> (); + fn set_scalar_mode_to_quadrant(&mut self) -> (); + fn set_scalar_mode_to_x(&mut self) -> (); + fn set_scalar_mode_to_y(&mut self) -> (); + fn set_scalar_mode_to_z(&mut self) -> (); + fn set_scalar_mode_to_distance(&mut self) -> (); + fn set_scalar_mode_to_function_defined(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkPartitionedDataSetCollectionSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_shapes(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_shapes_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_shapes_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_shapes(&mut self) -> core::ffi::c_int; +} +pub trait VtkPartitionedDataSetSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn enable_rank(&mut self, rank: core::ffi::c_int) -> (); + fn enable_all_ranks(&mut self) -> (); + fn disable_rank(&mut self, rank: core::ffi::c_int) -> (); + fn disable_all_ranks(&mut self) -> (); + fn is_enabled_rank(&mut self, rank: core::ffi::c_int) -> bool; + fn set_number_of_partitions(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_partitions_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_partitions_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_partitions(&mut self) -> core::ffi::c_int; + fn set_parametric_function(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_parametric_function(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPlaneSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_x_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_x_resolution(&mut self) -> core::ffi::c_int; + fn set_y_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_y_resolution(&mut self) -> core::ffi::c_int; + fn set_resolution(&mut self, xR: core::ffi::c_int, yR: core::ffi::c_int) -> (); + fn get_resolution( + &mut self, + xR: &mut core::ffi::c_int, + yR: &mut core::ffi::c_int, + ) -> (); + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_point_1( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_point_2( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_center( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_normal( + &mut self, + nx: core::ffi::c_double, + ny: core::ffi::c_double, + nz: core::ffi::c_double, + ) -> (); + fn push(&mut self, distance: core::ffi::c_double) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkPlatonicSolidSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_solid_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_solid_type_min_value(&mut self) -> core::ffi::c_int; + fn get_solid_type_max_value(&mut self) -> core::ffi::c_int; + fn get_solid_type(&mut self) -> core::ffi::c_int; + fn set_solid_type_to_tetrahedron(&mut self) -> (); + fn set_solid_type_to_cube(&mut self) -> (); + fn set_solid_type_to_octahedron(&mut self) -> (); + fn set_solid_type_to_icosahedron(&mut self) -> (); + fn set_solid_type_to_dodecahedron(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkPointHandleSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_position( + &mut self, + xPos: core::ffi::c_double, + yPos: core::ffi::c_double, + zPos: core::ffi::c_double, + ) -> (); + fn set_direction( + &mut self, + xDir: core::ffi::c_double, + yDir: core::ffi::c_double, + zDir: core::ffi::c_double, + ) -> (); +} +pub trait VtkPointSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_number_of_points_min_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_points_max_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_distribution(&mut self, _arg: core::ffi::c_int) -> (); + fn set_distribution_to_uniform(&mut self) -> (); + fn set_distribution_to_shell(&mut self) -> (); + fn get_distribution(&mut self) -> core::ffi::c_int; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; + fn set_random_sequence(&mut self, randomSequence: *mut core::ffi::c_void) -> (); + fn get_random_sequence(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPolyLineSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_closed(&mut self, _arg: core::ffi::c_int) -> (); + fn get_closed(&mut self) -> core::ffi::c_int; + fn closed_on(&mut self) -> (); + fn closed_off(&mut self) -> (); +} +pub trait VtkPolyPointSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> (); + fn set_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_points(&mut self, points: *mut core::ffi::c_void) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkProgrammableDataObjectSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_execute_method_arg_delete(&mut self, f: *mut core::ffi::c_void) -> (); +} +pub trait VtkProgrammableSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_execute_method_arg_delete(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_request_information_method(&mut self, f: *mut core::ffi::c_void) -> (); + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_graph_output(&mut self) -> *mut core::ffi::c_void; + fn get_molecule_output(&mut self) -> *mut core::ffi::c_void; + fn get_table_output(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkRandomHyperTreeGridSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_dimensions( + &mut self, + _arg1: core::ffi::c_uint, + _arg2: core::ffi::c_uint, + _arg3: core::ffi::c_uint, + ) -> (); + fn set_output_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> (); + fn get_seed(&mut self) -> core::ffi::c_uint; + fn set_seed(&mut self, _arg: core::ffi::c_uint) -> (); + fn get_max_depth(&mut self) -> core::ffi::c_longlong; + fn set_max_depth(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_max_depth_min_value(&mut self) -> core::ffi::c_longlong; + fn get_max_depth_max_value(&mut self) -> core::ffi::c_longlong; + fn get_split_fraction(&mut self) -> core::ffi::c_double; + fn set_split_fraction(&mut self, _arg: core::ffi::c_double) -> (); + fn get_split_fraction_min_value(&mut self) -> core::ffi::c_double; + fn get_split_fraction_max_value(&mut self) -> core::ffi::c_double; +} +pub trait VtkRectangularButtonSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_width(&mut self, _arg: core::ffi::c_double) -> (); + fn get_width_min_value(&mut self) -> core::ffi::c_double; + fn get_width_max_value(&mut self) -> core::ffi::c_double; + fn get_width(&mut self) -> core::ffi::c_double; + fn set_height(&mut self, _arg: core::ffi::c_double) -> (); + fn get_height_min_value(&mut self) -> core::ffi::c_double; + fn get_height_max_value(&mut self) -> core::ffi::c_double; + fn get_height(&mut self) -> core::ffi::c_double; + fn set_depth(&mut self, _arg: core::ffi::c_double) -> (); + fn get_depth_min_value(&mut self) -> core::ffi::c_double; + fn get_depth_max_value(&mut self) -> core::ffi::c_double; + fn get_depth(&mut self) -> core::ffi::c_double; + fn set_box_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_box_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_box_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_box_ratio(&mut self) -> core::ffi::c_double; + fn set_texture_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_texture_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_texture_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_texture_ratio(&mut self) -> core::ffi::c_double; + fn set_texture_height_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_texture_height_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_texture_height_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_texture_height_ratio(&mut self) -> core::ffi::c_double; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkRegularPolygonSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_sides(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_sides_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_sides_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_sides(&mut self) -> core::ffi::c_int; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_generate_polygon(&mut self, _arg: core::ffi::c_int) -> (); + fn get_generate_polygon(&mut self) -> core::ffi::c_int; + fn generate_polygon_on(&mut self) -> (); + fn generate_polygon_off(&mut self) -> (); + fn set_generate_polyline(&mut self, _arg: core::ffi::c_int) -> (); + fn get_generate_polyline(&mut self) -> core::ffi::c_int; + fn generate_polyline_on(&mut self) -> (); + fn generate_polyline_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkSelectionSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_id(&mut self, piece: core::ffi::c_longlong, id: core::ffi::c_longlong) -> (); + fn add_string_id(&mut self, piece: core::ffi::c_longlong, id: &str) -> (); + fn add_location( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn add_threshold( + &mut self, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> (); + fn add_block(&mut self, blockno: core::ffi::c_longlong) -> (); + fn add_block_selector(&mut self, selector: &str) -> (); + fn remove_all_block_selectors(&mut self) -> (); + fn remove_all_i_ds(&mut self) -> (); + fn remove_all_string_i_ds(&mut self) -> (); + fn remove_all_thresholds(&mut self) -> (); + fn remove_all_locations(&mut self) -> (); + fn remove_all_blocks(&mut self) -> (); + fn set_content_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_content_type(&mut self) -> core::ffi::c_int; + fn set_field_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_field_type(&mut self) -> core::ffi::c_int; + fn set_containing_cells(&mut self, _arg: core::ffi::c_int) -> (); + fn get_containing_cells(&mut self) -> core::ffi::c_int; + fn set_number_of_layers(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_layers_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_layers_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_layers(&mut self) -> core::ffi::c_int; + fn set_inverse(&mut self, _arg: core::ffi::c_int) -> (); + fn get_inverse(&mut self) -> core::ffi::c_int; + fn set_array_name(&mut self, _arg: &str) -> (); + fn set_array_component(&mut self, _arg: core::ffi::c_int) -> (); + fn get_array_component(&mut self) -> core::ffi::c_int; + fn set_composite_index(&mut self, _arg: core::ffi::c_int) -> (); + fn get_composite_index(&mut self) -> core::ffi::c_int; + fn set_hierarchical_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_hierarchical_level(&mut self) -> core::ffi::c_int; + fn set_hierarchical_index(&mut self, _arg: core::ffi::c_int) -> (); + fn get_hierarchical_index(&mut self) -> core::ffi::c_int; + fn set_assembly_name(&mut self, _arg: &str) -> (); + fn add_selector(&mut self, selector: &str) -> (); + fn remove_all_selectors(&mut self) -> (); + fn set_query_string(&mut self, _arg: &str) -> (); +} +pub trait VtkSphereSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution(&mut self) -> core::ffi::c_int; + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution(&mut self) -> core::ffi::c_int; + fn set_start_theta(&mut self, _arg: core::ffi::c_double) -> (); + fn get_start_theta_min_value(&mut self) -> core::ffi::c_double; + fn get_start_theta_max_value(&mut self) -> core::ffi::c_double; + fn get_start_theta(&mut self) -> core::ffi::c_double; + fn set_end_theta(&mut self, _arg: core::ffi::c_double) -> (); + fn get_end_theta_min_value(&mut self) -> core::ffi::c_double; + fn get_end_theta_max_value(&mut self) -> core::ffi::c_double; + fn get_end_theta(&mut self) -> core::ffi::c_double; + fn set_start_phi(&mut self, _arg: core::ffi::c_double) -> (); + fn get_start_phi_min_value(&mut self) -> core::ffi::c_double; + fn get_start_phi_max_value(&mut self) -> core::ffi::c_double; + fn get_start_phi(&mut self) -> core::ffi::c_double; + fn set_end_phi(&mut self, _arg: core::ffi::c_double) -> (); + fn get_end_phi_min_value(&mut self) -> core::ffi::c_double; + fn get_end_phi_max_value(&mut self) -> core::ffi::c_double; + fn get_end_phi(&mut self) -> core::ffi::c_double; + fn set_lat_long_tessellation(&mut self, _arg: core::ffi::c_int) -> (); + fn get_lat_long_tessellation(&mut self) -> core::ffi::c_int; + fn lat_long_tessellation_on(&mut self) -> (); + fn lat_long_tessellation_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; + fn set_generate_normals(&mut self, _arg: core::ffi::c_int) -> (); + fn get_generate_normals(&mut self) -> core::ffi::c_int; + fn generate_normals_on(&mut self) -> (); + fn generate_normals_off(&mut self) -> (); +} +pub trait VtkSuperquadricSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_theta_resolution(&mut self) -> core::ffi::c_int; + fn set_theta_resolution(&mut self, i: core::ffi::c_int) -> (); + fn get_phi_resolution(&mut self) -> core::ffi::c_int; + fn set_phi_resolution(&mut self, i: core::ffi::c_int) -> (); + fn get_thickness(&mut self) -> core::ffi::c_double; + fn set_thickness(&mut self, _arg: core::ffi::c_double) -> (); + fn get_thickness_min_value(&mut self) -> core::ffi::c_double; + fn get_thickness_max_value(&mut self) -> core::ffi::c_double; + fn get_phi_roundness(&mut self) -> core::ffi::c_double; + fn set_phi_roundness(&mut self, e: core::ffi::c_double) -> (); + fn get_theta_roundness(&mut self) -> core::ffi::c_double; + fn set_theta_roundness(&mut self, e: core::ffi::c_double) -> (); + fn set_size(&mut self, _arg: core::ffi::c_double) -> (); + fn get_size(&mut self) -> core::ffi::c_double; + fn set_axis_of_symmetry(&mut self, _arg: core::ffi::c_int) -> (); + fn get_axis_of_symmetry(&mut self) -> core::ffi::c_int; + fn set_x_axis_of_symmetry(&mut self) -> (); + fn set_y_axis_of_symmetry(&mut self) -> (); + fn set_z_axis_of_symmetry(&mut self) -> (); + fn toroidal_on(&mut self) -> (); + fn toroidal_off(&mut self) -> (); + fn get_toroidal(&mut self) -> core::ffi::c_int; + fn set_toroidal(&mut self, _arg: core::ffi::c_int) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkTessellatedBoxSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> (); + fn set_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_level(&mut self) -> core::ffi::c_int; + fn set_duplicate_shared_points(&mut self, _arg: core::ffi::c_int) -> (); + fn get_duplicate_shared_points(&mut self) -> core::ffi::c_int; + fn duplicate_shared_points_on(&mut self) -> (); + fn duplicate_shared_points_off(&mut self) -> (); + fn set_quads(&mut self, _arg: core::ffi::c_int) -> (); + fn get_quads(&mut self) -> core::ffi::c_int; + fn quads_on(&mut self) -> (); + fn quads_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkTextSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_text(&mut self, _arg: &str) -> (); + fn set_backing(&mut self, _arg: core::ffi::c_int) -> (); + fn get_backing(&mut self) -> core::ffi::c_int; + fn backing_on(&mut self) -> (); + fn backing_off(&mut self) -> (); + fn set_foreground_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_background_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkTexturedSphereSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution(&mut self) -> core::ffi::c_int; + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution(&mut self) -> core::ffi::c_int; + fn set_theta(&mut self, _arg: core::ffi::c_double) -> (); + fn get_theta_min_value(&mut self) -> core::ffi::c_double; + fn get_theta_max_value(&mut self) -> core::ffi::c_double; + fn get_theta(&mut self) -> core::ffi::c_double; + fn set_phi(&mut self, _arg: core::ffi::c_double) -> (); + fn get_phi_min_value(&mut self) -> core::ffi::c_double; + fn get_phi_max_value(&mut self) -> core::ffi::c_double; + fn get_phi(&mut self) -> core::ffi::c_double; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkUniformHyperTreeGridSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; +} +impl VtkArcSource for vtkArcSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arc_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arc_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arc_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arc_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arc_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arc_source_new_instance(self.0) } + } + fn set_point_1( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_point_1( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_point_1(self.0, _arg1, _arg2, _arg3) } + } + fn set_point_2( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_point_2( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_point_2(self.0, _arg1, _arg2, _arg3) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_normal( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_normal(self.0, _arg1, _arg2, _arg3) } + } + fn set_polar_vector( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_polar_vector( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_polar_vector(self.0, _arg1, _arg2, _arg3) } + } + fn set_angle(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_angle( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_angle(self.0, _arg) } + } + fn get_angle_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arc_source_get_angle_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arc_source_get_angle_min_value(self.0) } + } + fn get_angle_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arc_source_get_angle_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arc_source_get_angle_max_value(self.0) } + } + fn get_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arc_source_get_angle( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arc_source_get_angle(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_arc_source_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arc_source_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arc_source_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arc_source_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arc_source_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arc_source_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arc_source_get_resolution(self.0) } + } + fn set_negative(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_negative(sself: *mut core::ffi::c_void, _arg: bool); + } + unsafe { vtk_arc_source_set_negative(self.0, _arg) } + } + fn get_negative(&mut self) -> bool { + unsafe extern "C" { + fn vtk_arc_source_get_negative(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_arc_source_get_negative(self.0) } + } + fn negative_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_arc_source_negative_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arc_source_negative_on(self.0) } + } + fn negative_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_arc_source_negative_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arc_source_negative_off(self.0) } + } + fn set_use_normal_and_angle(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_use_normal_and_angle( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_arc_source_set_use_normal_and_angle(self.0, _arg) } + } + fn get_use_normal_and_angle(&mut self) -> bool { + unsafe extern "C" { + fn vtk_arc_source_get_use_normal_and_angle( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_arc_source_get_use_normal_and_angle(self.0) } + } + fn use_normal_and_angle_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_arc_source_use_normal_and_angle_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arc_source_use_normal_and_angle_on(self.0) } + } + fn use_normal_and_angle_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_arc_source_use_normal_and_angle_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arc_source_use_normal_and_angle_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_arc_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arc_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arc_source_get_output_points_precision(self.0) } + } +} +impl VtkArrowSource for vtkArrowSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arrow_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arrow_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arrow_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arrow_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arrow_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arrow_source_new_instance(self.0) } + } + fn set_tip_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_tip_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_arrow_source_set_tip_length(self.0, _arg) } + } + fn get_tip_length_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_length_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_length_min_value(self.0) } + } + fn get_tip_length_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_length_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_length_max_value(self.0) } + } + fn get_tip_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_length(self.0) } + } + fn set_tip_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_tip_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_arrow_source_set_tip_radius(self.0, _arg) } + } + fn get_tip_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_radius_min_value(self.0) } + } + fn get_tip_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_radius_max_value(self.0) } + } + fn get_tip_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_radius(self.0) } + } + fn set_tip_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_tip_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_arrow_source_set_tip_resolution(self.0, _arg) } + } + fn get_tip_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_tip_resolution_min_value(self.0) } + } + fn get_tip_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_tip_resolution_max_value(self.0) } + } + fn get_tip_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_tip_resolution(self.0) } + } + fn set_shaft_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_shaft_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_arrow_source_set_shaft_radius(self.0, _arg) } + } + fn get_shaft_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_shaft_radius_min_value(self.0) } + } + fn get_shaft_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_shaft_radius_max_value(self.0) } + } + fn get_shaft_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_shaft_radius(self.0) } + } + fn set_shaft_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_shaft_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_arrow_source_set_shaft_resolution(self.0, _arg) } + } + fn get_shaft_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_shaft_resolution_min_value(self.0) } + } + fn get_shaft_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_shaft_resolution_max_value(self.0) } + } + fn get_shaft_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_shaft_resolution(self.0) } + } + fn invert_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_arrow_source_invert_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arrow_source_invert_on(self.0) } + } + fn invert_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_arrow_source_invert_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arrow_source_invert_off(self.0) } + } + fn set_invert(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_invert(sself: *mut core::ffi::c_void, _arg: bool); + } + unsafe { vtk_arrow_source_set_invert(self.0, _arg) } + } + fn get_invert(&mut self) -> bool { + unsafe extern "C" { + fn vtk_arrow_source_get_invert(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_arrow_source_get_invert(self.0) } + } + fn set_arrow_origin_to_default(&mut self) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_arrow_origin_to_default( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_arrow_source_set_arrow_origin_to_default(self.0) } + } + fn set_arrow_origin_to_center(&mut self) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_arrow_origin_to_center( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_arrow_source_set_arrow_origin_to_center(self.0) } + } +} +impl VtkCapsuleSource for vtkCapsuleSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_capsule_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_capsule_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_capsule_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_capsule_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_capsule_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_capsule_source_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_capsule_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_capsule_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_cylinder_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_cylinder_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_capsule_source_set_cylinder_length(self.0, _arg) } + } + fn get_cylinder_length_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_cylinder_length_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_cylinder_length_min_value(self.0) } + } + fn get_cylinder_length_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_cylinder_length_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_cylinder_length_max_value(self.0) } + } + fn get_cylinder_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_cylinder_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_cylinder_length(self.0) } + } + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_theta_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_capsule_source_set_theta_resolution(self.0, _arg) } + } + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_theta_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_theta_resolution_min_value(self.0) } + } + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_theta_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_theta_resolution_max_value(self.0) } + } + fn get_theta_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_theta_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_theta_resolution(self.0) } + } + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_phi_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_capsule_source_set_phi_resolution(self.0, _arg) } + } + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_phi_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_phi_resolution_min_value(self.0) } + } + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_phi_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_phi_resolution_max_value(self.0) } + } + fn get_phi_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_phi_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_phi_resolution(self.0) } + } + fn set_lat_long_tessellation(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_lat_long_tessellation( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_capsule_source_set_lat_long_tessellation(self.0, _arg) } + } + fn get_lat_long_tessellation(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_lat_long_tessellation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_lat_long_tessellation(self.0) } + } + fn lat_long_tessellation_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_capsule_source_lat_long_tessellation_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_capsule_source_lat_long_tessellation_on(self.0) } + } + fn lat_long_tessellation_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_capsule_source_lat_long_tessellation_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_capsule_source_lat_long_tessellation_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_capsule_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_output_points_precision(self.0) } + } +} +impl VtkCellTypeSource for vtkCellTypeSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_type_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_type_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_type_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_type_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_type_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_type_source_new_instance(self.0) } + } + fn set_cell_type(&mut self, cellType: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_set_cell_type( + sself: *mut core::ffi::c_void, + cellType: core::ffi::c_int, + ); + } + unsafe { vtk_cell_type_source_set_cell_type(self.0, cellType) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_cell_type(self.0) } + } + fn set_cell_order(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_set_cell_order( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cell_type_source_set_cell_order(self.0, _arg) } + } + fn get_cell_order(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_cell_order( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_cell_order(self.0) } + } + fn set_complete_quadratic_simplicial_elements(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_set_complete_quadratic_simplicial_elements( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { + vtk_cell_type_source_set_complete_quadratic_simplicial_elements(self.0, _arg) + } + } + fn get_complete_quadratic_simplicial_elements(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_type_source_get_complete_quadratic_simplicial_elements( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_cell_type_source_get_complete_quadratic_simplicial_elements(self.0) + } + } + fn complete_quadratic_simplicial_elements_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_complete_quadratic_simplicial_elements_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_type_source_complete_quadratic_simplicial_elements_on(self.0) } + } + fn complete_quadratic_simplicial_elements_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_complete_quadratic_simplicial_elements_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_cell_type_source_complete_quadratic_simplicial_elements_off(self.0) + } + } + fn set_polynomial_field_order(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_set_polynomial_field_order( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cell_type_source_set_polynomial_field_order(self.0, _arg) } + } + fn get_polynomial_field_order_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_polynomial_field_order_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_polynomial_field_order_min_value(self.0) } + } + fn get_polynomial_field_order_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_polynomial_field_order_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_polynomial_field_order_max_value(self.0) } + } + fn get_polynomial_field_order(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_polynomial_field_order( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_polynomial_field_order(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_cell_dimension(self.0) } + } + fn set_output_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_set_output_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cell_type_source_set_output_precision(self.0, _arg) } + } + fn get_output_precision_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_output_precision_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_output_precision_min_value(self.0) } + } + fn get_output_precision_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_output_precision_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_output_precision_max_value(self.0) } + } + fn get_output_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_output_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_output_precision(self.0) } + } +} +impl VtkConeSource for vtkConeSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_source_new(self.0) } + } + fn set_height(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_height( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cone_source_set_height(self.0, _arg) } + } + fn get_height_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_height_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_height_min_value(self.0) } + } + fn get_height_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_height_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_height_max_value(self.0) } + } + fn get_height(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_height( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_height(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cone_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_radius(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cone_source_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cone_source_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cone_source_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cone_source_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cone_source_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cone_source_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cone_source_get_resolution(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cone_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_direction( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_direction( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cone_source_set_direction(self.0, _arg1, _arg2, _arg3) } + } + fn set_angle(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_angle( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_cone_source_set_angle(self.0, angle) } + } + fn get_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_angle( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_angle(self.0) } + } + fn set_capping(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_capping( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cone_source_set_capping(self.0, _arg) } + } + fn get_capping(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cone_source_get_capping( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cone_source_get_capping(self.0) } + } + fn capping_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_cone_source_capping_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cone_source_capping_on(self.0) } + } + fn capping_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_cone_source_capping_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cone_source_capping_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cone_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cone_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cone_source_get_output_points_precision(self.0) } + } +} +impl VtkCubeSource for vtkCubeSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cube_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cube_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cube_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cube_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cube_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cube_source_new_instance(self.0) } + } + fn set_x_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_x_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cube_source_set_x_length(self.0, _arg) } + } + fn get_x_length_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_x_length_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_x_length_min_value(self.0) } + } + fn get_x_length_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_x_length_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_x_length_max_value(self.0) } + } + fn get_x_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_x_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_x_length(self.0) } + } + fn set_y_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_y_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cube_source_set_y_length(self.0, _arg) } + } + fn get_y_length_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_y_length_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_y_length_min_value(self.0) } + } + fn get_y_length_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_y_length_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_y_length_max_value(self.0) } + } + fn get_y_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_y_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_y_length(self.0) } + } + fn set_z_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_z_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cube_source_set_z_length(self.0, _arg) } + } + fn get_z_length_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_z_length_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_z_length_min_value(self.0) } + } + fn get_z_length_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_z_length_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_z_length_max_value(self.0) } + } + fn get_z_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_z_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_z_length(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cube_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_bounds( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ); + } + unsafe { vtk_cube_source_set_bounds(self.0, xMin, xMax, yMin, yMax, zMin, zMax) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cube_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cube_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cube_source_get_output_points_precision(self.0) } + } +} +impl VtkCylinderSource for vtkCylinderSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_source_new_instance(self.0) } + } + fn set_height(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_height( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_source_set_height(self.0, _arg) } + } + fn get_height_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_height_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_height_min_value(self.0) } + } + fn get_height_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_height_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_height_max_value(self.0) } + } + fn get_height(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_height( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_height(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cylinder_source_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cylinder_source_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cylinder_source_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cylinder_source_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cylinder_source_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cylinder_source_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cylinder_source_get_resolution(self.0) } + } + fn set_capping(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_capping( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cylinder_source_set_capping(self.0, _arg) } + } + fn get_capping(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cylinder_source_get_capping( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cylinder_source_get_capping(self.0) } + } + fn capping_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_capping_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cylinder_source_capping_on(self.0) } + } + fn capping_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_capping_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cylinder_source_capping_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cylinder_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cylinder_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cylinder_source_get_output_points_precision(self.0) } + } +} +impl VtkDiagonalMatrixSource for vtkDiagonalMatrixSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_diagonal_matrix_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_diagonal_matrix_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_diagonal_matrix_source_new_instance(self.0) } + } + fn get_array_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_get_array_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_diagonal_matrix_source_get_array_type(self.0) } + } + fn set_array_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_array_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_diagonal_matrix_source_set_array_type(self.0, _arg) } + } + fn get_extents(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_get_extents( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_diagonal_matrix_source_get_extents(self.0) } + } + fn set_extents(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_extents( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_diagonal_matrix_source_set_extents(self.0, _arg) } + } + fn get_diagonal(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_get_diagonal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_diagonal_matrix_source_get_diagonal(self.0) } + } + fn set_diagonal(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_diagonal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_diagonal_matrix_source_set_diagonal(self.0, _arg) } + } + fn get_super_diagonal(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_get_super_diagonal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_diagonal_matrix_source_get_super_diagonal(self.0) } + } + fn set_super_diagonal(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_super_diagonal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_diagonal_matrix_source_set_super_diagonal(self.0, _arg) } + } + fn get_sub_diagonal(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_get_sub_diagonal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_diagonal_matrix_source_get_sub_diagonal(self.0) } + } + fn set_sub_diagonal(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_sub_diagonal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_diagonal_matrix_source_set_sub_diagonal(self.0, _arg) } + } + fn set_row_label(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_row_label( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_diagonal_matrix_source_set_row_label(self.0, c__arg.as_ptr()) } + } + fn set_column_label(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_column_label( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_diagonal_matrix_source_set_column_label(self.0, c__arg.as_ptr()) } + } +} +impl VtkDiskSource for vtkDiskSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_disk_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_disk_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_disk_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_disk_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_disk_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_disk_source_new_instance(self.0) } + } + fn set_inner_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_disk_source_set_inner_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_disk_source_set_inner_radius(self.0, _arg) } + } + fn get_inner_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_inner_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_inner_radius_min_value(self.0) } + } + fn get_inner_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_inner_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_inner_radius_max_value(self.0) } + } + fn get_inner_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_inner_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_inner_radius(self.0) } + } + fn set_outer_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_disk_source_set_outer_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_disk_source_set_outer_radius(self.0, _arg) } + } + fn get_outer_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_outer_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_outer_radius_min_value(self.0) } + } + fn get_outer_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_outer_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_outer_radius_max_value(self.0) } + } + fn get_outer_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_outer_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_outer_radius(self.0) } + } + fn set_radial_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_disk_source_set_radial_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_disk_source_set_radial_resolution(self.0, _arg) } + } + fn get_radial_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_radial_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_radial_resolution_min_value(self.0) } + } + fn get_radial_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_radial_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_radial_resolution_max_value(self.0) } + } + fn get_radial_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_radial_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_radial_resolution(self.0) } + } + fn set_circumferential_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_disk_source_set_circumferential_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_disk_source_set_circumferential_resolution(self.0, _arg) } + } + fn get_circumferential_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_circumferential_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_circumferential_resolution_min_value(self.0) } + } + fn get_circumferential_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_circumferential_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_circumferential_resolution_max_value(self.0) } + } + fn get_circumferential_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_circumferential_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_circumferential_resolution(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_disk_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_disk_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_output_points_precision(self.0) } + } +} +impl VtkEllipseArcSource for vtkEllipseArcSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ellipse_arc_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ellipse_arc_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ellipse_arc_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ellipse_arc_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ellipse_arc_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ellipse_arc_source_new_instance(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_ellipse_arc_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_normal( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_ellipse_arc_source_set_normal(self.0, _arg1, _arg2, _arg3) } + } + fn set_major_radius_vector( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_major_radius_vector( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { + vtk_ellipse_arc_source_set_major_radius_vector(self.0, _arg1, _arg2, _arg3) + } + } + fn set_start_angle(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_start_angle( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_ellipse_arc_source_set_start_angle(self.0, _arg) } + } + fn get_start_angle_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_start_angle_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_start_angle_min_value(self.0) } + } + fn get_start_angle_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_start_angle_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_start_angle_max_value(self.0) } + } + fn get_start_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_start_angle( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_start_angle(self.0) } + } + fn set_segment_angle(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_segment_angle( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_ellipse_arc_source_set_segment_angle(self.0, _arg) } + } + fn get_segment_angle_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_segment_angle_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_segment_angle_min_value(self.0) } + } + fn get_segment_angle_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_segment_angle_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_segment_angle_max_value(self.0) } + } + fn get_segment_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_segment_angle( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_segment_angle(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_ellipse_arc_source_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ellipse_arc_source_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ellipse_arc_source_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ellipse_arc_source_get_resolution(self.0) } + } + fn set_close(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_close( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_ellipse_arc_source_set_close(self.0, _arg) } + } + fn get_close(&mut self) -> bool { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_close(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_ellipse_arc_source_get_close(self.0) } + } + fn close_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_close_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ellipse_arc_source_close_on(self.0) } + } + fn close_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_close_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ellipse_arc_source_close_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_ellipse_arc_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ellipse_arc_source_get_output_points_precision(self.0) } + } + fn set_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_ellipse_arc_source_set_ratio(self.0, _arg) } + } + fn get_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_ratio_min_value(self.0) } + } + fn get_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_ratio_max_value(self.0) } + } + fn get_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_ratio(self.0) } + } +} +impl VtkEllipticalButtonSource for vtkEllipticalButtonSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_elliptical_button_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_elliptical_button_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_elliptical_button_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_elliptical_button_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_elliptical_button_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_elliptical_button_source_new(self.0) } + } + fn set_width(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_width( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_elliptical_button_source_set_width(self.0, _arg) } + } + fn get_width_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_width_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_width_min_value(self.0) } + } + fn get_width_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_width_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_width_max_value(self.0) } + } + fn get_width(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_width( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_width(self.0) } + } + fn set_height(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_height( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_elliptical_button_source_set_height(self.0, _arg) } + } + fn get_height_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_height_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_height_min_value(self.0) } + } + fn get_height_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_height_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_height_max_value(self.0) } + } + fn get_height(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_height( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_height(self.0) } + } + fn set_depth(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_depth( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_elliptical_button_source_set_depth(self.0, _arg) } + } + fn get_depth_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_depth_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_depth_min_value(self.0) } + } + fn get_depth_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_depth_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_depth_max_value(self.0) } + } + fn get_depth(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_depth( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_depth(self.0) } + } + fn set_circumferential_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_circumferential_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_elliptical_button_source_set_circumferential_resolution(self.0, _arg) + } + } + fn get_circumferential_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_circumferential_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_elliptical_button_source_get_circumferential_resolution_min_value(self.0) + } + } + fn get_circumferential_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_circumferential_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_elliptical_button_source_get_circumferential_resolution_max_value(self.0) + } + } + fn get_circumferential_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_circumferential_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_circumferential_resolution(self.0) } + } + fn set_texture_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_texture_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_elliptical_button_source_set_texture_resolution(self.0, _arg) } + } + fn get_texture_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_texture_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_texture_resolution_min_value(self.0) } + } + fn get_texture_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_texture_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_texture_resolution_max_value(self.0) } + } + fn get_texture_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_texture_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_texture_resolution(self.0) } + } + fn set_shoulder_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_shoulder_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_elliptical_button_source_set_shoulder_resolution(self.0, _arg) } + } + fn get_shoulder_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_shoulder_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_shoulder_resolution_min_value(self.0) } + } + fn get_shoulder_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_shoulder_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_shoulder_resolution_max_value(self.0) } + } + fn get_shoulder_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_shoulder_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_shoulder_resolution(self.0) } + } + fn set_radial_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_radial_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_elliptical_button_source_set_radial_ratio(self.0, _arg) } + } + fn get_radial_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_radial_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_radial_ratio_min_value(self.0) } + } + fn get_radial_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_radial_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_radial_ratio_max_value(self.0) } + } + fn get_radial_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_radial_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_radial_ratio(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_elliptical_button_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_output_points_precision(self.0) } + } +} +impl VtkFrustumSource for vtkFrustumSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_frustum_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_frustum_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_frustum_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_frustum_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_frustum_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_frustum_source_new_instance(self.0) } + } + fn get_planes(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_frustum_source_get_planes( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_frustum_source_get_planes(self.0) } + } + fn set_planes(&mut self, planes: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_frustum_source_set_planes( + sself: *mut core::ffi::c_void, + planes: *mut core::ffi::c_void, + ); + } + unsafe { vtk_frustum_source_set_planes(self.0, planes) } + } + fn get_show_lines(&mut self) -> bool { + unsafe extern "C" { + fn vtk_frustum_source_get_show_lines(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_frustum_source_get_show_lines(self.0) } + } + fn set_show_lines(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_frustum_source_set_show_lines( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_frustum_source_set_show_lines(self.0, _arg) } + } + fn show_lines_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_frustum_source_show_lines_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_frustum_source_show_lines_on(self.0) } + } + fn show_lines_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_frustum_source_show_lines_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_frustum_source_show_lines_off(self.0) } + } + fn get_lines_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_frustum_source_get_lines_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_frustum_source_get_lines_length(self.0) } + } + fn set_lines_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_frustum_source_set_lines_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_frustum_source_set_lines_length(self.0, _arg) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_frustum_source_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_frustum_source_get_m_time(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_frustum_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_frustum_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_frustum_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_frustum_source_get_output_points_precision(self.0) } + } +} +impl VtkGlyphSource2D for vtkGlyphSource2D { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_glyph_source_2_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_glyph_source_2_d_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_glyph_source_2_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_glyph_source_2_d_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_glyph_source_2_d_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_glyph_source_2_d_new(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_glyph_source_2_d_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_scale(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_scale( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_glyph_source_2_d_set_scale(self.0, _arg) } + } + fn get_scale_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale_min_value(self.0) } + } + fn get_scale_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale_max_value(self.0) } + } + fn get_scale(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale(self.0) } + } + fn set_scale_2(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_scale_2( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_glyph_source_2_d_set_scale_2(self.0, _arg) } + } + fn get_scale_2_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale_2_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale_2_min_value(self.0) } + } + fn get_scale_2_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale_2_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale_2_max_value(self.0) } + } + fn get_scale_2(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale_2( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale_2(self.0) } + } + fn set_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_glyph_source_2_d_set_color(self.0, _arg1, _arg2, _arg3) } + } + fn set_filled(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_filled( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_filled(self.0, _arg) } + } + fn get_filled(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_filled( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_filled(self.0) } + } + fn filled_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_filled_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_filled_on(self.0) } + } + fn filled_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_filled_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_filled_off(self.0) } + } + fn set_dash(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_dash( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_dash(self.0, _arg) } + } + fn get_dash(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_dash( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_dash(self.0) } + } + fn dash_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_dash_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_dash_on(self.0) } + } + fn dash_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_dash_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_dash_off(self.0) } + } + fn set_cross(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_cross( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_cross(self.0, _arg) } + } + fn get_cross(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_cross( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_cross(self.0) } + } + fn cross_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_cross_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_cross_on(self.0) } + } + fn cross_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_cross_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_cross_off(self.0) } + } + fn set_rotation_angle(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_rotation_angle( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_glyph_source_2_d_set_rotation_angle(self.0, _arg) } + } + fn get_rotation_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_rotation_angle( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_rotation_angle(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_resolution(self.0) } + } + fn set_glyph_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type(self.0, _arg) } + } + fn get_glyph_type_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_glyph_type_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_glyph_type_min_value(self.0) } + } + fn get_glyph_type_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_glyph_type_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_glyph_type_max_value(self.0) } + } + fn get_glyph_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_glyph_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_glyph_type(self.0) } + } + fn set_glyph_type_to_none(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_none( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_none(self.0) } + } + fn set_glyph_type_to_vertex(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_vertex( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_vertex(self.0) } + } + fn set_glyph_type_to_dash(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_dash( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_dash(self.0) } + } + fn set_glyph_type_to_cross(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_cross( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_cross(self.0) } + } + fn set_glyph_type_to_thick_cross(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_thick_cross( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_thick_cross(self.0) } + } + fn set_glyph_type_to_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_triangle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_triangle(self.0) } + } + fn set_glyph_type_to_square(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_square( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_square(self.0) } + } + fn set_glyph_type_to_circle(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_circle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_circle(self.0) } + } + fn set_glyph_type_to_diamond(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_diamond( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_diamond(self.0) } + } + fn set_glyph_type_to_arrow(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_arrow( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_arrow(self.0) } + } + fn set_glyph_type_to_thick_arrow(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_thick_arrow( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_thick_arrow(self.0) } + } + fn set_glyph_type_to_hooked_arrow(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_hooked_arrow( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_hooked_arrow(self.0) } + } + fn set_glyph_type_to_edge_arrow(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_edge_arrow( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_edge_arrow(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_output_points_precision(self.0) } + } +} +impl VtkGraphToPolyData for vtkGraphToPolyData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_to_poly_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_to_poly_data_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_to_poly_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_to_poly_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_to_poly_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_to_poly_data_new_instance(self.0) } + } + fn set_edge_glyph_output(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_graph_to_poly_data_set_edge_glyph_output( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_graph_to_poly_data_set_edge_glyph_output(self.0, _arg) } + } + fn get_edge_glyph_output(&mut self) -> bool { + unsafe extern "C" { + fn vtk_graph_to_poly_data_get_edge_glyph_output( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_graph_to_poly_data_get_edge_glyph_output(self.0) } + } + fn edge_glyph_output_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_graph_to_poly_data_edge_glyph_output_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_graph_to_poly_data_edge_glyph_output_on(self.0) } + } + fn edge_glyph_output_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_graph_to_poly_data_edge_glyph_output_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_graph_to_poly_data_edge_glyph_output_off(self.0) } + } + fn set_edge_glyph_position(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_graph_to_poly_data_set_edge_glyph_position( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_graph_to_poly_data_set_edge_glyph_position(self.0, _arg) } + } + fn get_edge_glyph_position(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_graph_to_poly_data_get_edge_glyph_position( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_graph_to_poly_data_get_edge_glyph_position(self.0) } + } +} +impl VtkHyperTreeGridSource for vtkHyperTreeGridSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_new(self.0) } + } + fn get_maximum_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_maximum_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_maximum_level(self.0) } + } + fn set_maximum_level(&mut self, levels: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_maximum_level( + sself: *mut core::ffi::c_void, + levels: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_maximum_level(self.0, levels) } + } + fn get_max_depth(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_max_depth( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_max_depth(self.0) } + } + fn set_max_depth(&mut self, levels: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_max_depth( + sself: *mut core::ffi::c_void, + levels: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_max_depth(self.0, levels) } + } + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_origin( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_origin(self.0, _arg1, _arg2, _arg3) } + } + fn set_grid_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_grid_scale( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_grid_scale(self.0, _arg1, _arg2, _arg3) } + } + fn set_transposed_root_indexing(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_transposed_root_indexing( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_transposed_root_indexing(self.0, _arg) } + } + fn get_transposed_root_indexing(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_transposed_root_indexing( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_source_get_transposed_root_indexing(self.0) } + } + fn set_indexing_mode_to_kji(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_indexing_mode_to_kji( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_indexing_mode_to_kji(self.0) } + } + fn set_indexing_mode_to_ijk(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_indexing_mode_to_ijk( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_indexing_mode_to_ijk(self.0) } + } + fn get_orientation(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_orientation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_orientation(self.0) } + } + fn set_branch_factor(&mut self, _arg: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_branch_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_branch_factor(self.0, _arg) } + } + fn get_branch_factor_min_value(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_branch_factor_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_branch_factor_min_value(self.0) } + } + fn get_branch_factor_max_value(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_branch_factor_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_branch_factor_max_value(self.0) } + } + fn get_branch_factor(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_branch_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_branch_factor(self.0) } + } + fn set_use_descriptor(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_use_descriptor( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_use_descriptor(self.0, _arg) } + } + fn get_use_descriptor(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_use_descriptor( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_source_get_use_descriptor(self.0) } + } + fn use_descriptor_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_use_descriptor_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_use_descriptor_on(self.0) } + } + fn use_descriptor_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_use_descriptor_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_use_descriptor_off(self.0) } + } + fn set_use_mask(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_use_mask( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_use_mask(self.0, _arg) } + } + fn get_use_mask(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_use_mask( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_source_get_use_mask(self.0) } + } + fn use_mask_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_use_mask_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_source_use_mask_on(self.0) } + } + fn use_mask_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_use_mask_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_source_use_mask_off(self.0) } + } + fn set_generate_interface_fields(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_generate_interface_fields( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_generate_interface_fields(self.0, _arg) } + } + fn get_generate_interface_fields(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_generate_interface_fields( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_source_get_generate_interface_fields(self.0) } + } + fn generate_interface_fields_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_generate_interface_fields_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_generate_interface_fields_on(self.0) } + } + fn generate_interface_fields_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_generate_interface_fields_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_generate_interface_fields_off(self.0) } + } + fn set_descriptor(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_descriptor( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_descriptor(self.0, c__arg.as_ptr()) } + } + fn set_mask(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_mask( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_mask(self.0, c__arg.as_ptr()) } + } + fn set_descriptor_bits(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_descriptor_bits( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_descriptor_bits(self.0, p0) } + } + fn get_descriptor_bits(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_descriptor_bits( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_get_descriptor_bits(self.0) } + } + fn set_level_zero_material_index(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_level_zero_material_index( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_level_zero_material_index(self.0, p0) } + } + fn set_mask_bits(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_mask_bits( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_mask_bits(self.0, p0) } + } + fn get_mask_bits(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_mask_bits( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_get_mask_bits(self.0) } + } + fn set_quadric(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_quadric( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_quadric(self.0, p0) } + } + fn get_quadric(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_quadric( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_get_quadric(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_hyper_tree_grid_source_get_m_time(self.0) } + } + fn convert_descriptor_string_to_bit_array( + &mut self, + p0: &str, + ) -> *mut core::ffi::c_void { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_convert_descriptor_string_to_bit_array( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_source_convert_descriptor_string_to_bit_array( + self.0, + c_p0.as_ptr(), + ) + } + } + fn convert_mask_string_to_bit_array(&mut self, p0: &str) -> *mut core::ffi::c_void { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_convert_mask_string_to_bit_array( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_source_convert_mask_string_to_bit_array( + self.0, + c_p0.as_ptr(), + ) + } + } +} +impl VtkLineSource for vtkLineSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_source_new_instance(self.0) } + } + fn set_point_1( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_source_set_point_1( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_line_source_set_point_1(self.0, _arg1, _arg2, _arg3) } + } + fn set_point_2( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_source_set_point_2( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_line_source_set_point_2(self.0, _arg1, _arg2, _arg3) } + } + fn set_use_regular_refinement(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_line_source_set_use_regular_refinement( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_line_source_set_use_regular_refinement(self.0, _arg) } + } + fn get_use_regular_refinement(&mut self) -> bool { + unsafe extern "C" { + fn vtk_line_source_get_use_regular_refinement( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_line_source_get_use_regular_refinement(self.0) } + } + fn use_regular_refinement_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_line_source_use_regular_refinement_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_line_source_use_regular_refinement_on(self.0) } + } + fn use_regular_refinement_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_line_source_use_regular_refinement_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_line_source_use_regular_refinement_off(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_line_source_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_line_source_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_source_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_source_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_source_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_source_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_source_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_source_get_resolution(self.0) } + } + fn set_number_of_refinement_ratios(&mut self, p0: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_line_source_set_number_of_refinement_ratios( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ); + } + unsafe { vtk_line_source_set_number_of_refinement_ratios(self.0, p0) } + } + fn set_refinement_ratio( + &mut self, + index: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_source_set_refinement_ratio( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_line_source_set_refinement_ratio(self.0, index, value) } + } + fn get_number_of_refinement_ratios(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_source_get_number_of_refinement_ratios( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_source_get_number_of_refinement_ratios(self.0) } + } + fn get_refinement_ratio(&mut self, index: core::ffi::c_int) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_line_source_get_refinement_ratio( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_line_source_get_refinement_ratio(self.0, index) } + } + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_line_source_set_points( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_line_source_set_points(self.0, p0) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_source_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_source_get_points(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_line_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_line_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_source_get_output_points_precision(self.0) } + } +} +impl VtkOutlineCornerFilter for vtkOutlineCornerFilter { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_filter_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_filter_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_filter_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_filter_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_filter_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_filter_new(self.0) } + } + fn set_corner_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_outline_corner_filter_set_corner_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_outline_corner_filter_set_corner_factor(self.0, _arg) } + } + fn get_corner_factor_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_filter_get_corner_factor_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_filter_get_corner_factor_min_value(self.0) } + } + fn get_corner_factor_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_filter_get_corner_factor_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_filter_get_corner_factor_max_value(self.0) } + } + fn get_corner_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_filter_get_corner_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_filter_get_corner_factor(self.0) } + } +} +impl VtkOutlineCornerSource for vtkOutlineCornerSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_source_new(self.0) } + } + fn set_corner_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_outline_corner_source_set_corner_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_outline_corner_source_set_corner_factor(self.0, _arg) } + } + fn get_corner_factor_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_source_get_corner_factor_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_source_get_corner_factor_min_value(self.0) } + } + fn get_corner_factor_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_source_get_corner_factor_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_source_get_corner_factor_max_value(self.0) } + } + fn get_corner_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_source_get_corner_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_source_get_corner_factor(self.0) } + } +} +impl VtkOutlineSource for vtkOutlineSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_source_new_instance(self.0) } + } + fn set_box_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_box_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_outline_source_set_box_type(self.0, _arg) } + } + fn get_box_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_outline_source_get_box_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_outline_source_get_box_type(self.0) } + } + fn set_box_type_to_axis_aligned(&mut self) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_box_type_to_axis_aligned( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_outline_source_set_box_type_to_axis_aligned(self.0) } + } + fn set_box_type_to_oriented(&mut self) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_box_type_to_oriented( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_outline_source_set_box_type_to_oriented(self.0) } + } + fn set_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_bounds( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ); + } + unsafe { + vtk_outline_source_set_bounds( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn set_generate_faces(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_generate_faces( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_outline_source_set_generate_faces(self.0, _arg) } + } + fn generate_faces_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_outline_source_generate_faces_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_outline_source_generate_faces_on(self.0) } + } + fn generate_faces_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_outline_source_generate_faces_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_outline_source_generate_faces_off(self.0) } + } + fn get_generate_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_outline_source_get_generate_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_outline_source_get_generate_faces(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_outline_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_outline_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_outline_source_get_output_points_precision(self.0) } + } +} +impl VtkParametricFunctionSource for vtkParametricFunctionSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_function_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_function_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_function_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_function_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_function_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_function_source_new(self.0) } + } + fn set_parametric_function(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_parametric_function( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_parametric_function(self.0, p0) } + } + fn get_parametric_function(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_function_source_get_parametric_function( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_function_source_get_parametric_function(self.0) } + } + fn set_u_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_u_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_function_source_set_u_resolution(self.0, _arg) } + } + fn get_u_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_u_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_u_resolution_min_value(self.0) } + } + fn get_u_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_u_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_u_resolution_max_value(self.0) } + } + fn get_u_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_u_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_u_resolution(self.0) } + } + fn set_v_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_v_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_function_source_set_v_resolution(self.0, _arg) } + } + fn get_v_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_v_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_v_resolution_min_value(self.0) } + } + fn get_v_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_v_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_v_resolution_max_value(self.0) } + } + fn get_v_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_v_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_v_resolution(self.0) } + } + fn set_w_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_w_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_function_source_set_w_resolution(self.0, _arg) } + } + fn get_w_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_w_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_w_resolution_min_value(self.0) } + } + fn get_w_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_w_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_w_resolution_max_value(self.0) } + } + fn get_w_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_w_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_w_resolution(self.0) } + } + fn generate_texture_coordinates_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_generate_texture_coordinates_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_generate_texture_coordinates_on(self.0) } + } + fn generate_texture_coordinates_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_generate_texture_coordinates_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_parametric_function_source_generate_texture_coordinates_off(self.0) + } + } + fn set_generate_texture_coordinates(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_generate_texture_coordinates( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_parametric_function_source_set_generate_texture_coordinates(self.0, _arg) + } + } + fn get_generate_texture_coordinates_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_texture_coordinates_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_parametric_function_source_get_generate_texture_coordinates_min_value( + self.0, + ) + } + } + fn get_generate_texture_coordinates_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_texture_coordinates_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_parametric_function_source_get_generate_texture_coordinates_max_value( + self.0, + ) + } + } + fn get_generate_texture_coordinates(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_texture_coordinates( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_parametric_function_source_get_generate_texture_coordinates(self.0) + } + } + fn generate_normals_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_generate_normals_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_generate_normals_on(self.0) } + } + fn generate_normals_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_generate_normals_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_generate_normals_off(self.0) } + } + fn set_generate_normals(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_generate_normals( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_function_source_set_generate_normals(self.0, _arg) } + } + fn get_generate_normals_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_normals_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_generate_normals_min_value(self.0) } + } + fn get_generate_normals_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_normals_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_generate_normals_max_value(self.0) } + } + fn get_generate_normals(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_normals( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_generate_normals(self.0) } + } + fn set_scalar_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode(self.0, _arg) } + } + fn get_scalar_mode_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_scalar_mode_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_scalar_mode_min_value(self.0) } + } + fn get_scalar_mode_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_scalar_mode_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_scalar_mode_max_value(self.0) } + } + fn get_scalar_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_scalar_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_scalar_mode(self.0) } + } + fn set_scalar_mode_to_none(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_none( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_none(self.0) } + } + fn set_scalar_mode_to_u(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_u( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_u(self.0) } + } + fn set_scalar_mode_to_v(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_v( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_v(self.0) } + } + fn set_scalar_mode_to_u_0(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_u_0( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_u_0(self.0) } + } + fn set_scalar_mode_to_v_0(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_v_0( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_v_0(self.0) } + } + fn set_scalar_mode_to_u_0_v_0(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_u_0_v_0( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_u_0_v_0(self.0) } + } + fn set_scalar_mode_to_modulus(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_modulus( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_modulus(self.0) } + } + fn set_scalar_mode_to_phase(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_phase( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_phase(self.0) } + } + fn set_scalar_mode_to_quadrant(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_quadrant( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_quadrant(self.0) } + } + fn set_scalar_mode_to_x(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_x( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_x(self.0) } + } + fn set_scalar_mode_to_y(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_y( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_y(self.0) } + } + fn set_scalar_mode_to_z(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_z( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_z(self.0) } + } + fn set_scalar_mode_to_distance(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_distance( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_distance(self.0) } + } + fn set_scalar_mode_to_function_defined(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_function_defined( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_parametric_function_source_set_scalar_mode_to_function_defined(self.0) + } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_parametric_function_source_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_parametric_function_source_get_m_time(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_parametric_function_source_set_output_points_precision(self.0, _arg) + } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_output_points_precision(self.0) } + } +} +impl VtkPartitionedDataSetCollectionSource for vtkPartitionedDataSetCollectionSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_source_new_instance(self.0) } + } + fn set_number_of_shapes(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_set_number_of_shapes( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_partitioned_data_set_collection_source_set_number_of_shapes(self.0, _arg) + } + } + fn get_number_of_shapes_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_get_number_of_shapes_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_partitioned_data_set_collection_source_get_number_of_shapes_min_value( + self.0, + ) + } + } + fn get_number_of_shapes_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_get_number_of_shapes_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_partitioned_data_set_collection_source_get_number_of_shapes_max_value( + self.0, + ) + } + } + fn get_number_of_shapes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_get_number_of_shapes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_partitioned_data_set_collection_source_get_number_of_shapes(self.0) + } + } +} +impl VtkPartitionedDataSetSource for vtkPartitionedDataSetSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_source_new_instance(self.0) } + } + fn enable_rank(&mut self, rank: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_enable_rank( + sself: *mut core::ffi::c_void, + rank: core::ffi::c_int, + ); + } + unsafe { vtk_partitioned_data_set_source_enable_rank(self.0, rank) } + } + fn enable_all_ranks(&mut self) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_enable_all_ranks( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_source_enable_all_ranks(self.0) } + } + fn disable_rank(&mut self, rank: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_disable_rank( + sself: *mut core::ffi::c_void, + rank: core::ffi::c_int, + ); + } + unsafe { vtk_partitioned_data_set_source_disable_rank(self.0, rank) } + } + fn disable_all_ranks(&mut self) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_disable_all_ranks( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_source_disable_all_ranks(self.0) } + } + fn is_enabled_rank(&mut self, rank: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_is_enabled_rank( + sself: *mut core::ffi::c_void, + rank: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_partitioned_data_set_source_is_enabled_rank(self.0, rank) } + } + fn set_number_of_partitions(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_set_number_of_partitions( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_partitioned_data_set_source_set_number_of_partitions(self.0, _arg) } + } + fn get_number_of_partitions_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_get_number_of_partitions_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_partitioned_data_set_source_get_number_of_partitions_min_value(self.0) + } + } + fn get_number_of_partitions_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_get_number_of_partitions_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_partitioned_data_set_source_get_number_of_partitions_max_value(self.0) + } + } + fn get_number_of_partitions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_get_number_of_partitions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_partitioned_data_set_source_get_number_of_partitions(self.0) } + } + fn set_parametric_function(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_set_parametric_function( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_source_set_parametric_function(self.0, p0) } + } + fn get_parametric_function(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_get_parametric_function( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_source_get_parametric_function(self.0) } + } +} +impl VtkPlaneSource for vtkPlaneSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_source_new(self.0) } + } + fn set_x_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_x_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_plane_source_set_x_resolution(self.0, _arg) } + } + fn get_x_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_source_get_x_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_source_get_x_resolution(self.0) } + } + fn set_y_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_y_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_plane_source_set_y_resolution(self.0, _arg) } + } + fn get_y_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_source_get_y_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_source_get_y_resolution(self.0) } + } + fn set_resolution(&mut self, xR: core::ffi::c_int, yR: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_resolution( + sself: *mut core::ffi::c_void, + xR: core::ffi::c_int, + yR: core::ffi::c_int, + ); + } + unsafe { vtk_plane_source_set_resolution(self.0, xR, yR) } + } + fn get_resolution( + &mut self, + xR: &mut core::ffi::c_int, + yR: &mut core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_get_resolution( + sself: *mut core::ffi::c_void, + xR: &mut core::ffi::c_int, + yR: &mut core::ffi::c_int, + ); + } + unsafe { vtk_plane_source_get_resolution(self.0, xR, yR) } + } + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_origin( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_set_origin(self.0, _arg1, _arg2, _arg3) } + } + fn set_point_1( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_point_1( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_set_point_1(self.0, x, y, z) } + } + fn set_point_2( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_point_2( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_set_point_2(self.0, x, y, z) } + } + fn set_center( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_center( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_set_center(self.0, x, y, z) } + } + fn set_normal( + &mut self, + nx: core::ffi::c_double, + ny: core::ffi::c_double, + nz: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_normal( + sself: *mut core::ffi::c_void, + nx: core::ffi::c_double, + ny: core::ffi::c_double, + nz: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_set_normal(self.0, nx, ny, nz) } + } + fn push(&mut self, distance: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_plane_source_push( + sself: *mut core::ffi::c_void, + distance: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_push(self.0, distance) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_plane_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_source_get_output_points_precision(self.0) } + } +} +impl VtkPlatonicSolidSource for vtkPlatonicSolidSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_platonic_solid_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_platonic_solid_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_platonic_solid_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_platonic_solid_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_platonic_solid_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_platonic_solid_source_new_instance(self.0) } + } + fn set_solid_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type(self.0, _arg) } + } + fn get_solid_type_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_platonic_solid_source_get_solid_type_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_platonic_solid_source_get_solid_type_min_value(self.0) } + } + fn get_solid_type_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_platonic_solid_source_get_solid_type_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_platonic_solid_source_get_solid_type_max_value(self.0) } + } + fn get_solid_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_platonic_solid_source_get_solid_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_platonic_solid_source_get_solid_type(self.0) } + } + fn set_solid_type_to_tetrahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type_to_tetrahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type_to_tetrahedron(self.0) } + } + fn set_solid_type_to_cube(&mut self) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type_to_cube( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type_to_cube(self.0) } + } + fn set_solid_type_to_octahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type_to_octahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type_to_octahedron(self.0) } + } + fn set_solid_type_to_icosahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type_to_icosahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type_to_icosahedron(self.0) } + } + fn set_solid_type_to_dodecahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type_to_dodecahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type_to_dodecahedron(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_platonic_solid_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_platonic_solid_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_platonic_solid_source_get_output_points_precision(self.0) } + } +} +impl VtkPointHandleSource for vtkPointHandleSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_handle_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_handle_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_handle_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_handle_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_handle_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_handle_source_new_instance(self.0) } + } + fn set_position( + &mut self, + xPos: core::ffi::c_double, + yPos: core::ffi::c_double, + zPos: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_point_handle_source_set_position( + sself: *mut core::ffi::c_void, + xPos: core::ffi::c_double, + yPos: core::ffi::c_double, + zPos: core::ffi::c_double, + ); + } + unsafe { vtk_point_handle_source_set_position(self.0, xPos, yPos, zPos) } + } + fn set_direction( + &mut self, + xDir: core::ffi::c_double, + yDir: core::ffi::c_double, + zDir: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_point_handle_source_set_direction( + sself: *mut core::ffi::c_void, + xDir: core::ffi::c_double, + yDir: core::ffi::c_double, + zDir: core::ffi::c_double, + ); + } + unsafe { vtk_point_handle_source_set_direction(self.0, xDir, yDir, zDir) } + } +} +impl VtkPointSource for vtkPointSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_source_new_instance(self.0) } + } + fn set_number_of_points(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_point_source_set_number_of_points( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_point_source_set_number_of_points(self.0, _arg) } + } + fn get_number_of_points_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_point_source_get_number_of_points_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_point_source_get_number_of_points_min_value(self.0) } + } + fn get_number_of_points_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_point_source_get_number_of_points_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_point_source_get_number_of_points_max_value(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_point_source_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_point_source_get_number_of_points(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_point_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_point_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_point_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_point_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_point_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_point_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_point_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_point_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_point_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_point_source_get_radius(self.0) } + } + fn set_distribution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_point_source_set_distribution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_point_source_set_distribution(self.0, _arg) } + } + fn set_distribution_to_uniform(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_source_set_distribution_to_uniform( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_source_set_distribution_to_uniform(self.0) } + } + fn set_distribution_to_shell(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_source_set_distribution_to_shell(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_source_set_distribution_to_shell(self.0) } + } + fn get_distribution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_source_get_distribution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_source_get_distribution(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_point_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_point_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_source_get_output_points_precision(self.0) } + } + fn set_random_sequence(&mut self, randomSequence: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_source_set_random_sequence( + sself: *mut core::ffi::c_void, + randomSequence: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_source_set_random_sequence(self.0, randomSequence) } + } + fn get_random_sequence(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_source_get_random_sequence( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_source_get_random_sequence(self.0) } + } +} +impl VtkPolyLineSource for vtkPolyLineSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_source_new_instance(self.0) } + } + fn set_closed(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_poly_line_source_set_closed( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_poly_line_source_set_closed(self.0, _arg) } + } + fn get_closed(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_source_get_closed( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_source_get_closed(self.0) } + } + fn closed_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_line_source_closed_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_line_source_closed_on(self.0) } + } + fn closed_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_line_source_closed_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_line_source_closed_off(self.0) } + } +} +impl VtkPolyPointSource for vtkPolyPointSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_point_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_point_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_point_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_point_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_point_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_point_source_new_instance(self.0) } + } + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_poly_point_source_set_number_of_points( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_point_source_set_number_of_points(self.0, numPoints) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_poly_point_source_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_poly_point_source_get_number_of_points(self.0) } + } + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_poly_point_source_resize( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_point_source_resize(self.0, numPoints) } + } + fn set_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_poly_point_source_set_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_poly_point_source_set_point(self.0, id, x, y, z) } + } + fn set_points(&mut self, points: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_point_source_set_points( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_point_source_set_points(self.0, points) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_point_source_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_point_source_get_points(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_poly_point_source_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_poly_point_source_get_m_time(self.0) } + } +} +impl VtkProgrammableDataObjectSource for vtkProgrammableDataObjectSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_data_object_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_data_object_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_data_object_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_data_object_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_data_object_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_data_object_source_new_instance(self.0) } + } + fn set_execute_method_arg_delete(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_programmable_data_object_source_set_execute_method_arg_delete( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_programmable_data_object_source_set_execute_method_arg_delete(self.0, f) + } + } +} +impl VtkProgrammableSource for vtkProgrammableSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_new_instance(self.0) } + } + fn set_execute_method_arg_delete(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_programmable_source_set_execute_method_arg_delete( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_programmable_source_set_execute_method_arg_delete(self.0, f) } + } + fn set_request_information_method(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_programmable_source_set_request_information_method( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_programmable_source_set_request_information_method(self.0, f) } + } + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_poly_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_poly_data_output(self.0) } + } + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_structured_points_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_structured_points_output(self.0) } + } + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_structured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_structured_grid_output(self.0) } + } + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_unstructured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_unstructured_grid_output(self.0) } + } + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_rectilinear_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_rectilinear_grid_output(self.0) } + } + fn get_graph_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_graph_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_graph_output(self.0) } + } + fn get_molecule_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_molecule_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_molecule_output(self.0) } + } + fn get_table_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_table_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_table_output(self.0) } + } +} +impl VtkRandomHyperTreeGridSource for vtkRandomHyperTreeGridSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_hyper_tree_grid_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_hyper_tree_grid_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_hyper_tree_grid_source_new_instance(self.0) } + } + fn set_dimensions( + &mut self, + _arg1: core::ffi::c_uint, + _arg2: core::ffi::c_uint, + _arg3: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_set_dimensions( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_uint, + _arg2: core::ffi::c_uint, + _arg3: core::ffi::c_uint, + ); + } + unsafe { + vtk_random_hyper_tree_grid_source_set_dimensions(self.0, _arg1, _arg2, _arg3) + } + } + fn set_output_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_set_output_bounds( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ); + } + unsafe { + vtk_random_hyper_tree_grid_source_set_output_bounds( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn get_seed(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_seed( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_random_hyper_tree_grid_source_get_seed(self.0) } + } + fn set_seed(&mut self, _arg: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_set_seed( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uint, + ); + } + unsafe { vtk_random_hyper_tree_grid_source_set_seed(self.0, _arg) } + } + fn get_max_depth(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_max_depth( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_hyper_tree_grid_source_get_max_depth(self.0) } + } + fn set_max_depth(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_set_max_depth( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_random_hyper_tree_grid_source_set_max_depth(self.0, _arg) } + } + fn get_max_depth_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_max_depth_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_hyper_tree_grid_source_get_max_depth_min_value(self.0) } + } + fn get_max_depth_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_max_depth_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_hyper_tree_grid_source_get_max_depth_max_value(self.0) } + } + fn get_split_fraction(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_split_fraction( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_random_hyper_tree_grid_source_get_split_fraction(self.0) } + } + fn set_split_fraction(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_set_split_fraction( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_random_hyper_tree_grid_source_set_split_fraction(self.0, _arg) } + } + fn get_split_fraction_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_split_fraction_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_random_hyper_tree_grid_source_get_split_fraction_min_value(self.0) } + } + fn get_split_fraction_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_split_fraction_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_random_hyper_tree_grid_source_get_split_fraction_max_value(self.0) } + } +} +impl VtkRectangularButtonSource for vtkRectangularButtonSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectangular_button_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectangular_button_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectangular_button_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectangular_button_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectangular_button_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectangular_button_source_new(self.0) } + } + fn set_width(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_width( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_width(self.0, _arg) } + } + fn get_width_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_width_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_width_min_value(self.0) } + } + fn get_width_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_width_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_width_max_value(self.0) } + } + fn get_width(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_width( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_width(self.0) } + } + fn set_height(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_height( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_height(self.0, _arg) } + } + fn get_height_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_height_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_height_min_value(self.0) } + } + fn get_height_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_height_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_height_max_value(self.0) } + } + fn get_height(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_height( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_height(self.0) } + } + fn set_depth(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_depth( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_depth(self.0, _arg) } + } + fn get_depth_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_depth_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_depth_min_value(self.0) } + } + fn get_depth_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_depth_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_depth_max_value(self.0) } + } + fn get_depth(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_depth( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_depth(self.0) } + } + fn set_box_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_box_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_box_ratio(self.0, _arg) } + } + fn get_box_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_box_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_box_ratio_min_value(self.0) } + } + fn get_box_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_box_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_box_ratio_max_value(self.0) } + } + fn get_box_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_box_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_box_ratio(self.0) } + } + fn set_texture_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_texture_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_texture_ratio(self.0, _arg) } + } + fn get_texture_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_texture_ratio_min_value(self.0) } + } + fn get_texture_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_texture_ratio_max_value(self.0) } + } + fn get_texture_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_texture_ratio(self.0) } + } + fn set_texture_height_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_texture_height_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_texture_height_ratio(self.0, _arg) } + } + fn get_texture_height_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_height_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { + vtk_rectangular_button_source_get_texture_height_ratio_min_value(self.0) + } + } + fn get_texture_height_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_height_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { + vtk_rectangular_button_source_get_texture_height_ratio_max_value(self.0) + } + } + fn get_texture_height_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_height_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_texture_height_ratio(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_rectangular_button_source_set_output_points_precision(self.0, _arg) + } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectangular_button_source_get_output_points_precision(self.0) } + } +} +impl VtkRegularPolygonSource for vtkRegularPolygonSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_regular_polygon_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_regular_polygon_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_regular_polygon_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_regular_polygon_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_regular_polygon_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_regular_polygon_source_new_instance(self.0) } + } + fn set_number_of_sides(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_number_of_sides( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_regular_polygon_source_set_number_of_sides(self.0, _arg) } + } + fn get_number_of_sides_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_number_of_sides_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_number_of_sides_min_value(self.0) } + } + fn get_number_of_sides_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_number_of_sides_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_number_of_sides_max_value(self.0) } + } + fn get_number_of_sides(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_number_of_sides( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_number_of_sides(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_regular_polygon_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_normal( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_regular_polygon_source_set_normal(self.0, _arg1, _arg2, _arg3) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_regular_polygon_source_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_regular_polygon_source_get_radius(self.0) } + } + fn set_generate_polygon(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_generate_polygon( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_regular_polygon_source_set_generate_polygon(self.0, _arg) } + } + fn get_generate_polygon(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_generate_polygon( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_generate_polygon(self.0) } + } + fn generate_polygon_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_generate_polygon_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_regular_polygon_source_generate_polygon_on(self.0) } + } + fn generate_polygon_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_generate_polygon_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_regular_polygon_source_generate_polygon_off(self.0) } + } + fn set_generate_polyline(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_generate_polyline( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_regular_polygon_source_set_generate_polyline(self.0, _arg) } + } + fn get_generate_polyline(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_generate_polyline( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_generate_polyline(self.0) } + } + fn generate_polyline_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_generate_polyline_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_regular_polygon_source_generate_polyline_on(self.0) } + } + fn generate_polyline_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_generate_polyline_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_regular_polygon_source_generate_polyline_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_regular_polygon_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_output_points_precision(self.0) } + } +} +impl VtkSelectionSource for vtkSelectionSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_source_new_instance(self.0) } + } + fn add_id(&mut self, piece: core::ffi::c_longlong, id: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_selection_source_add_id( + sself: *mut core::ffi::c_void, + piece: core::ffi::c_longlong, + id: core::ffi::c_longlong, + ); + } + unsafe { vtk_selection_source_add_id(self.0, piece, id) } + } + fn add_string_id(&mut self, piece: core::ffi::c_longlong, id: &str) -> () { + let c_id = std::ffi::CString::new(id).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_add_string_id( + sself: *mut core::ffi::c_void, + piece: core::ffi::c_longlong, + id: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_add_string_id(self.0, piece, c_id.as_ptr()) } + } + fn add_location( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_selection_source_add_location( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_selection_source_add_location(self.0, x, y, z) } + } + fn add_threshold( + &mut self, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_selection_source_add_threshold( + sself: *mut core::ffi::c_void, + min: core::ffi::c_double, + max: core::ffi::c_double, + ); + } + unsafe { vtk_selection_source_add_threshold(self.0, min, max) } + } + fn add_block(&mut self, blockno: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_selection_source_add_block( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_longlong, + ); + } + unsafe { vtk_selection_source_add_block(self.0, blockno) } + } + fn add_block_selector(&mut self, selector: &str) -> () { + let c_selector = std::ffi::CString::new(selector).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_add_block_selector( + sself: *mut core::ffi::c_void, + selector: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_add_block_selector(self.0, c_selector.as_ptr()) } + } + fn remove_all_block_selectors(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_block_selectors( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_source_remove_all_block_selectors(self.0) } + } + fn remove_all_i_ds(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_i_ds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_source_remove_all_i_ds(self.0) } + } + fn remove_all_string_i_ds(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_string_i_ds( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_source_remove_all_string_i_ds(self.0) } + } + fn remove_all_thresholds(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_thresholds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_source_remove_all_thresholds(self.0) } + } + fn remove_all_locations(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_locations(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_source_remove_all_locations(self.0) } + } + fn remove_all_blocks(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_blocks(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_source_remove_all_blocks(self.0) } + } + fn set_content_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_content_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_content_type(self.0, _arg) } + } + fn get_content_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_content_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_content_type(self.0) } + } + fn set_field_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_field_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_field_type(self.0, _arg) } + } + fn get_field_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_field_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_field_type(self.0) } + } + fn set_containing_cells(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_containing_cells( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_containing_cells(self.0, _arg) } + } + fn get_containing_cells(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_containing_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_containing_cells(self.0) } + } + fn set_number_of_layers(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_number_of_layers( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_number_of_layers(self.0, _arg) } + } + fn get_number_of_layers_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_number_of_layers_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_number_of_layers_min_value(self.0) } + } + fn get_number_of_layers_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_number_of_layers_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_number_of_layers_max_value(self.0) } + } + fn get_number_of_layers(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_number_of_layers( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_number_of_layers(self.0) } + } + fn set_inverse(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_inverse( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_inverse(self.0, _arg) } + } + fn get_inverse(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_inverse( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_inverse(self.0) } + } + fn set_array_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_set_array_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_set_array_name(self.0, c__arg.as_ptr()) } + } + fn set_array_component(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_array_component( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_array_component(self.0, _arg) } + } + fn get_array_component(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_array_component( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_array_component(self.0) } + } + fn set_composite_index(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_composite_index( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_composite_index(self.0, _arg) } + } + fn get_composite_index(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_composite_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_composite_index(self.0) } + } + fn set_hierarchical_level(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_hierarchical_level( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_hierarchical_level(self.0, _arg) } + } + fn get_hierarchical_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_hierarchical_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_hierarchical_level(self.0) } + } + fn set_hierarchical_index(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_hierarchical_index( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_hierarchical_index(self.0, _arg) } + } + fn get_hierarchical_index(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_hierarchical_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_hierarchical_index(self.0) } + } + fn set_assembly_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_set_assembly_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_set_assembly_name(self.0, c__arg.as_ptr()) } + } + fn add_selector(&mut self, selector: &str) -> () { + let c_selector = std::ffi::CString::new(selector).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_add_selector( + sself: *mut core::ffi::c_void, + selector: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_add_selector(self.0, c_selector.as_ptr()) } + } + fn remove_all_selectors(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_selectors(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_source_remove_all_selectors(self.0) } + } + fn set_query_string(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_set_query_string( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_set_query_string(self.0, c__arg.as_ptr()) } + } +} +impl VtkSphereSource for vtkSphereSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_source_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_theta_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_source_set_theta_resolution(self.0, _arg) } + } + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_theta_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_theta_resolution_min_value(self.0) } + } + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_theta_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_theta_resolution_max_value(self.0) } + } + fn get_theta_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_theta_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_theta_resolution(self.0) } + } + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_phi_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_source_set_phi_resolution(self.0, _arg) } + } + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_phi_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_phi_resolution_min_value(self.0) } + } + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_phi_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_phi_resolution_max_value(self.0) } + } + fn get_phi_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_phi_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_phi_resolution(self.0) } + } + fn set_start_theta(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_start_theta( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_start_theta(self.0, _arg) } + } + fn get_start_theta_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_theta_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_theta_min_value(self.0) } + } + fn get_start_theta_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_theta_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_theta_max_value(self.0) } + } + fn get_start_theta(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_theta( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_theta(self.0) } + } + fn set_end_theta(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_end_theta( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_end_theta(self.0, _arg) } + } + fn get_end_theta_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_theta_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_theta_min_value(self.0) } + } + fn get_end_theta_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_theta_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_theta_max_value(self.0) } + } + fn get_end_theta(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_theta( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_theta(self.0) } + } + fn set_start_phi(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_start_phi( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_start_phi(self.0, _arg) } + } + fn get_start_phi_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_phi_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_phi_min_value(self.0) } + } + fn get_start_phi_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_phi_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_phi_max_value(self.0) } + } + fn get_start_phi(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_phi( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_phi(self.0) } + } + fn set_end_phi(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_end_phi( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_end_phi(self.0, _arg) } + } + fn get_end_phi_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_phi_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_phi_min_value(self.0) } + } + fn get_end_phi_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_phi_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_phi_max_value(self.0) } + } + fn get_end_phi(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_phi( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_phi(self.0) } + } + fn set_lat_long_tessellation(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_lat_long_tessellation( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_source_set_lat_long_tessellation(self.0, _arg) } + } + fn get_lat_long_tessellation(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_lat_long_tessellation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_lat_long_tessellation(self.0) } + } + fn lat_long_tessellation_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_source_lat_long_tessellation_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_source_lat_long_tessellation_on(self.0) } + } + fn lat_long_tessellation_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_source_lat_long_tessellation_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sphere_source_lat_long_tessellation_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_output_points_precision(self.0) } + } + fn set_generate_normals(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_generate_normals( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_source_set_generate_normals(self.0, _arg) } + } + fn get_generate_normals(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_generate_normals( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_generate_normals(self.0) } + } + fn generate_normals_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_source_generate_normals_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_source_generate_normals_on(self.0) } + } + fn generate_normals_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_source_generate_normals_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_source_generate_normals_off(self.0) } + } +} +impl VtkSuperquadricSource for vtkSuperquadricSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_source_new_instance(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_scale( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_scale(self.0, _arg1, _arg2, _arg3) } + } + fn get_theta_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_source_get_theta_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_source_get_theta_resolution(self.0) } + } + fn set_theta_resolution(&mut self, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_theta_resolution( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_source_set_theta_resolution(self.0, i) } + } + fn get_phi_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_source_get_phi_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_source_get_phi_resolution(self.0) } + } + fn set_phi_resolution(&mut self, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_phi_resolution( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_source_set_phi_resolution(self.0, i) } + } + fn get_thickness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_thickness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_thickness(self.0) } + } + fn set_thickness(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_thickness( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_thickness(self.0, _arg) } + } + fn get_thickness_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_thickness_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_thickness_min_value(self.0) } + } + fn get_thickness_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_thickness_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_thickness_max_value(self.0) } + } + fn get_phi_roundness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_phi_roundness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_phi_roundness(self.0) } + } + fn set_phi_roundness(&mut self, e: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_phi_roundness( + sself: *mut core::ffi::c_void, + e: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_phi_roundness(self.0, e) } + } + fn get_theta_roundness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_theta_roundness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_theta_roundness(self.0) } + } + fn set_theta_roundness(&mut self, e: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_theta_roundness( + sself: *mut core::ffi::c_void, + e: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_theta_roundness(self.0, e) } + } + fn set_size(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_size(self.0, _arg) } + } + fn get_size(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_size(self.0) } + } + fn set_axis_of_symmetry(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_axis_of_symmetry( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_source_set_axis_of_symmetry(self.0, _arg) } + } + fn get_axis_of_symmetry(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_source_get_axis_of_symmetry( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_source_get_axis_of_symmetry(self.0) } + } + fn set_x_axis_of_symmetry(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_x_axis_of_symmetry( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_superquadric_source_set_x_axis_of_symmetry(self.0) } + } + fn set_y_axis_of_symmetry(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_y_axis_of_symmetry( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_superquadric_source_set_y_axis_of_symmetry(self.0) } + } + fn set_z_axis_of_symmetry(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_z_axis_of_symmetry( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_superquadric_source_set_z_axis_of_symmetry(self.0) } + } + fn toroidal_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_toroidal_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_superquadric_source_toroidal_on(self.0) } + } + fn toroidal_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_toroidal_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_superquadric_source_toroidal_off(self.0) } + } + fn get_toroidal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_source_get_toroidal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_source_get_toroidal(self.0) } + } + fn set_toroidal(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_toroidal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_source_set_toroidal(self.0, _arg) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_source_get_output_points_precision(self.0) } + } +} +impl VtkTessellatedBoxSource for vtkTessellatedBoxSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tessellated_box_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tessellated_box_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tessellated_box_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tessellated_box_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tessellated_box_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tessellated_box_source_new_instance(self.0) } + } + fn set_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_set_bounds( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ); + } + unsafe { + vtk_tessellated_box_source_set_bounds( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn set_level(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_set_level( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_tessellated_box_source_set_level(self.0, _arg) } + } + fn get_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tessellated_box_source_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tessellated_box_source_get_level(self.0) } + } + fn set_duplicate_shared_points(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_set_duplicate_shared_points( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_tessellated_box_source_set_duplicate_shared_points(self.0, _arg) } + } + fn get_duplicate_shared_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tessellated_box_source_get_duplicate_shared_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tessellated_box_source_get_duplicate_shared_points(self.0) } + } + fn duplicate_shared_points_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_duplicate_shared_points_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tessellated_box_source_duplicate_shared_points_on(self.0) } + } + fn duplicate_shared_points_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_duplicate_shared_points_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tessellated_box_source_duplicate_shared_points_off(self.0) } + } + fn set_quads(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_set_quads( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_tessellated_box_source_set_quads(self.0, _arg) } + } + fn get_quads(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tessellated_box_source_get_quads( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tessellated_box_source_get_quads(self.0) } + } + fn quads_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_quads_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_tessellated_box_source_quads_on(self.0) } + } + fn quads_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_quads_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_tessellated_box_source_quads_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_tessellated_box_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tessellated_box_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tessellated_box_source_get_output_points_precision(self.0) } + } +} +impl VtkTextSource for vtkTextSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_text_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_text_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_text_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_text_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_text_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_text_source_new(self.0) } + } + fn set_text(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_text_source_set_text( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_text_source_set_text(self.0, c__arg.as_ptr()) } + } + fn set_backing(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_text_source_set_backing( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_text_source_set_backing(self.0, _arg) } + } + fn get_backing(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_text_source_get_backing( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_text_source_get_backing(self.0) } + } + fn backing_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_text_source_backing_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_text_source_backing_on(self.0) } + } + fn backing_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_text_source_backing_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_text_source_backing_off(self.0) } + } + fn set_foreground_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_text_source_set_foreground_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_text_source_set_foreground_color(self.0, _arg1, _arg2, _arg3) } + } + fn set_background_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_text_source_set_background_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_text_source_set_background_color(self.0, _arg1, _arg2, _arg3) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_text_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_text_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_text_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_text_source_get_output_points_precision(self.0) } + } +} +impl VtkTexturedSphereSource for vtkTexturedSphereSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_textured_sphere_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_textured_sphere_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_textured_sphere_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_textured_sphere_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_textured_sphere_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_textured_sphere_source_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_textured_sphere_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_radius(self.0) } + } + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_theta_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_textured_sphere_source_set_theta_resolution(self.0, _arg) } + } + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_theta_resolution_min_value(self.0) } + } + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_theta_resolution_max_value(self.0) } + } + fn get_theta_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_theta_resolution(self.0) } + } + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_phi_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_textured_sphere_source_set_phi_resolution(self.0, _arg) } + } + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_phi_resolution_min_value(self.0) } + } + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_phi_resolution_max_value(self.0) } + } + fn get_phi_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_phi_resolution(self.0) } + } + fn set_theta(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_theta( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_textured_sphere_source_set_theta(self.0, _arg) } + } + fn get_theta_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_theta_min_value(self.0) } + } + fn get_theta_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_theta_max_value(self.0) } + } + fn get_theta(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_theta(self.0) } + } + fn set_phi(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_phi( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_textured_sphere_source_set_phi(self.0, _arg) } + } + fn get_phi_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_phi_min_value(self.0) } + } + fn get_phi_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_phi_max_value(self.0) } + } + fn get_phi(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_phi(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_textured_sphere_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_output_points_precision(self.0) } + } +} +impl VtkUniformHyperTreeGridSource for vtkUniformHyperTreeGridSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_source_new(self.0) } + } +} +/// create a circular arc +/// +/// +/// +/// vtkArcSource is a source object that creates an arc defined by two +/// endpoints and a center. The number of segments composing the polyline +/// is controlled by setting the object resolution. +/// Alternatively, one can use a better API (that does not allow for +/// inconsistent nor ambiguous inputs), using a starting point (polar vector, +/// measured from the arc's center), a normal to the plane of the arc, +/// and an angle defining the arc length. +/// Since the default API remains the original one, in order to use +/// the improved API, one must switch the UseNormalAndAngle flag to TRUE. +/// +/// The development of an improved, consistent API (based on point, normal, +/// and angle) was supported by CEA/DIF - Commissariat a l'Energie Atomique, +/// Centre DAM Ile-De-France, BP12, F-91297 Arpajon, France, and implemented +/// by Philippe Pebay, Kitware SAS 2012. +/// +/// @sa +/// vtkEllipseArcSource +#[allow(non_camel_case_types)] +pub struct vtkArcSource(*mut core::ffi::c_void); +impl vtkArcSource { + /// Creates a new [vtkArcSource] via `vtkArcSource::New()` + #[doc(alias = "vtkArcSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkArcSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkArcSource_new() }) + } +} +impl std::default::Default for vtkArcSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkArcSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkArcSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkArcSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkArcSource_create_drop() { + let obj = vtkArcSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Appends a cylinder to a cone to form an arrow. +/// +/// +/// vtkArrowSource was intended to be used as the source for a glyph. +/// The shaft base is always at (0,0,0). The arrow tip is always at (1,0,0). If +/// "Invert" is true, then the ends are flipped i.e. tip is at (0,0,0) while +/// base is at (1, 0, 0). +/// The resolution of the cone and shaft can be set and default to 6. +/// The radius of the cone and shaft can be set and default to 0.03 and 0.1. +/// The length of the tip can also be set, and defaults to 0.35. +#[allow(non_camel_case_types)] +pub struct vtkArrowSource(*mut core::ffi::c_void); +impl vtkArrowSource { + /// Creates a new [vtkArrowSource] via `vtkArrowSource::New()` + #[doc(alias = "vtkArrowSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkArrowSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkArrowSource_new() }) + } +} +impl std::default::Default for vtkArrowSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkArrowSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkArrowSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkArrowSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkArrowSource_create_drop() { + let obj = vtkArrowSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Generate a capsule centered at the origin +/// +/// +/// vtkCapsuleSource creates a capsule (represented by polygons) of specified +/// radius centered at the origin. The resolution (polygonal discretization) in +/// both the latitude (phi) and longitude (theta) directions can be specified as +/// well as the length of the capsule cylinder (CylinderLength). By default, the +/// surface tessellation of the sphere uses triangles; however you can set +/// LatLongTessellation to produce a tessellation using quadrilaterals (except +/// at the poles of the capsule). +#[allow(non_camel_case_types)] +pub struct vtkCapsuleSource(*mut core::ffi::c_void); +impl vtkCapsuleSource { + /// Creates a new [vtkCapsuleSource] via `vtkCapsuleSource::New()` + #[doc(alias = "vtkCapsuleSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkCapsuleSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkCapsuleSource_new() }) + } +} +impl std::default::Default for vtkCapsuleSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkCapsuleSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkCapsuleSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkCapsuleSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkCapsuleSource_create_drop() { + let obj = vtkCapsuleSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Create cells of a given type +/// +/// +/// vtkCellTypeSource is a source object that creates cells of the given +/// input type. BlocksDimensions specifies the number of cell "blocks" in each +/// direction. A cell block may be divided into multiple cells based on +/// the chosen cell type (e.g. 6 pyramid cells make up a single cell block). +/// If a 1D cell is selected then only the first dimension is +/// used to specify how many cells are generated. If a 2D cell is +/// selected then only the first and second dimensions are used to +/// determine how many cells are created. The source respects pieces. +#[allow(non_camel_case_types)] +pub struct vtkCellTypeSource(*mut core::ffi::c_void); +impl vtkCellTypeSource { + /// Creates a new [vtkCellTypeSource] via `vtkCellTypeSource::New()` + #[doc(alias = "vtkCellTypeSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkCellTypeSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkCellTypeSource_new() }) + } +} +impl std::default::Default for vtkCellTypeSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkCellTypeSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkCellTypeSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkCellTypeSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkCellTypeSource_create_drop() { + let obj = vtkCellTypeSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// generate polygonal cone +/// +/// +/// vtkConeSource creates a cone centered at a specified point and pointing in +/// a specified direction. (By default, the center is the origin and the +/// direction is the x-axis.) Depending upon the resolution of this object, +/// different representations are created. If resolution=0 a line is created; +/// if resolution=1, a single triangle is created; if resolution=2, two +/// crossed triangles are created. For resolution > 2, a 3D cone (with +/// resolution number of sides) is created. It also is possible to control +/// whether the bottom of the cone is capped with a (resolution-sided) +/// polygon, and to specify the height and radius of the cone. +#[allow(non_camel_case_types)] +pub struct vtkConeSource(*mut core::ffi::c_void); +impl vtkConeSource { + /// Creates a new [vtkConeSource] via `vtkConeSource::New()` + #[doc(alias = "vtkConeSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkConeSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkConeSource_new() }) + } +} +impl std::default::Default for vtkConeSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkConeSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkConeSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkConeSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkConeSource_create_drop() { + let obj = vtkConeSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a polygonal representation of a cube +/// +/// +/// vtkCubeSource creates a cube centered at origin. The cube is represented +/// with four-sided polygons. It is possible to specify the length, width, +/// and height of the cube independently. +#[allow(non_camel_case_types)] +pub struct vtkCubeSource(*mut core::ffi::c_void); +impl vtkCubeSource { + /// Creates a new [vtkCubeSource] via `vtkCubeSource::New()` + #[doc(alias = "vtkCubeSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkCubeSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkCubeSource_new() }) + } +} +impl std::default::Default for vtkCubeSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkCubeSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkCubeSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkCubeSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkCubeSource_create_drop() { + let obj = vtkCubeSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// generate a cylinder centered at origin +/// +/// +/// vtkCylinderSource creates a polygonal cylinder centered at Center; +/// The axis of the cylinder is aligned along the global y-axis. +/// The height and radius of the cylinder can be specified, as well as the +/// number of sides. It is also possible to control whether the cylinder is +/// open-ended or capped. If you have the end points of the cylinder, you +/// should use a vtkLineSource followed by a vtkTubeFilter instead of the +/// vtkCylinderSource. +#[allow(non_camel_case_types)] +pub struct vtkCylinderSource(*mut core::ffi::c_void); +impl vtkCylinderSource { + /// Creates a new [vtkCylinderSource] via `vtkCylinderSource::New()` + #[doc(alias = "vtkCylinderSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkCylinderSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkCylinderSource_new() }) + } +} +impl std::default::Default for vtkCylinderSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkCylinderSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkCylinderSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkCylinderSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkCylinderSource_create_drop() { + let obj = vtkCylinderSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// generates a sparse or dense square matrix +/// +/// with user-specified values for the diagonal, superdiagonal, and subdiagonal. +/// +/// @par Thanks: +/// Developed by Timothy M. Shead (tshead@sandia.gov) at Sandia National Laboratories. +#[allow(non_camel_case_types)] +pub struct vtkDiagonalMatrixSource(*mut core::ffi::c_void); +impl vtkDiagonalMatrixSource { + /// Creates a new [vtkDiagonalMatrixSource] via `vtkDiagonalMatrixSource::New()` + #[doc(alias = "vtkDiagonalMatrixSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkDiagonalMatrixSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkDiagonalMatrixSource_new() }) + } +} +impl std::default::Default for vtkDiagonalMatrixSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkDiagonalMatrixSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkDiagonalMatrixSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkDiagonalMatrixSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkDiagonalMatrixSource_create_drop() { + let obj = vtkDiagonalMatrixSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a disk with hole in center +/// +/// +/// vtkDiskSource creates a polygonal disk with a hole in the center. The +/// disk has zero height. The user can specify the inner and outer radius +/// of the disk, and the radial and circumferential resolution of the +/// polygonal representation. +/// @sa +/// vtkLinearExtrusionFilter +#[allow(non_camel_case_types)] +pub struct vtkDiskSource(*mut core::ffi::c_void); +impl vtkDiskSource { + /// Creates a new [vtkDiskSource] via `vtkDiskSource::New()` + #[doc(alias = "vtkDiskSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkDiskSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkDiskSource_new() }) + } +} +impl std::default::Default for vtkDiskSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkDiskSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkDiskSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkDiskSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkDiskSource_create_drop() { + let obj = vtkDiskSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create an elliptical arc +/// +/// +/// +/// vtkEllipseArcSource is a source object that creates an elliptical arc +/// defined by a normal, a center and the major radius vector. +/// You can define an angle to draw only a section of the ellipse. The number of +/// segments composing the polyline is controlled by setting the object +/// resolution. +/// +/// @sa +/// vtkArcSource +#[allow(non_camel_case_types)] +pub struct vtkEllipseArcSource(*mut core::ffi::c_void); +impl vtkEllipseArcSource { + /// Creates a new [vtkEllipseArcSource] via `vtkEllipseArcSource::New()` + #[doc(alias = "vtkEllipseArcSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkEllipseArcSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkEllipseArcSource_new() }) + } +} +impl std::default::Default for vtkEllipseArcSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkEllipseArcSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkEllipseArcSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkEllipseArcSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkEllipseArcSource_create_drop() { + let obj = vtkEllipseArcSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a ellipsoidal-shaped button +/// +/// +/// vtkEllipticalButtonSource creates a ellipsoidal shaped button with +/// texture coordinates suitable for application of a texture map. This +/// provides a way to make nice looking 3D buttons. The buttons are +/// represented as vtkPolyData that includes texture coordinates and +/// normals. The button lies in the x-y plane. +/// +/// To use this class you must define the major and minor axes lengths of an +/// ellipsoid (expressed as width (x), height (y) and depth (z)). The button +/// has a rectangular mesh region in the center with texture coordinates that +/// range smoothly from (0,1). (This flat region is called the texture +/// region.) The outer, curved portion of the button (called the shoulder) has +/// texture coordinates set to a user specified value (by default (0,0). +/// (This results in coloring the button curve the same color as the (s,t) +/// location of the texture map.) The resolution in the radial direction, the +/// texture region, and the shoulder region must also be set. The button can +/// be moved by specifying an origin. +/// +/// @sa +/// vtkButtonSource vtkRectangularButtonSource +#[allow(non_camel_case_types)] +pub struct vtkEllipticalButtonSource(*mut core::ffi::c_void); +impl vtkEllipticalButtonSource { + /// Creates a new [vtkEllipticalButtonSource] via `vtkEllipticalButtonSource::New()` + #[doc(alias = "vtkEllipticalButtonSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkEllipticalButtonSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkEllipticalButtonSource_new() }) + } +} +impl std::default::Default for vtkEllipticalButtonSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkEllipticalButtonSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkEllipticalButtonSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkEllipticalButtonSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkEllipticalButtonSource_create_drop() { + let obj = vtkEllipticalButtonSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a polygonal representation of a frustum +/// +/// +/// vtkFrustumSource creates a frustum defines by a set of planes. The frustum +/// is represented with four-sided polygons. It is possible to specify extra +/// lines to better visualize the field of view. +/// +/// @par Usage: +/// Typical use consists of 3 steps: +/// 1. get the planes coefficients from a vtkCamera with +/// vtkCamera::GetFrustumPlanes() +/// 2. initialize the planes with vtkPlanes::SetFrustumPlanes() with the planes +/// coefficients +/// 3. pass the vtkPlanes to a vtkFrustumSource. +#[allow(non_camel_case_types)] +pub struct vtkFrustumSource(*mut core::ffi::c_void); +impl vtkFrustumSource { + /// Creates a new [vtkFrustumSource] via `vtkFrustumSource::New()` + #[doc(alias = "vtkFrustumSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkFrustumSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkFrustumSource_new() }) + } +} +impl std::default::Default for vtkFrustumSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkFrustumSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkFrustumSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkFrustumSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkFrustumSource_create_drop() { + let obj = vtkFrustumSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create 2D glyphs represented by vtkPolyData +/// +/// +/// vtkGlyphSource2D can generate a family of 2D glyphs each of which lies +/// in the x-y plane (i.e., the z-coordinate is zero). The class is a helper +/// class to be used with vtkGlyph2D and vtkXYPlotActor. +/// +/// To use this class, specify the glyph type to use and its +/// attributes. Attributes include its position (i.e., center point), scale, +/// color, and whether the symbol is filled or not (a polygon or closed line +/// sequence). You can also put a short line through the glyph running from -x +/// to +x (the glyph looks like it's on a line), or a cross. +#[allow(non_camel_case_types)] +pub struct vtkGlyphSource2D(*mut core::ffi::c_void); +impl vtkGlyphSource2D { + /// Creates a new [vtkGlyphSource2D] via `vtkGlyphSource2D::New()` + #[doc(alias = "vtkGlyphSource2D")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkGlyphSource2D_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkGlyphSource2D_new() }) + } +} +impl std::default::Default for vtkGlyphSource2D { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkGlyphSource2D { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkGlyphSource2D_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkGlyphSource2D_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkGlyphSource2D_create_drop() { + let obj = vtkGlyphSource2D::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// convert a vtkGraph to vtkPolyData +/// +/// +/// +/// Converts a vtkGraph to a vtkPolyData. This assumes that the points +/// of the graph have already been filled (perhaps by vtkGraphLayout), +/// and coverts all the edge of the graph into lines in the polydata. +/// The vertex data is passed along to the point data, and the edge data +/// is passed along to the cell data. +/// +/// Only the owned graph edges (i.e. edges with ghost level 0) are copied +/// into the vtkPolyData. +#[allow(non_camel_case_types)] +pub struct vtkGraphToPolyData(*mut core::ffi::c_void); +impl vtkGraphToPolyData { + /// Creates a new [vtkGraphToPolyData] via `vtkGraphToPolyData::New()` + #[doc(alias = "vtkGraphToPolyData")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkGraphToPolyData_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkGraphToPolyData_new() }) + } +} +impl std::default::Default for vtkGraphToPolyData { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkGraphToPolyData { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkGraphToPolyData_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkGraphToPolyData_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkGraphToPolyData_create_drop() { + let obj = vtkGraphToPolyData::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Create a synthetic grid of hypertrees. +/// +/// +/// +/// This class uses input parameters, most notably a string descriptor, +/// to generate a vtkHyperTreeGrid instance representing the corresponding +/// tree-based AMR grid. This descriptor uses the following conventions, +/// e.g., to describe a 1-D ternary subdivision with 2 root cells +/// L0 L1 L2 +/// RR | .R. ... | ... +/// For this tree: +/// HTG: . +/// / \ +/// L0: . . +/// /|\ /|\ +/// L1: c . c c c c +/// /|\ +/// L2: c c c +/// The top level of the tree is not considered a grid level +/// NB: For ease of legibility, white spaces are allowed and ignored. +/// +/// @par Thanks: +/// This class was written by Philippe Pebay, Joachim Pouderoux, and Charles Law, Kitware 2013 +/// This class was modified by Guenole Harel and Jacques-Bernard Lekien 2014 +/// This class was modified by Philippe Pebay, 2016 +/// This work was supported by Commissariat a l'Energie Atomique (CEA/DIF) +/// CEA, DAM, DIF, F-91297 Arpajon, France. +#[allow(non_camel_case_types)] +pub struct vtkHyperTreeGridSource(*mut core::ffi::c_void); +impl vtkHyperTreeGridSource { + /// Creates a new [vtkHyperTreeGridSource] via `vtkHyperTreeGridSource::New()` + #[doc(alias = "vtkHyperTreeGridSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkHyperTreeGridSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkHyperTreeGridSource_new() }) + } +} +impl std::default::Default for vtkHyperTreeGridSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkHyperTreeGridSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkHyperTreeGridSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkHyperTreeGridSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkHyperTreeGridSource_create_drop() { + let obj = vtkHyperTreeGridSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a line defined by two end points +/// +/// +/// vtkLineSource is a source object that creates a polyline defined by +/// two endpoints or a collection of connected line segments. To define the line +/// by end points, use `SetPoint1` and `SetPoint2` methods. To define a broken +/// line comprising of multiple line segments, use `SetPoints` to provide the +/// corner points that for the line. +/// +/// Intermediate points within line segment (when specifying end points alone) or +/// each of the individual line segments (when specifying broken line) can be +/// specified in two ways. First, when `UseRegularRefinement` is true (default), +/// the `Resolution` is used to determine how many intermediate points to add +/// using regular refinement. Thus, if `Resolution` is set to 1, a mid point will +/// be added for each of the line segments resulting in a line with 3 points: the +/// two end points and the mid point. Second, when `UseRegularRefinement` is +/// false, refinement ratios for points per segment are specified using +/// `SetRefinementRatio` and `SetNumberOfRefinementRatios`. To generate same +/// points as `Resolution` set to 1, the refinement ratios will be `[0, 0.5, +/// 1.0]`. To add the end points of the line segment `0.0` and `1.0` must be +/// included in the collection of refinement ratios. +/// +/// @section ChangesVTK9 Changes in VTK 9.0 +/// +/// Prior to VTK 9.0, when broken line was being generated, the texture +/// coordinates for each of the individual breaks in the line ranged from [0.0, +/// 1.0]. This has been changed to generate texture coordinates in the range +/// [0.0, 1.0] over the entire output line irrespective of whether the line was +/// generated by simply specifying the end points or multiple line segments. +/// +/// @par Thanks: +/// This class was extended by Philippe Pebay, Kitware SAS 2011, to support +/// broken lines as well as simple lines. +#[allow(non_camel_case_types)] +pub struct vtkLineSource(*mut core::ffi::c_void); +impl vtkLineSource { + /// Creates a new [vtkLineSource] via `vtkLineSource::New()` + #[doc(alias = "vtkLineSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkLineSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkLineSource_new() }) + } +} +impl std::default::Default for vtkLineSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkLineSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkLineSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkLineSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkLineSource_create_drop() { + let obj = vtkLineSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create wireframe outline corners for arbitrary data set +/// +/// +/// vtkOutlineCornerFilter is a filter that generates wireframe outline corners of any +/// data set. The outline consists of the eight corners of the dataset +/// bounding box. +#[allow(non_camel_case_types)] +pub struct vtkOutlineCornerFilter(*mut core::ffi::c_void); +impl vtkOutlineCornerFilter { + /// Creates a new [vtkOutlineCornerFilter] via `vtkOutlineCornerFilter::New()` + #[doc(alias = "vtkOutlineCornerFilter")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkOutlineCornerFilter_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkOutlineCornerFilter_new() }) + } +} +impl std::default::Default for vtkOutlineCornerFilter { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkOutlineCornerFilter { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkOutlineCornerFilter_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkOutlineCornerFilter_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkOutlineCornerFilter_create_drop() { + let obj = vtkOutlineCornerFilter::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create wireframe outline corners around bounding box +/// +/// +/// vtkOutlineCornerSource creates wireframe outline corners around a user-specified +/// bounding box. +#[allow(non_camel_case_types)] +pub struct vtkOutlineCornerSource(*mut core::ffi::c_void); +impl vtkOutlineCornerSource { + /// Creates a new [vtkOutlineCornerSource] via `vtkOutlineCornerSource::New()` + #[doc(alias = "vtkOutlineCornerSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkOutlineCornerSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkOutlineCornerSource_new() }) + } +} +impl std::default::Default for vtkOutlineCornerSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkOutlineCornerSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkOutlineCornerSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkOutlineCornerSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkOutlineCornerSource_create_drop() { + let obj = vtkOutlineCornerSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create wireframe outline around bounding box +/// +/// +/// vtkOutlineSource creates a wireframe outline around a +/// user-specified bounding box. The outline may be created aligned +/// with the {x,y,z} axis - in which case it is defined by the 6 bounds +/// {xmin,xmax,ymin,ymax,zmin,zmax} via SetBounds(). Alternatively, the +/// box may be arbitrarily aligned, in which case it should be set via +/// the SetCorners() member. +#[allow(non_camel_case_types)] +pub struct vtkOutlineSource(*mut core::ffi::c_void); +impl vtkOutlineSource { + /// Creates a new [vtkOutlineSource] via `vtkOutlineSource::New()` + #[doc(alias = "vtkOutlineSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkOutlineSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkOutlineSource_new() }) + } +} +impl std::default::Default for vtkOutlineSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkOutlineSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkOutlineSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkOutlineSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkOutlineSource_create_drop() { + let obj = vtkOutlineSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// tessellate parametric functions +/// +/// +/// This class tessellates parametric functions. The user must specify how +/// many points in the parametric coordinate directions are required (i.e., +/// the resolution), and the mode to use to generate scalars. +/// +/// @par Thanks: +/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing +/// the class. +/// +/// @sa +/// vtkParametricFunction +/// +/// @sa +/// Implementation of parametrics for 1D lines: +/// vtkParametricSpline +/// +/// @sa +/// Subclasses of vtkParametricFunction implementing non-orentable surfaces: +/// vtkParametricBoy vtkParametricCrossCap vtkParametricFigure8Klein +/// vtkParametricKlein vtkParametricMobius vtkParametricRoman +/// +/// @sa +/// Subclasses of vtkParametricFunction implementing orientable surfaces: +/// vtkParametricConicSpiral vtkParametricDini vtkParametricEllipsoid +/// vtkParametricEnneper vtkParametricRandomHills vtkParametricSuperEllipsoid +/// vtkParametricSuperToroid vtkParametricTorus +#[allow(non_camel_case_types)] +pub struct vtkParametricFunctionSource(*mut core::ffi::c_void); +impl vtkParametricFunctionSource { + /// Creates a new [vtkParametricFunctionSource] via `vtkParametricFunctionSource::New()` + #[doc(alias = "vtkParametricFunctionSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkParametricFunctionSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkParametricFunctionSource_new() }) + } +} +impl std::default::Default for vtkParametricFunctionSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkParametricFunctionSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkParametricFunctionSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkParametricFunctionSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkParametricFunctionSource_create_drop() { + let obj = vtkParametricFunctionSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// a source that produces a vtkPartitionedDataSetCollection. +/// +/// +/// vtkPartitionedDataSetCollection generates a vtkPartitionedDataSetCollection +/// for testing purposes. It uses vtkParametricFunctionSource internally to +/// generate different types of surfaces for each partitioned dataset in the +/// collection. Each partitioned dataset is split among ranks in an even fashion. +/// Thus the number of partitions per rank for a partitioned dataset are always +/// different. +#[allow(non_camel_case_types)] +pub struct vtkPartitionedDataSetCollectionSource(*mut core::ffi::c_void); +impl vtkPartitionedDataSetCollectionSource { + /// Creates a new [vtkPartitionedDataSetCollectionSource] via `vtkPartitionedDataSetCollectionSource::New()` + #[doc(alias = "vtkPartitionedDataSetCollectionSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPartitionedDataSetCollectionSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPartitionedDataSetCollectionSource_new() }) + } +} +impl std::default::Default for vtkPartitionedDataSetCollectionSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPartitionedDataSetCollectionSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPartitionedDataSetCollectionSource_destructor( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtkPartitionedDataSetCollectionSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPartitionedDataSetCollectionSource_create_drop() { + let obj = vtkPartitionedDataSetCollectionSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// a source that produces a vtkPartitionedDataSet. +/// +/// +/// vtkPartitionedDataSetSource generates a vtkPartitionedDataSet which is +/// composed of partitions of a given vtkParametricFunction. +/// The resulting partitioned dataset is split among ranks in an even fashion +/// by default. +/// +/// The user can pass the parametric function to be used using SetParametricFunction. +/// Otherwise it will default to vtkParametricKlein as its Parametric function. +/// +/// The partitioning scheme for the produced vtkPartitionedDataSet can be controlled +/// with the methods: SetNumberOfPartitiones, EnableRank, DisableRank, EnableAllRanks, +/// DisableAllRanks. +/// +/// @see vtkParametricFunction +/// @see vtkPartitionedDataSet +#[allow(non_camel_case_types)] +pub struct vtkPartitionedDataSetSource(*mut core::ffi::c_void); +impl vtkPartitionedDataSetSource { + /// Creates a new [vtkPartitionedDataSetSource] via `vtkPartitionedDataSetSource::New()` + #[doc(alias = "vtkPartitionedDataSetSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPartitionedDataSetSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPartitionedDataSetSource_new() }) + } +} +impl std::default::Default for vtkPartitionedDataSetSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPartitionedDataSetSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPartitionedDataSetSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPartitionedDataSetSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPartitionedDataSetSource_create_drop() { + let obj = vtkPartitionedDataSetSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create an array of quadrilaterals located in a plane +/// +/// +/// vtkPlaneSource creates an m x n array of quadrilaterals arranged as +/// a regular tiling in a plane. The plane is defined by specifying an +/// origin point, and then two other points that, together with the +/// origin, define two axes for the plane. These axes do not have to be +/// orthogonal - so you can create a parallelogram. (The axes must not +/// be parallel.) The resolution of the plane (i.e., number of subdivisions) is +/// controlled by the ivars XResolution and YResolution. +/// +/// By default, the plane is centered at the origin and perpendicular to the +/// z-axis, with width and height of length 1 and resolutions set to 1. +/// +/// There are three convenience methods that allow you to easily move the +/// plane. The first, SetNormal(), allows you to specify the plane +/// normal. The effect of this method is to rotate the plane around the center +/// of the plane, aligning the plane normal with the specified normal. The +/// rotation is about the axis defined by the cross product of the current +/// normal with the new normal. The second, SetCenter(), translates the center +/// of the plane to the specified center point. The third method, Push(), +/// allows you to translate the plane along the plane normal by the distance +/// specified. (Negative Push values translate the plane in the negative +/// normal direction.) Note that the SetNormal(), SetCenter() and Push() +/// methods modify the Origin, Point1, and/or Point2 instance variables. +/// +/// @warning +/// The normal to the plane will point in the direction of the cross product +/// of the first axis (Origin->Point1) with the second (Origin->Point2). This +/// also affects the normals to the generated polygons. +#[allow(non_camel_case_types)] +pub struct vtkPlaneSource(*mut core::ffi::c_void); +impl vtkPlaneSource { + /// Creates a new [vtkPlaneSource] via `vtkPlaneSource::New()` + #[doc(alias = "vtkPlaneSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPlaneSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPlaneSource_new() }) + } +} +impl std::default::Default for vtkPlaneSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPlaneSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPlaneSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPlaneSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPlaneSource_create_drop() { + let obj = vtkPlaneSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// produce polygonal Platonic solids +/// +/// +/// vtkPlatonicSolidSource can generate each of the five Platonic solids: +/// tetrahedron, cube, octahedron, icosahedron, and dodecahedron. Each of the +/// solids is placed inside a sphere centered at the origin with radius 1.0. +/// To use this class, simply specify the solid to create. Note that this +/// source object creates cell scalars that are (integral value) face numbers. +#[allow(non_camel_case_types)] +pub struct vtkPlatonicSolidSource(*mut core::ffi::c_void); +impl vtkPlatonicSolidSource { + /// Creates a new [vtkPlatonicSolidSource] via `vtkPlatonicSolidSource::New()` + #[doc(alias = "vtkPlatonicSolidSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPlatonicSolidSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPlatonicSolidSource_new() }) + } +} +impl std::default::Default for vtkPlatonicSolidSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPlatonicSolidSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPlatonicSolidSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPlatonicSolidSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPlatonicSolidSource_create_drop() { + let obj = vtkPlatonicSolidSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// handle source used to represent points. +/// +/// +/// vtkPointHandleSource is deriving vtkHandleSource interface. +/// This handle represents a point with its shape being a sphere. +/// Its center and radius can be modified. +/// If the point is also parametered by any direction, it is then +/// represented as a cone pointing in this direction. +#[allow(non_camel_case_types)] +pub struct vtkPointHandleSource(*mut core::ffi::c_void); +impl vtkPointHandleSource { + /// Creates a new [vtkPointHandleSource] via `vtkPointHandleSource::New()` + #[doc(alias = "vtkPointHandleSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPointHandleSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPointHandleSource_new() }) + } +} +impl std::default::Default for vtkPointHandleSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPointHandleSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPointHandleSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPointHandleSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPointHandleSource_create_drop() { + let obj = vtkPointHandleSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a random cloud of points +/// +/// +/// vtkPointSource is a source object that creates a user-specified number +/// of points within a specified radius about a specified center point. +/// By default location of the points is random within the sphere. It is +/// also possible to generate random points only on the surface of the +/// sphere. The output PolyData has the specified number of points and +/// 1 cell - a vtkPolyVertex containing all of the points. +#[allow(non_camel_case_types)] +pub struct vtkPointSource(*mut core::ffi::c_void); +impl vtkPointSource { + /// Creates a new [vtkPointSource] via `vtkPointSource::New()` + #[doc(alias = "vtkPointSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPointSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPointSource_new() }) + } +} +impl std::default::Default for vtkPointSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPointSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPointSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPointSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPointSource_create_drop() { + let obj = vtkPointSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a poly line from a list of input points +/// +/// +/// vtkPolyLineSource is a source object that creates a poly line from +/// user-specified points. The output is a vtkPolyLine. +#[allow(non_camel_case_types)] +pub struct vtkPolyLineSource(*mut core::ffi::c_void); +impl vtkPolyLineSource { + /// Creates a new [vtkPolyLineSource] via `vtkPolyLineSource::New()` + #[doc(alias = "vtkPolyLineSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPolyLineSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPolyLineSource_new() }) + } +} +impl std::default::Default for vtkPolyLineSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPolyLineSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPolyLineSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPolyLineSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPolyLineSource_create_drop() { + let obj = vtkPolyLineSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create points from a list of input points +/// +/// +/// vtkPolyPointSource is a source object that creates a vert from +/// user-specified points. The output is a vtkPolyData. +#[allow(non_camel_case_types)] +pub struct vtkPolyPointSource(*mut core::ffi::c_void); +impl vtkPolyPointSource { + /// Creates a new [vtkPolyPointSource] via `vtkPolyPointSource::New()` + #[doc(alias = "vtkPolyPointSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPolyPointSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPolyPointSource_new() }) + } +} +impl std::default::Default for vtkPolyPointSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPolyPointSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPolyPointSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPolyPointSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPolyPointSource_create_drop() { + let obj = vtkPolyPointSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// generate source data object via a user-specified function +/// +/// +/// vtkProgrammableDataObjectSource is a source object that is programmable by +/// the user. The output of the filter is a data object (vtkDataObject) which +/// represents data via an instance of field data. To use this object, you +/// must specify a function that creates the output. +/// +/// Example use of this filter includes reading tabular data and encoding it +/// as vtkFieldData. You can then use filters like vtkDataObjectToDataSetFilter +/// to convert the data object to a dataset and then visualize it. Another +/// important use of this class is that it allows users of interpreters (e.g., +/// Java) the ability to write source objects without having to +/// recompile C++ code or generate new libraries. +/// +/// @sa +/// vtkProgrammableFilter vtkProgrammableAttributeDataFilter +/// vtkProgrammableSource vtkDataObjectToDataSetFilter +#[allow(non_camel_case_types)] +pub struct vtkProgrammableDataObjectSource(*mut core::ffi::c_void); +impl vtkProgrammableDataObjectSource { + /// Creates a new [vtkProgrammableDataObjectSource] via `vtkProgrammableDataObjectSource::New()` + #[doc(alias = "vtkProgrammableDataObjectSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkProgrammableDataObjectSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkProgrammableDataObjectSource_new() }) + } +} +impl std::default::Default for vtkProgrammableDataObjectSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkProgrammableDataObjectSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkProgrammableDataObjectSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkProgrammableDataObjectSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkProgrammableDataObjectSource_create_drop() { + let obj = vtkProgrammableDataObjectSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// generate source dataset via a user-specified function +/// +/// +/// vtkProgrammableSource is a source object that is programmable by the +/// user. To use this object, you must specify a function that creates the +/// output. It is possible to generate an output dataset of any (concrete) +/// type; it is up to the function to properly initialize and define the +/// output. Typically, you use one of the methods to get a concrete output +/// type (e.g., GetPolyDataOutput() or GetStructuredPointsOutput()), and +/// then manipulate the output in the user-specified function. +/// +/// Example use of this include writing a function to read a data file or +/// interface to another system. (You might want to do this in favor of +/// deriving a new class.) Another important use of this class is that it +/// allows users of interpreters (e.g., Java) the ability to write +/// source objects without having to recompile C++ code or generate new +/// libraries. +/// @sa +/// vtkProgrammableFilter vtkProgrammableAttributeDataFilter +/// vtkProgrammableDataObjectSource +#[allow(non_camel_case_types)] +pub struct vtkProgrammableSource(*mut core::ffi::c_void); +impl vtkProgrammableSource { + /// Creates a new [vtkProgrammableSource] via `vtkProgrammableSource::New()` + #[doc(alias = "vtkProgrammableSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkProgrammableSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkProgrammableSource_new() }) + } +} +impl std::default::Default for vtkProgrammableSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkProgrammableSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkProgrammableSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkProgrammableSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkProgrammableSource_create_drop() { + let obj = vtkProgrammableSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Builds a randomized but reproducible vtkHyperTreeGrid. +/// +#[allow(non_camel_case_types)] +pub struct vtkRandomHyperTreeGridSource(*mut core::ffi::c_void); +impl vtkRandomHyperTreeGridSource { + /// Creates a new [vtkRandomHyperTreeGridSource] via `vtkRandomHyperTreeGridSource::New()` + #[doc(alias = "vtkRandomHyperTreeGridSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkRandomHyperTreeGridSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkRandomHyperTreeGridSource_new() }) + } +} +impl std::default::Default for vtkRandomHyperTreeGridSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkRandomHyperTreeGridSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkRandomHyperTreeGridSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkRandomHyperTreeGridSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkRandomHyperTreeGridSource_create_drop() { + let obj = vtkRandomHyperTreeGridSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a rectangular button +/// +/// +/// vtkRectangularButtonSource creates a rectangular shaped button with +/// texture coordinates suitable for application of a texture map. This +/// provides a way to make nice looking 3D buttons. The buttons are +/// represented as vtkPolyData that includes texture coordinates and +/// normals. The button lies in the x-y plane. +/// +/// To use this class you must define its width, height and length. These +/// measurements are all taken with respect to the shoulder of the button. +/// The shoulder is defined as follows. Imagine a box sitting on the floor. +/// The distance from the floor to the top of the box is the depth; the other +/// directions are the length (x-direction) and height (y-direction). In +/// this particular widget the box can have a smaller bottom than top. The +/// ratio in size between bottom and top is called the box ratio (by +/// default=1.0). The ratio of the texture region to the shoulder region +/// is the texture ratio. And finally the texture region may be out of plane +/// compared to the shoulder. The texture height ratio controls this. +/// +/// @sa +/// vtkButtonSource vtkEllipticalButtonSource +/// +/// @warning +/// The button is defined in the x-y plane. Use vtkTransformPolyDataFilter +/// or vtkGlyph3D to orient the button in a different direction. +#[allow(non_camel_case_types)] +pub struct vtkRectangularButtonSource(*mut core::ffi::c_void); +impl vtkRectangularButtonSource { + /// Creates a new [vtkRectangularButtonSource] via `vtkRectangularButtonSource::New()` + #[doc(alias = "vtkRectangularButtonSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkRectangularButtonSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkRectangularButtonSource_new() }) + } +} +impl std::default::Default for vtkRectangularButtonSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkRectangularButtonSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkRectangularButtonSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkRectangularButtonSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkRectangularButtonSource_create_drop() { + let obj = vtkRectangularButtonSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a regular, n-sided polygon and/or polyline +/// +/// +/// vtkRegularPolygonSource is a source object that creates a single n-sided polygon and/or +/// polyline. The polygon is centered at a specified point, orthogonal to +/// a specified normal, and with a circumscribing radius set by the user. The user can +/// also specify the number of sides of the polygon ranging from [3,N]. +/// +/// This object can be used for seeding streamlines or defining regions for clipping/cutting. +#[allow(non_camel_case_types)] +pub struct vtkRegularPolygonSource(*mut core::ffi::c_void); +impl vtkRegularPolygonSource { + /// Creates a new [vtkRegularPolygonSource] via `vtkRegularPolygonSource::New()` + #[doc(alias = "vtkRegularPolygonSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkRegularPolygonSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkRegularPolygonSource_new() }) + } +} +impl std::default::Default for vtkRegularPolygonSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkRegularPolygonSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkRegularPolygonSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkRegularPolygonSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkRegularPolygonSource_create_drop() { + let obj = vtkRegularPolygonSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Generate selection from given set of ids +/// +/// vtkSelectionSource generates a vtkSelection from a set of +/// (piece id, cell id) pairs. It will only generate the selection values +/// that match UPDATE_PIECE_NUMBER (i.e. piece == UPDATE_PIECE_NUMBER). +/// +/// User-supplied, application-specific selections (with a ContentType of +/// vtkSelectionNode::USER) are not supported. +#[allow(non_camel_case_types)] +pub struct vtkSelectionSource(*mut core::ffi::c_void); +impl vtkSelectionSource { + /// Creates a new [vtkSelectionSource] via `vtkSelectionSource::New()` + #[doc(alias = "vtkSelectionSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkSelectionSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkSelectionSource_new() }) + } +} +impl std::default::Default for vtkSelectionSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkSelectionSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkSelectionSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkSelectionSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkSelectionSource_create_drop() { + let obj = vtkSelectionSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a polygonal sphere centered at the origin +/// +/// +/// vtkSphereSource creates a sphere (represented by polygons) of specified +/// radius centered at the origin. The resolution (polygonal discretization) +/// in both the latitude (phi) and longitude (theta) directions can be +/// specified. It also is possible to create partial spheres by specifying +/// maximum phi and theta angles. By default, the surface tessellation of +/// the sphere uses triangles; however you can set LatLongTessellation to +/// produce a tessellation using quadrilaterals. +/// +/// @warning +/// Resolution means the number of latitude or longitude lines for a complete +/// sphere. If you create partial spheres the number of latitude/longitude +/// lines may be off by one. +#[allow(non_camel_case_types)] +pub struct vtkSphereSource(*mut core::ffi::c_void); +impl vtkSphereSource { + /// Creates a new [vtkSphereSource] via `vtkSphereSource::New()` + #[doc(alias = "vtkSphereSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkSphereSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkSphereSource_new() }) + } +} +impl std::default::Default for vtkSphereSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkSphereSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkSphereSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkSphereSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkSphereSource_create_drop() { + let obj = vtkSphereSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a polygonal superquadric centered +/// +/// at the origin +/// +/// vtkSuperquadricSource creates a superquadric (represented by polygons) of +/// specified size centered at the origin. The alignment of the axis of the +/// superquadric along one of the global axes can be specified. The resolution +/// (polygonal discretization) +/// in both the latitude (phi) and longitude (theta) directions can be +/// specified. Roundness parameters (PhiRoundness and ThetaRoundness) control +/// the shape of the superquadric. The Toroidal boolean controls whether +/// a toroidal superquadric is produced. If so, the Thickness parameter +/// controls the thickness of the toroid: 0 is the thinnest allowable +/// toroid, and 1 has a minimum sized hole. The Scale parameters allow +/// the superquadric to be scaled in x, y, and z (normal vectors are correctly +/// generated in any case). The Size parameter controls size of the +/// superquadric. +/// +/// This code is based on "Rigid physically based superquadrics", A. H. Barr, +/// in "Graphics Gems III", David Kirk, ed., Academic Press, 1992. +/// +/// @warning +/// Resolution means the number of latitude or longitude lines for a complete +/// superquadric. The resolution parameters are rounded to the nearest 4 +/// in phi and 8 in theta. +/// +/// @warning +/// Texture coordinates are not equally distributed around all superquadrics. +/// +/// @warning +/// The Size and Thickness parameters control coefficients of superquadric +/// generation, and may do not exactly describe the size of the superquadric. +#[allow(non_camel_case_types)] +pub struct vtkSuperquadricSource(*mut core::ffi::c_void); +impl vtkSuperquadricSource { + /// Creates a new [vtkSuperquadricSource] via `vtkSuperquadricSource::New()` + #[doc(alias = "vtkSuperquadricSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkSuperquadricSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkSuperquadricSource_new() }) + } +} +impl std::default::Default for vtkSuperquadricSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkSuperquadricSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkSuperquadricSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkSuperquadricSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkSuperquadricSource_create_drop() { + let obj = vtkSuperquadricSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Create a polygonal representation of a box +/// +/// with a given level of subdivision. +/// +/// vtkTessellatedBoxSource creates a axis-aligned box defined by its bounds +/// and a level of subdivision. Connectivity is strong: points of the vertices +/// and inside the edges are shared between faces. In other words, faces are +/// connected. Each face looks like a grid of quads, each quad is composed of +/// 2 triangles. +/// Given a level of subdivision `l', each edge has `l'+2 points, `l' of them +/// are internal edge points, the 2 other ones are the vertices. +/// Each face has a total of (`l'+2)*(`l'+2) points, 4 of them are vertices, +/// 4*`l' are internal edge points, it remains `l'^2 internal face points. +/// +/// This source only generate geometry, no DataArrays like normals or texture +/// coordinates. +#[allow(non_camel_case_types)] +pub struct vtkTessellatedBoxSource(*mut core::ffi::c_void); +impl vtkTessellatedBoxSource { + /// Creates a new [vtkTessellatedBoxSource] via `vtkTessellatedBoxSource::New()` + #[doc(alias = "vtkTessellatedBoxSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkTessellatedBoxSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkTessellatedBoxSource_new() }) + } +} +impl std::default::Default for vtkTessellatedBoxSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkTessellatedBoxSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkTessellatedBoxSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkTessellatedBoxSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkTessellatedBoxSource_create_drop() { + let obj = vtkTessellatedBoxSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create polygonal text +/// +/// +/// vtkTextSource converts a text string into polygons. This way you can +/// insert text into your renderings. It uses the 9x15 font from X Windows. +/// You can specify if you want the background to be drawn or not. The +/// characters are formed by scan converting the raster font into +/// quadrilaterals. Colors are assigned to the letters using scalar data. +/// To set the color of the characters with the source's actor property, set +/// BackingOff on the text source and ScalarVisibilityOff on the associated +/// vtkPolyDataMapper. Then, the color can be set using the associated actor's +/// property. +/// +/// vtkVectorText generates higher quality polygonal representations of +/// characters. +/// +/// @sa +/// vtkVectorText +#[allow(non_camel_case_types)] +pub struct vtkTextSource(*mut core::ffi::c_void); +impl vtkTextSource { + /// Creates a new [vtkTextSource] via `vtkTextSource::New()` + #[doc(alias = "vtkTextSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkTextSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkTextSource_new() }) + } +} +impl std::default::Default for vtkTextSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkTextSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkTextSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkTextSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkTextSource_create_drop() { + let obj = vtkTextSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a sphere centered at the origin +/// +/// +/// vtkTexturedSphereSource creates a polygonal sphere of specified radius +/// centered at the origin. The resolution (polygonal discretization) in both +/// the latitude (phi) and longitude (theta) directions can be specified. +/// It also is possible to create partial sphere by specifying maximum phi and +/// theta angles. +#[allow(non_camel_case_types)] +pub struct vtkTexturedSphereSource(*mut core::ffi::c_void); +impl vtkTexturedSphereSource { + /// Creates a new [vtkTexturedSphereSource] via `vtkTexturedSphereSource::New()` + #[doc(alias = "vtkTexturedSphereSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkTexturedSphereSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkTexturedSphereSource_new() }) + } +} +impl std::default::Default for vtkTexturedSphereSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkTexturedSphereSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkTexturedSphereSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkTexturedSphereSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkTexturedSphereSource_create_drop() { + let obj = vtkTexturedSphereSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Create a synthetic grid of uniform hypertrees. +/// +/// +/// This class uses input parameters, most notably a string descriptor, +/// to generate a vtkHyperTreeGrid instance representing the corresponding +/// tree-based AMR grid with uniform root cell sizes along each axis. +/// +/// @sa +/// vtkHyperTreeGridSource vtkUniformHyperTreeGrid +/// +/// @par Thanks: +/// This class was written by Philippe Pebay, NexGen Analytics 2017 +/// This work was supported by Commissariat a l'Energie Atomique (CEA/DIF) +/// CEA, DAM, DIF, F-91297 Arpajon, France. +#[allow(non_camel_case_types)] +pub struct vtkUniformHyperTreeGridSource(*mut core::ffi::c_void); +impl vtkUniformHyperTreeGridSource { + /// Creates a new [vtkUniformHyperTreeGridSource] via `vtkUniformHyperTreeGridSource::New()` + #[doc(alias = "vtkUniformHyperTreeGridSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkUniformHyperTreeGridSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkUniformHyperTreeGridSource_new() }) + } +} +impl std::default::Default for vtkUniformHyperTreeGridSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkUniformHyperTreeGridSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkUniformHyperTreeGridSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkUniformHyperTreeGridSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkUniformHyperTreeGridSource_create_drop() { + let obj = vtkUniformHyperTreeGridSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} From 74e4ccb98e96c4ef291d4d4c7b82f4855073cd2c Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 23:11:57 +0200 Subject: [PATCH 27/30] remove the version bound example (unnecessary) --- vtk-rs-9.1/examples/sphere_source.rs | 37 ---------------------------- 1 file changed, 37 deletions(-) delete mode 100644 vtk-rs-9.1/examples/sphere_source.rs diff --git a/vtk-rs-9.1/examples/sphere_source.rs b/vtk-rs-9.1/examples/sphere_source.rs deleted file mode 100644 index 186824d..0000000 --- a/vtk-rs-9.1/examples/sphere_source.rs +++ /dev/null @@ -1,37 +0,0 @@ -use vtk_rs as vtk; -use vtk_rs::prelude::*; - -fn main() { - let _colors = vtk::NamedColors::new(); - - // Create a sphere - let mut sphere_source = vtk::SphereSource::new(); - sphere_source.set_center(0., 0., 0.); - sphere_source.set_radius(5.0); - - // Make the surface smooth - sphere_source.set_phi_resolution(100); - sphere_source.set_theta_resolution(100); - - /* let mut mapper = vtk::PolyDataMapper::new(); - mapper.set_input_connection(sphere_source.get_output_port()); - let mut mapper = vtkPolyDataMapper::New(); - mapper.SetInputConnection(sphere_source.GetOutputPort()); - - let mut actor = vtkActor::New(); - actor.SetMapper(&mapper); - actor.GetProperty().SetColor(colors.GetColor3d("Cornsilk")); - - let mut renderer = vtkRenderer::New(); - let mut render_window = vtkRenderWindow::New(); - render_window.SetWindowName("Sphere"); - render_window.AddRenderer(&renderer); - let render_window_interactor = vtkRenderWindowInteractor::New(); - render_window_interactor.SetRenderWindow(&render_window); - - renderer.AddActor(&actor); - renderer.SetBackground(colors.GetColor3d("DarkGreen")); - - render_window.Render(); - render_window_interactor.Start();*/ -} From 4f3214c1424e66f6ed9ff2b1fe19e19dd4bac693 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 23:32:23 +0200 Subject: [PATCH 28/30] cleanup CHANGELOG and README --- CHANGELOG.md | 7 +++++-- README.md | 10 +++++++--- 2 files changed, 12 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 56cb505..4fbce9b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,11 +1,14 @@ ## [0.3.0] - 2026-05-29 +This change will introduce the new feature of automatically creating the hierarchy. Additionally, tests were added for all the core functionalities of `vtk-gen` (not complete for possible edge cases, focused on straight forward functionality assessment). Most other changes are a result of getting everything to build without errors (e.g. handling rust keywords, handling different cpp pointers, ...). + +Detailed summary: ### Added - `vtkFiltersSources` module is now generated and linked, adding `SphereSource` and 20+ other source classes. - Re-export all constructable VTK classes at the crate root with the `vtk` prefix stripped (e.g. `vtk_rs::SphereSource`, `vtk_rs::NamedColors`). - `pub mod prelude` in the generated `lib.rs` that re-exports all module contents via glob, enabling `use vtk_rs::prelude::*` for ergonomic trait method access without explicit trait imports. - `sphere_source` example in `vtk-rs-9.1/examples/`, runnable via `cargo run --example sphere_source -p vtk-rs`. -- `has_ancestor(class_name, target) -> bool` on `ClassHierarchy` — iterative DFS to walk the full ancestor chain (not just direct parents). Used to correctly detect `vtkObjectBase` ancestry across deep inheritance hierarchies. +- `has_ancestor(class_name, target) -> bool` on `ClassHierarchy` -> iterative DFS to walk the full ancestor chain (not just direct parents). Used to correctly detect `vtkObjectBase` ancestry across deep inheritance hierarchies. - `IRStruct::has_vtk_object_base_ancestor: bool` field, computed via `has_ancestor` rather than checking direct parents only, fixing `is_constructable()` for deeply inherited classes. - `IRMethod::vtk_name: String` field (PascalCase VTK method name) and `short_name()` helper for generating clean Rust method names. - `c_signed_char` IR type to distinguish VTK's explicitly-typed `signed char` (used in typed data arrays such as `vtkSignedCharArray`) from plain `char` (used for C strings). `CppType::PlainChar` added to the C++ parser for the same reason. @@ -25,7 +28,7 @@ - **`vtkNew` ABI mismatch in generated C++ wrappers**: `vtkNew` has a non-trivial destructor, so passing or returning it by value in `extern "C"` functions violates the x86-64 SysV ABI and causes the wrapped VTK object to be destroyed on every method call. Constructor, destructor, get-ptr, and all method wrappers now use raw `T*` (`T::New()` / `sself->Delete()` / `return sself`) instead of `vtkNew`. - **`std::string` return types** (`IRType::String`): bridging `std::string` as `const char*` is illegal (dangling pointer). These methods are now skipped on both the Rust and C++ sides. - **`const char*` vs `const char* const*`**: `StarStarConst` and `StarStar` now always bail instead of incorrectly reducing to a single pointer. -- **Mutable `char**` output parameters**: `StarStar` always bails — VTK_FILEPATH uses `pointer="*"` in the actual XML, never `pointer="**"`. The previous special-case for `Const(SignedChar)**` was unreachable dead code and has been removed. +- **Mutable `char**` output parameters**: `StarStar` always bails -> VTK_FILEPATH uses `pointer="*"` in the actual XML, never `pointer="**"`. The previous special-case for `Const(SignedChar)**` was unreachable dead code and has been removed. - **Mutable `char*` vs `signed char*`**: `Pointer(c_char)` (without `Const`) is now rejected on both Rust and C++ sides — VTK typed-data-array methods use `signed char*`, which is not implicitly convertible from `char*` in C++. - **`signed char*` data array methods**: Separated `CppType::PlainChar` (`"char"`) from `CppType::SignedChar` (`"signed char"`) so typed-data-array parameters (`const signed char*`) generate the correct C++ type and are rejected at the Rust FFI boundary (not safely bridgeable without element-count information). - **`Path` types by value/reference** (e.g. `const vtkStdString&`, `vtkColor3ub`): rejected in `ir_type_is_supported`; VTK object types are only bridgeable as opaque pointers. diff --git a/README.md b/README.md index 2115507..71e88c9 100644 --- a/README.md +++ b/README.md @@ -64,7 +64,7 @@ To implement the desired class methods, we use Rust ## Contributing / Development Setup This section is for contributors who want to regenerate bindings for a new VTK version. -If you only want to *use* the existing `vtk-rs-9.1` bindings, skip this section — a system VTK install and `cargo build` is sufficient. +If you only want to *use* the existing `vtk-rs-9.1` bindings, skip this section since a system VTK install and `cargo build` is sufficient. ### Prerequisites @@ -98,7 +98,7 @@ brew install cmake python libarchive ### 1. Run the setup script `libvtk9-dev` (the system package) does **not** install the internal wrapping tool headers (e.g. `vtkParseAttributes.h`) that WrapVTK needs. -Use the provided `setup_vtk.sh` script to clone VTK from source, build it, initialise the `WrapVTK` submodule if needed, build WrapVTK against it, and verify the XML output — all in one step: +Use the provided `setup_vtk.sh` script to clone VTK from source, build it, initialise the `WrapVTK` submodule if needed, build WrapVTK against it, and verify the XML output all in one step: ```bash ./setup_vtk.sh 9.2.0 @@ -121,9 +121,13 @@ cargo run -p vtk-gen -- \ --opath vtk-rs-9.2 \ --wrap-vtk WrapVTK ``` +or one-line +```bash +cargo run -p vtk-gen -- --opath vtk-rs-9.2 --wrap-vtk WrapVTK +``` This regenerates all files in `vtk-rs-9.2/` from the WrapVTK XML output. -To target a different VTK version, run `./setup_vtk.sh ` first, then repeat this step with a matching output path (e.g. `--opath vtk-rs-9.3`). +To target a different VTK version, run `./setup_vtk.sh ` first, then repeat this step with a matching output path (e.g. `--opath vtk-rs-9.1` as included in the repository). ## Roadmap 1. [x] Stabilize Build system From 6f2a48eb190f7cae750fcf00d68f85ec5c27e4a2 Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 23:46:13 +0200 Subject: [PATCH 29/30] refactor remove now unsued get_ptr C++ binding and get_ptr_binding_name --- CHANGELOG.md | 2 +- Cargo.toml | 1 + vtk-gen/src/code_gen_cpp.rs | 10 ---------- vtk-gen/src/intermediate_representation.rs | 4 ---- 4 files changed, 2 insertions(+), 15 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4fbce9b..72ba791 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,7 +7,7 @@ Detailed summary: - `vtkFiltersSources` module is now generated and linked, adding `SphereSource` and 20+ other source classes. - Re-export all constructable VTK classes at the crate root with the `vtk` prefix stripped (e.g. `vtk_rs::SphereSource`, `vtk_rs::NamedColors`). - `pub mod prelude` in the generated `lib.rs` that re-exports all module contents via glob, enabling `use vtk_rs::prelude::*` for ergonomic trait method access without explicit trait imports. -- `sphere_source` example in `vtk-rs-9.1/examples/`, runnable via `cargo run --example sphere_source -p vtk-rs`. +- `sphere_source` example in `examples/` (workspace root), runnable via `cargo run --example sphere_source`. - `has_ancestor(class_name, target) -> bool` on `ClassHierarchy` -> iterative DFS to walk the full ancestor chain (not just direct parents). Used to correctly detect `vtkObjectBase` ancestry across deep inheritance hierarchies. - `IRStruct::has_vtk_object_base_ancestor: bool` field, computed via `has_ancestor` rather than checking direct parents only, fixing `is_constructable()` for deeply inherited classes. - `IRMethod::vtk_name: String` field (PascalCase VTK method name) and `short_name()` helper for generating clean Rust method names. diff --git a/Cargo.toml b/Cargo.toml index 14ffb74..60bd557 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,4 +1,5 @@ [workspace] +resolver = "3" members = [ "vtk-gen", "vtk-rs-9.1", diff --git a/vtk-gen/src/code_gen_cpp.rs b/vtk-gen/src/code_gen_cpp.rs index 30c3ebd..58ae719 100644 --- a/vtk-gen/src/code_gen_cpp.rs +++ b/vtk-gen/src/code_gen_cpp.rs @@ -293,14 +293,8 @@ impl IRStruct { return; })?; - let get_ptr = self.get_ptr_binding_name(); - let func3 = cpp!(extern "C" void* #get_ptr(#ty* sself) { - return sself; - })?; - writeln!(writer, "{func1}")?; writeln!(writer, "{func2}")?; - writeln!(writer, "{func3}")?; Ok(()) } @@ -312,12 +306,8 @@ impl IRStruct { let destructor = self.destructor_binding_name(); let func2 = cpp!(extern "C" void #destructor(#ty* sself);)?; - let get_ptr = self.get_ptr_binding_name(); - let func3 = cpp!(extern "C" void* #get_ptr(#ty* sself);)?; - writeln!(writer, "{func1}")?; writeln!(writer, "{func2}")?; - writeln!(writer, "{func3}")?; Ok(()) } } diff --git a/vtk-gen/src/intermediate_representation.rs b/vtk-gen/src/intermediate_representation.rs index 0ce20ed..37d8bd4 100644 --- a/vtk-gen/src/intermediate_representation.rs +++ b/vtk-gen/src/intermediate_representation.rs @@ -211,10 +211,6 @@ impl IRStruct { format!("{}_destructor", self.name) } - pub fn get_ptr_binding_name(&self) -> String { - format!("{}_get_ptr", self.name) - } - pub(crate) fn is_constructable(&self) -> bool { self.constructors .iter() From ed060e597ad6b9ac7f578f781974a346148eba8e Mon Sep 17 00:00:00 2001 From: yungselm Date: Fri, 29 May 2026 23:49:11 +0200 Subject: [PATCH 30/30] add the updated vtk-rs-9.1 --- .../libvtkrs/include/vtk_common_color.h | 2 - .../vtk_common_computational_geometry.h | 24 --- vtk-rs-9.1/libvtkrs/include/vtk_common_core.h | 76 ------- .../libvtkrs/include/vtk_common_data_model.h | 187 ------------------ .../include/vtk_common_execution_model.h | 51 ----- vtk-rs-9.1/libvtkrs/include/vtk_common_math.h | 9 - vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h | 5 - .../libvtkrs/include/vtk_common_system.h | 7 - .../libvtkrs/include/vtk_common_transforms.h | 12 -- .../libvtkrs/include/vtk_filters_sources.h | 40 ---- vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp | 2 - .../src/vtk_common_computational_geometry.cpp | 24 --- vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp | 76 ------- .../libvtkrs/src/vtk_common_data_model.cpp | 187 ------------------ .../src/vtk_common_execution_model.cpp | 51 ----- vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp | 9 - vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp | 5 - vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp | 7 - .../libvtkrs/src/vtk_common_transforms.cpp | 12 -- .../libvtkrs/src/vtk_filters_sources.cpp | 40 ---- 20 files changed, 826 deletions(-) diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h index bef080d..a3104ae 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h @@ -9,7 +9,6 @@ // Declare exported functions extern "C" vtkColorSeries * vtkColorSeries_new () ; extern "C" void vtkColorSeries_destructor (vtkColorSeries * sself) ; -extern "C" void * vtkColorSeries_get_ptr (vtkColorSeries * sself) ; extern "C" void vtk_color_series_set_color_scheme(vtkColorSeries* sself, int scheme); extern "C" int vtk_color_series_get_number_of_color_schemes(vtkColorSeries* sself); extern "C" int vtk_color_series_get_color_scheme(vtkColorSeries* sself); @@ -19,6 +18,5 @@ extern "C" void vtk_color_series_remove_color(vtkColorSeries* sself, int index); extern "C" void vtk_color_series_clear_colors(vtkColorSeries* sself); extern "C" vtkNamedColors * vtkNamedColors_new () ; extern "C" void vtkNamedColors_destructor (vtkNamedColors * sself) ; -extern "C" void * vtkNamedColors_get_ptr (vtkNamedColors * sself) ; extern "C" int vtk_named_colors_get_number_of_colors(vtkNamedColors* sself); extern "C" void vtk_named_colors_reset_colors(vtkNamedColors* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h index 41a48b6..7707502 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h @@ -33,12 +33,10 @@ // Declare exported functions extern "C" vtkCardinalSpline * vtkCardinalSpline_new () ; extern "C" void vtkCardinalSpline_destructor (vtkCardinalSpline * sself) ; -extern "C" void * vtkCardinalSpline_get_ptr (vtkCardinalSpline * sself) ; extern "C" void vtk_cardinal_spline_compute(vtkCardinalSpline* sself); extern "C" double vtk_cardinal_spline_evaluate(vtkCardinalSpline* sself, double t); extern "C" vtkKochanekSpline * vtkKochanekSpline_new () ; extern "C" void vtkKochanekSpline_destructor (vtkKochanekSpline * sself) ; -extern "C" void * vtkKochanekSpline_get_ptr (vtkKochanekSpline * sself) ; extern "C" void vtk_kochanek_spline_compute(vtkKochanekSpline* sself); extern "C" double vtk_kochanek_spline_evaluate(vtkKochanekSpline* sself, double t); extern "C" void vtk_kochanek_spline_set_default_bias(vtkKochanekSpline* sself, double _arg); @@ -49,7 +47,6 @@ extern "C" void vtk_kochanek_spline_set_default_continuity(vtkKochanekSpline* ss extern "C" double vtk_kochanek_spline_get_default_continuity(vtkKochanekSpline* sself); extern "C" vtkParametricBohemianDome * vtkParametricBohemianDome_new () ; extern "C" void vtkParametricBohemianDome_destructor (vtkParametricBohemianDome * sself) ; -extern "C" void * vtkParametricBohemianDome_get_ptr (vtkParametricBohemianDome * sself) ; extern "C" double vtk_parametric_bohemian_dome_get_a(vtkParametricBohemianDome* sself); extern "C" void vtk_parametric_bohemian_dome_set_a(vtkParametricBohemianDome* sself, double _arg); extern "C" double vtk_parametric_bohemian_dome_get_b(vtkParametricBohemianDome* sself); @@ -59,21 +56,17 @@ extern "C" void vtk_parametric_bohemian_dome_set_c(vtkParametricBohemianDome* ss extern "C" int vtk_parametric_bohemian_dome_get_dimension(vtkParametricBohemianDome* sself); extern "C" vtkParametricBour * vtkParametricBour_new () ; extern "C" void vtkParametricBour_destructor (vtkParametricBour * sself) ; -extern "C" void * vtkParametricBour_get_ptr (vtkParametricBour * sself) ; extern "C" int vtk_parametric_bour_get_dimension(vtkParametricBour* sself); extern "C" vtkParametricBoy * vtkParametricBoy_new () ; extern "C" void vtkParametricBoy_destructor (vtkParametricBoy * sself) ; -extern "C" void * vtkParametricBoy_get_ptr (vtkParametricBoy * sself) ; extern "C" int vtk_parametric_boy_get_dimension(vtkParametricBoy* sself); extern "C" void vtk_parametric_boy_set_z_scale(vtkParametricBoy* sself, double _arg); extern "C" double vtk_parametric_boy_get_z_scale(vtkParametricBoy* sself); extern "C" vtkParametricCatalanMinimal * vtkParametricCatalanMinimal_new () ; extern "C" void vtkParametricCatalanMinimal_destructor (vtkParametricCatalanMinimal * sself) ; -extern "C" void * vtkParametricCatalanMinimal_get_ptr (vtkParametricCatalanMinimal * sself) ; extern "C" int vtk_parametric_catalan_minimal_get_dimension(vtkParametricCatalanMinimal* sself); extern "C" vtkParametricConicSpiral * vtkParametricConicSpiral_new () ; extern "C" void vtkParametricConicSpiral_destructor (vtkParametricConicSpiral * sself) ; -extern "C" void * vtkParametricConicSpiral_get_ptr (vtkParametricConicSpiral * sself) ; extern "C" int vtk_parametric_conic_spiral_get_dimension(vtkParametricConicSpiral* sself); extern "C" void vtk_parametric_conic_spiral_set_a(vtkParametricConicSpiral* sself, double _arg); extern "C" double vtk_parametric_conic_spiral_get_a(vtkParametricConicSpiral* sself); @@ -85,11 +78,9 @@ extern "C" void vtk_parametric_conic_spiral_set_n(vtkParametricConicSpiral* ssel extern "C" double vtk_parametric_conic_spiral_get_n(vtkParametricConicSpiral* sself); extern "C" vtkParametricCrossCap * vtkParametricCrossCap_new () ; extern "C" void vtkParametricCrossCap_destructor (vtkParametricCrossCap * sself) ; -extern "C" void * vtkParametricCrossCap_get_ptr (vtkParametricCrossCap * sself) ; extern "C" int vtk_parametric_cross_cap_get_dimension(vtkParametricCrossCap* sself); extern "C" vtkParametricDini * vtkParametricDini_new () ; extern "C" void vtkParametricDini_destructor (vtkParametricDini * sself) ; -extern "C" void * vtkParametricDini_get_ptr (vtkParametricDini * sself) ; extern "C" int vtk_parametric_dini_get_dimension(vtkParametricDini* sself); extern "C" void vtk_parametric_dini_set_a(vtkParametricDini* sself, double _arg); extern "C" double vtk_parametric_dini_get_a(vtkParametricDini* sself); @@ -97,7 +88,6 @@ extern "C" void vtk_parametric_dini_set_b(vtkParametricDini* sself, double _arg) extern "C" double vtk_parametric_dini_get_b(vtkParametricDini* sself); extern "C" vtkParametricEllipsoid * vtkParametricEllipsoid_new () ; extern "C" void vtkParametricEllipsoid_destructor (vtkParametricEllipsoid * sself) ; -extern "C" void * vtkParametricEllipsoid_get_ptr (vtkParametricEllipsoid * sself) ; extern "C" int vtk_parametric_ellipsoid_get_dimension(vtkParametricEllipsoid* sself); extern "C" void vtk_parametric_ellipsoid_set_x_radius(vtkParametricEllipsoid* sself, double _arg); extern "C" double vtk_parametric_ellipsoid_get_x_radius(vtkParametricEllipsoid* sself); @@ -107,47 +97,38 @@ extern "C" void vtk_parametric_ellipsoid_set_z_radius(vtkParametricEllipsoid* ss extern "C" double vtk_parametric_ellipsoid_get_z_radius(vtkParametricEllipsoid* sself); extern "C" vtkParametricEnneper * vtkParametricEnneper_new () ; extern "C" void vtkParametricEnneper_destructor (vtkParametricEnneper * sself) ; -extern "C" void * vtkParametricEnneper_get_ptr (vtkParametricEnneper * sself) ; extern "C" int vtk_parametric_enneper_get_dimension(vtkParametricEnneper* sself); extern "C" vtkParametricFigure8Klein * vtkParametricFigure8Klein_new () ; extern "C" void vtkParametricFigure8Klein_destructor (vtkParametricFigure8Klein * sself) ; -extern "C" void * vtkParametricFigure8Klein_get_ptr (vtkParametricFigure8Klein * sself) ; extern "C" void vtk_parametric_figure_8_klein_set_radius(vtkParametricFigure8Klein* sself, double _arg); extern "C" double vtk_parametric_figure_8_klein_get_radius(vtkParametricFigure8Klein* sself); extern "C" int vtk_parametric_figure_8_klein_get_dimension(vtkParametricFigure8Klein* sself); extern "C" vtkParametricHenneberg * vtkParametricHenneberg_new () ; extern "C" void vtkParametricHenneberg_destructor (vtkParametricHenneberg * sself) ; -extern "C" void * vtkParametricHenneberg_get_ptr (vtkParametricHenneberg * sself) ; extern "C" int vtk_parametric_henneberg_get_dimension(vtkParametricHenneberg* sself); extern "C" vtkParametricKlein * vtkParametricKlein_new () ; extern "C" void vtkParametricKlein_destructor (vtkParametricKlein * sself) ; -extern "C" void * vtkParametricKlein_get_ptr (vtkParametricKlein * sself) ; extern "C" int vtk_parametric_klein_get_dimension(vtkParametricKlein* sself); extern "C" vtkParametricKuen * vtkParametricKuen_new () ; extern "C" void vtkParametricKuen_destructor (vtkParametricKuen * sself) ; -extern "C" void * vtkParametricKuen_get_ptr (vtkParametricKuen * sself) ; extern "C" int vtk_parametric_kuen_get_dimension(vtkParametricKuen* sself); extern "C" void vtk_parametric_kuen_set_delta_v_0(vtkParametricKuen* sself, double _arg); extern "C" double vtk_parametric_kuen_get_delta_v_0(vtkParametricKuen* sself); extern "C" vtkParametricMobius * vtkParametricMobius_new () ; extern "C" void vtkParametricMobius_destructor (vtkParametricMobius * sself) ; -extern "C" void * vtkParametricMobius_get_ptr (vtkParametricMobius * sself) ; extern "C" void vtk_parametric_mobius_set_radius(vtkParametricMobius* sself, double _arg); extern "C" double vtk_parametric_mobius_get_radius(vtkParametricMobius* sself); extern "C" int vtk_parametric_mobius_get_dimension(vtkParametricMobius* sself); extern "C" vtkParametricPluckerConoid * vtkParametricPluckerConoid_new () ; extern "C" void vtkParametricPluckerConoid_destructor (vtkParametricPluckerConoid * sself) ; -extern "C" void * vtkParametricPluckerConoid_get_ptr (vtkParametricPluckerConoid * sself) ; extern "C" int vtk_parametric_plucker_conoid_get_n(vtkParametricPluckerConoid* sself); extern "C" void vtk_parametric_plucker_conoid_set_n(vtkParametricPluckerConoid* sself, int _arg); extern "C" int vtk_parametric_plucker_conoid_get_dimension(vtkParametricPluckerConoid* sself); extern "C" vtkParametricPseudosphere * vtkParametricPseudosphere_new () ; extern "C" void vtkParametricPseudosphere_destructor (vtkParametricPseudosphere * sself) ; -extern "C" void * vtkParametricPseudosphere_get_ptr (vtkParametricPseudosphere * sself) ; extern "C" int vtk_parametric_pseudosphere_get_dimension(vtkParametricPseudosphere* sself); extern "C" vtkParametricRandomHills * vtkParametricRandomHills_new () ; extern "C" void vtkParametricRandomHills_destructor (vtkParametricRandomHills * sself) ; -extern "C" void * vtkParametricRandomHills_get_ptr (vtkParametricRandomHills * sself) ; extern "C" int vtk_parametric_random_hills_get_dimension(vtkParametricRandomHills* sself); extern "C" void vtk_parametric_random_hills_set_number_of_hills(vtkParametricRandomHills* sself, int _arg); extern "C" int vtk_parametric_random_hills_get_number_of_hills(vtkParametricRandomHills* sself); @@ -173,13 +154,11 @@ extern "C" void vtk_parametric_random_hills_set_amplitude_scale_factor(vtkParame extern "C" double vtk_parametric_random_hills_get_amplitude_scale_factor(vtkParametricRandomHills* sself); extern "C" vtkParametricRoman * vtkParametricRoman_new () ; extern "C" void vtkParametricRoman_destructor (vtkParametricRoman * sself) ; -extern "C" void * vtkParametricRoman_get_ptr (vtkParametricRoman * sself) ; extern "C" int vtk_parametric_roman_get_dimension(vtkParametricRoman* sself); extern "C" void vtk_parametric_roman_set_radius(vtkParametricRoman* sself, double _arg); extern "C" double vtk_parametric_roman_get_radius(vtkParametricRoman* sself); extern "C" vtkParametricSpline * vtkParametricSpline_new () ; extern "C" void vtkParametricSpline_destructor (vtkParametricSpline * sself) ; -extern "C" void * vtkParametricSpline_get_ptr (vtkParametricSpline * sself) ; extern "C" int vtk_parametric_spline_get_dimension(vtkParametricSpline* sself); extern "C" void vtk_parametric_spline_set_number_of_points(vtkParametricSpline* sself, long long numPts); extern "C" void vtk_parametric_spline_set_point(vtkParametricSpline* sself, long long index, double x, double y, double z); @@ -205,7 +184,6 @@ extern "C" void vtk_parametric_spline_set_right_value(vtkParametricSpline* sself extern "C" double vtk_parametric_spline_get_right_value(vtkParametricSpline* sself); extern "C" vtkParametricSuperEllipsoid * vtkParametricSuperEllipsoid_new () ; extern "C" void vtkParametricSuperEllipsoid_destructor (vtkParametricSuperEllipsoid * sself) ; -extern "C" void * vtkParametricSuperEllipsoid_get_ptr (vtkParametricSuperEllipsoid * sself) ; extern "C" int vtk_parametric_super_ellipsoid_get_dimension(vtkParametricSuperEllipsoid* sself); extern "C" void vtk_parametric_super_ellipsoid_set_x_radius(vtkParametricSuperEllipsoid* sself, double _arg); extern "C" double vtk_parametric_super_ellipsoid_get_x_radius(vtkParametricSuperEllipsoid* sself); @@ -219,7 +197,6 @@ extern "C" void vtk_parametric_super_ellipsoid_set_n_2(vtkParametricSuperEllipso extern "C" double vtk_parametric_super_ellipsoid_get_n_2(vtkParametricSuperEllipsoid* sself); extern "C" vtkParametricSuperToroid * vtkParametricSuperToroid_new () ; extern "C" void vtkParametricSuperToroid_destructor (vtkParametricSuperToroid * sself) ; -extern "C" void * vtkParametricSuperToroid_get_ptr (vtkParametricSuperToroid * sself) ; extern "C" int vtk_parametric_super_toroid_get_dimension(vtkParametricSuperToroid* sself); extern "C" void vtk_parametric_super_toroid_set_ring_radius(vtkParametricSuperToroid* sself, double _arg); extern "C" double vtk_parametric_super_toroid_get_ring_radius(vtkParametricSuperToroid* sself); @@ -237,7 +214,6 @@ extern "C" void vtk_parametric_super_toroid_set_n_2(vtkParametricSuperToroid* ss extern "C" double vtk_parametric_super_toroid_get_n_2(vtkParametricSuperToroid* sself); extern "C" vtkParametricTorus * vtkParametricTorus_new () ; extern "C" void vtkParametricTorus_destructor (vtkParametricTorus * sself) ; -extern "C" void * vtkParametricTorus_get_ptr (vtkParametricTorus * sself) ; extern "C" void vtk_parametric_torus_set_ring_radius(vtkParametricTorus* sself, double _arg); extern "C" double vtk_parametric_torus_get_ring_radius(vtkParametricTorus* sself); extern "C" void vtk_parametric_torus_set_cross_section_radius(vtkParametricTorus* sself, double _arg); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h index c33c6f6..c38f884 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h @@ -164,7 +164,6 @@ // Declare exported functions extern "C" vtkAnimationCue * vtkAnimationCue_new () ; extern "C" void vtkAnimationCue_destructor (vtkAnimationCue * sself) ; -extern "C" void * vtkAnimationCue_get_ptr (vtkAnimationCue * sself) ; extern "C" void vtk_animation_cue_set_time_mode(vtkAnimationCue* sself, int mode); extern "C" int vtk_animation_cue_get_time_mode(vtkAnimationCue* sself); extern "C" void vtk_animation_cue_set_time_mode_to_relative(vtkAnimationCue* sself); @@ -181,7 +180,6 @@ extern "C" double vtk_animation_cue_get_delta_time(vtkAnimationCue* sself); extern "C" double vtk_animation_cue_get_clock_time(vtkAnimationCue* sself); extern "C" vtkArchiver * vtkArchiver_new () ; extern "C" void vtkArchiver_destructor (vtkArchiver * sself) ; -extern "C" void * vtkArchiver_get_ptr (vtkArchiver * sself) ; extern "C" void vtk_archiver_set_archive_name(vtkArchiver* sself, const char* _arg); extern "C" void vtk_archiver_open_archive(vtkArchiver* sself); extern "C" void vtk_archiver_close_archive(vtkArchiver* sself); @@ -189,7 +187,6 @@ extern "C" void vtk_archiver_insert_into_archive(vtkArchiver* sself, const char* extern "C" bool vtk_archiver_contains(vtkArchiver* sself, const char*& relativePath); extern "C" vtkBitArray * vtkBitArray_new () ; extern "C" void vtkBitArray_destructor (vtkBitArray * sself) ; -extern "C" void * vtkBitArray_get_ptr (vtkBitArray * sself) ; extern "C" int vtk_bit_array_allocate(vtkBitArray* sself, long long sz, long long ext); extern "C" void vtk_bit_array_initialize(vtkBitArray* sself); extern "C" int vtk_bit_array_get_data_type(vtkBitArray* sself); @@ -212,7 +209,6 @@ extern "C" void vtk_bit_array_data_changed(vtkBitArray* sself); extern "C" void vtk_bit_array_clear_lookup(vtkBitArray* sself); extern "C" vtkBitArrayIterator * vtkBitArrayIterator_new () ; extern "C" void vtkBitArrayIterator_destructor (vtkBitArrayIterator * sself) ; -extern "C" void * vtkBitArrayIterator_get_ptr (vtkBitArrayIterator * sself) ; extern "C" int vtk_bit_array_iterator_get_value(vtkBitArrayIterator* sself, long long id); extern "C" long long vtk_bit_array_iterator_get_number_of_tuples(vtkBitArrayIterator* sself); extern "C" long long vtk_bit_array_iterator_get_number_of_values(vtkBitArrayIterator* sself); @@ -222,13 +218,11 @@ extern "C" int vtk_bit_array_iterator_get_data_type_size(vtkBitArrayIterator* ss extern "C" void vtk_bit_array_iterator_set_value(vtkBitArrayIterator* sself, long long id, int value); extern "C" vtkBoxMuellerRandomSequence * vtkBoxMuellerRandomSequence_new () ; extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkBoxMuellerRandomSequence * sself) ; -extern "C" void * vtkBoxMuellerRandomSequence_get_ptr (vtkBoxMuellerRandomSequence * sself) ; extern "C" void vtk_box_mueller_random_sequence_initialize(vtkBoxMuellerRandomSequence* sself, unsigned int seed); extern "C" double vtk_box_mueller_random_sequence_get_value(vtkBoxMuellerRandomSequence* sself); extern "C" void vtk_box_mueller_random_sequence_next(vtkBoxMuellerRandomSequence* sself); extern "C" vtkByteSwap * vtkByteSwap_new () ; extern "C" void vtkByteSwap_destructor (vtkByteSwap * sself) ; -extern "C" void * vtkByteSwap_get_ptr (vtkByteSwap * sself) ; extern "C" void vtk_byte_swap_swap_2_le(vtkByteSwap* sself, void* p); extern "C" void vtk_byte_swap_swap_4_le(vtkByteSwap* sself, void* p); extern "C" void vtk_byte_swap_swap_8_le(vtkByteSwap* sself, void* p); @@ -244,7 +238,6 @@ extern "C" void vtk_byte_swap_swap_8_be_range(vtkByteSwap* sself, void* p, size_ extern "C" void vtk_byte_swap_swap_void_range(vtkByteSwap* sself, void* buffer, size_t numWords, size_t wordSize); extern "C" vtkCallbackCommand * vtkCallbackCommand_new () ; extern "C" void vtkCallbackCommand_destructor (vtkCallbackCommand * sself) ; -extern "C" void * vtkCallbackCommand_get_ptr (vtkCallbackCommand * sself) ; extern "C" void vtk_callback_command_set_client_data(vtkCallbackCommand* sself, void* cd); extern "C" void* vtk_callback_command_get_client_data(vtkCallbackCommand* sself); extern "C" void vtk_callback_command_set_abort_flag_on_execute(vtkCallbackCommand* sself, int f); @@ -253,7 +246,6 @@ extern "C" void vtk_callback_command_abort_flag_on_execute_on(vtkCallbackCommand extern "C" void vtk_callback_command_abort_flag_on_execute_off(vtkCallbackCommand* sself); extern "C" vtkCharArray * vtkCharArray_new () ; extern "C" void vtkCharArray_destructor (vtkCharArray * sself) ; -extern "C" void * vtkCharArray_get_ptr (vtkCharArray * sself) ; extern "C" int vtk_char_array_get_data_type(vtkCharArray* sself); extern "C" void vtk_char_array_set_typed_tuple(vtkCharArray* sself, long long i, const char* tuple); extern "C" void vtk_char_array_insert_typed_tuple(vtkCharArray* sself, long long i, const char* tuple); @@ -267,33 +259,27 @@ extern "C" char vtk_char_array_get_data_type_value_min(vtkCharArray* sself); extern "C" char vtk_char_array_get_data_type_value_max(vtkCharArray* sself); extern "C" vtkCollection * vtkCollection_new () ; extern "C" void vtkCollection_destructor (vtkCollection * sself) ; -extern "C" void * vtkCollection_get_ptr (vtkCollection * sself) ; extern "C" void vtk_collection_remove_item(vtkCollection* sself, int i); extern "C" void vtk_collection_remove_all_items(vtkCollection* sself); extern "C" int vtk_collection_get_number_of_items(vtkCollection* sself); extern "C" void vtk_collection_init_traversal(vtkCollection* sself); extern "C" vtkCollectionIterator * vtkCollectionIterator_new () ; extern "C" void vtkCollectionIterator_destructor (vtkCollectionIterator * sself) ; -extern "C" void * vtkCollectionIterator_get_ptr (vtkCollectionIterator * sself) ; extern "C" void vtk_collection_iterator_init_traversal(vtkCollectionIterator* sself); extern "C" void vtk_collection_iterator_go_to_first_item(vtkCollectionIterator* sself); extern "C" void vtk_collection_iterator_go_to_next_item(vtkCollectionIterator* sself); extern "C" int vtk_collection_iterator_is_done_with_traversal(vtkCollectionIterator* sself); extern "C" vtkCriticalSection * vtkCriticalSection_new () ; extern "C" void vtkCriticalSection_destructor (vtkCriticalSection * sself) ; -extern "C" void * vtkCriticalSection_get_ptr (vtkCriticalSection * sself) ; extern "C" void vtk_critical_section_lock(vtkCriticalSection* sself); extern "C" void vtk_critical_section_unlock(vtkCriticalSection* sself); extern "C" vtkDataArrayCollection * vtkDataArrayCollection_new () ; extern "C" void vtkDataArrayCollection_destructor (vtkDataArrayCollection * sself) ; -extern "C" void * vtkDataArrayCollection_get_ptr (vtkDataArrayCollection * sself) ; extern "C" int vtk_data_array_collection_get_number_of_items(vtkDataArrayCollection* sself); extern "C" vtkDataArrayCollectionIterator * vtkDataArrayCollectionIterator_new () ; extern "C" void vtkDataArrayCollectionIterator_destructor (vtkDataArrayCollectionIterator * sself) ; -extern "C" void * vtkDataArrayCollectionIterator_get_ptr (vtkDataArrayCollectionIterator * sself) ; extern "C" vtkDataArraySelection * vtkDataArraySelection_new () ; extern "C" void vtkDataArraySelection_destructor (vtkDataArraySelection * sself) ; -extern "C" void * vtkDataArraySelection_get_ptr (vtkDataArraySelection * sself) ; extern "C" void vtk_data_array_selection_enable_array(vtkDataArraySelection* sself, const char* name); extern "C" void vtk_data_array_selection_disable_array(vtkDataArraySelection* sself, const char* name); extern "C" int vtk_data_array_selection_array_is_enabled(vtkDataArraySelection* sself, const char* name); @@ -315,13 +301,11 @@ extern "C" void vtk_data_array_selection_set_unknown_array_setting(vtkDataArrayS extern "C" int vtk_data_array_selection_get_unknown_array_setting(vtkDataArraySelection* sself); extern "C" vtkDebugLeaks * vtkDebugLeaks_new () ; extern "C" void vtkDebugLeaks_destructor (vtkDebugLeaks * sself) ; -extern "C" void * vtkDebugLeaks_get_ptr (vtkDebugLeaks * sself) ; extern "C" int vtk_debug_leaks_print_current_leaks(vtkDebugLeaks* sself); extern "C" int vtk_debug_leaks_get_exit_error(vtkDebugLeaks* sself); extern "C" void vtk_debug_leaks_set_exit_error(vtkDebugLeaks* sself, int p0); extern "C" vtkDoubleArray * vtkDoubleArray_new () ; extern "C" void vtkDoubleArray_destructor (vtkDoubleArray * sself) ; -extern "C" void * vtkDoubleArray_get_ptr (vtkDoubleArray * sself) ; extern "C" int vtk_double_array_get_data_type(vtkDoubleArray* sself); extern "C" double vtk_double_array_get_value(vtkDoubleArray* sself, long long id); extern "C" void vtk_double_array_set_value(vtkDoubleArray* sself, long long id, double value); @@ -332,24 +316,19 @@ extern "C" double vtk_double_array_get_data_type_value_min(vtkDoubleArray* sself extern "C" double vtk_double_array_get_data_type_value_max(vtkDoubleArray* sself); extern "C" vtkDynamicLoader * vtkDynamicLoader_new () ; extern "C" void vtkDynamicLoader_destructor (vtkDynamicLoader * sself) ; -extern "C" void * vtkDynamicLoader_get_ptr (vtkDynamicLoader * sself) ; extern "C" const char* vtk_dynamic_loader_lib_prefix(vtkDynamicLoader* sself); extern "C" const char* vtk_dynamic_loader_lib_extension(vtkDynamicLoader* sself); extern "C" const char* vtk_dynamic_loader_last_error(vtkDynamicLoader* sself); extern "C" vtkEventDataDevice3D * vtkEventDataDevice3D_new () ; extern "C" void vtkEventDataDevice3D_destructor (vtkEventDataDevice3D * sself) ; -extern "C" void * vtkEventDataDevice3D_get_ptr (vtkEventDataDevice3D * sself) ; extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkEventDataDevice3D* sself, double x, double y); extern "C" vtkEventDataForDevice * vtkEventDataForDevice_new () ; extern "C" void vtkEventDataForDevice_destructor (vtkEventDataForDevice * sself) ; -extern "C" void * vtkEventDataForDevice_get_ptr (vtkEventDataForDevice * sself) ; extern "C" vtkEventForwarderCommand * vtkEventForwarderCommand_new () ; extern "C" void vtkEventForwarderCommand_destructor (vtkEventForwarderCommand * sself) ; -extern "C" void * vtkEventForwarderCommand_get_ptr (vtkEventForwarderCommand * sself) ; extern "C" void* vtk_event_forwarder_command_get_target(vtkEventForwarderCommand* sself); extern "C" vtkFileOutputWindow * vtkFileOutputWindow_new () ; extern "C" void vtkFileOutputWindow_destructor (vtkFileOutputWindow * sself) ; -extern "C" void * vtkFileOutputWindow_get_ptr (vtkFileOutputWindow * sself) ; extern "C" void vtk_file_output_window_display_text(vtkFileOutputWindow* sself, const char* p0); extern "C" void vtk_file_output_window_set_file_name(vtkFileOutputWindow* sself, const char* _arg); extern "C" void vtk_file_output_window_set_flush(vtkFileOutputWindow* sself, int _arg); @@ -362,7 +341,6 @@ extern "C" void vtk_file_output_window_append_on(vtkFileOutputWindow* sself); extern "C" void vtk_file_output_window_append_off(vtkFileOutputWindow* sself); extern "C" vtkFloatArray * vtkFloatArray_new () ; extern "C" void vtkFloatArray_destructor (vtkFloatArray * sself) ; -extern "C" void * vtkFloatArray_get_ptr (vtkFloatArray * sself) ; extern "C" int vtk_float_array_get_data_type(vtkFloatArray* sself); extern "C" float vtk_float_array_get_value(vtkFloatArray* sself, long long id); extern "C" void vtk_float_array_set_value(vtkFloatArray* sself, long long id, float value); @@ -373,7 +351,6 @@ extern "C" float vtk_float_array_get_data_type_value_min(vtkFloatArray* sself); extern "C" float vtk_float_array_get_data_type_value_max(vtkFloatArray* sself); extern "C" vtkGarbageCollector * vtkGarbageCollector_new () ; extern "C" void vtkGarbageCollector_destructor (vtkGarbageCollector * sself) ; -extern "C" void * vtkGarbageCollector_get_ptr (vtkGarbageCollector * sself) ; extern "C" void vtk_garbage_collector_collect(vtkGarbageCollector* sself); extern "C" void vtk_garbage_collector_deferred_collection_push(vtkGarbageCollector* sself); extern "C" void vtk_garbage_collector_deferred_collection_pop(vtkGarbageCollector* sself); @@ -381,7 +358,6 @@ extern "C" void vtk_garbage_collector_set_global_debug_flag(vtkGarbageCollector* extern "C" bool vtk_garbage_collector_get_global_debug_flag(vtkGarbageCollector* sself); extern "C" vtkIdList * vtkIdList_new () ; extern "C" void vtkIdList_destructor (vtkIdList * sself) ; -extern "C" void * vtkIdList_get_ptr (vtkIdList * sself) ; extern "C" void vtk_id_list_initialize(vtkIdList* sself); extern "C" int vtk_id_list_allocate(vtkIdList* sself, const long long sz, const int strategy); extern "C" long long vtk_id_list_get_number_of_ids(vtkIdList* sself); @@ -400,11 +376,9 @@ extern "C" void vtk_id_list_delete_id(vtkIdList* sself, long long vtkid); extern "C" long long vtk_id_list_is_id(vtkIdList* sself, long long vtkid); extern "C" vtkIdListCollection * vtkIdListCollection_new () ; extern "C" void vtkIdListCollection_destructor (vtkIdListCollection * sself) ; -extern "C" void * vtkIdListCollection_get_ptr (vtkIdListCollection * sself) ; extern "C" int vtk_id_list_collection_get_number_of_items(vtkIdListCollection* sself); extern "C" vtkIdTypeArray * vtkIdTypeArray_new () ; extern "C" void vtkIdTypeArray_destructor (vtkIdTypeArray * sself) ; -extern "C" void * vtkIdTypeArray_get_ptr (vtkIdTypeArray * sself) ; extern "C" int vtk_id_type_array_get_data_type(vtkIdTypeArray* sself); extern "C" long long vtk_id_type_array_get_value(vtkIdTypeArray* sself, long long id); extern "C" void vtk_id_type_array_set_value(vtkIdTypeArray* sself, long long id, long long value); @@ -415,28 +389,23 @@ extern "C" long long vtk_id_type_array_get_data_type_value_min(vtkIdTypeArray* s extern "C" long long vtk_id_type_array_get_data_type_value_max(vtkIdTypeArray* sself); extern "C" vtkInformation * vtkInformation_new () ; extern "C" void vtkInformation_destructor (vtkInformation * sself) ; -extern "C" void * vtkInformation_get_ptr (vtkInformation * sself) ; extern "C" void vtk_information_modified(vtkInformation* sself); extern "C" void vtk_information_clear(vtkInformation* sself); extern "C" int vtk_information_get_number_of_keys(vtkInformation* sself); extern "C" vtkInformationIterator * vtkInformationIterator_new () ; extern "C" void vtkInformationIterator_destructor (vtkInformationIterator * sself) ; -extern "C" void * vtkInformationIterator_get_ptr (vtkInformationIterator * sself) ; extern "C" void vtk_information_iterator_init_traversal(vtkInformationIterator* sself); extern "C" void vtk_information_iterator_go_to_first_item(vtkInformationIterator* sself); extern "C" void vtk_information_iterator_go_to_next_item(vtkInformationIterator* sself); extern "C" int vtk_information_iterator_is_done_with_traversal(vtkInformationIterator* sself); extern "C" vtkInformationKeyLookup * vtkInformationKeyLookup_new () ; extern "C" void vtkInformationKeyLookup_destructor (vtkInformationKeyLookup * sself) ; -extern "C" void * vtkInformationKeyLookup_get_ptr (vtkInformationKeyLookup * sself) ; extern "C" vtkInformationVector * vtkInformationVector_new () ; extern "C" void vtkInformationVector_destructor (vtkInformationVector * sself) ; -extern "C" void * vtkInformationVector_get_ptr (vtkInformationVector * sself) ; extern "C" int vtk_information_vector_get_number_of_information_objects(vtkInformationVector* sself); extern "C" void vtk_information_vector_set_number_of_information_objects(vtkInformationVector* sself, int n); extern "C" vtkIntArray * vtkIntArray_new () ; extern "C" void vtkIntArray_destructor (vtkIntArray * sself) ; -extern "C" void * vtkIntArray_get_ptr (vtkIntArray * sself) ; extern "C" int vtk_int_array_get_data_type(vtkIntArray* sself); extern "C" int vtk_int_array_get_value(vtkIntArray* sself, long long id); extern "C" void vtk_int_array_set_value(vtkIntArray* sself, long long id, int value); @@ -447,7 +416,6 @@ extern "C" int vtk_int_array_get_data_type_value_min(vtkIntArray* sself); extern "C" int vtk_int_array_get_data_type_value_max(vtkIntArray* sself); extern "C" vtkLongArray * vtkLongArray_new () ; extern "C" void vtkLongArray_destructor (vtkLongArray * sself) ; -extern "C" void * vtkLongArray_get_ptr (vtkLongArray * sself) ; extern "C" int vtk_long_array_get_data_type(vtkLongArray* sself); extern "C" long vtk_long_array_get_value(vtkLongArray* sself, long long id); extern "C" void vtk_long_array_set_value(vtkLongArray* sself, long long id, long value); @@ -458,7 +426,6 @@ extern "C" long vtk_long_array_get_data_type_value_min(vtkLongArray* sself); extern "C" long vtk_long_array_get_data_type_value_max(vtkLongArray* sself); extern "C" vtkLongLongArray * vtkLongLongArray_new () ; extern "C" void vtkLongLongArray_destructor (vtkLongLongArray * sself) ; -extern "C" void * vtkLongLongArray_get_ptr (vtkLongLongArray * sself) ; extern "C" int vtk_long_long_array_get_data_type(vtkLongLongArray* sself); extern "C" long long vtk_long_long_array_get_value(vtkLongLongArray* sself, long long id); extern "C" void vtk_long_long_array_set_value(vtkLongLongArray* sself, long long id, long long value); @@ -469,7 +436,6 @@ extern "C" long long vtk_long_long_array_get_data_type_value_min(vtkLongLongArra extern "C" long long vtk_long_long_array_get_data_type_value_max(vtkLongLongArray* sself); extern "C" vtkLookupTable * vtkLookupTable_new () ; extern "C" void vtkLookupTable_destructor (vtkLookupTable * sself) ; -extern "C" void * vtkLookupTable_get_ptr (vtkLookupTable * sself) ; extern "C" int vtk_lookup_table_is_opaque(vtkLookupTable* sself); extern "C" int vtk_lookup_table_allocate(vtkLookupTable* sself, int sz, int ext); extern "C" void vtk_lookup_table_build(vtkLookupTable* sself); @@ -512,7 +478,6 @@ extern "C" long long vtk_lookup_table_get_number_of_colors(vtkLookupTable* sself extern "C" int vtk_lookup_table_using_log_scale(vtkLookupTable* sself); extern "C" vtkMath * vtkMath_new () ; extern "C" void vtkMath_destructor (vtkMath * sself) ; -extern "C" void * vtkMath_get_ptr (vtkMath * sself) ; extern "C" double vtk_math_pi(vtkMath* sself); extern "C" float vtk_math_radians_from_degrees(vtkMath* sself, float degrees); extern "C" float vtk_math_degrees_from_radians(vtkMath* sself, float radians); @@ -542,7 +507,6 @@ extern "C" int vtk_math_is_nan(vtkMath* sself, double x); extern "C" bool vtk_math_is_finite(vtkMath* sself, double x); extern "C" vtkMersenneTwister * vtkMersenneTwister_new () ; extern "C" void vtkMersenneTwister_destructor (vtkMersenneTwister * sself) ; -extern "C" void * vtkMersenneTwister_get_ptr (vtkMersenneTwister * sself) ; extern "C" void vtk_mersenne_twister_initialize(vtkMersenneTwister* sself, unsigned int seed); extern "C" unsigned int vtk_mersenne_twister_initialize_new_sequence(vtkMersenneTwister* sself, unsigned int seed, int p); extern "C" void vtk_mersenne_twister_initialize_sequence(vtkMersenneTwister* sself, unsigned int id, unsigned int seed, int p); @@ -550,7 +514,6 @@ extern "C" double vtk_mersenne_twister_get_value(vtkMersenneTwister* sself, unsi extern "C" void vtk_mersenne_twister_next(vtkMersenneTwister* sself, unsigned int id); extern "C" vtkMinimalStandardRandomSequence * vtkMinimalStandardRandomSequence_new () ; extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkMinimalStandardRandomSequence * sself) ; -extern "C" void * vtkMinimalStandardRandomSequence_get_ptr (vtkMinimalStandardRandomSequence * sself) ; extern "C" void vtk_minimal_standard_random_sequence_initialize(vtkMinimalStandardRandomSequence* sself, unsigned int seed); extern "C" void vtk_minimal_standard_random_sequence_set_seed(vtkMinimalStandardRandomSequence* sself, int value); extern "C" void vtk_minimal_standard_random_sequence_set_seed_only(vtkMinimalStandardRandomSequence* sself, int value); @@ -561,7 +524,6 @@ extern "C" double vtk_minimal_standard_random_sequence_get_range_value(vtkMinima extern "C" double vtk_minimal_standard_random_sequence_get_next_range_value(vtkMinimalStandardRandomSequence* sself, double rangeMin, double rangeMax); extern "C" vtkMultiThreader * vtkMultiThreader_new () ; extern "C" void vtkMultiThreader_destructor (vtkMultiThreader * sself) ; -extern "C" void * vtkMultiThreader_get_ptr (vtkMultiThreader * sself) ; extern "C" void vtk_multi_threader_set_number_of_threads(vtkMultiThreader* sself, int _arg); extern "C" int vtk_multi_threader_get_number_of_threads_min_value(vtkMultiThreader* sself); extern "C" int vtk_multi_threader_get_number_of_threads_max_value(vtkMultiThreader* sself); @@ -577,7 +539,6 @@ extern "C" void vtk_multi_threader_terminate_thread(vtkMultiThreader* sself, int extern "C" int vtk_multi_threader_is_thread_active(vtkMultiThreader* sself, int threadId); extern "C" vtkObject * vtkObject_new () ; extern "C" void vtkObject_destructor (vtkObject * sself) ; -extern "C" void * vtkObject_get_ptr (vtkObject * sself) ; extern "C" int vtk_object_is_type_of(vtkObject* sself, const char* type); extern "C" int vtk_object_is_a(vtkObject* sself, const char* type); extern "C" long long vtk_object_get_number_of_generations_from_base_type(vtkObject* sself, const char* type); @@ -597,14 +558,11 @@ extern "C" void vtk_object_remove_all_observers(vtkObject* sself); extern "C" int vtk_object_invoke_event(vtkObject* sself, unsigned long event, void* callData); extern "C" vtkObjectFactoryCollection * vtkObjectFactoryCollection_new () ; extern "C" void vtkObjectFactoryCollection_destructor (vtkObjectFactoryCollection * sself) ; -extern "C" void * vtkObjectFactoryCollection_get_ptr (vtkObjectFactoryCollection * sself) ; extern "C" vtkOldStyleCallbackCommand * vtkOldStyleCallbackCommand_new () ; extern "C" void vtkOldStyleCallbackCommand_destructor (vtkOldStyleCallbackCommand * sself) ; -extern "C" void * vtkOldStyleCallbackCommand_get_ptr (vtkOldStyleCallbackCommand * sself) ; extern "C" void vtk_old_style_callback_command_set_client_data(vtkOldStyleCallbackCommand* sself, void* cd); extern "C" vtkOutputWindow * vtkOutputWindow_new () ; extern "C" void vtkOutputWindow_destructor (vtkOutputWindow * sself) ; -extern "C" void * vtkOutputWindow_get_ptr (vtkOutputWindow * sself) ; extern "C" void vtk_output_window_display_text(vtkOutputWindow* sself, const char* p0); extern "C" void vtk_output_window_display_error_text(vtkOutputWindow* sself, const char* p0); extern "C" void vtk_output_window_display_warning_text(vtkOutputWindow* sself, const char* p0); @@ -627,10 +585,8 @@ extern "C" void vtk_output_window_set_display_mode_to_always(vtkOutputWindow* ss extern "C" void vtk_output_window_set_display_mode_to_always_std_err(vtkOutputWindow* sself); extern "C" vtkOverrideInformationCollection * vtkOverrideInformationCollection_new () ; extern "C" void vtkOverrideInformationCollection_destructor (vtkOverrideInformationCollection * sself) ; -extern "C" void * vtkOverrideInformationCollection_get_ptr (vtkOverrideInformationCollection * sself) ; extern "C" vtkPoints * vtkPoints_new () ; extern "C" void vtkPoints_destructor (vtkPoints * sself) ; -extern "C" void * vtkPoints_get_ptr (vtkPoints * sself) ; extern "C" int vtk_points_allocate(vtkPoints* sself, long long sz, long long ext); extern "C" void vtk_points_initialize(vtkPoints* sself); extern "C" int vtk_points_get_data_type(vtkPoints* sself); @@ -661,7 +617,6 @@ extern "C" unsigned long vtk_points_get_m_time(vtkPoints* sself); extern "C" void vtk_points_modified(vtkPoints* sself); extern "C" vtkPoints2D * vtkPoints2D_new () ; extern "C" void vtkPoints2D_destructor (vtkPoints2D * sself) ; -extern "C" void * vtkPoints2D_get_ptr (vtkPoints2D * sself) ; extern "C" int vtk_points_2_d_allocate(vtkPoints2D* sself, long long sz, long long ext); extern "C" void vtk_points_2_d_initialize(vtkPoints2D* sself); extern "C" int vtk_points_2_d_get_data_type(vtkPoints2D* sself); @@ -691,7 +646,6 @@ extern "C" int vtk_points_2_d_resize(vtkPoints2D* sself, long long numPoints); extern "C" void vtk_points_2_d_compute_bounds(vtkPoints2D* sself); extern "C" vtkPriorityQueue * vtkPriorityQueue_new () ; extern "C" void vtkPriorityQueue_destructor (vtkPriorityQueue * sself) ; -extern "C" void * vtkPriorityQueue_get_ptr (vtkPriorityQueue * sself) ; extern "C" void vtk_priority_queue_allocate(vtkPriorityQueue* sself, long long sz, long long ext); extern "C" void vtk_priority_queue_insert(vtkPriorityQueue* sself, double priority, long long id); extern "C" long long vtk_priority_queue_pop(vtkPriorityQueue* sself, long long location, double& priority); @@ -702,7 +656,6 @@ extern "C" long long vtk_priority_queue_get_number_of_items(vtkPriorityQueue* ss extern "C" void vtk_priority_queue_reset(vtkPriorityQueue* sself); extern "C" vtkRandomPool * vtkRandomPool_new () ; extern "C" void vtkRandomPool_destructor (vtkRandomPool * sself) ; -extern "C" void * vtkRandomPool_get_ptr (vtkRandomPool * sself) ; extern "C" void vtk_random_pool_set_size(vtkRandomPool* sself, long long _arg); extern "C" long long vtk_random_pool_get_size_min_value(vtkRandomPool* sself); extern "C" long long vtk_random_pool_get_size_max_value(vtkRandomPool* sself); @@ -719,10 +672,8 @@ extern "C" long long vtk_random_pool_get_chunk_size_max_value(vtkRandomPool* sse extern "C" long long vtk_random_pool_get_chunk_size(vtkRandomPool* sself); extern "C" vtkReferenceCount * vtkReferenceCount_new () ; extern "C" void vtkReferenceCount_destructor (vtkReferenceCount * sself) ; -extern "C" void * vtkReferenceCount_get_ptr (vtkReferenceCount * sself) ; extern "C" vtkScalarsToColors * vtkScalarsToColors_new () ; extern "C" void vtkScalarsToColors_destructor (vtkScalarsToColors * sself) ; -extern "C" void * vtkScalarsToColors_get_ptr (vtkScalarsToColors * sself) ; extern "C" int vtk_scalars_to_colors_is_opaque(vtkScalarsToColors* sself); extern "C" void vtk_scalars_to_colors_build(vtkScalarsToColors* sself); extern "C" void vtk_scalars_to_colors_set_range(vtkScalarsToColors* sself, double min, double max); @@ -749,7 +700,6 @@ extern "C" void vtk_scalars_to_colors_indexed_lookup_on(vtkScalarsToColors* ssel extern "C" void vtk_scalars_to_colors_indexed_lookup_off(vtkScalarsToColors* sself); extern "C" vtkShortArray * vtkShortArray_new () ; extern "C" void vtkShortArray_destructor (vtkShortArray * sself) ; -extern "C" void * vtkShortArray_get_ptr (vtkShortArray * sself) ; extern "C" int vtk_short_array_get_data_type(vtkShortArray* sself); extern "C" short vtk_short_array_get_value(vtkShortArray* sself, long long id); extern "C" void vtk_short_array_set_value(vtkShortArray* sself, long long id, short value); @@ -760,7 +710,6 @@ extern "C" short vtk_short_array_get_data_type_value_min(vtkShortArray* sself); extern "C" short vtk_short_array_get_data_type_value_max(vtkShortArray* sself); extern "C" vtkSignedCharArray * vtkSignedCharArray_new () ; extern "C" void vtkSignedCharArray_destructor (vtkSignedCharArray * sself) ; -extern "C" void * vtkSignedCharArray_get_ptr (vtkSignedCharArray * sself) ; extern "C" int vtk_signed_char_array_get_data_type(vtkSignedCharArray* sself); extern "C" signed char vtk_signed_char_array_get_value(vtkSignedCharArray* sself, long long id); extern "C" void vtk_signed_char_array_set_value(vtkSignedCharArray* sself, long long id, signed char value); @@ -771,10 +720,8 @@ extern "C" signed char vtk_signed_char_array_get_data_type_value_min(vtkSignedCh extern "C" signed char vtk_signed_char_array_get_data_type_value_max(vtkSignedCharArray* sself); extern "C" vtkSortDataArray * vtkSortDataArray_new () ; extern "C" void vtkSortDataArray_destructor (vtkSortDataArray * sself) ; -extern "C" void * vtkSortDataArray_get_ptr (vtkSortDataArray * sself) ; extern "C" vtkStringArray * vtkStringArray_new () ; extern "C" void vtkStringArray_destructor (vtkStringArray * sself) ; -extern "C" void * vtkStringArray_get_ptr (vtkStringArray * sself) ; extern "C" int vtk_string_array_get_data_type(vtkStringArray* sself); extern "C" int vtk_string_array_is_numeric(vtkStringArray* sself); extern "C" void vtk_string_array_initialize(vtkStringArray* sself); @@ -795,11 +742,9 @@ extern "C" void vtk_string_array_data_element_changed(vtkStringArray* sself, lon extern "C" void vtk_string_array_clear_lookup(vtkStringArray* sself); extern "C" vtkStringOutputWindow * vtkStringOutputWindow_new () ; extern "C" void vtkStringOutputWindow_destructor (vtkStringOutputWindow * sself) ; -extern "C" void * vtkStringOutputWindow_get_ptr (vtkStringOutputWindow * sself) ; extern "C" void vtk_string_output_window_display_text(vtkStringOutputWindow* sself, const char* p0); extern "C" vtkTimePointUtility * vtkTimePointUtility_new () ; extern "C" void vtkTimePointUtility_destructor (vtkTimePointUtility * sself) ; -extern "C" void * vtkTimePointUtility_get_ptr (vtkTimePointUtility * sself) ; extern "C" unsigned long long vtk_time_point_utility_date_to_time_point(vtkTimePointUtility* sself, int year, int month, int day); extern "C" unsigned long long vtk_time_point_utility_time_to_time_point(vtkTimePointUtility* sself, int hour, int minute, int second, int millis); extern "C" unsigned long long vtk_time_point_utility_date_time_to_time_point(vtkTimePointUtility* sself, int year, int month, int day, int hour, int minute, int sec, int millis); @@ -816,37 +761,26 @@ extern "C" int vtk_time_point_utility_get_millisecond(vtkTimePointUtility* sself extern "C" const char* vtk_time_point_utility_time_point_to_iso_8601(vtkTimePointUtility* sself, unsigned long long p0, int format); extern "C" vtkTypeFloat32Array * vtkTypeFloat32Array_new () ; extern "C" void vtkTypeFloat32Array_destructor (vtkTypeFloat32Array * sself) ; -extern "C" void * vtkTypeFloat32Array_get_ptr (vtkTypeFloat32Array * sself) ; extern "C" vtkTypeFloat64Array * vtkTypeFloat64Array_new () ; extern "C" void vtkTypeFloat64Array_destructor (vtkTypeFloat64Array * sself) ; -extern "C" void * vtkTypeFloat64Array_get_ptr (vtkTypeFloat64Array * sself) ; extern "C" vtkTypeInt16Array * vtkTypeInt16Array_new () ; extern "C" void vtkTypeInt16Array_destructor (vtkTypeInt16Array * sself) ; -extern "C" void * vtkTypeInt16Array_get_ptr (vtkTypeInt16Array * sself) ; extern "C" vtkTypeInt32Array * vtkTypeInt32Array_new () ; extern "C" void vtkTypeInt32Array_destructor (vtkTypeInt32Array * sself) ; -extern "C" void * vtkTypeInt32Array_get_ptr (vtkTypeInt32Array * sself) ; extern "C" vtkTypeInt64Array * vtkTypeInt64Array_new () ; extern "C" void vtkTypeInt64Array_destructor (vtkTypeInt64Array * sself) ; -extern "C" void * vtkTypeInt64Array_get_ptr (vtkTypeInt64Array * sself) ; extern "C" vtkTypeInt8Array * vtkTypeInt8Array_new () ; extern "C" void vtkTypeInt8Array_destructor (vtkTypeInt8Array * sself) ; -extern "C" void * vtkTypeInt8Array_get_ptr (vtkTypeInt8Array * sself) ; extern "C" vtkTypeUInt16Array * vtkTypeUInt16Array_new () ; extern "C" void vtkTypeUInt16Array_destructor (vtkTypeUInt16Array * sself) ; -extern "C" void * vtkTypeUInt16Array_get_ptr (vtkTypeUInt16Array * sself) ; extern "C" vtkTypeUInt32Array * vtkTypeUInt32Array_new () ; extern "C" void vtkTypeUInt32Array_destructor (vtkTypeUInt32Array * sself) ; -extern "C" void * vtkTypeUInt32Array_get_ptr (vtkTypeUInt32Array * sself) ; extern "C" vtkTypeUInt64Array * vtkTypeUInt64Array_new () ; extern "C" void vtkTypeUInt64Array_destructor (vtkTypeUInt64Array * sself) ; -extern "C" void * vtkTypeUInt64Array_get_ptr (vtkTypeUInt64Array * sself) ; extern "C" vtkTypeUInt8Array * vtkTypeUInt8Array_new () ; extern "C" void vtkTypeUInt8Array_destructor (vtkTypeUInt8Array * sself) ; -extern "C" void * vtkTypeUInt8Array_get_ptr (vtkTypeUInt8Array * sself) ; extern "C" vtkUnicodeStringArray * vtkUnicodeStringArray_new () ; extern "C" void vtkUnicodeStringArray_destructor (vtkUnicodeStringArray * sself) ; -extern "C" void * vtkUnicodeStringArray_get_ptr (vtkUnicodeStringArray * sself) ; extern "C" int vtk_unicode_string_array_allocate(vtkUnicodeStringArray* sself, long long sz, long long ext); extern "C" void vtk_unicode_string_array_initialize(vtkUnicodeStringArray* sself); extern "C" int vtk_unicode_string_array_get_data_type(vtkUnicodeStringArray* sself); @@ -866,7 +800,6 @@ extern "C" void vtk_unicode_string_array_set_utf_8_value(vtkUnicodeStringArray* extern "C" const char* vtk_unicode_string_array_get_utf_8_value(vtkUnicodeStringArray* sself, long long i); extern "C" vtkUnsignedCharArray * vtkUnsignedCharArray_new () ; extern "C" void vtkUnsignedCharArray_destructor (vtkUnsignedCharArray * sself) ; -extern "C" void * vtkUnsignedCharArray_get_ptr (vtkUnsignedCharArray * sself) ; extern "C" int vtk_unsigned_char_array_get_data_type(vtkUnsignedCharArray* sself); extern "C" unsigned char vtk_unsigned_char_array_get_value(vtkUnsignedCharArray* sself, long long id); extern "C" void vtk_unsigned_char_array_set_value(vtkUnsignedCharArray* sself, long long id, unsigned char value); @@ -877,7 +810,6 @@ extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_min(vtkUnsi extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_max(vtkUnsignedCharArray* sself); extern "C" vtkUnsignedIntArray * vtkUnsignedIntArray_new () ; extern "C" void vtkUnsignedIntArray_destructor (vtkUnsignedIntArray * sself) ; -extern "C" void * vtkUnsignedIntArray_get_ptr (vtkUnsignedIntArray * sself) ; extern "C" int vtk_unsigned_int_array_get_data_type(vtkUnsignedIntArray* sself); extern "C" unsigned int vtk_unsigned_int_array_get_value(vtkUnsignedIntArray* sself, long long id); extern "C" void vtk_unsigned_int_array_set_value(vtkUnsignedIntArray* sself, long long id, unsigned int value); @@ -888,7 +820,6 @@ extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_min(vtkUnsign extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_max(vtkUnsignedIntArray* sself); extern "C" vtkUnsignedLongArray * vtkUnsignedLongArray_new () ; extern "C" void vtkUnsignedLongArray_destructor (vtkUnsignedLongArray * sself) ; -extern "C" void * vtkUnsignedLongArray_get_ptr (vtkUnsignedLongArray * sself) ; extern "C" int vtk_unsigned_long_array_get_data_type(vtkUnsignedLongArray* sself); extern "C" unsigned long vtk_unsigned_long_array_get_value(vtkUnsignedLongArray* sself, long long id); extern "C" void vtk_unsigned_long_array_set_value(vtkUnsignedLongArray* sself, long long id, unsigned long value); @@ -899,7 +830,6 @@ extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_min(vtkUnsi extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_max(vtkUnsignedLongArray* sself); extern "C" vtkUnsignedLongLongArray * vtkUnsignedLongLongArray_new () ; extern "C" void vtkUnsignedLongLongArray_destructor (vtkUnsignedLongLongArray * sself) ; -extern "C" void * vtkUnsignedLongLongArray_get_ptr (vtkUnsignedLongLongArray * sself) ; extern "C" int vtk_unsigned_long_long_array_get_data_type(vtkUnsignedLongLongArray* sself); extern "C" unsigned long long vtk_unsigned_long_long_array_get_value(vtkUnsignedLongLongArray* sself, long long id); extern "C" void vtk_unsigned_long_long_array_set_value(vtkUnsignedLongLongArray* sself, long long id, unsigned long long value); @@ -910,7 +840,6 @@ extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_m extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_max(vtkUnsignedLongLongArray* sself); extern "C" vtkUnsignedShortArray * vtkUnsignedShortArray_new () ; extern "C" void vtkUnsignedShortArray_destructor (vtkUnsignedShortArray * sself) ; -extern "C" void * vtkUnsignedShortArray_get_ptr (vtkUnsignedShortArray * sself) ; extern "C" int vtk_unsigned_short_array_get_data_type(vtkUnsignedShortArray* sself); extern "C" unsigned short vtk_unsigned_short_array_get_value(vtkUnsignedShortArray* sself, long long id); extern "C" void vtk_unsigned_short_array_set_value(vtkUnsignedShortArray* sself, long long id, unsigned short value); @@ -921,7 +850,6 @@ extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_min(vtkUn extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_max(vtkUnsignedShortArray* sself); extern "C" vtkVariantArray * vtkVariantArray_new () ; extern "C" void vtkVariantArray_destructor (vtkVariantArray * sself) ; -extern "C" void * vtkVariantArray_get_ptr (vtkVariantArray * sself) ; extern "C" int vtk_variant_array_allocate(vtkVariantArray* sself, long long sz, long long ext); extern "C" void vtk_variant_array_initialize(vtkVariantArray* sself); extern "C" int vtk_variant_array_get_data_type(vtkVariantArray* sself); @@ -940,7 +868,6 @@ extern "C" void vtk_variant_array_data_element_changed(vtkVariantArray* sself, l extern "C" void vtk_variant_array_clear_lookup(vtkVariantArray* sself); extern "C" vtkVersion * vtkVersion_new () ; extern "C" void vtkVersion_destructor (vtkVersion * sself) ; -extern "C" void * vtkVersion_get_ptr (vtkVersion * sself) ; extern "C" const char* vtk_version_get_vtk_version(vtkVersion* sself); extern "C" const char* vtk_version_get_vtk_version_full(vtkVersion* sself); extern "C" int vtk_version_get_vtk_major_version(vtkVersion* sself); @@ -949,7 +876,6 @@ extern "C" int vtk_version_get_vtk_build_version(vtkVersion* sself); extern "C" const char* vtk_version_get_vtk_source_version(vtkVersion* sself); extern "C" vtkVoidArray * vtkVoidArray_new () ; extern "C" void vtkVoidArray_destructor (vtkVoidArray * sself) ; -extern "C" void * vtkVoidArray_get_ptr (vtkVoidArray * sself) ; extern "C" int vtk_void_array_allocate(vtkVoidArray* sself, long long sz, long long ext); extern "C" void vtk_void_array_initialize(vtkVoidArray* sself); extern "C" int vtk_void_array_get_data_type(vtkVoidArray* sself); @@ -964,9 +890,7 @@ extern "C" void vtk_void_array_reset(vtkVoidArray* sself); extern "C" void vtk_void_array_squeeze(vtkVoidArray* sself); extern "C" vtkWeakReference * vtkWeakReference_new () ; extern "C" void vtkWeakReference_destructor (vtkWeakReference * sself) ; -extern "C" void * vtkWeakReference_get_ptr (vtkWeakReference * sself) ; extern "C" vtkXMLFileOutputWindow * vtkXMLFileOutputWindow_new () ; extern "C" void vtkXMLFileOutputWindow_destructor (vtkXMLFileOutputWindow * sself) ; -extern "C" void * vtkXMLFileOutputWindow_get_ptr (vtkXMLFileOutputWindow * sself) ; extern "C" void vtk_xml_file_output_window_display_text(vtkXMLFileOutputWindow* sself, const char* p0); extern "C" void vtk_xml_file_output_window_display_tag(vtkXMLFileOutputWindow* sself, const char* p0); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h index 712326b..8580d50 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h @@ -281,19 +281,16 @@ // Declare exported functions extern "C" vtkAMRDataInternals * vtkAMRDataInternals_new () ; extern "C" void vtkAMRDataInternals_destructor (vtkAMRDataInternals * sself) ; -extern "C" void * vtkAMRDataInternals_get_ptr (vtkAMRDataInternals * sself) ; extern "C" void vtk_amr_data_internals_initialize(vtkAMRDataInternals* sself); extern "C" bool vtk_amr_data_internals_empty(vtkAMRDataInternals* sself); extern "C" unsigned int vtk_amr_data_internals_get_number_of_blocks(vtkAMRDataInternals* sself); extern "C" vtkAdjacentVertexIterator * vtkAdjacentVertexIterator_new () ; extern "C" void vtkAdjacentVertexIterator_destructor (vtkAdjacentVertexIterator * sself) ; -extern "C" void * vtkAdjacentVertexIterator_get_ptr (vtkAdjacentVertexIterator * sself) ; extern "C" long long vtk_adjacent_vertex_iterator_get_vertex(vtkAdjacentVertexIterator* sself); extern "C" long long vtk_adjacent_vertex_iterator_next(vtkAdjacentVertexIterator* sself); extern "C" bool vtk_adjacent_vertex_iterator_has_next(vtkAdjacentVertexIterator* sself); extern "C" vtkAnimationScene * vtkAnimationScene_new () ; extern "C" void vtkAnimationScene_destructor (vtkAnimationScene * sself) ; -extern "C" void * vtkAnimationScene_get_ptr (vtkAnimationScene * sself) ; extern "C" void vtk_animation_scene_set_play_mode(vtkAnimationScene* sself, int _arg); extern "C" void vtk_animation_scene_set_mode_to_sequence(vtkAnimationScene* sself); extern "C" void vtk_animation_scene_set_mode_to_real_time(vtkAnimationScene* sself); @@ -311,40 +308,34 @@ extern "C" void vtk_animation_scene_set_time_mode(vtkAnimationScene* sself, int extern "C" int vtk_animation_scene_is_in_play(vtkAnimationScene* sself); extern "C" vtkAnnotation * vtkAnnotation_new () ; extern "C" void vtkAnnotation_destructor (vtkAnnotation * sself) ; -extern "C" void * vtkAnnotation_get_ptr (vtkAnnotation * sself) ; extern "C" int vtk_annotation_get_data_object_type(vtkAnnotation* sself); extern "C" void vtk_annotation_initialize(vtkAnnotation* sself); extern "C" unsigned long vtk_annotation_get_m_time(vtkAnnotation* sself); extern "C" vtkAnnotationLayers * vtkAnnotationLayers_new () ; extern "C" void vtkAnnotationLayers_destructor (vtkAnnotationLayers * sself) ; -extern "C" void * vtkAnnotationLayers_get_ptr (vtkAnnotationLayers * sself) ; extern "C" int vtk_annotation_layers_get_data_object_type(vtkAnnotationLayers* sself); extern "C" unsigned int vtk_annotation_layers_get_number_of_annotations(vtkAnnotationLayers* sself); extern "C" void vtk_annotation_layers_initialize(vtkAnnotationLayers* sself); extern "C" unsigned long vtk_annotation_layers_get_m_time(vtkAnnotationLayers* sself); extern "C" vtkArrayData * vtkArrayData_new () ; extern "C" void vtkArrayData_destructor (vtkArrayData * sself) ; -extern "C" void * vtkArrayData_get_ptr (vtkArrayData * sself) ; extern "C" void vtk_array_data_clear_arrays(vtkArrayData* sself); extern "C" long long vtk_array_data_get_number_of_arrays(vtkArrayData* sself); extern "C" int vtk_array_data_get_data_object_type(vtkArrayData* sself); extern "C" vtkAttributesErrorMetric * vtkAttributesErrorMetric_new () ; extern "C" void vtkAttributesErrorMetric_destructor (vtkAttributesErrorMetric * sself) ; -extern "C" void * vtkAttributesErrorMetric_get_ptr (vtkAttributesErrorMetric * sself) ; extern "C" double vtk_attributes_error_metric_get_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself); extern "C" void vtk_attributes_error_metric_set_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself, double value); extern "C" double vtk_attributes_error_metric_get_attribute_tolerance(vtkAttributesErrorMetric* sself); extern "C" void vtk_attributes_error_metric_set_attribute_tolerance(vtkAttributesErrorMetric* sself, double value); extern "C" vtkBSPCuts * vtkBSPCuts_new () ; extern "C" void vtkBSPCuts_destructor (vtkBSPCuts * sself) ; -extern "C" void * vtkBSPCuts_get_ptr (vtkBSPCuts * sself) ; extern "C" int vtk_bsp_cuts_get_data_object_type(vtkBSPCuts* sself); extern "C" int vtk_bsp_cuts_get_number_of_cuts(vtkBSPCuts* sself); extern "C" void vtk_bsp_cuts_print_tree(vtkBSPCuts* sself); extern "C" void vtk_bsp_cuts_print_arrays(vtkBSPCuts* sself); extern "C" vtkBSPIntersections * vtkBSPIntersections_new () ; extern "C" void vtkBSPIntersections_destructor (vtkBSPIntersections * sself) ; -extern "C" void * vtkBSPIntersections_get_ptr (vtkBSPIntersections * sself) ; extern "C" int vtk_bsp_intersections_get_number_of_regions(vtkBSPIntersections* sself); extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkBSPIntersections* sself, int regionId, double x, double y, double z, double rSquared); extern "C" int vtk_bsp_intersections_get_compute_intersections_using_data_bounds(vtkBSPIntersections* sself); @@ -353,62 +344,50 @@ extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_on extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_off(vtkBSPIntersections* sself); extern "C" vtkBezierCurve * vtkBezierCurve_new () ; extern "C" void vtkBezierCurve_destructor (vtkBezierCurve * sself) ; -extern "C" void * vtkBezierCurve_get_ptr (vtkBezierCurve * sself) ; extern "C" int vtk_bezier_curve_get_cell_type(vtkBezierCurve* sself); extern "C" vtkBezierHexahedron * vtkBezierHexahedron_new () ; extern "C" void vtkBezierHexahedron_destructor (vtkBezierHexahedron * sself) ; -extern "C" void * vtkBezierHexahedron_get_ptr (vtkBezierHexahedron * sself) ; extern "C" int vtk_bezier_hexahedron_get_cell_type(vtkBezierHexahedron* sself); extern "C" vtkBezierInterpolation * vtkBezierInterpolation_new () ; extern "C" void vtkBezierInterpolation_destructor (vtkBezierInterpolation * sself) ; -extern "C" void * vtkBezierInterpolation_get_ptr (vtkBezierInterpolation * sself) ; extern "C" vtkBezierQuadrilateral * vtkBezierQuadrilateral_new () ; extern "C" void vtkBezierQuadrilateral_destructor (vtkBezierQuadrilateral * sself) ; -extern "C" void * vtkBezierQuadrilateral_get_ptr (vtkBezierQuadrilateral * sself) ; extern "C" int vtk_bezier_quadrilateral_get_cell_type(vtkBezierQuadrilateral* sself); extern "C" vtkBezierTetra * vtkBezierTetra_new () ; extern "C" void vtkBezierTetra_destructor (vtkBezierTetra * sself) ; -extern "C" void * vtkBezierTetra_get_ptr (vtkBezierTetra * sself) ; extern "C" int vtk_bezier_tetra_get_cell_type(vtkBezierTetra* sself); extern "C" vtkBezierTriangle * vtkBezierTriangle_new () ; extern "C" void vtkBezierTriangle_destructor (vtkBezierTriangle * sself) ; -extern "C" void * vtkBezierTriangle_get_ptr (vtkBezierTriangle * sself) ; extern "C" int vtk_bezier_triangle_get_cell_type(vtkBezierTriangle* sself); extern "C" vtkBezierWedge * vtkBezierWedge_new () ; extern "C" void vtkBezierWedge_destructor (vtkBezierWedge * sself) ; -extern "C" void * vtkBezierWedge_get_ptr (vtkBezierWedge * sself) ; extern "C" int vtk_bezier_wedge_get_cell_type(vtkBezierWedge* sself); extern "C" vtkBiQuadraticQuad * vtkBiQuadraticQuad_new () ; extern "C" void vtkBiQuadraticQuad_destructor (vtkBiQuadraticQuad * sself) ; -extern "C" void * vtkBiQuadraticQuad_get_ptr (vtkBiQuadraticQuad * sself) ; extern "C" int vtk_bi_quadratic_quad_get_cell_type(vtkBiQuadraticQuad* sself); extern "C" int vtk_bi_quadratic_quad_get_cell_dimension(vtkBiQuadraticQuad* sself); extern "C" int vtk_bi_quadratic_quad_get_number_of_edges(vtkBiQuadraticQuad* sself); extern "C" int vtk_bi_quadratic_quad_get_number_of_faces(vtkBiQuadraticQuad* sself); extern "C" vtkBiQuadraticQuadraticHexahedron * vtkBiQuadraticQuadraticHexahedron_new () ; extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkBiQuadraticQuadraticHexahedron * sself) ; -extern "C" void * vtkBiQuadraticQuadraticHexahedron_get_ptr (vtkBiQuadraticQuadraticHexahedron * sself) ; extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(vtkBiQuadraticQuadraticHexahedron* sself); extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(vtkBiQuadraticQuadraticHexahedron* sself); extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(vtkBiQuadraticQuadraticHexahedron* sself); extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(vtkBiQuadraticQuadraticHexahedron* sself); extern "C" vtkBiQuadraticQuadraticWedge * vtkBiQuadraticQuadraticWedge_new () ; extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkBiQuadraticQuadraticWedge * sself) ; -extern "C" void * vtkBiQuadraticQuadraticWedge_get_ptr (vtkBiQuadraticQuadraticWedge * sself) ; extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_type(vtkBiQuadraticQuadraticWedge* sself); extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(vtkBiQuadraticQuadraticWedge* sself); extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(vtkBiQuadraticQuadraticWedge* sself); extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(vtkBiQuadraticQuadraticWedge* sself); extern "C" vtkBiQuadraticTriangle * vtkBiQuadraticTriangle_new () ; extern "C" void vtkBiQuadraticTriangle_destructor (vtkBiQuadraticTriangle * sself) ; -extern "C" void * vtkBiQuadraticTriangle_get_ptr (vtkBiQuadraticTriangle * sself) ; extern "C" int vtk_bi_quadratic_triangle_get_cell_type(vtkBiQuadraticTriangle* sself); extern "C" int vtk_bi_quadratic_triangle_get_cell_dimension(vtkBiQuadraticTriangle* sself); extern "C" int vtk_bi_quadratic_triangle_get_number_of_edges(vtkBiQuadraticTriangle* sself); extern "C" int vtk_bi_quadratic_triangle_get_number_of_faces(vtkBiQuadraticTriangle* sself); extern "C" vtkBox * vtkBox_new () ; extern "C" void vtkBox_destructor (vtkBox * sself) ; -extern "C" void * vtkBox_get_ptr (vtkBox * sself) ; extern "C" void vtk_box_set_x_min(vtkBox* sself, double x, double y, double z); extern "C" void vtk_box_get_x_min(vtkBox* sself, double& x, double& y, double& z); extern "C" void vtk_box_set_x_max(vtkBox* sself, double x, double y, double z); @@ -417,7 +396,6 @@ extern "C" void vtk_box_set_bounds(vtkBox* sself, double xMin, double xMax, doub extern "C" void vtk_box_get_bounds(vtkBox* sself, double& xMin, double& xMax, double& yMin, double& yMax, double& zMin, double& zMax); extern "C" vtkCellArray * vtkCellArray_new () ; extern "C" void vtkCellArray_destructor (vtkCellArray * sself) ; -extern "C" void * vtkCellArray_get_ptr (vtkCellArray * sself) ; extern "C" int vtk_cell_array_allocate(vtkCellArray* sself, long long sz, long long ext); extern "C" bool vtk_cell_array_allocate_estimate(vtkCellArray* sself, long long numCells, long long maxCellSize); extern "C" bool vtk_cell_array_allocate_exact(vtkCellArray* sself, long long numCells, long long connectivitySize); @@ -461,7 +439,6 @@ extern "C" void vtk_cell_array_set_traversal_location(vtkCellArray* sself, long extern "C" void vtk_cell_array_reverse_cell(vtkCellArray* sself, long long loc); extern "C" vtkCellArrayIterator * vtkCellArrayIterator_new () ; extern "C" void vtkCellArrayIterator_destructor (vtkCellArrayIterator * sself) ; -extern "C" void * vtkCellArrayIterator_get_ptr (vtkCellArrayIterator * sself) ; extern "C" void vtk_cell_array_iterator_go_to_cell(vtkCellArrayIterator* sself, long long cellId); extern "C" void vtk_cell_array_iterator_go_to_first_cell(vtkCellArrayIterator* sself); extern "C" void vtk_cell_array_iterator_go_to_next_cell(vtkCellArrayIterator* sself); @@ -470,10 +447,8 @@ extern "C" long long vtk_cell_array_iterator_get_current_cell_id(vtkCellArrayIte extern "C" void vtk_cell_array_iterator_reverse_current_cell(vtkCellArrayIterator* sself); extern "C" vtkCellData * vtkCellData_new () ; extern "C" void vtkCellData_destructor (vtkCellData * sself) ; -extern "C" void * vtkCellData_get_ptr (vtkCellData * sself) ; extern "C" vtkCellLinks * vtkCellLinks_new () ; extern "C" void vtkCellLinks_destructor (vtkCellLinks * sself) ; -extern "C" void * vtkCellLinks_get_ptr (vtkCellLinks * sself) ; extern "C" void vtk_cell_links_allocate(vtkCellLinks* sself, long long numLinks, long long ext); extern "C" void vtk_cell_links_initialize(vtkCellLinks* sself); extern "C" long long vtk_cell_links_get_ncells(vtkCellLinks* sself, long long ptId); @@ -488,7 +463,6 @@ extern "C" void vtk_cell_links_reset(vtkCellLinks* sself); extern "C" unsigned long vtk_cell_links_get_actual_memory_size(vtkCellLinks* sself); extern "C" vtkCellLocator * vtkCellLocator_new () ; extern "C" void vtkCellLocator_destructor (vtkCellLocator * sself) ; -extern "C" void * vtkCellLocator_get_ptr (vtkCellLocator * sself) ; extern "C" void vtk_cell_locator_set_number_of_cells_per_bucket(vtkCellLocator* sself, int N); extern "C" int vtk_cell_locator_get_number_of_cells_per_bucket(vtkCellLocator* sself); extern "C" int vtk_cell_locator_get_number_of_buckets(vtkCellLocator* sself); @@ -499,10 +473,8 @@ extern "C" void vtk_cell_locator_force_build_locator(vtkCellLocator* sself); extern "C" void vtk_cell_locator_build_locator_internal(vtkCellLocator* sself); extern "C" vtkCellLocatorStrategy * vtkCellLocatorStrategy_new () ; extern "C" void vtkCellLocatorStrategy_destructor (vtkCellLocatorStrategy * sself) ; -extern "C" void * vtkCellLocatorStrategy_get_ptr (vtkCellLocatorStrategy * sself) ; extern "C" vtkCellTypes * vtkCellTypes_new () ; extern "C" void vtkCellTypes_destructor (vtkCellTypes * sself) ; -extern "C" void * vtkCellTypes_get_ptr (vtkCellTypes * sself) ; extern "C" int vtk_cell_types_allocate(vtkCellTypes* sself, long long sz, long long ext); extern "C" void vtk_cell_types_insert_cell(vtkCellTypes* sself, long long id, unsigned char type, long long loc); extern "C" long long vtk_cell_types_insert_next_cell(vtkCellTypes* sself, unsigned char type, long long loc); @@ -520,24 +492,20 @@ extern "C" int vtk_cell_types_get_type_id_from_class_name(vtkCellTypes* sself, c extern "C" int vtk_cell_types_is_linear(vtkCellTypes* sself, unsigned char type); extern "C" vtkClosestNPointsStrategy * vtkClosestNPointsStrategy_new () ; extern "C" void vtkClosestNPointsStrategy_destructor (vtkClosestNPointsStrategy * sself) ; -extern "C" void * vtkClosestNPointsStrategy_get_ptr (vtkClosestNPointsStrategy * sself) ; extern "C" void vtk_closest_n_points_strategy_set_closest_n_points(vtkClosestNPointsStrategy* sself, int _arg); extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_min_value(vtkClosestNPointsStrategy* sself); extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_max_value(vtkClosestNPointsStrategy* sself); extern "C" int vtk_closest_n_points_strategy_get_closest_n_points(vtkClosestNPointsStrategy* sself); extern "C" vtkClosestPointStrategy * vtkClosestPointStrategy_new () ; extern "C" void vtkClosestPointStrategy_destructor (vtkClosestPointStrategy * sself) ; -extern "C" void * vtkClosestPointStrategy_get_ptr (vtkClosestPointStrategy * sself) ; extern "C" vtkCone * vtkCone_new () ; extern "C" void vtkCone_destructor (vtkCone * sself) ; -extern "C" void * vtkCone_get_ptr (vtkCone * sself) ; extern "C" void vtk_cone_set_angle(vtkCone* sself, double _arg); extern "C" double vtk_cone_get_angle_min_value(vtkCone* sself); extern "C" double vtk_cone_get_angle_max_value(vtkCone* sself); extern "C" double vtk_cone_get_angle(vtkCone* sself); extern "C" vtkConvexPointSet * vtkConvexPointSet_new () ; extern "C" void vtkConvexPointSet_destructor (vtkConvexPointSet * sself) ; -extern "C" void * vtkConvexPointSet_get_ptr (vtkConvexPointSet * sself) ; extern "C" int vtk_convex_point_set_has_fixed_topology(vtkConvexPointSet* sself); extern "C" int vtk_convex_point_set_get_cell_type(vtkConvexPointSet* sself); extern "C" int vtk_convex_point_set_requires_initialization(vtkConvexPointSet* sself); @@ -546,21 +514,18 @@ extern "C" int vtk_convex_point_set_get_number_of_faces(vtkConvexPointSet* sself extern "C" int vtk_convex_point_set_is_primary_cell(vtkConvexPointSet* sself); extern "C" vtkCubicLine * vtkCubicLine_new () ; extern "C" void vtkCubicLine_destructor (vtkCubicLine * sself) ; -extern "C" void * vtkCubicLine_get_ptr (vtkCubicLine * sself) ; extern "C" int vtk_cubic_line_get_cell_type(vtkCubicLine* sself); extern "C" int vtk_cubic_line_get_cell_dimension(vtkCubicLine* sself); extern "C" int vtk_cubic_line_get_number_of_edges(vtkCubicLine* sself); extern "C" int vtk_cubic_line_get_number_of_faces(vtkCubicLine* sself); extern "C" vtkCylinder * vtkCylinder_new () ; extern "C" void vtkCylinder_destructor (vtkCylinder * sself) ; -extern "C" void * vtkCylinder_get_ptr (vtkCylinder * sself) ; extern "C" void vtk_cylinder_set_radius(vtkCylinder* sself, double _arg); extern "C" double vtk_cylinder_get_radius(vtkCylinder* sself); extern "C" void vtk_cylinder_set_center(vtkCylinder* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_cylinder_set_axis(vtkCylinder* sself, double ax, double ay, double az); extern "C" vtkDataAssembly * vtkDataAssembly_new () ; extern "C" void vtkDataAssembly_destructor (vtkDataAssembly * sself) ; -extern "C" void * vtkDataAssembly_get_ptr (vtkDataAssembly * sself) ; extern "C" void vtk_data_assembly_initialize(vtkDataAssembly* sself); extern "C" bool vtk_data_assembly_initialize_from_xml(vtkDataAssembly* sself, const char* xmlcontents); extern "C" int vtk_data_assembly_get_root_node(vtkDataAssembly* sself); @@ -588,11 +553,9 @@ extern "C" bool vtk_data_assembly_is_node_name_valid(vtkDataAssembly* sself, con extern "C" bool vtk_data_assembly_is_node_name_reserved(vtkDataAssembly* sself, const char* name); extern "C" vtkDataAssemblyUtilities * vtkDataAssemblyUtilities_new () ; extern "C" void vtkDataAssemblyUtilities_destructor (vtkDataAssemblyUtilities * sself) ; -extern "C" void * vtkDataAssemblyUtilities_get_ptr (vtkDataAssemblyUtilities * sself) ; extern "C" const char* vtk_data_assembly_utilities_hierarchy_name(vtkDataAssemblyUtilities* sself); extern "C" vtkDataObject * vtkDataObject_new () ; extern "C" void vtkDataObject_destructor (vtkDataObject * sself) ; -extern "C" void * vtkDataObject_get_ptr (vtkDataObject * sself) ; extern "C" unsigned long vtk_data_object_get_m_time(vtkDataObject* sself); extern "C" void vtk_data_object_initialize(vtkDataObject* sself); extern "C" void vtk_data_object_release_data(vtkDataObject* sself); @@ -612,11 +575,9 @@ extern "C" const char* vtk_data_object_get_association_type_as_string(vtkDataObj extern "C" int vtk_data_object_get_association_type_from_string(vtkDataObject* sself, const char* associationName); extern "C" vtkDataObjectCollection * vtkDataObjectCollection_new () ; extern "C" void vtkDataObjectCollection_destructor (vtkDataObjectCollection * sself) ; -extern "C" void * vtkDataObjectCollection_get_ptr (vtkDataObjectCollection * sself) ; extern "C" int vtk_data_object_collection_get_number_of_items(vtkDataObjectCollection* sself); extern "C" vtkDataObjectTreeIterator * vtkDataObjectTreeIterator_new () ; extern "C" void vtkDataObjectTreeIterator_destructor (vtkDataObjectTreeIterator * sself) ; -extern "C" void * vtkDataObjectTreeIterator_get_ptr (vtkDataObjectTreeIterator * sself) ; extern "C" void vtk_data_object_tree_iterator_go_to_first_item(vtkDataObjectTreeIterator* sself); extern "C" void vtk_data_object_tree_iterator_go_to_next_item(vtkDataObjectTreeIterator* sself); extern "C" int vtk_data_object_tree_iterator_is_done_with_traversal(vtkDataObjectTreeIterator* sself); @@ -632,14 +593,12 @@ extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_on(vtkDataObject extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_off(vtkDataObjectTreeIterator* sself); extern "C" vtkDataObjectTypes * vtkDataObjectTypes_new () ; extern "C" void vtkDataObjectTypes_destructor (vtkDataObjectTypes * sself) ; -extern "C" void * vtkDataObjectTypes_get_ptr (vtkDataObjectTypes * sself) ; extern "C" const char* vtk_data_object_types_get_class_name_from_type_id(vtkDataObjectTypes* sself, int typeId); extern "C" int vtk_data_object_types_get_type_id_from_class_name(vtkDataObjectTypes* sself, const char* classname); extern "C" bool vtk_data_object_types_type_id_is_a(vtkDataObjectTypes* sself, int typeId, int targetTypeId); extern "C" int vtk_data_object_types_get_common_base_type_id(vtkDataObjectTypes* sself, int typeA, int typeB); extern "C" vtkDataSetAttributes * vtkDataSetAttributes_new () ; extern "C" void vtkDataSetAttributes_destructor (vtkDataSetAttributes * sself) ; -extern "C" void * vtkDataSetAttributes_get_ptr (vtkDataSetAttributes * sself) ; extern "C" void vtk_data_set_attributes_initialize(vtkDataSetAttributes* sself); extern "C" void vtk_data_set_attributes_update(vtkDataSetAttributes* sself); extern "C" const char* vtk_data_set_attributes_ghost_array_name(vtkDataSetAttributes* sself); @@ -703,26 +662,20 @@ extern "C" void vtk_data_set_attributes_copy_all_on(vtkDataSetAttributes* sself, extern "C" void vtk_data_set_attributes_copy_all_off(vtkDataSetAttributes* sself, int ctype); extern "C" vtkDataSetCellIterator * vtkDataSetCellIterator_new () ; extern "C" void vtkDataSetCellIterator_destructor (vtkDataSetCellIterator * sself) ; -extern "C" void * vtkDataSetCellIterator_get_ptr (vtkDataSetCellIterator * sself) ; extern "C" bool vtk_data_set_cell_iterator_is_done_with_traversal(vtkDataSetCellIterator* sself); extern "C" long long vtk_data_set_cell_iterator_get_cell_id(vtkDataSetCellIterator* sself); extern "C" vtkDataSetCollection * vtkDataSetCollection_new () ; extern "C" void vtkDataSetCollection_destructor (vtkDataSetCollection * sself) ; -extern "C" void * vtkDataSetCollection_get_ptr (vtkDataSetCollection * sself) ; extern "C" int vtk_data_set_collection_get_number_of_items(vtkDataSetCollection* sself); extern "C" vtkDirectedAcyclicGraph * vtkDirectedAcyclicGraph_new () ; extern "C" void vtkDirectedAcyclicGraph_destructor (vtkDirectedAcyclicGraph * sself) ; -extern "C" void * vtkDirectedAcyclicGraph_get_ptr (vtkDirectedAcyclicGraph * sself) ; extern "C" vtkDirectedGraph * vtkDirectedGraph_new () ; extern "C" void vtkDirectedGraph_destructor (vtkDirectedGraph * sself) ; -extern "C" void * vtkDirectedGraph_get_ptr (vtkDirectedGraph * sself) ; extern "C" vtkEdgeListIterator * vtkEdgeListIterator_new () ; extern "C" void vtkEdgeListIterator_destructor (vtkEdgeListIterator * sself) ; -extern "C" void * vtkEdgeListIterator_get_ptr (vtkEdgeListIterator * sself) ; extern "C" bool vtk_edge_list_iterator_has_next(vtkEdgeListIterator* sself); extern "C" vtkEdgeTable * vtkEdgeTable_new () ; extern "C" void vtkEdgeTable_destructor (vtkEdgeTable * sself) ; -extern "C" void * vtkEdgeTable_get_ptr (vtkEdgeTable * sself) ; extern "C" void vtk_edge_table_initialize(vtkEdgeTable* sself); extern "C" int vtk_edge_table_init_edge_insertion(vtkEdgeTable* sself, long long numPoints, int storeAttributes); extern "C" long long vtk_edge_table_insert_edge(vtkEdgeTable* sself, long long p1, long long p2); @@ -733,14 +686,12 @@ extern "C" long long vtk_edge_table_get_next_edge(vtkEdgeTable* sself, long long extern "C" void vtk_edge_table_reset(vtkEdgeTable* sself); extern "C" vtkEmptyCell * vtkEmptyCell_new () ; extern "C" void vtkEmptyCell_destructor (vtkEmptyCell * sself) ; -extern "C" void * vtkEmptyCell_get_ptr (vtkEmptyCell * sself) ; extern "C" int vtk_empty_cell_get_cell_type(vtkEmptyCell* sself); extern "C" int vtk_empty_cell_get_cell_dimension(vtkEmptyCell* sself); extern "C" int vtk_empty_cell_get_number_of_edges(vtkEmptyCell* sself); extern "C" int vtk_empty_cell_get_number_of_faces(vtkEmptyCell* sself); extern "C" vtkExplicitStructuredGrid * vtkExplicitStructuredGrid_new () ; extern "C" void vtkExplicitStructuredGrid_destructor (vtkExplicitStructuredGrid * sself) ; -extern "C" void * vtkExplicitStructuredGrid_get_ptr (vtkExplicitStructuredGrid * sself) ; extern "C" int vtk_explicit_structured_grid_get_data_object_type(vtkExplicitStructuredGrid* sself); extern "C" void vtk_explicit_structured_grid_initialize(vtkExplicitStructuredGrid* sself); extern "C" int vtk_explicit_structured_grid_get_cell_type(vtkExplicitStructuredGrid* sself, long long cellId); @@ -763,7 +714,6 @@ extern "C" unsigned long vtk_explicit_structured_grid_get_actual_memory_size(vtk extern "C" void vtk_explicit_structured_grid_check_and_reorder_faces(vtkExplicitStructuredGrid* sself); extern "C" vtkExtractStructuredGridHelper * vtkExtractStructuredGridHelper_new () ; extern "C" void vtkExtractStructuredGridHelper_destructor (vtkExtractStructuredGridHelper * sself) ; -extern "C" void * vtkExtractStructuredGridHelper_get_ptr (vtkExtractStructuredGridHelper * sself) ; extern "C" bool vtk_extract_structured_grid_helper_is_valid(vtkExtractStructuredGridHelper* sself); extern "C" int vtk_extract_structured_grid_helper_get_size(vtkExtractStructuredGridHelper* sself, const int dim); extern "C" int vtk_extract_structured_grid_helper_get_mapped_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx); @@ -772,7 +722,6 @@ extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value(vtkExt extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx); extern "C" vtkFieldData * vtkFieldData_new () ; extern "C" void vtkFieldData_destructor (vtkFieldData * sself) ; -extern "C" void * vtkFieldData_get_ptr (vtkFieldData * sself) ; extern "C" void vtk_field_data_initialize(vtkFieldData* sself); extern "C" int vtk_field_data_allocate(vtkFieldData* sself, long long sz, long long ext); extern "C" void vtk_field_data_allocate_arrays(vtkFieldData* sself, int num); @@ -795,7 +744,6 @@ extern "C" long long vtk_field_data_get_number_of_tuples(vtkFieldData* sself); extern "C" void vtk_field_data_set_number_of_tuples(vtkFieldData* sself, const long long number); extern "C" vtkGenericAttributeCollection * vtkGenericAttributeCollection_new () ; extern "C" void vtkGenericAttributeCollection_destructor (vtkGenericAttributeCollection * sself) ; -extern "C" void * vtkGenericAttributeCollection_get_ptr (vtkGenericAttributeCollection * sself) ; extern "C" int vtk_generic_attribute_collection_get_number_of_attributes(vtkGenericAttributeCollection* sself); extern "C" int vtk_generic_attribute_collection_get_number_of_components(vtkGenericAttributeCollection* sself); extern "C" int vtk_generic_attribute_collection_get_number_of_point_centered_components(vtkGenericAttributeCollection* sself); @@ -814,7 +762,6 @@ extern "C" int vtk_generic_attribute_collection_get_number_of_attributes_to_inte extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(vtkGenericAttributeCollection* sself); extern "C" vtkGenericCell * vtkGenericCell_new () ; extern "C" void vtkGenericCell_destructor (vtkGenericCell * sself) ; -extern "C" void * vtkGenericCell_get_ptr (vtkGenericCell * sself) ; extern "C" int vtk_generic_cell_get_cell_type(vtkGenericCell* sself); extern "C" int vtk_generic_cell_get_cell_dimension(vtkGenericCell* sself); extern "C" int vtk_generic_cell_get_number_of_edges(vtkGenericCell* sself); @@ -870,7 +817,6 @@ extern "C" void vtk_generic_cell_set_cell_type_to_bezier_hexahedron(vtkGenericCe extern "C" void vtk_generic_cell_set_cell_type_to_bezier_wedge(vtkGenericCell* sself); extern "C" vtkGenericEdgeTable * vtkGenericEdgeTable_new () ; extern "C" void vtkGenericEdgeTable_destructor (vtkGenericEdgeTable * sself) ; -extern "C" void * vtkGenericEdgeTable_get_ptr (vtkGenericEdgeTable * sself) ; extern "C" void vtk_generic_edge_table_insert_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long cellId, int ref, long long& ptId); extern "C" int vtk_generic_edge_table_remove_edge(vtkGenericEdgeTable* sself, long long e1, long long e2); extern "C" int vtk_generic_edge_table_check_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long& ptId); @@ -886,7 +832,6 @@ extern "C" void vtk_generic_edge_table_dump_table(vtkGenericEdgeTable* sself); extern "C" void vtk_generic_edge_table_load_factor(vtkGenericEdgeTable* sself); extern "C" vtkGenericInterpolatedVelocityField * vtkGenericInterpolatedVelocityField_new () ; extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkGenericInterpolatedVelocityField * sself) ; -extern "C" void * vtkGenericInterpolatedVelocityField_get_ptr (vtkGenericInterpolatedVelocityField * sself) ; extern "C" void vtk_generic_interpolated_velocity_field_clear_last_cell(vtkGenericInterpolatedVelocityField* sself); extern "C" int vtk_generic_interpolated_velocity_field_get_caching(vtkGenericInterpolatedVelocityField* sself); extern "C" void vtk_generic_interpolated_velocity_field_set_caching(vtkGenericInterpolatedVelocityField* sself, int _arg); @@ -897,13 +842,11 @@ extern "C" int vtk_generic_interpolated_velocity_field_get_cache_miss(vtkGeneric extern "C" void vtk_generic_interpolated_velocity_field_select_vectors(vtkGenericInterpolatedVelocityField* sself, const char* fieldName); extern "C" vtkGeometricErrorMetric * vtkGeometricErrorMetric_new () ; extern "C" void vtkGeometricErrorMetric_destructor (vtkGeometricErrorMetric * sself) ; -extern "C" void * vtkGeometricErrorMetric_get_ptr (vtkGeometricErrorMetric * sself) ; extern "C" double vtk_geometric_error_metric_get_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself); extern "C" void vtk_geometric_error_metric_set_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself, double value); extern "C" int vtk_geometric_error_metric_get_relative(vtkGeometricErrorMetric* sself); extern "C" vtkGraphEdge * vtkGraphEdge_new () ; extern "C" void vtkGraphEdge_destructor (vtkGraphEdge * sself) ; -extern "C" void * vtkGraphEdge_get_ptr (vtkGraphEdge * sself) ; extern "C" void vtk_graph_edge_set_source(vtkGraphEdge* sself, long long _arg); extern "C" long long vtk_graph_edge_get_source(vtkGraphEdge* sself); extern "C" void vtk_graph_edge_set_target(vtkGraphEdge* sself, long long _arg); @@ -912,28 +855,22 @@ extern "C" void vtk_graph_edge_set_id(vtkGraphEdge* sself, long long _arg); extern "C" long long vtk_graph_edge_get_id(vtkGraphEdge* sself); extern "C" vtkGraphInternals * vtkGraphInternals_new () ; extern "C" void vtkGraphInternals_destructor (vtkGraphInternals * sself) ; -extern "C" void * vtkGraphInternals_get_ptr (vtkGraphInternals * sself) ; extern "C" vtkHexagonalPrism * vtkHexagonalPrism_new () ; extern "C" void vtkHexagonalPrism_destructor (vtkHexagonalPrism * sself) ; -extern "C" void * vtkHexagonalPrism_get_ptr (vtkHexagonalPrism * sself) ; extern "C" int vtk_hexagonal_prism_get_cell_type(vtkHexagonalPrism* sself); extern "C" int vtk_hexagonal_prism_get_number_of_edges(vtkHexagonalPrism* sself); extern "C" int vtk_hexagonal_prism_get_number_of_faces(vtkHexagonalPrism* sself); extern "C" vtkHexahedron * vtkHexahedron_new () ; extern "C" void vtkHexahedron_destructor (vtkHexahedron * sself) ; -extern "C" void * vtkHexahedron_get_ptr (vtkHexahedron * sself) ; extern "C" int vtk_hexahedron_get_cell_type(vtkHexahedron* sself); extern "C" int vtk_hexahedron_get_number_of_edges(vtkHexahedron* sself); extern "C" int vtk_hexahedron_get_number_of_faces(vtkHexahedron* sself); extern "C" vtkHierarchicalBoxDataIterator * vtkHierarchicalBoxDataIterator_new () ; extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkHierarchicalBoxDataIterator * sself) ; -extern "C" void * vtkHierarchicalBoxDataIterator_get_ptr (vtkHierarchicalBoxDataIterator * sself) ; extern "C" vtkHierarchicalBoxDataSet * vtkHierarchicalBoxDataSet_new () ; extern "C" void vtkHierarchicalBoxDataSet_destructor (vtkHierarchicalBoxDataSet * sself) ; -extern "C" void * vtkHierarchicalBoxDataSet_get_ptr (vtkHierarchicalBoxDataSet * sself) ; extern "C" vtkHyperTreeGrid * vtkHyperTreeGrid_new () ; extern "C" void vtkHyperTreeGrid_destructor (vtkHyperTreeGrid * sself) ; -extern "C" void * vtkHyperTreeGrid_get_ptr (vtkHyperTreeGrid * sself) ; extern "C" void vtk_hyper_tree_grid_set_mode_squeeze(vtkHyperTreeGrid* sself, const char* _arg); extern "C" void vtk_hyper_tree_grid_squeeze(vtkHyperTreeGrid* sself); extern "C" int vtk_hyper_tree_grid_get_data_object_type(vtkHyperTreeGrid* sself); @@ -983,7 +920,6 @@ extern "C" bool vtk_hyper_tree_grid_has_any_ghost_cells(vtkHyperTreeGrid* sself) extern "C" long long vtk_hyper_tree_grid_get_number_of_elements(vtkHyperTreeGrid* sself, int type); extern "C" vtkHyperTreeGridNonOrientedCursor * vtkHyperTreeGridNonOrientedCursor_new () ; extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkHyperTreeGridNonOrientedCursor * sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedCursor_get_ptr (vtkHyperTreeGridNonOrientedCursor * sself) ; extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_has_tree(vtkHyperTreeGridNonOrientedCursor* sself); extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedCursor* sself); extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedCursor* sself); @@ -1002,7 +938,6 @@ extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_root(vtkHyperTreeGrid extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_parent(vtkHyperTreeGridNonOrientedCursor* sself); extern "C" vtkHyperTreeGridNonOrientedGeometryCursor * vtkHyperTreeGridNonOrientedGeometryCursor_new () ; extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkHyperTreeGridNonOrientedGeometryCursor * sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr (vtkHyperTreeGridNonOrientedGeometryCursor * sself) ; extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(vtkHyperTreeGridNonOrientedGeometryCursor* sself); extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedGeometryCursor* sself); extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedGeometryCursor* sself); @@ -1021,19 +956,14 @@ extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(vtkHype extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(vtkHyperTreeGridNonOrientedGeometryCursor* sself); extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursor * vtkHyperTreeGridNonOrientedMooreSuperCursor_new () ; extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursor * sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr (vtkHyperTreeGridNonOrientedMooreSuperCursor * sself) ; extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursorLight * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new () ; extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursorLight * sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr (vtkHyperTreeGridNonOrientedMooreSuperCursorLight * sself) ; extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new () ; extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr (vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * sself) ; extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new () ; extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr (vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * sself) ; extern "C" vtkHyperTreeGridOrientedCursor * vtkHyperTreeGridOrientedCursor_new () ; extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkHyperTreeGridOrientedCursor * sself) ; -extern "C" void * vtkHyperTreeGridOrientedCursor_get_ptr (vtkHyperTreeGridOrientedCursor * sself) ; extern "C" bool vtk_hyper_tree_grid_oriented_cursor_has_tree(vtkHyperTreeGridOrientedCursor* sself); extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(vtkHyperTreeGridOrientedCursor* sself); extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(vtkHyperTreeGridOrientedCursor* sself); @@ -1050,7 +980,6 @@ extern "C" unsigned int vtk_hyper_tree_grid_oriented_cursor_get_level(vtkHyperTr extern "C" void vtk_hyper_tree_grid_oriented_cursor_to_child(vtkHyperTreeGridOrientedCursor* sself, unsigned char ichild); extern "C" vtkHyperTreeGridOrientedGeometryCursor * vtkHyperTreeGridOrientedGeometryCursor_new () ; extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkHyperTreeGridOrientedGeometryCursor * sself) ; -extern "C" void * vtkHyperTreeGridOrientedGeometryCursor_get_ptr (vtkHyperTreeGridOrientedGeometryCursor * sself) ; extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(vtkHyperTreeGridOrientedGeometryCursor* sself); extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridOrientedGeometryCursor* sself); extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridOrientedGeometryCursor* sself); @@ -1067,7 +996,6 @@ extern "C" unsigned int vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(v extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(vtkHyperTreeGridOrientedGeometryCursor* sself, unsigned char ichild); extern "C" vtkImageData * vtkImageData_new () ; extern "C" void vtkImageData_destructor (vtkImageData * sself) ; -extern "C" void * vtkImageData_get_ptr (vtkImageData * sself) ; extern "C" int vtk_image_data_get_data_object_type(vtkImageData* sself); extern "C" long long vtk_image_data_get_number_of_cells(vtkImageData* sself); extern "C" long long vtk_image_data_get_number_of_points(vtkImageData* sself); @@ -1096,10 +1024,8 @@ extern "C" void vtk_image_data_prepare_for_new_data(vtkImageData* sself); extern "C" int vtk_image_data_get_extent_type(vtkImageData* sself); extern "C" vtkImageTransform * vtkImageTransform_new () ; extern "C" void vtkImageTransform_destructor (vtkImageTransform * sself) ; -extern "C" void * vtkImageTransform_get_ptr (vtkImageTransform * sself) ; extern "C" vtkImplicitBoolean * vtkImplicitBoolean_new () ; extern "C" void vtkImplicitBoolean_destructor (vtkImplicitBoolean * sself) ; -extern "C" void * vtkImplicitBoolean_get_ptr (vtkImplicitBoolean * sself) ; extern "C" unsigned long vtk_implicit_boolean_get_m_time(vtkImplicitBoolean* sself); extern "C" void vtk_implicit_boolean_set_operation_type(vtkImplicitBoolean* sself, int _arg); extern "C" int vtk_implicit_boolean_get_operation_type_min_value(vtkImplicitBoolean* sself); @@ -1112,17 +1038,14 @@ extern "C" void vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(v extern "C" const char* vtk_implicit_boolean_get_operation_type_as_string(vtkImplicitBoolean* sself); extern "C" vtkImplicitDataSet * vtkImplicitDataSet_new () ; extern "C" void vtkImplicitDataSet_destructor (vtkImplicitDataSet * sself) ; -extern "C" void * vtkImplicitDataSet_get_ptr (vtkImplicitDataSet * sself) ; extern "C" unsigned long vtk_implicit_data_set_get_m_time(vtkImplicitDataSet* sself); extern "C" void vtk_implicit_data_set_set_out_value(vtkImplicitDataSet* sself, double _arg); extern "C" double vtk_implicit_data_set_get_out_value(vtkImplicitDataSet* sself); extern "C" void vtk_implicit_data_set_set_out_gradient(vtkImplicitDataSet* sself, double _arg1, double _arg2, double _arg3); extern "C" vtkImplicitFunctionCollection * vtkImplicitFunctionCollection_new () ; extern "C" void vtkImplicitFunctionCollection_destructor (vtkImplicitFunctionCollection * sself) ; -extern "C" void * vtkImplicitFunctionCollection_get_ptr (vtkImplicitFunctionCollection * sself) ; extern "C" vtkImplicitHalo * vtkImplicitHalo_new () ; extern "C" void vtkImplicitHalo_destructor (vtkImplicitHalo * sself) ; -extern "C" void * vtkImplicitHalo_get_ptr (vtkImplicitHalo * sself) ; extern "C" void vtk_implicit_halo_set_radius(vtkImplicitHalo* sself, double _arg); extern "C" double vtk_implicit_halo_get_radius(vtkImplicitHalo* sself); extern "C" void vtk_implicit_halo_set_center(vtkImplicitHalo* sself, double _arg1, double _arg2, double _arg3); @@ -1130,7 +1053,6 @@ extern "C" void vtk_implicit_halo_set_fade_out(vtkImplicitHalo* sself, double _a extern "C" double vtk_implicit_halo_get_fade_out(vtkImplicitHalo* sself); extern "C" vtkImplicitSelectionLoop * vtkImplicitSelectionLoop_new () ; extern "C" void vtkImplicitSelectionLoop_destructor (vtkImplicitSelectionLoop * sself) ; -extern "C" void * vtkImplicitSelectionLoop_get_ptr (vtkImplicitSelectionLoop * sself) ; extern "C" void vtk_implicit_selection_loop_set_automatic_normal_generation(vtkImplicitSelectionLoop* sself, int _arg); extern "C" int vtk_implicit_selection_loop_get_automatic_normal_generation(vtkImplicitSelectionLoop* sself); extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_on(vtkImplicitSelectionLoop* sself); @@ -1139,7 +1061,6 @@ extern "C" void vtk_implicit_selection_loop_set_normal(vtkImplicitSelectionLoop* extern "C" unsigned long vtk_implicit_selection_loop_get_m_time(vtkImplicitSelectionLoop* sself); extern "C" vtkImplicitSum * vtkImplicitSum_new () ; extern "C" void vtkImplicitSum_destructor (vtkImplicitSum * sself) ; -extern "C" void * vtkImplicitSum_get_ptr (vtkImplicitSum * sself) ; extern "C" unsigned long vtk_implicit_sum_get_m_time(vtkImplicitSum* sself); extern "C" void vtk_implicit_sum_remove_all_functions(vtkImplicitSum* sself); extern "C" void vtk_implicit_sum_set_normalize_by_weight(vtkImplicitSum* sself, int _arg); @@ -1148,25 +1069,21 @@ extern "C" void vtk_implicit_sum_normalize_by_weight_on(vtkImplicitSum* sself); extern "C" void vtk_implicit_sum_normalize_by_weight_off(vtkImplicitSum* sself); extern "C" vtkImplicitVolume * vtkImplicitVolume_new () ; extern "C" void vtkImplicitVolume_destructor (vtkImplicitVolume * sself) ; -extern "C" void * vtkImplicitVolume_get_ptr (vtkImplicitVolume * sself) ; extern "C" unsigned long vtk_implicit_volume_get_m_time(vtkImplicitVolume* sself); extern "C" void vtk_implicit_volume_set_out_value(vtkImplicitVolume* sself, double _arg); extern "C" double vtk_implicit_volume_get_out_value(vtkImplicitVolume* sself); extern "C" void vtk_implicit_volume_set_out_gradient(vtkImplicitVolume* sself, double _arg1, double _arg2, double _arg3); extern "C" vtkImplicitWindowFunction * vtkImplicitWindowFunction_new () ; extern "C" void vtkImplicitWindowFunction_destructor (vtkImplicitWindowFunction * sself) ; -extern "C" void * vtkImplicitWindowFunction_get_ptr (vtkImplicitWindowFunction * sself) ; extern "C" void vtk_implicit_window_function_set_window_range(vtkImplicitWindowFunction* sself, double _arg1, double _arg2); extern "C" void vtk_implicit_window_function_set_window_values(vtkImplicitWindowFunction* sself, double _arg1, double _arg2); extern "C" unsigned long vtk_implicit_window_function_get_m_time(vtkImplicitWindowFunction* sself); extern "C" vtkInEdgeIterator * vtkInEdgeIterator_new () ; extern "C" void vtkInEdgeIterator_destructor (vtkInEdgeIterator * sself) ; -extern "C" void * vtkInEdgeIterator_get_ptr (vtkInEdgeIterator * sself) ; extern "C" long long vtk_in_edge_iterator_get_vertex(vtkInEdgeIterator* sself); extern "C" bool vtk_in_edge_iterator_has_next(vtkInEdgeIterator* sself); extern "C" vtkIncrementalOctreeNode * vtkIncrementalOctreeNode_new () ; extern "C" void vtkIncrementalOctreeNode_destructor (vtkIncrementalOctreeNode * sself) ; -extern "C" void * vtkIncrementalOctreeNode_get_ptr (vtkIncrementalOctreeNode * sself) ; extern "C" int vtk_incremental_octree_node_get_number_of_points(vtkIncrementalOctreeNode* sself); extern "C" void vtk_incremental_octree_node_delete_child_nodes(vtkIncrementalOctreeNode* sself); extern "C" void vtk_incremental_octree_node_set_bounds(vtkIncrementalOctreeNode* sself, double x1, double x2, double y1, double y2, double z1, double z2); @@ -1175,7 +1092,6 @@ extern "C" int vtk_incremental_octree_node_get_number_of_levels(vtkIncrementalOc extern "C" int vtk_incremental_octree_node_get_id(vtkIncrementalOctreeNode* sself); extern "C" vtkIncrementalOctreePointLocator * vtkIncrementalOctreePointLocator_new () ; extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkIncrementalOctreePointLocator * sself) ; -extern "C" void * vtkIncrementalOctreePointLocator_get_ptr (vtkIncrementalOctreePointLocator * sself) ; extern "C" void vtk_incremental_octree_point_locator_set_max_points_per_leaf(vtkIncrementalOctreePointLocator* sself, int _arg); extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value(vtkIncrementalOctreePointLocator* sself); extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value(vtkIncrementalOctreePointLocator* sself); @@ -1194,7 +1110,6 @@ extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkI extern "C" int vtk_incremental_octree_point_locator_get_number_of_levels(vtkIncrementalOctreePointLocator* sself); extern "C" vtkIterativeClosestPointTransform * vtkIterativeClosestPointTransform_new () ; extern "C" void vtkIterativeClosestPointTransform_destructor (vtkIterativeClosestPointTransform * sself) ; -extern "C" void * vtkIterativeClosestPointTransform_get_ptr (vtkIterativeClosestPointTransform * sself) ; extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself, int _arg); extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself); extern "C" int vtk_iterative_closest_point_transform_get_number_of_iterations(vtkIterativeClosestPointTransform* sself); @@ -1221,7 +1136,6 @@ extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroid extern "C" void vtk_iterative_closest_point_transform_inverse(vtkIterativeClosestPointTransform* sself); extern "C" vtkKdNode * vtkKdNode_new () ; extern "C" void vtkKdNode_destructor (vtkKdNode * sself) ; -extern "C" void * vtkKdNode_get_ptr (vtkKdNode * sself) ; extern "C" void vtk_kd_node_set_dim(vtkKdNode* sself, int _arg); extern "C" int vtk_kd_node_get_dim(vtkKdNode* sself); extern "C" double vtk_kd_node_get_division_position(vtkKdNode* sself); @@ -1246,7 +1160,6 @@ extern "C" void vtk_kd_node_print_node(vtkKdNode* sself, int depth); extern "C" void vtk_kd_node_print_verbose_node(vtkKdNode* sself, int depth); extern "C" vtkKdTree * vtkKdTree_new () ; extern "C" void vtkKdTree_destructor (vtkKdTree * sself) ; -extern "C" void * vtkKdTree_get_ptr (vtkKdTree * sself) ; extern "C" void vtk_kd_tree_timing_on(vtkKdTree* sself); extern "C" void vtk_kd_tree_timing_off(vtkKdTree* sself); extern "C" void vtk_kd_tree_set_timing(vtkKdTree* sself, int _arg); @@ -1289,39 +1202,30 @@ extern "C" int vtk_kd_tree_new_geometry(vtkKdTree* sself); extern "C" void vtk_kd_tree_invalidate_geometry(vtkKdTree* sself); extern "C" vtkKdTreePointLocator * vtkKdTreePointLocator_new () ; extern "C" void vtkKdTreePointLocator_destructor (vtkKdTreePointLocator * sself) ; -extern "C" void * vtkKdTreePointLocator_get_ptr (vtkKdTreePointLocator * sself) ; extern "C" void vtk_kd_tree_point_locator_free_search_structure(vtkKdTreePointLocator* sself); extern "C" void vtk_kd_tree_point_locator_build_locator(vtkKdTreePointLocator* sself); extern "C" vtkLagrangeCurve * vtkLagrangeCurve_new () ; extern "C" void vtkLagrangeCurve_destructor (vtkLagrangeCurve * sself) ; -extern "C" void * vtkLagrangeCurve_get_ptr (vtkLagrangeCurve * sself) ; extern "C" int vtk_lagrange_curve_get_cell_type(vtkLagrangeCurve* sself); extern "C" vtkLagrangeHexahedron * vtkLagrangeHexahedron_new () ; extern "C" void vtkLagrangeHexahedron_destructor (vtkLagrangeHexahedron * sself) ; -extern "C" void * vtkLagrangeHexahedron_get_ptr (vtkLagrangeHexahedron * sself) ; extern "C" int vtk_lagrange_hexahedron_get_cell_type(vtkLagrangeHexahedron* sself); extern "C" vtkLagrangeInterpolation * vtkLagrangeInterpolation_new () ; extern "C" void vtkLagrangeInterpolation_destructor (vtkLagrangeInterpolation * sself) ; -extern "C" void * vtkLagrangeInterpolation_get_ptr (vtkLagrangeInterpolation * sself) ; extern "C" vtkLagrangeQuadrilateral * vtkLagrangeQuadrilateral_new () ; extern "C" void vtkLagrangeQuadrilateral_destructor (vtkLagrangeQuadrilateral * sself) ; -extern "C" void * vtkLagrangeQuadrilateral_get_ptr (vtkLagrangeQuadrilateral * sself) ; extern "C" int vtk_lagrange_quadrilateral_get_cell_type(vtkLagrangeQuadrilateral* sself); extern "C" vtkLagrangeTetra * vtkLagrangeTetra_new () ; extern "C" void vtkLagrangeTetra_destructor (vtkLagrangeTetra * sself) ; -extern "C" void * vtkLagrangeTetra_get_ptr (vtkLagrangeTetra * sself) ; extern "C" int vtk_lagrange_tetra_get_cell_type(vtkLagrangeTetra* sself); extern "C" vtkLagrangeTriangle * vtkLagrangeTriangle_new () ; extern "C" void vtkLagrangeTriangle_destructor (vtkLagrangeTriangle * sself) ; -extern "C" void * vtkLagrangeTriangle_get_ptr (vtkLagrangeTriangle * sself) ; extern "C" int vtk_lagrange_triangle_get_cell_type(vtkLagrangeTriangle* sself); extern "C" vtkLagrangeWedge * vtkLagrangeWedge_new () ; extern "C" void vtkLagrangeWedge_destructor (vtkLagrangeWedge * sself) ; -extern "C" void * vtkLagrangeWedge_get_ptr (vtkLagrangeWedge * sself) ; extern "C" int vtk_lagrange_wedge_get_cell_type(vtkLagrangeWedge* sself); extern "C" vtkLine * vtkLine_new () ; extern "C" void vtkLine_destructor (vtkLine * sself) ; -extern "C" void * vtkLine_get_ptr (vtkLine * sself) ; extern "C" int vtk_line_get_cell_type(vtkLine* sself); extern "C" int vtk_line_get_cell_dimension(vtkLine* sself); extern "C" int vtk_line_get_number_of_edges(vtkLine* sself); @@ -1329,13 +1233,10 @@ extern "C" int vtk_line_get_number_of_faces(vtkLine* sself); extern "C" int vtk_line_inflate(vtkLine* sself, double dist); extern "C" vtkMeanValueCoordinatesInterpolator * vtkMeanValueCoordinatesInterpolator_new () ; extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkMeanValueCoordinatesInterpolator * sself) ; -extern "C" void * vtkMeanValueCoordinatesInterpolator_get_ptr (vtkMeanValueCoordinatesInterpolator * sself) ; extern "C" vtkMergePoints * vtkMergePoints_new () ; extern "C" void vtkMergePoints_destructor (vtkMergePoints * sself) ; -extern "C" void * vtkMergePoints_get_ptr (vtkMergePoints * sself) ; extern "C" vtkMolecule * vtkMolecule_new () ; extern "C" void vtkMolecule_destructor (vtkMolecule * sself) ; -extern "C" void * vtkMolecule_get_ptr (vtkMolecule * sself) ; extern "C" long long vtk_molecule_get_number_of_atoms(vtkMolecule* sself); extern "C" long long vtk_molecule_get_number_of_bonds(vtkMolecule* sself); extern "C" unsigned short vtk_molecule_get_atom_atomic_number(vtkMolecule* sself, long long atomId); @@ -1352,19 +1253,16 @@ extern "C" void vtk_molecule_set_atomic_number_array_name(vtkMolecule* sself, co extern "C" void vtk_molecule_set_bond_orders_array_name(vtkMolecule* sself, const char* _arg); extern "C" vtkMultiBlockDataSet * vtkMultiBlockDataSet_new () ; extern "C" void vtkMultiBlockDataSet_destructor (vtkMultiBlockDataSet * sself) ; -extern "C" void * vtkMultiBlockDataSet_get_ptr (vtkMultiBlockDataSet * sself) ; extern "C" void vtk_multi_block_data_set_set_number_of_blocks(vtkMultiBlockDataSet* sself, unsigned int numBlocks); extern "C" unsigned int vtk_multi_block_data_set_get_number_of_blocks(vtkMultiBlockDataSet* sself); extern "C" void vtk_multi_block_data_set_remove_block(vtkMultiBlockDataSet* sself, unsigned int blockno); extern "C" int vtk_multi_block_data_set_has_meta_data(vtkMultiBlockDataSet* sself, unsigned int blockno); extern "C" vtkMultiPieceDataSet * vtkMultiPieceDataSet_new () ; extern "C" void vtkMultiPieceDataSet_destructor (vtkMultiPieceDataSet * sself) ; -extern "C" void * vtkMultiPieceDataSet_get_ptr (vtkMultiPieceDataSet * sself) ; extern "C" void vtk_multi_piece_data_set_set_number_of_pieces(vtkMultiPieceDataSet* sself, unsigned int numpieces); extern "C" unsigned int vtk_multi_piece_data_set_get_number_of_pieces(vtkMultiPieceDataSet* sself); extern "C" vtkMutableDirectedGraph * vtkMutableDirectedGraph_new () ; extern "C" void vtkMutableDirectedGraph_destructor (vtkMutableDirectedGraph * sself) ; -extern "C" void * vtkMutableDirectedGraph_get_ptr (vtkMutableDirectedGraph * sself) ; extern "C" long long vtk_mutable_directed_graph_set_number_of_vertices(vtkMutableDirectedGraph* sself, long long numVerts); extern "C" long long vtk_mutable_directed_graph_add_vertex(vtkMutableDirectedGraph* sself); extern "C" void vtk_mutable_directed_graph_lazy_add_vertex(vtkMutableDirectedGraph* sself); @@ -1372,7 +1270,6 @@ extern "C" void vtk_mutable_directed_graph_remove_vertex(vtkMutableDirectedGraph extern "C" void vtk_mutable_directed_graph_remove_edge(vtkMutableDirectedGraph* sself, long long e); extern "C" vtkMutableUndirectedGraph * vtkMutableUndirectedGraph_new () ; extern "C" void vtkMutableUndirectedGraph_destructor (vtkMutableUndirectedGraph * sself) ; -extern "C" void * vtkMutableUndirectedGraph_get_ptr (vtkMutableUndirectedGraph * sself) ; extern "C" long long vtk_mutable_undirected_graph_set_number_of_vertices(vtkMutableUndirectedGraph* sself, long long numVerts); extern "C" long long vtk_mutable_undirected_graph_add_vertex(vtkMutableUndirectedGraph* sself); extern "C" void vtk_mutable_undirected_graph_lazy_add_vertex(vtkMutableUndirectedGraph* sself); @@ -1381,15 +1278,12 @@ extern "C" void vtk_mutable_undirected_graph_remove_vertex(vtkMutableUndirectedG extern "C" void vtk_mutable_undirected_graph_remove_edge(vtkMutableUndirectedGraph* sself, long long e); extern "C" vtkNonMergingPointLocator * vtkNonMergingPointLocator_new () ; extern "C" void vtkNonMergingPointLocator_destructor (vtkNonMergingPointLocator * sself) ; -extern "C" void * vtkNonMergingPointLocator_get_ptr (vtkNonMergingPointLocator * sself) ; extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNonMergingPointLocator* sself, double p0, double p1, double p2); extern "C" vtkNonOverlappingAMR * vtkNonOverlappingAMR_new () ; extern "C" void vtkNonOverlappingAMR_destructor (vtkNonOverlappingAMR * sself) ; -extern "C" void * vtkNonOverlappingAMR_get_ptr (vtkNonOverlappingAMR * sself) ; extern "C" int vtk_non_overlapping_amr_get_data_object_type(vtkNonOverlappingAMR* sself); extern "C" vtkOctreePointLocator * vtkOctreePointLocator_new () ; extern "C" void vtkOctreePointLocator_destructor (vtkOctreePointLocator * sself) ; -extern "C" void * vtkOctreePointLocator_get_ptr (vtkOctreePointLocator * sself) ; extern "C" void vtk_octree_point_locator_set_maximum_points_per_region(vtkOctreePointLocator* sself, int _arg); extern "C" int vtk_octree_point_locator_get_maximum_points_per_region(vtkOctreePointLocator* sself); extern "C" void vtk_octree_point_locator_set_create_cubic_octants(vtkOctreePointLocator* sself, int _arg); @@ -1403,7 +1297,6 @@ extern "C" long long vtk_octree_point_locator_find_closest_point(vtkOctreePointL extern "C" void vtk_octree_point_locator_free_search_structure(vtkOctreePointLocator* sself); extern "C" vtkOctreePointLocatorNode * vtkOctreePointLocatorNode_new () ; extern "C" void vtkOctreePointLocatorNode_destructor (vtkOctreePointLocatorNode * sself) ; -extern "C" void * vtkOctreePointLocatorNode_get_ptr (vtkOctreePointLocatorNode * sself) ; extern "C" void vtk_octree_point_locator_node_set_number_of_points(vtkOctreePointLocatorNode* sself, int numberOfPoints); extern "C" int vtk_octree_point_locator_node_get_number_of_points(vtkOctreePointLocatorNode* sself); extern "C" void vtk_octree_point_locator_node_set_bounds(vtkOctreePointLocatorNode* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); @@ -1415,7 +1308,6 @@ extern "C" void vtk_octree_point_locator_node_delete_child_nodes(vtkOctreePointL extern "C" int vtk_octree_point_locator_node_contains_point(vtkOctreePointLocatorNode* sself, double x, double y, double z, int useDataBounds); extern "C" vtkOrderedTriangulator * vtkOrderedTriangulator_new () ; extern "C" void vtkOrderedTriangulator_destructor (vtkOrderedTriangulator * sself) ; -extern "C" void * vtkOrderedTriangulator_get_ptr (vtkOrderedTriangulator * sself) ; extern "C" void vtk_ordered_triangulator_init_triangulation(vtkOrderedTriangulator* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts); extern "C" void vtk_ordered_triangulator_triangulate(vtkOrderedTriangulator* sself); extern "C" void vtk_ordered_triangulator_template_triangulate(vtkOrderedTriangulator* sself, int cellType, int numPts, int numEdges); @@ -1437,12 +1329,10 @@ extern "C" void vtk_ordered_triangulator_use_two_sort_ids_off(vtkOrderedTriangul extern "C" void vtk_ordered_triangulator_init_tetra_traversal(vtkOrderedTriangulator* sself); extern "C" vtkOutEdgeIterator * vtkOutEdgeIterator_new () ; extern "C" void vtkOutEdgeIterator_destructor (vtkOutEdgeIterator * sself) ; -extern "C" void * vtkOutEdgeIterator_get_ptr (vtkOutEdgeIterator * sself) ; extern "C" long long vtk_out_edge_iterator_get_vertex(vtkOutEdgeIterator* sself); extern "C" bool vtk_out_edge_iterator_has_next(vtkOutEdgeIterator* sself); extern "C" vtkOverlappingAMR * vtkOverlappingAMR_new () ; extern "C" void vtkOverlappingAMR_destructor (vtkOverlappingAMR * sself) ; -extern "C" void * vtkOverlappingAMR_get_ptr (vtkOverlappingAMR * sself) ; extern "C" void vtk_overlapping_amr_set_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level, int refRatio); extern "C" int vtk_overlapping_amr_get_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level); extern "C" void vtk_overlapping_amr_set_amr_block_source_index(vtkOverlappingAMR* sself, unsigned int level, unsigned int id, int sourceId); @@ -1453,14 +1343,12 @@ extern "C" void vtk_overlapping_amr_print_parent_child_info(vtkOverlappingAMR* s extern "C" void vtk_overlapping_amr_audit(vtkOverlappingAMR* sself); extern "C" vtkPartitionedDataSet * vtkPartitionedDataSet_new () ; extern "C" void vtkPartitionedDataSet_destructor (vtkPartitionedDataSet * sself) ; -extern "C" void * vtkPartitionedDataSet_get_ptr (vtkPartitionedDataSet * sself) ; extern "C" void vtk_partitioned_data_set_set_number_of_partitions(vtkPartitionedDataSet* sself, unsigned int numPartitions); extern "C" unsigned int vtk_partitioned_data_set_get_number_of_partitions(vtkPartitionedDataSet* sself); extern "C" int vtk_partitioned_data_set_has_meta_data(vtkPartitionedDataSet* sself, unsigned int idx); extern "C" void vtk_partitioned_data_set_remove_null_partitions(vtkPartitionedDataSet* sself); extern "C" vtkPartitionedDataSetCollection * vtkPartitionedDataSetCollection_new () ; extern "C" void vtkPartitionedDataSetCollection_destructor (vtkPartitionedDataSetCollection * sself) ; -extern "C" void * vtkPartitionedDataSetCollection_get_ptr (vtkPartitionedDataSetCollection * sself) ; extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself, unsigned int numDataSets); extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself); extern "C" void vtk_partitioned_data_set_collection_remove_partitioned_data_set(vtkPartitionedDataSetCollection* sself, unsigned int idx); @@ -1471,7 +1359,6 @@ extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index( extern "C" unsigned long vtk_partitioned_data_set_collection_get_m_time(vtkPartitionedDataSetCollection* sself); extern "C" vtkPath * vtkPath_new () ; extern "C" void vtkPath_destructor (vtkPath * sself) ; -extern "C" void * vtkPath_get_ptr (vtkPath * sself) ; extern "C" int vtk_path_get_data_object_type(vtkPath* sself); extern "C" void vtk_path_insert_next_point(vtkPath* sself, double x, double y, double z, int code); extern "C" long long vtk_path_get_number_of_cells(vtkPath* sself); @@ -1480,20 +1367,17 @@ extern "C" void vtk_path_allocate(vtkPath* sself, long long size, int extSize); extern "C" void vtk_path_reset(vtkPath* sself); extern "C" vtkPentagonalPrism * vtkPentagonalPrism_new () ; extern "C" void vtkPentagonalPrism_destructor (vtkPentagonalPrism * sself) ; -extern "C" void * vtkPentagonalPrism_get_ptr (vtkPentagonalPrism * sself) ; extern "C" int vtk_pentagonal_prism_get_cell_type(vtkPentagonalPrism* sself); extern "C" int vtk_pentagonal_prism_get_number_of_edges(vtkPentagonalPrism* sself); extern "C" int vtk_pentagonal_prism_get_number_of_faces(vtkPentagonalPrism* sself); extern "C" vtkPerlinNoise * vtkPerlinNoise_new () ; extern "C" void vtkPerlinNoise_destructor (vtkPerlinNoise * sself) ; -extern "C" void * vtkPerlinNoise_get_ptr (vtkPerlinNoise * sself) ; extern "C" void vtk_perlin_noise_set_frequency(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_perlin_noise_set_phase(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_perlin_noise_set_amplitude(vtkPerlinNoise* sself, double _arg); extern "C" double vtk_perlin_noise_get_amplitude(vtkPerlinNoise* sself); extern "C" vtkPiecewiseFunction * vtkPiecewiseFunction_new () ; extern "C" void vtkPiecewiseFunction_destructor (vtkPiecewiseFunction * sself) ; -extern "C" void * vtkPiecewiseFunction_get_ptr (vtkPiecewiseFunction * sself) ; extern "C" int vtk_piecewise_function_get_data_object_type(vtkPiecewiseFunction* sself); extern "C" int vtk_piecewise_function_get_size(vtkPiecewiseFunction* sself); extern "C" int vtk_piecewise_function_add_point(vtkPiecewiseFunction* sself, double x, double y); @@ -1520,7 +1404,6 @@ extern "C" void vtk_piecewise_function_allow_duplicate_scalars_off(vtkPiecewiseF extern "C" int vtk_piecewise_function_estimate_min_number_of_samples(vtkPiecewiseFunction* sself, const double& x1, const double& x2); extern "C" vtkPixel * vtkPixel_new () ; extern "C" void vtkPixel_destructor (vtkPixel * sself) ; -extern "C" void * vtkPixel_get_ptr (vtkPixel * sself) ; extern "C" int vtk_pixel_get_cell_type(vtkPixel* sself); extern "C" int vtk_pixel_get_cell_dimension(vtkPixel* sself); extern "C" int vtk_pixel_get_number_of_edges(vtkPixel* sself); @@ -1528,31 +1411,25 @@ extern "C" int vtk_pixel_get_number_of_faces(vtkPixel* sself); extern "C" int vtk_pixel_inflate(vtkPixel* sself, double dist); extern "C" vtkPlane * vtkPlane_new () ; extern "C" void vtkPlane_destructor (vtkPlane * sself) ; -extern "C" void * vtkPlane_get_ptr (vtkPlane * sself) ; extern "C" void vtk_plane_set_normal(vtkPlane* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_plane_set_origin(vtkPlane* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_plane_push(vtkPlane* sself, double distance); extern "C" vtkPlaneCollection * vtkPlaneCollection_new () ; extern "C" void vtkPlaneCollection_destructor (vtkPlaneCollection * sself) ; -extern "C" void * vtkPlaneCollection_get_ptr (vtkPlaneCollection * sself) ; extern "C" int vtk_plane_collection_get_number_of_items(vtkPlaneCollection* sself); extern "C" vtkPlanes * vtkPlanes_new () ; extern "C" void vtkPlanes_destructor (vtkPlanes * sself) ; -extern "C" void * vtkPlanes_get_ptr (vtkPlanes * sself) ; extern "C" void vtk_planes_set_bounds(vtkPlanes* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax); extern "C" int vtk_planes_get_number_of_planes(vtkPlanes* sself); extern "C" vtkPlanesIntersection * vtkPlanesIntersection_new () ; extern "C" void vtkPlanesIntersection_destructor (vtkPlanesIntersection * sself) ; -extern "C" void * vtkPlanesIntersection_get_ptr (vtkPlanesIntersection * sself) ; extern "C" int vtk_planes_intersection_get_number_of_region_vertices(vtkPlanesIntersection* sself); extern "C" int vtk_planes_intersection_get_num_region_vertices(vtkPlanesIntersection* sself); extern "C" vtkPointData * vtkPointData_new () ; extern "C" void vtkPointData_destructor (vtkPointData * sself) ; -extern "C" void * vtkPointData_get_ptr (vtkPointData * sself) ; extern "C" void vtk_point_data_null_point(vtkPointData* sself, long long ptId); extern "C" vtkPointLocator * vtkPointLocator_new () ; extern "C" void vtkPointLocator_destructor (vtkPointLocator * sself) ; -extern "C" void * vtkPointLocator_get_ptr (vtkPointLocator * sself) ; extern "C" void vtk_point_locator_set_divisions(vtkPointLocator* sself, int _arg1, int _arg2, int _arg3); extern "C" void vtk_point_locator_set_number_of_points_per_bucket(vtkPointLocator* sself, int _arg); extern "C" int vtk_point_locator_get_number_of_points_per_bucket_min_value(vtkPointLocator* sself); @@ -1564,7 +1441,6 @@ extern "C" void vtk_point_locator_free_search_structure(vtkPointLocator* sself); extern "C" void vtk_point_locator_build_locator(vtkPointLocator* sself); extern "C" vtkPointSet * vtkPointSet_new () ; extern "C" void vtkPointSet_destructor (vtkPointSet * sself) ; -extern "C" void * vtkPointSet_get_ptr (vtkPointSet * sself) ; extern "C" void vtk_point_set_set_editable(vtkPointSet* sself, bool _arg); extern "C" bool vtk_point_set_get_editable(vtkPointSet* sself); extern "C" void vtk_point_set_editable_on(vtkPointSet* sself); @@ -1582,19 +1458,16 @@ extern "C" void vtk_point_set_compute_bounds(vtkPointSet* sself); extern "C" void vtk_point_set_squeeze(vtkPointSet* sself); extern "C" vtkPointSetCellIterator * vtkPointSetCellIterator_new () ; extern "C" void vtkPointSetCellIterator_destructor (vtkPointSetCellIterator * sself) ; -extern "C" void * vtkPointSetCellIterator_get_ptr (vtkPointSetCellIterator * sself) ; extern "C" bool vtk_point_set_cell_iterator_is_done_with_traversal(vtkPointSetCellIterator* sself); extern "C" long long vtk_point_set_cell_iterator_get_cell_id(vtkPointSetCellIterator* sself); extern "C" vtkPointsProjectedHull * vtkPointsProjectedHull_new () ; extern "C" void vtkPointsProjectedHull_destructor (vtkPointsProjectedHull * sself) ; -extern "C" void * vtkPointsProjectedHull_get_ptr (vtkPointsProjectedHull * sself) ; extern "C" int vtk_points_projected_hull_get_size_ccw_hull_x(vtkPointsProjectedHull* sself); extern "C" int vtk_points_projected_hull_get_size_ccw_hull_y(vtkPointsProjectedHull* sself); extern "C" int vtk_points_projected_hull_get_size_ccw_hull_z(vtkPointsProjectedHull* sself); extern "C" void vtk_points_projected_hull_update(vtkPointsProjectedHull* sself); extern "C" vtkPolyData * vtkPolyData_new () ; extern "C" void vtkPolyData_destructor (vtkPolyData * sself) ; -extern "C" void * vtkPolyData_get_ptr (vtkPolyData * sself) ; extern "C" int vtk_poly_data_get_data_object_type(vtkPolyData* sself); extern "C" long long vtk_poly_data_get_number_of_cells(vtkPolyData* sself); extern "C" int vtk_poly_data_get_cell_type(vtkPolyData* sself, long long cellId); @@ -1638,28 +1511,23 @@ extern "C" unsigned long vtk_poly_data_get_mesh_m_time(vtkPolyData* sself); extern "C" unsigned long vtk_poly_data_get_m_time(vtkPolyData* sself); extern "C" vtkPolyDataCollection * vtkPolyDataCollection_new () ; extern "C" void vtkPolyDataCollection_destructor (vtkPolyDataCollection * sself) ; -extern "C" void * vtkPolyDataCollection_get_ptr (vtkPolyDataCollection * sself) ; extern "C" vtkPolyLine * vtkPolyLine_new () ; extern "C" void vtkPolyLine_destructor (vtkPolyLine * sself) ; -extern "C" void * vtkPolyLine_get_ptr (vtkPolyLine * sself) ; extern "C" int vtk_poly_line_get_cell_type(vtkPolyLine* sself); extern "C" int vtk_poly_line_get_cell_dimension(vtkPolyLine* sself); extern "C" int vtk_poly_line_get_number_of_edges(vtkPolyLine* sself); extern "C" int vtk_poly_line_get_number_of_faces(vtkPolyLine* sself); extern "C" vtkPolyPlane * vtkPolyPlane_new () ; extern "C" void vtkPolyPlane_destructor (vtkPolyPlane * sself) ; -extern "C" void * vtkPolyPlane_get_ptr (vtkPolyPlane * sself) ; extern "C" unsigned long vtk_poly_plane_get_m_time(vtkPolyPlane* sself); extern "C" vtkPolyVertex * vtkPolyVertex_new () ; extern "C" void vtkPolyVertex_destructor (vtkPolyVertex * sself) ; -extern "C" void * vtkPolyVertex_get_ptr (vtkPolyVertex * sself) ; extern "C" int vtk_poly_vertex_get_cell_type(vtkPolyVertex* sself); extern "C" int vtk_poly_vertex_get_cell_dimension(vtkPolyVertex* sself); extern "C" int vtk_poly_vertex_get_number_of_edges(vtkPolyVertex* sself); extern "C" int vtk_poly_vertex_get_number_of_faces(vtkPolyVertex* sself); extern "C" vtkPolygon * vtkPolygon_new () ; extern "C" void vtkPolygon_destructor (vtkPolygon * sself) ; -extern "C" void * vtkPolygon_get_ptr (vtkPolygon * sself) ; extern "C" int vtk_polygon_get_cell_type(vtkPolygon* sself); extern "C" int vtk_polygon_get_cell_dimension(vtkPolygon* sself); extern "C" int vtk_polygon_get_number_of_edges(vtkPolygon* sself); @@ -1676,7 +1544,6 @@ extern "C" int vtk_polygon_ear_cut_triangulation(vtkPolygon* sself, int measure) extern "C" int vtk_polygon_unbiased_ear_cut_triangulation(vtkPolygon* sself, int seed, int measure); extern "C" vtkPolyhedron * vtkPolyhedron_new () ; extern "C" void vtkPolyhedron_destructor (vtkPolyhedron * sself) ; -extern "C" void * vtkPolyhedron_get_ptr (vtkPolyhedron * sself) ; extern "C" int vtk_polyhedron_get_cell_type(vtkPolyhedron* sself); extern "C" int vtk_polyhedron_requires_initialization(vtkPolyhedron* sself); extern "C" int vtk_polyhedron_get_number_of_edges(vtkPolyhedron* sself); @@ -1686,48 +1553,41 @@ extern "C" int vtk_polyhedron_requires_explicit_face_representation(vtkPolyhedro extern "C" bool vtk_polyhedron_is_convex(vtkPolyhedron* sself); extern "C" vtkPyramid * vtkPyramid_new () ; extern "C" void vtkPyramid_destructor (vtkPyramid * sself) ; -extern "C" void * vtkPyramid_get_ptr (vtkPyramid * sself) ; extern "C" int vtk_pyramid_get_cell_type(vtkPyramid* sself); extern "C" int vtk_pyramid_get_number_of_edges(vtkPyramid* sself); extern "C" int vtk_pyramid_get_number_of_faces(vtkPyramid* sself); extern "C" vtkQuad * vtkQuad_new () ; extern "C" void vtkQuad_destructor (vtkQuad * sself) ; -extern "C" void * vtkQuad_get_ptr (vtkQuad * sself) ; extern "C" int vtk_quad_get_cell_type(vtkQuad* sself); extern "C" int vtk_quad_get_cell_dimension(vtkQuad* sself); extern "C" int vtk_quad_get_number_of_edges(vtkQuad* sself); extern "C" int vtk_quad_get_number_of_faces(vtkQuad* sself); extern "C" vtkQuadraticEdge * vtkQuadraticEdge_new () ; extern "C" void vtkQuadraticEdge_destructor (vtkQuadraticEdge * sself) ; -extern "C" void * vtkQuadraticEdge_get_ptr (vtkQuadraticEdge * sself) ; extern "C" int vtk_quadratic_edge_get_cell_type(vtkQuadraticEdge* sself); extern "C" int vtk_quadratic_edge_get_cell_dimension(vtkQuadraticEdge* sself); extern "C" int vtk_quadratic_edge_get_number_of_edges(vtkQuadraticEdge* sself); extern "C" int vtk_quadratic_edge_get_number_of_faces(vtkQuadraticEdge* sself); extern "C" vtkQuadraticHexahedron * vtkQuadraticHexahedron_new () ; extern "C" void vtkQuadraticHexahedron_destructor (vtkQuadraticHexahedron * sself) ; -extern "C" void * vtkQuadraticHexahedron_get_ptr (vtkQuadraticHexahedron * sself) ; extern "C" int vtk_quadratic_hexahedron_get_cell_type(vtkQuadraticHexahedron* sself); extern "C" int vtk_quadratic_hexahedron_get_cell_dimension(vtkQuadraticHexahedron* sself); extern "C" int vtk_quadratic_hexahedron_get_number_of_edges(vtkQuadraticHexahedron* sself); extern "C" int vtk_quadratic_hexahedron_get_number_of_faces(vtkQuadraticHexahedron* sself); extern "C" vtkQuadraticLinearQuad * vtkQuadraticLinearQuad_new () ; extern "C" void vtkQuadraticLinearQuad_destructor (vtkQuadraticLinearQuad * sself) ; -extern "C" void * vtkQuadraticLinearQuad_get_ptr (vtkQuadraticLinearQuad * sself) ; extern "C" int vtk_quadratic_linear_quad_get_cell_type(vtkQuadraticLinearQuad* sself); extern "C" int vtk_quadratic_linear_quad_get_cell_dimension(vtkQuadraticLinearQuad* sself); extern "C" int vtk_quadratic_linear_quad_get_number_of_edges(vtkQuadraticLinearQuad* sself); extern "C" int vtk_quadratic_linear_quad_get_number_of_faces(vtkQuadraticLinearQuad* sself); extern "C" vtkQuadraticLinearWedge * vtkQuadraticLinearWedge_new () ; extern "C" void vtkQuadraticLinearWedge_destructor (vtkQuadraticLinearWedge * sself) ; -extern "C" void * vtkQuadraticLinearWedge_get_ptr (vtkQuadraticLinearWedge * sself) ; extern "C" int vtk_quadratic_linear_wedge_get_cell_type(vtkQuadraticLinearWedge* sself); extern "C" int vtk_quadratic_linear_wedge_get_cell_dimension(vtkQuadraticLinearWedge* sself); extern "C" int vtk_quadratic_linear_wedge_get_number_of_edges(vtkQuadraticLinearWedge* sself); extern "C" int vtk_quadratic_linear_wedge_get_number_of_faces(vtkQuadraticLinearWedge* sself); extern "C" vtkQuadraticPolygon * vtkQuadraticPolygon_new () ; extern "C" void vtkQuadraticPolygon_destructor (vtkQuadraticPolygon * sself) ; -extern "C" void * vtkQuadraticPolygon_get_ptr (vtkQuadraticPolygon * sself) ; extern "C" int vtk_quadratic_polygon_get_cell_type(vtkQuadraticPolygon* sself); extern "C" int vtk_quadratic_polygon_get_cell_dimension(vtkQuadraticPolygon* sself); extern "C" int vtk_quadratic_polygon_get_number_of_edges(vtkQuadraticPolygon* sself); @@ -1736,42 +1596,36 @@ extern "C" bool vtk_quadratic_polygon_get_use_mvc_interpolation(vtkQuadraticPoly extern "C" void vtk_quadratic_polygon_set_use_mvc_interpolation(vtkQuadraticPolygon* sself, bool _arg); extern "C" vtkQuadraticPyramid * vtkQuadraticPyramid_new () ; extern "C" void vtkQuadraticPyramid_destructor (vtkQuadraticPyramid * sself) ; -extern "C" void * vtkQuadraticPyramid_get_ptr (vtkQuadraticPyramid * sself) ; extern "C" int vtk_quadratic_pyramid_get_cell_type(vtkQuadraticPyramid* sself); extern "C" int vtk_quadratic_pyramid_get_cell_dimension(vtkQuadraticPyramid* sself); extern "C" int vtk_quadratic_pyramid_get_number_of_edges(vtkQuadraticPyramid* sself); extern "C" int vtk_quadratic_pyramid_get_number_of_faces(vtkQuadraticPyramid* sself); extern "C" vtkQuadraticQuad * vtkQuadraticQuad_new () ; extern "C" void vtkQuadraticQuad_destructor (vtkQuadraticQuad * sself) ; -extern "C" void * vtkQuadraticQuad_get_ptr (vtkQuadraticQuad * sself) ; extern "C" int vtk_quadratic_quad_get_cell_type(vtkQuadraticQuad* sself); extern "C" int vtk_quadratic_quad_get_cell_dimension(vtkQuadraticQuad* sself); extern "C" int vtk_quadratic_quad_get_number_of_edges(vtkQuadraticQuad* sself); extern "C" int vtk_quadratic_quad_get_number_of_faces(vtkQuadraticQuad* sself); extern "C" vtkQuadraticTetra * vtkQuadraticTetra_new () ; extern "C" void vtkQuadraticTetra_destructor (vtkQuadraticTetra * sself) ; -extern "C" void * vtkQuadraticTetra_get_ptr (vtkQuadraticTetra * sself) ; extern "C" int vtk_quadratic_tetra_get_cell_type(vtkQuadraticTetra* sself); extern "C" int vtk_quadratic_tetra_get_cell_dimension(vtkQuadraticTetra* sself); extern "C" int vtk_quadratic_tetra_get_number_of_edges(vtkQuadraticTetra* sself); extern "C" int vtk_quadratic_tetra_get_number_of_faces(vtkQuadraticTetra* sself); extern "C" vtkQuadraticTriangle * vtkQuadraticTriangle_new () ; extern "C" void vtkQuadraticTriangle_destructor (vtkQuadraticTriangle * sself) ; -extern "C" void * vtkQuadraticTriangle_get_ptr (vtkQuadraticTriangle * sself) ; extern "C" int vtk_quadratic_triangle_get_cell_type(vtkQuadraticTriangle* sself); extern "C" int vtk_quadratic_triangle_get_cell_dimension(vtkQuadraticTriangle* sself); extern "C" int vtk_quadratic_triangle_get_number_of_edges(vtkQuadraticTriangle* sself); extern "C" int vtk_quadratic_triangle_get_number_of_faces(vtkQuadraticTriangle* sself); extern "C" vtkQuadraticWedge * vtkQuadraticWedge_new () ; extern "C" void vtkQuadraticWedge_destructor (vtkQuadraticWedge * sself) ; -extern "C" void * vtkQuadraticWedge_get_ptr (vtkQuadraticWedge * sself) ; extern "C" int vtk_quadratic_wedge_get_cell_type(vtkQuadraticWedge* sself); extern "C" int vtk_quadratic_wedge_get_cell_dimension(vtkQuadraticWedge* sself); extern "C" int vtk_quadratic_wedge_get_number_of_edges(vtkQuadraticWedge* sself); extern "C" int vtk_quadratic_wedge_get_number_of_faces(vtkQuadraticWedge* sself); extern "C" vtkQuadratureSchemeDefinition * vtkQuadratureSchemeDefinition_new () ; extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkQuadratureSchemeDefinition * sself) ; -extern "C" void * vtkQuadratureSchemeDefinition_get_ptr (vtkQuadratureSchemeDefinition * sself) ; extern "C" void vtk_quadrature_scheme_definition_clear(vtkQuadratureSchemeDefinition* sself); extern "C" int vtk_quadrature_scheme_definition_get_cell_type(vtkQuadratureSchemeDefinition* sself); extern "C" int vtk_quadrature_scheme_definition_get_quadrature_key(vtkQuadratureSchemeDefinition* sself); @@ -1779,11 +1633,9 @@ extern "C" int vtk_quadrature_scheme_definition_get_number_of_nodes(vtkQuadratur extern "C" int vtk_quadrature_scheme_definition_get_number_of_quadrature_points(vtkQuadratureSchemeDefinition* sself); extern "C" vtkQuadric * vtkQuadric_new () ; extern "C" void vtkQuadric_destructor (vtkQuadric * sself) ; -extern "C" void * vtkQuadric_get_ptr (vtkQuadric * sself) ; extern "C" void vtk_quadric_set_coefficients(vtkQuadric* sself, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9); extern "C" vtkRectilinearGrid * vtkRectilinearGrid_new () ; extern "C" void vtkRectilinearGrid_destructor (vtkRectilinearGrid * sself) ; -extern "C" void * vtkRectilinearGrid_get_ptr (vtkRectilinearGrid * sself) ; extern "C" int vtk_rectilinear_grid_get_data_object_type(vtkRectilinearGrid* sself); extern "C" void vtk_rectilinear_grid_initialize(vtkRectilinearGrid* sself); extern "C" long long vtk_rectilinear_grid_get_number_of_cells(vtkRectilinearGrid* sself); @@ -1801,20 +1653,17 @@ extern "C" int vtk_rectilinear_grid_get_extent_type(vtkRectilinearGrid* sself); extern "C" const char* vtk_rectilinear_grid_get_scalar_type_as_string(vtkRectilinearGrid* sself); extern "C" vtkReebGraph * vtkReebGraph_new () ; extern "C" void vtkReebGraph_destructor (vtkReebGraph * sself) ; -extern "C" void * vtkReebGraph_get_ptr (vtkReebGraph * sself) ; extern "C" int vtk_reeb_graph_stream_triangle(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2); extern "C" int vtk_reeb_graph_stream_tetrahedron(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2, long long vertex3Id, double scalar3); extern "C" void vtk_reeb_graph_close_stream(vtkReebGraph* sself); extern "C" vtkReebGraphSimplificationMetric * vtkReebGraphSimplificationMetric_new () ; extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkReebGraphSimplificationMetric * sself) ; -extern "C" void * vtkReebGraphSimplificationMetric_get_ptr (vtkReebGraphSimplificationMetric * sself) ; extern "C" void vtk_reeb_graph_simplification_metric_set_lower_bound(vtkReebGraphSimplificationMetric* sself, double _arg); extern "C" double vtk_reeb_graph_simplification_metric_get_lower_bound(vtkReebGraphSimplificationMetric* sself); extern "C" void vtk_reeb_graph_simplification_metric_set_upper_bound(vtkReebGraphSimplificationMetric* sself, double _arg); extern "C" double vtk_reeb_graph_simplification_metric_get_upper_bound(vtkReebGraphSimplificationMetric* sself); extern "C" vtkSelection * vtkSelection_new () ; extern "C" void vtkSelection_destructor (vtkSelection * sself) ; -extern "C" void * vtkSelection_get_ptr (vtkSelection * sself) ; extern "C" int vtk_selection_get_data_object_type(vtkSelection* sself); extern "C" unsigned int vtk_selection_get_number_of_nodes(vtkSelection* sself); extern "C" void vtk_selection_remove_node(vtkSelection* sself, unsigned int idx); @@ -1824,7 +1673,6 @@ extern "C" unsigned long vtk_selection_get_m_time(vtkSelection* sself); extern "C" void vtk_selection_dump(vtkSelection* sself); extern "C" vtkSelectionNode * vtkSelectionNode_new () ; extern "C" void vtkSelectionNode_destructor (vtkSelectionNode * sself) ; -extern "C" void * vtkSelectionNode_get_ptr (vtkSelectionNode * sself) ; extern "C" void vtk_selection_node_initialize(vtkSelectionNode* sself); extern "C" unsigned long vtk_selection_node_get_m_time(vtkSelectionNode* sself); extern "C" void vtk_selection_node_set_content_type(vtkSelectionNode* sself, int type); @@ -1839,7 +1687,6 @@ extern "C" int vtk_selection_node_convert_attribute_type_to_selection_field(vtkS extern "C" void vtk_selection_node_set_query_string(vtkSelectionNode* sself, const char* _arg); extern "C" vtkSimpleCellTessellator * vtkSimpleCellTessellator_new () ; extern "C" void vtkSimpleCellTessellator_destructor (vtkSimpleCellTessellator * sself) ; -extern "C" void * vtkSimpleCellTessellator_get_ptr (vtkSimpleCellTessellator * sself) ; extern "C" void vtk_simple_cell_tessellator_reset(vtkSimpleCellTessellator* sself); extern "C" int vtk_simple_cell_tessellator_get_fixed_subdivisions(vtkSimpleCellTessellator* sself); extern "C" int vtk_simple_cell_tessellator_get_max_subdivision_level(vtkSimpleCellTessellator* sself); @@ -1849,25 +1696,20 @@ extern "C" void vtk_simple_cell_tessellator_set_max_subdivision_level(vtkSimpleC extern "C" void vtk_simple_cell_tessellator_set_subdivision_levels(vtkSimpleCellTessellator* sself, int fixed, int maxLevel); extern "C" vtkSmoothErrorMetric * vtkSmoothErrorMetric_new () ; extern "C" void vtkSmoothErrorMetric_destructor (vtkSmoothErrorMetric * sself) ; -extern "C" void * vtkSmoothErrorMetric_get_ptr (vtkSmoothErrorMetric * sself) ; extern "C" double vtk_smooth_error_metric_get_angle_tolerance(vtkSmoothErrorMetric* sself); extern "C" void vtk_smooth_error_metric_set_angle_tolerance(vtkSmoothErrorMetric* sself, double value); extern "C" vtkSortFieldData * vtkSortFieldData_new () ; extern "C" void vtkSortFieldData_destructor (vtkSortFieldData * sself) ; -extern "C" void * vtkSortFieldData_get_ptr (vtkSortFieldData * sself) ; extern "C" vtkSphere * vtkSphere_new () ; extern "C" void vtkSphere_destructor (vtkSphere * sself) ; -extern "C" void * vtkSphere_get_ptr (vtkSphere * sself) ; extern "C" void vtk_sphere_set_radius(vtkSphere* sself, double _arg); extern "C" double vtk_sphere_get_radius(vtkSphere* sself); extern "C" void vtk_sphere_set_center(vtkSphere* sself, double _arg1, double _arg2, double _arg3); extern "C" vtkSpheres * vtkSpheres_new () ; extern "C" void vtkSpheres_destructor (vtkSpheres * sself) ; -extern "C" void * vtkSpheres_get_ptr (vtkSpheres * sself) ; extern "C" int vtk_spheres_get_number_of_spheres(vtkSpheres* sself); extern "C" vtkStaticCellLinks * vtkStaticCellLinks_new () ; extern "C" void vtkStaticCellLinks_destructor (vtkStaticCellLinks * sself) ; -extern "C" void * vtkStaticCellLinks_get_ptr (vtkStaticCellLinks * sself) ; extern "C" long long vtk_static_cell_links_get_number_of_cells(vtkStaticCellLinks* sself, long long ptId); extern "C" long long vtk_static_cell_links_get_ncells(vtkStaticCellLinks* sself, long long ptId); extern "C" void vtk_static_cell_links_initialize(vtkStaticCellLinks* sself); @@ -1876,7 +1718,6 @@ extern "C" void vtk_static_cell_links_reset(vtkStaticCellLinks* sself); extern "C" unsigned long vtk_static_cell_links_get_actual_memory_size(vtkStaticCellLinks* sself); extern "C" vtkStaticCellLocator * vtkStaticCellLocator_new () ; extern "C" void vtkStaticCellLocator_destructor (vtkStaticCellLocator * sself) ; -extern "C" void * vtkStaticCellLocator_get_ptr (vtkStaticCellLocator * sself) ; extern "C" void vtk_static_cell_locator_set_divisions(vtkStaticCellLocator* sself, int _arg1, int _arg2, int _arg3); extern "C" void vtk_static_cell_locator_free_search_structure(vtkStaticCellLocator* sself); extern "C" void vtk_static_cell_locator_build_locator(vtkStaticCellLocator* sself); @@ -1891,7 +1732,6 @@ extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_on(vtkStat extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_off(vtkStaticCellLocator* sself); extern "C" vtkStaticPointLocator * vtkStaticPointLocator_new () ; extern "C" void vtkStaticPointLocator_destructor (vtkStaticPointLocator * sself) ; -extern "C" void * vtkStaticPointLocator_get_ptr (vtkStaticPointLocator * sself) ; extern "C" void vtk_static_point_locator_set_number_of_points_per_bucket(vtkStaticPointLocator* sself, int _arg); extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator* sself); extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator* sself); @@ -1908,7 +1748,6 @@ extern "C" long long vtk_static_point_locator_get_max_number_of_buckets(vtkStati extern "C" bool vtk_static_point_locator_get_large_ids(vtkStaticPointLocator* sself); extern "C" vtkStaticPointLocator2D * vtkStaticPointLocator2D_new () ; extern "C" void vtkStaticPointLocator2D_destructor (vtkStaticPointLocator2D * sself) ; -extern "C" void * vtkStaticPointLocator2D_get_ptr (vtkStaticPointLocator2D * sself) ; extern "C" void vtk_static_point_locator_2_d_set_number_of_points_per_bucket(vtkStaticPointLocator2D* sself, int _arg); extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator2D* sself); extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator2D* sself); @@ -1925,10 +1764,8 @@ extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets(vtkS extern "C" bool vtk_static_point_locator_2_d_get_large_ids(vtkStaticPointLocator2D* sself); extern "C" vtkStructuredExtent * vtkStructuredExtent_new () ; extern "C" void vtkStructuredExtent_destructor (vtkStructuredExtent * sself) ; -extern "C" void * vtkStructuredExtent_get_ptr (vtkStructuredExtent * sself) ; extern "C" vtkStructuredGrid * vtkStructuredGrid_new () ; extern "C" void vtkStructuredGrid_destructor (vtkStructuredGrid * sself) ; -extern "C" void * vtkStructuredGrid_get_ptr (vtkStructuredGrid * sself) ; extern "C" int vtk_structured_grid_get_data_object_type(vtkStructuredGrid* sself); extern "C" long long vtk_structured_grid_get_number_of_points(vtkStructuredGrid* sself); extern "C" int vtk_structured_grid_get_cell_type(vtkStructuredGrid* sself, long long cellId); @@ -1946,14 +1783,11 @@ extern "C" bool vtk_structured_grid_has_any_blank_points(vtkStructuredGrid* ssel extern "C" bool vtk_structured_grid_has_any_blank_cells(vtkStructuredGrid* sself); extern "C" vtkStructuredPoints * vtkStructuredPoints_new () ; extern "C" void vtkStructuredPoints_destructor (vtkStructuredPoints * sself) ; -extern "C" void * vtkStructuredPoints_get_ptr (vtkStructuredPoints * sself) ; extern "C" int vtk_structured_points_get_data_object_type(vtkStructuredPoints* sself); extern "C" vtkStructuredPointsCollection * vtkStructuredPointsCollection_new () ; extern "C" void vtkStructuredPointsCollection_destructor (vtkStructuredPointsCollection * sself) ; -extern "C" void * vtkStructuredPointsCollection_get_ptr (vtkStructuredPointsCollection * sself) ; extern "C" vtkSuperquadric * vtkSuperquadric_new () ; extern "C" void vtkSuperquadric_destructor (vtkSuperquadric * sself) ; -extern "C" void * vtkSuperquadric_get_ptr (vtkSuperquadric * sself) ; extern "C" void vtk_superquadric_set_center(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_superquadric_set_scale(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3); extern "C" double vtk_superquadric_get_thickness(vtkSuperquadric* sself); @@ -1972,7 +1806,6 @@ extern "C" int vtk_superquadric_get_toroidal(vtkSuperquadric* sself); extern "C" void vtk_superquadric_set_toroidal(vtkSuperquadric* sself, int _arg); extern "C" vtkTable * vtkTable_new () ; extern "C" void vtkTable_destructor (vtkTable * sself) ; -extern "C" void * vtkTable_get_ptr (vtkTable * sself) ; extern "C" void vtk_table_dump(vtkTable* sself, unsigned int colWidth, int rowLimit); extern "C" int vtk_table_get_data_object_type(vtkTable* sself); extern "C" long long vtk_table_get_number_of_rows(vtkTable* sself); @@ -1987,13 +1820,11 @@ extern "C" void vtk_table_initialize(vtkTable* sself); extern "C" long long vtk_table_get_number_of_elements(vtkTable* sself, int type); extern "C" vtkTetra * vtkTetra_new () ; extern "C" void vtkTetra_destructor (vtkTetra * sself) ; -extern "C" void * vtkTetra_get_ptr (vtkTetra * sself) ; extern "C" int vtk_tetra_get_cell_type(vtkTetra* sself); extern "C" int vtk_tetra_get_number_of_edges(vtkTetra* sself); extern "C" int vtk_tetra_get_number_of_faces(vtkTetra* sself); extern "C" vtkTree * vtkTree_new () ; extern "C" void vtkTree_destructor (vtkTree * sself) ; -extern "C" void * vtkTree_get_ptr (vtkTree * sself) ; extern "C" long long vtk_tree_get_root(vtkTree* sself); extern "C" long long vtk_tree_get_number_of_children(vtkTree* sself, long long v); extern "C" long long vtk_tree_get_child(vtkTree* sself, long long v, long long i); @@ -2002,29 +1833,24 @@ extern "C" long long vtk_tree_get_level(vtkTree* sself, long long v); extern "C" bool vtk_tree_is_leaf(vtkTree* sself, long long vertex); extern "C" vtkTreeBFSIterator * vtkTreeBFSIterator_new () ; extern "C" void vtkTreeBFSIterator_destructor (vtkTreeBFSIterator * sself) ; -extern "C" void * vtkTreeBFSIterator_get_ptr (vtkTreeBFSIterator * sself) ; extern "C" vtkTreeDFSIterator * vtkTreeDFSIterator_new () ; extern "C" void vtkTreeDFSIterator_destructor (vtkTreeDFSIterator * sself) ; -extern "C" void * vtkTreeDFSIterator_get_ptr (vtkTreeDFSIterator * sself) ; extern "C" void vtk_tree_dfs_iterator_set_mode(vtkTreeDFSIterator* sself, int mode); extern "C" int vtk_tree_dfs_iterator_get_mode(vtkTreeDFSIterator* sself); extern "C" vtkTriQuadraticHexahedron * vtkTriQuadraticHexahedron_new () ; extern "C" void vtkTriQuadraticHexahedron_destructor (vtkTriQuadraticHexahedron * sself) ; -extern "C" void * vtkTriQuadraticHexahedron_get_ptr (vtkTriQuadraticHexahedron * sself) ; extern "C" int vtk_tri_quadratic_hexahedron_get_cell_type(vtkTriQuadraticHexahedron* sself); extern "C" int vtk_tri_quadratic_hexahedron_get_cell_dimension(vtkTriQuadraticHexahedron* sself); extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_edges(vtkTriQuadraticHexahedron* sself); extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_faces(vtkTriQuadraticHexahedron* sself); extern "C" vtkTriQuadraticPyramid * vtkTriQuadraticPyramid_new () ; extern "C" void vtkTriQuadraticPyramid_destructor (vtkTriQuadraticPyramid * sself) ; -extern "C" void * vtkTriQuadraticPyramid_get_ptr (vtkTriQuadraticPyramid * sself) ; extern "C" int vtk_tri_quadratic_pyramid_get_cell_type(vtkTriQuadraticPyramid* sself); extern "C" int vtk_tri_quadratic_pyramid_get_cell_dimension(vtkTriQuadraticPyramid* sself); extern "C" int vtk_tri_quadratic_pyramid_get_number_of_edges(vtkTriQuadraticPyramid* sself); extern "C" int vtk_tri_quadratic_pyramid_get_number_of_faces(vtkTriQuadraticPyramid* sself); extern "C" vtkTriangle * vtkTriangle_new () ; extern "C" void vtkTriangle_destructor (vtkTriangle * sself) ; -extern "C" void * vtkTriangle_get_ptr (vtkTriangle * sself) ; extern "C" int vtk_triangle_get_cell_type(vtkTriangle* sself); extern "C" int vtk_triangle_get_cell_dimension(vtkTriangle* sself); extern "C" int vtk_triangle_get_number_of_edges(vtkTriangle* sself); @@ -2032,18 +1858,15 @@ extern "C" int vtk_triangle_get_number_of_faces(vtkTriangle* sself); extern "C" double vtk_triangle_compute_area(vtkTriangle* sself); extern "C" vtkTriangleStrip * vtkTriangleStrip_new () ; extern "C" void vtkTriangleStrip_destructor (vtkTriangleStrip * sself) ; -extern "C" void * vtkTriangleStrip_get_ptr (vtkTriangleStrip * sself) ; extern "C" int vtk_triangle_strip_get_cell_type(vtkTriangleStrip* sself); extern "C" int vtk_triangle_strip_get_cell_dimension(vtkTriangleStrip* sself); extern "C" int vtk_triangle_strip_get_number_of_edges(vtkTriangleStrip* sself); extern "C" int vtk_triangle_strip_get_number_of_faces(vtkTriangleStrip* sself); extern "C" vtkUndirectedGraph * vtkUndirectedGraph_new () ; extern "C" void vtkUndirectedGraph_destructor (vtkUndirectedGraph * sself) ; -extern "C" void * vtkUndirectedGraph_get_ptr (vtkUndirectedGraph * sself) ; extern "C" long long vtk_undirected_graph_get_in_degree(vtkUndirectedGraph* sself, long long v); extern "C" vtkUniformGrid * vtkUniformGrid_new () ; extern "C" void vtkUniformGrid_destructor (vtkUniformGrid * sself) ; -extern "C" void * vtkUniformGrid_get_ptr (vtkUniformGrid * sself) ; extern "C" int vtk_uniform_grid_get_grid_description(vtkUniformGrid* sself); extern "C" void vtk_uniform_grid_blank_point(vtkUniformGrid* sself, long long ptId); extern "C" void vtk_uniform_grid_un_blank_point(vtkUniformGrid* sself, long long ptId); @@ -2053,7 +1876,6 @@ extern "C" unsigned char vtk_uniform_grid_is_point_visible(vtkUniformGrid* sself extern "C" unsigned char vtk_uniform_grid_is_cell_visible(vtkUniformGrid* sself, long long cellId); extern "C" vtkUniformGridAMR * vtkUniformGridAMR_new () ; extern "C" void vtkUniformGridAMR_destructor (vtkUniformGridAMR * sself) ; -extern "C" void * vtkUniformGridAMR_get_ptr (vtkUniformGridAMR * sself) ; extern "C" int vtk_uniform_grid_amr_get_data_object_type(vtkUniformGridAMR* sself); extern "C" void vtk_uniform_grid_amr_initialize(vtkUniformGridAMR* sself); extern "C" void vtk_uniform_grid_amr_set_grid_description(vtkUniformGridAMR* sself, int gridDescription); @@ -2065,7 +1887,6 @@ extern "C" int vtk_uniform_grid_amr_get_composite_index(vtkUniformGridAMR* sself extern "C" void vtk_uniform_grid_amr_get_level_and_index(vtkUniformGridAMR* sself, const unsigned int compositeIdx, unsigned int& level, unsigned int& idx); extern "C" vtkUniformGridAMRDataIterator * vtkUniformGridAMRDataIterator_new () ; extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkUniformGridAMRDataIterator * sself) ; -extern "C" void * vtkUniformGridAMRDataIterator_get_ptr (vtkUniformGridAMRDataIterator * sself) ; extern "C" int vtk_uniform_grid_amr_data_iterator_has_current_meta_data(vtkUniformGridAMRDataIterator* sself); extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_flat_index(vtkUniformGridAMRDataIterator* sself); extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_level(vtkUniformGridAMRDataIterator* sself); @@ -2075,13 +1896,11 @@ extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_next_item(vtkUniformGri extern "C" int vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(vtkUniformGridAMRDataIterator* sself); extern "C" vtkUniformHyperTreeGrid * vtkUniformHyperTreeGrid_new () ; extern "C" void vtkUniformHyperTreeGrid_destructor (vtkUniformHyperTreeGrid * sself) ; -extern "C" void * vtkUniformHyperTreeGrid_get_ptr (vtkUniformHyperTreeGrid * sself) ; extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkUniformHyperTreeGrid* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkUniformHyperTreeGrid* sself, double p0, double p1, double p2); extern "C" unsigned long vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(vtkUniformHyperTreeGrid* sself); extern "C" vtkUnstructuredGrid * vtkUnstructuredGrid_new () ; extern "C" void vtkUnstructuredGrid_destructor (vtkUnstructuredGrid * sself) ; -extern "C" void * vtkUnstructuredGrid_get_ptr (vtkUnstructuredGrid * sself) ; extern "C" int vtk_unstructured_grid_get_data_object_type(vtkUnstructuredGrid* sself); extern "C" bool vtk_unstructured_grid_allocate_estimate(vtkUnstructuredGrid* sself, long long numCells, long long maxCellSize); extern "C" bool vtk_unstructured_grid_allocate_exact(vtkUnstructuredGrid* sself, long long numCells, long long connectivitySize); @@ -2104,13 +1923,11 @@ extern "C" int vtk_unstructured_grid_initialize_faces_representation(vtkUnstruct extern "C" unsigned long vtk_unstructured_grid_get_mesh_m_time(vtkUnstructuredGrid* sself); extern "C" vtkUnstructuredGridCellIterator * vtkUnstructuredGridCellIterator_new () ; extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkUnstructuredGridCellIterator * sself) ; -extern "C" void * vtkUnstructuredGridCellIterator_get_ptr (vtkUnstructuredGridCellIterator * sself) ; extern "C" bool vtk_unstructured_grid_cell_iterator_is_done_with_traversal(vtkUnstructuredGridCellIterator* sself); extern "C" long long vtk_unstructured_grid_cell_iterator_get_cell_id(vtkUnstructuredGridCellIterator* sself); extern "C" void vtk_unstructured_grid_cell_iterator_go_to_cell(vtkUnstructuredGridCellIterator* sself, long long cellId); extern "C" vtkVertex * vtkVertex_new () ; extern "C" void vtkVertex_destructor (vtkVertex * sself) ; -extern "C" void * vtkVertex_get_ptr (vtkVertex * sself) ; extern "C" int vtk_vertex_get_cell_type(vtkVertex* sself); extern "C" int vtk_vertex_get_cell_dimension(vtkVertex* sself); extern "C" int vtk_vertex_get_number_of_edges(vtkVertex* sself); @@ -2118,25 +1935,21 @@ extern "C" int vtk_vertex_get_number_of_faces(vtkVertex* sself); extern "C" int vtk_vertex_inflate(vtkVertex* sself, double p0); extern "C" vtkVertexListIterator * vtkVertexListIterator_new () ; extern "C" void vtkVertexListIterator_destructor (vtkVertexListIterator * sself) ; -extern "C" void * vtkVertexListIterator_get_ptr (vtkVertexListIterator * sself) ; extern "C" long long vtk_vertex_list_iterator_next(vtkVertexListIterator* sself); extern "C" bool vtk_vertex_list_iterator_has_next(vtkVertexListIterator* sself); extern "C" vtkVoxel * vtkVoxel_new () ; extern "C" void vtkVoxel_destructor (vtkVoxel * sself) ; -extern "C" void * vtkVoxel_get_ptr (vtkVoxel * sself) ; extern "C" int vtk_voxel_get_cell_type(vtkVoxel* sself); extern "C" int vtk_voxel_get_number_of_edges(vtkVoxel* sself); extern "C" int vtk_voxel_get_number_of_faces(vtkVoxel* sself); extern "C" int vtk_voxel_inflate(vtkVoxel* sself, double dist); extern "C" vtkWedge * vtkWedge_new () ; extern "C" void vtkWedge_destructor (vtkWedge * sself) ; -extern "C" void * vtkWedge_get_ptr (vtkWedge * sself) ; extern "C" int vtk_wedge_get_cell_type(vtkWedge* sself); extern "C" int vtk_wedge_get_number_of_edges(vtkWedge* sself); extern "C" int vtk_wedge_get_number_of_faces(vtkWedge* sself); extern "C" vtkXMLDataElement * vtkXMLDataElement_new () ; extern "C" void vtkXMLDataElement_destructor (vtkXMLDataElement * sself) ; -extern "C" void * vtkXMLDataElement_get_ptr (vtkXMLDataElement * sself) ; extern "C" void vtk_xml_data_element_set_name(vtkXMLDataElement* sself, const char* _arg); extern "C" void vtk_xml_data_element_set_id(vtkXMLDataElement* sself, const char* _arg); extern "C" const char* vtk_xml_data_element_get_attribute(vtkXMLDataElement* sself, const char* name); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h index 5506ede..192380b 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h @@ -76,7 +76,6 @@ // Declare exported functions extern "C" vtkAlgorithm * vtkAlgorithm_new () ; extern "C" void vtkAlgorithm_destructor (vtkAlgorithm * sself) ; -extern "C" void * vtkAlgorithm_get_ptr (vtkAlgorithm * sself) ; extern "C" int vtk_algorithm_has_executive(vtkAlgorithm* sself); extern "C" int vtk_algorithm_get_number_of_input_ports(vtkAlgorithm* sself); extern "C" int vtk_algorithm_get_number_of_output_ports(vtkAlgorithm* sself); @@ -112,38 +111,28 @@ extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkAlgorithm* sself); extern "C" int vtk_algorithm_get_update_ghost_level(vtkAlgorithm* sself); extern "C" vtkAlgorithmOutput * vtkAlgorithmOutput_new () ; extern "C" void vtkAlgorithmOutput_destructor (vtkAlgorithmOutput * sself) ; -extern "C" void * vtkAlgorithmOutput_get_ptr (vtkAlgorithmOutput * sself) ; extern "C" void vtk_algorithm_output_set_index(vtkAlgorithmOutput* sself, int index); extern "C" int vtk_algorithm_output_get_index(vtkAlgorithmOutput* sself); extern "C" vtkAnnotationLayersAlgorithm * vtkAnnotationLayersAlgorithm_new () ; extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkAnnotationLayersAlgorithm * sself) ; -extern "C" void * vtkAnnotationLayersAlgorithm_get_ptr (vtkAnnotationLayersAlgorithm * sself) ; extern "C" vtkArrayDataAlgorithm * vtkArrayDataAlgorithm_new () ; extern "C" void vtkArrayDataAlgorithm_destructor (vtkArrayDataAlgorithm * sself) ; -extern "C" void * vtkArrayDataAlgorithm_get_ptr (vtkArrayDataAlgorithm * sself) ; extern "C" vtkCachedStreamingDemandDrivenPipeline * vtkCachedStreamingDemandDrivenPipeline_new () ; extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkCachedStreamingDemandDrivenPipeline * sself) ; -extern "C" void * vtkCachedStreamingDemandDrivenPipeline_get_ptr (vtkCachedStreamingDemandDrivenPipeline * sself) ; extern "C" void vtk_cached_streaming_demand_driven_pipeline_set_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself, int size); extern "C" int vtk_cached_streaming_demand_driven_pipeline_get_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself); extern "C" vtkCastToConcrete * vtkCastToConcrete_new () ; extern "C" void vtkCastToConcrete_destructor (vtkCastToConcrete * sself) ; -extern "C" void * vtkCastToConcrete_get_ptr (vtkCastToConcrete * sself) ; extern "C" vtkCompositeDataPipeline * vtkCompositeDataPipeline_new () ; extern "C" void vtkCompositeDataPipeline_destructor (vtkCompositeDataPipeline * sself) ; -extern "C" void * vtkCompositeDataPipeline_get_ptr (vtkCompositeDataPipeline * sself) ; extern "C" vtkCompositeDataSetAlgorithm * vtkCompositeDataSetAlgorithm_new () ; extern "C" void vtkCompositeDataSetAlgorithm_destructor (vtkCompositeDataSetAlgorithm * sself) ; -extern "C" void * vtkCompositeDataSetAlgorithm_get_ptr (vtkCompositeDataSetAlgorithm * sself) ; extern "C" vtkDataObjectAlgorithm * vtkDataObjectAlgorithm_new () ; extern "C" void vtkDataObjectAlgorithm_destructor (vtkDataObjectAlgorithm * sself) ; -extern "C" void * vtkDataObjectAlgorithm_get_ptr (vtkDataObjectAlgorithm * sself) ; extern "C" vtkDataSetAlgorithm * vtkDataSetAlgorithm_new () ; extern "C" void vtkDataSetAlgorithm_destructor (vtkDataSetAlgorithm * sself) ; -extern "C" void * vtkDataSetAlgorithm_get_ptr (vtkDataSetAlgorithm * sself) ; extern "C" vtkDemandDrivenPipeline * vtkDemandDrivenPipeline_new () ; extern "C" void vtkDemandDrivenPipeline_destructor (vtkDemandDrivenPipeline * sself) ; -extern "C" void * vtkDemandDrivenPipeline_get_ptr (vtkDemandDrivenPipeline * sself) ; extern "C" unsigned long vtk_demand_driven_pipeline_get_pipeline_m_time(vtkDemandDrivenPipeline* sself); extern "C" int vtk_demand_driven_pipeline_set_release_data_flag(vtkDemandDrivenPipeline* sself, int port, int n); extern "C" int vtk_demand_driven_pipeline_get_release_data_flag(vtkDemandDrivenPipeline* sself, int port); @@ -152,20 +141,16 @@ extern "C" int vtk_demand_driven_pipeline_update_data_object(vtkDemandDrivenPipe extern "C" int vtk_demand_driven_pipeline_update_data(vtkDemandDrivenPipeline* sself, int outputPort); extern "C" vtkDirectedGraphAlgorithm * vtkDirectedGraphAlgorithm_new () ; extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkDirectedGraphAlgorithm * sself) ; -extern "C" void * vtkDirectedGraphAlgorithm_get_ptr (vtkDirectedGraphAlgorithm * sself) ; extern "C" vtkEnsembleSource * vtkEnsembleSource_new () ; extern "C" void vtkEnsembleSource_destructor (vtkEnsembleSource * sself) ; -extern "C" void * vtkEnsembleSource_get_ptr (vtkEnsembleSource * sself) ; extern "C" void vtk_ensemble_source_remove_all_members(vtkEnsembleSource* sself); extern "C" unsigned int vtk_ensemble_source_get_number_of_members(vtkEnsembleSource* sself); extern "C" void vtk_ensemble_source_set_current_member(vtkEnsembleSource* sself, unsigned int _arg); extern "C" unsigned int vtk_ensemble_source_get_current_member(vtkEnsembleSource* sself); extern "C" vtkExplicitStructuredGridAlgorithm * vtkExplicitStructuredGridAlgorithm_new () ; extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkExplicitStructuredGridAlgorithm * sself) ; -extern "C" void * vtkExplicitStructuredGridAlgorithm_get_ptr (vtkExplicitStructuredGridAlgorithm * sself) ; extern "C" vtkExtentRCBPartitioner * vtkExtentRCBPartitioner_new () ; extern "C" void vtkExtentRCBPartitioner_destructor (vtkExtentRCBPartitioner * sself) ; -extern "C" void * vtkExtentRCBPartitioner_get_ptr (vtkExtentRCBPartitioner * sself) ; extern "C" void vtk_extent_rcb_partitioner_set_number_of_partitions(vtkExtentRCBPartitioner* sself, const int N); extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkExtentRCBPartitioner* sself, int imin, int imax, int jmin, int jmax, int kmin, int kmax); extern "C" void vtk_extent_rcb_partitioner_set_duplicate_nodes(vtkExtentRCBPartitioner* sself, int _arg); @@ -178,7 +163,6 @@ extern "C" int vtk_extent_rcb_partitioner_get_num_extents(vtkExtentRCBPartitione extern "C" void vtk_extent_rcb_partitioner_partition(vtkExtentRCBPartitioner* sself); extern "C" vtkExtentSplitter * vtkExtentSplitter_new () ; extern "C" void vtkExtentSplitter_destructor (vtkExtentSplitter * sself) ; -extern "C" void * vtkExtentSplitter_get_ptr (vtkExtentSplitter * sself) ; extern "C" void vtk_extent_splitter_add_extent_source(vtkExtentSplitter* sself, int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1); extern "C" void vtk_extent_splitter_remove_extent_source(vtkExtentSplitter* sself, int id); extern "C" void vtk_extent_splitter_remove_all_extent_sources(vtkExtentSplitter* sself); @@ -192,7 +176,6 @@ extern "C" void vtk_extent_splitter_point_mode_on(vtkExtentSplitter* sself); extern "C" void vtk_extent_splitter_point_mode_off(vtkExtentSplitter* sself); extern "C" vtkExtentTranslator * vtkExtentTranslator_new () ; extern "C" void vtkExtentTranslator_destructor (vtkExtentTranslator * sself) ; -extern "C" void * vtkExtentTranslator_get_ptr (vtkExtentTranslator * sself) ; extern "C" void vtk_extent_translator_set_whole_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); extern "C" void vtk_extent_translator_set_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); extern "C" void vtk_extent_translator_set_piece(vtkExtentTranslator* sself, int _arg); @@ -210,40 +193,28 @@ extern "C" void vtk_extent_translator_set_split_mode_to_z_slab(vtkExtentTranslat extern "C" int vtk_extent_translator_get_split_mode(vtkExtentTranslator* sself); extern "C" vtkGraphAlgorithm * vtkGraphAlgorithm_new () ; extern "C" void vtkGraphAlgorithm_destructor (vtkGraphAlgorithm * sself) ; -extern "C" void * vtkGraphAlgorithm_get_ptr (vtkGraphAlgorithm * sself) ; extern "C" vtkHierarchicalBoxDataSetAlgorithm * vtkHierarchicalBoxDataSetAlgorithm_new () ; extern "C" void vtkHierarchicalBoxDataSetAlgorithm_destructor (vtkHierarchicalBoxDataSetAlgorithm * sself) ; -extern "C" void * vtkHierarchicalBoxDataSetAlgorithm_get_ptr (vtkHierarchicalBoxDataSetAlgorithm * sself) ; extern "C" vtkImageToStructuredGrid * vtkImageToStructuredGrid_new () ; extern "C" void vtkImageToStructuredGrid_destructor (vtkImageToStructuredGrid * sself) ; -extern "C" void * vtkImageToStructuredGrid_get_ptr (vtkImageToStructuredGrid * sself) ; extern "C" vtkImageToStructuredPoints * vtkImageToStructuredPoints_new () ; extern "C" void vtkImageToStructuredPoints_destructor (vtkImageToStructuredPoints * sself) ; -extern "C" void * vtkImageToStructuredPoints_get_ptr (vtkImageToStructuredPoints * sself) ; extern "C" vtkMoleculeAlgorithm * vtkMoleculeAlgorithm_new () ; extern "C" void vtkMoleculeAlgorithm_destructor (vtkMoleculeAlgorithm * sself) ; -extern "C" void * vtkMoleculeAlgorithm_get_ptr (vtkMoleculeAlgorithm * sself) ; extern "C" vtkMultiBlockDataSetAlgorithm * vtkMultiBlockDataSetAlgorithm_new () ; extern "C" void vtkMultiBlockDataSetAlgorithm_destructor (vtkMultiBlockDataSetAlgorithm * sself) ; -extern "C" void * vtkMultiBlockDataSetAlgorithm_get_ptr (vtkMultiBlockDataSetAlgorithm * sself) ; extern "C" vtkMultiTimeStepAlgorithm * vtkMultiTimeStepAlgorithm_new () ; extern "C" void vtkMultiTimeStepAlgorithm_destructor (vtkMultiTimeStepAlgorithm * sself) ; -extern "C" void * vtkMultiTimeStepAlgorithm_get_ptr (vtkMultiTimeStepAlgorithm * sself) ; extern "C" vtkNonOverlappingAMRAlgorithm * vtkNonOverlappingAMRAlgorithm_new () ; extern "C" void vtkNonOverlappingAMRAlgorithm_destructor (vtkNonOverlappingAMRAlgorithm * sself) ; -extern "C" void * vtkNonOverlappingAMRAlgorithm_get_ptr (vtkNonOverlappingAMRAlgorithm * sself) ; extern "C" vtkOverlappingAMRAlgorithm * vtkOverlappingAMRAlgorithm_new () ; extern "C" void vtkOverlappingAMRAlgorithm_destructor (vtkOverlappingAMRAlgorithm * sself) ; -extern "C" void * vtkOverlappingAMRAlgorithm_get_ptr (vtkOverlappingAMRAlgorithm * sself) ; extern "C" vtkPassInputTypeAlgorithm * vtkPassInputTypeAlgorithm_new () ; extern "C" void vtkPassInputTypeAlgorithm_destructor (vtkPassInputTypeAlgorithm * sself) ; -extern "C" void * vtkPassInputTypeAlgorithm_get_ptr (vtkPassInputTypeAlgorithm * sself) ; extern "C" vtkPiecewiseFunctionAlgorithm * vtkPiecewiseFunctionAlgorithm_new () ; extern "C" void vtkPiecewiseFunctionAlgorithm_destructor (vtkPiecewiseFunctionAlgorithm * sself) ; -extern "C" void * vtkPiecewiseFunctionAlgorithm_get_ptr (vtkPiecewiseFunctionAlgorithm * sself) ; extern "C" vtkPiecewiseFunctionShiftScale * vtkPiecewiseFunctionShiftScale_new () ; extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkPiecewiseFunctionShiftScale * sself) ; -extern "C" void * vtkPiecewiseFunctionShiftScale_get_ptr (vtkPiecewiseFunctionShiftScale * sself) ; extern "C" void vtk_piecewise_function_shift_scale_set_position_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg); extern "C" void vtk_piecewise_function_shift_scale_set_position_scale(vtkPiecewiseFunctionShiftScale* sself, double _arg); extern "C" void vtk_piecewise_function_shift_scale_set_value_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg); @@ -254,31 +225,23 @@ extern "C" double vtk_piecewise_function_shift_scale_get_value_shift(vtkPiecewis extern "C" double vtk_piecewise_function_shift_scale_get_value_scale(vtkPiecewiseFunctionShiftScale* sself); extern "C" vtkPointSetAlgorithm * vtkPointSetAlgorithm_new () ; extern "C" void vtkPointSetAlgorithm_destructor (vtkPointSetAlgorithm * sself) ; -extern "C" void * vtkPointSetAlgorithm_get_ptr (vtkPointSetAlgorithm * sself) ; extern "C" vtkPolyDataAlgorithm * vtkPolyDataAlgorithm_new () ; extern "C" void vtkPolyDataAlgorithm_destructor (vtkPolyDataAlgorithm * sself) ; -extern "C" void * vtkPolyDataAlgorithm_get_ptr (vtkPolyDataAlgorithm * sself) ; extern "C" vtkProgressObserver * vtkProgressObserver_new () ; extern "C" void vtkProgressObserver_destructor (vtkProgressObserver * sself) ; -extern "C" void * vtkProgressObserver_get_ptr (vtkProgressObserver * sself) ; extern "C" void vtk_progress_observer_update_progress(vtkProgressObserver* sself, double amount); extern "C" double vtk_progress_observer_get_progress(vtkProgressObserver* sself); extern "C" vtkReaderExecutive * vtkReaderExecutive_new () ; extern "C" void vtkReaderExecutive_destructor (vtkReaderExecutive * sself) ; -extern "C" void * vtkReaderExecutive_get_ptr (vtkReaderExecutive * sself) ; extern "C" vtkRectilinearGridAlgorithm * vtkRectilinearGridAlgorithm_new () ; extern "C" void vtkRectilinearGridAlgorithm_destructor (vtkRectilinearGridAlgorithm * sself) ; -extern "C" void * vtkRectilinearGridAlgorithm_get_ptr (vtkRectilinearGridAlgorithm * sself) ; extern "C" vtkSMPProgressObserver * vtkSMPProgressObserver_new () ; extern "C" void vtkSMPProgressObserver_destructor (vtkSMPProgressObserver * sself) ; -extern "C" void * vtkSMPProgressObserver_get_ptr (vtkSMPProgressObserver * sself) ; extern "C" void vtk_smp_progress_observer_update_progress(vtkSMPProgressObserver* sself, double progress); extern "C" vtkSelectionAlgorithm * vtkSelectionAlgorithm_new () ; extern "C" void vtkSelectionAlgorithm_destructor (vtkSelectionAlgorithm * sself) ; -extern "C" void * vtkSelectionAlgorithm_get_ptr (vtkSelectionAlgorithm * sself) ; extern "C" vtkSimpleScalarTree * vtkSimpleScalarTree_new () ; extern "C" void vtkSimpleScalarTree_destructor (vtkSimpleScalarTree * sself) ; -extern "C" void * vtkSimpleScalarTree_get_ptr (vtkSimpleScalarTree * sself) ; extern "C" void vtk_simple_scalar_tree_set_branching_factor(vtkSimpleScalarTree* sself, int _arg); extern "C" int vtk_simple_scalar_tree_get_branching_factor_min_value(vtkSimpleScalarTree* sself); extern "C" int vtk_simple_scalar_tree_get_branching_factor_max_value(vtkSimpleScalarTree* sself); @@ -294,7 +257,6 @@ extern "C" void vtk_simple_scalar_tree_init_traversal(vtkSimpleScalarTree* sself extern "C" long long vtk_simple_scalar_tree_get_number_of_cell_batches(vtkSimpleScalarTree* sself, double scalarValue); extern "C" vtkSpanSpace * vtkSpanSpace_new () ; extern "C" void vtkSpanSpace_destructor (vtkSpanSpace * sself) ; -extern "C" void * vtkSpanSpace_get_ptr (vtkSpanSpace * sself) ; extern "C" void vtk_span_space_set_scalar_range(vtkSpanSpace* sself, double _arg1, double _arg2); extern "C" void vtk_span_space_set_compute_scalar_range(vtkSpanSpace* sself, int _arg); extern "C" int vtk_span_space_get_compute_scalar_range(vtkSpanSpace* sself); @@ -322,7 +284,6 @@ extern "C" long long vtk_span_space_get_batch_size_max_value(vtkSpanSpace* sself extern "C" long long vtk_span_space_get_batch_size(vtkSpanSpace* sself); extern "C" vtkSphereTree * vtkSphereTree_new () ; extern "C" void vtkSphereTree_destructor (vtkSphereTree * sself) ; -extern "C" void * vtkSphereTree_get_ptr (vtkSphereTree * sself) ; extern "C" void vtk_sphere_tree_build(vtkSphereTree* sself); extern "C" void vtk_sphere_tree_set_build_hierarchy(vtkSphereTree* sself, bool _arg); extern "C" bool vtk_sphere_tree_get_build_hierarchy(vtkSphereTree* sself); @@ -339,7 +300,6 @@ extern "C" int vtk_sphere_tree_get_max_level(vtkSphereTree* sself); extern "C" int vtk_sphere_tree_get_number_of_levels(vtkSphereTree* sself); extern "C" vtkStreamingDemandDrivenPipeline * vtkStreamingDemandDrivenPipeline_new () ; extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkStreamingDemandDrivenPipeline * sself) ; -extern "C" void * vtkStreamingDemandDrivenPipeline_get_ptr (vtkStreamingDemandDrivenPipeline * sself) ; extern "C" int vtk_streaming_demand_driven_pipeline_update(vtkStreamingDemandDrivenPipeline* sself); extern "C" int vtk_streaming_demand_driven_pipeline_update_whole_extent(vtkStreamingDemandDrivenPipeline* sself); extern "C" int vtk_streaming_demand_driven_pipeline_propagate_update_extent(vtkStreamingDemandDrivenPipeline* sself, int outputPort); @@ -349,33 +309,24 @@ extern "C" int vtk_streaming_demand_driven_pipeline_set_request_exact_extent(vtk extern "C" int vtk_streaming_demand_driven_pipeline_get_request_exact_extent(vtkStreamingDemandDrivenPipeline* sself, int port); extern "C" vtkStructuredGridAlgorithm * vtkStructuredGridAlgorithm_new () ; extern "C" void vtkStructuredGridAlgorithm_destructor (vtkStructuredGridAlgorithm * sself) ; -extern "C" void * vtkStructuredGridAlgorithm_get_ptr (vtkStructuredGridAlgorithm * sself) ; extern "C" vtkTableAlgorithm * vtkTableAlgorithm_new () ; extern "C" void vtkTableAlgorithm_destructor (vtkTableAlgorithm * sself) ; -extern "C" void * vtkTableAlgorithm_get_ptr (vtkTableAlgorithm * sself) ; extern "C" vtkThreadedCompositeDataPipeline * vtkThreadedCompositeDataPipeline_new () ; extern "C" void vtkThreadedCompositeDataPipeline_destructor (vtkThreadedCompositeDataPipeline * sself) ; -extern "C" void * vtkThreadedCompositeDataPipeline_get_ptr (vtkThreadedCompositeDataPipeline * sself) ; extern "C" vtkTreeAlgorithm * vtkTreeAlgorithm_new () ; extern "C" void vtkTreeAlgorithm_destructor (vtkTreeAlgorithm * sself) ; -extern "C" void * vtkTreeAlgorithm_get_ptr (vtkTreeAlgorithm * sself) ; extern "C" vtkTrivialConsumer * vtkTrivialConsumer_new () ; extern "C" void vtkTrivialConsumer_destructor (vtkTrivialConsumer * sself) ; -extern "C" void * vtkTrivialConsumer_get_ptr (vtkTrivialConsumer * sself) ; extern "C" vtkTrivialProducer * vtkTrivialProducer_new () ; extern "C" void vtkTrivialProducer_destructor (vtkTrivialProducer * sself) ; -extern "C" void * vtkTrivialProducer_get_ptr (vtkTrivialProducer * sself) ; extern "C" unsigned long vtk_trivial_producer_get_m_time(vtkTrivialProducer* sself); extern "C" void vtk_trivial_producer_set_whole_extent(vtkTrivialProducer* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); extern "C" vtkUndirectedGraphAlgorithm * vtkUndirectedGraphAlgorithm_new () ; extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkUndirectedGraphAlgorithm * sself) ; -extern "C" void * vtkUndirectedGraphAlgorithm_get_ptr (vtkUndirectedGraphAlgorithm * sself) ; extern "C" vtkUniformGridAMRAlgorithm * vtkUniformGridAMRAlgorithm_new () ; extern "C" void vtkUniformGridAMRAlgorithm_destructor (vtkUniformGridAMRAlgorithm * sself) ; -extern "C" void * vtkUniformGridAMRAlgorithm_get_ptr (vtkUniformGridAMRAlgorithm * sself) ; extern "C" vtkUniformGridPartitioner * vtkUniformGridPartitioner_new () ; extern "C" void vtkUniformGridPartitioner_destructor (vtkUniformGridPartitioner * sself) ; -extern "C" void * vtkUniformGridPartitioner_get_ptr (vtkUniformGridPartitioner * sself) ; extern "C" int vtk_uniform_grid_partitioner_get_number_of_partitions(vtkUniformGridPartitioner* sself); extern "C" void vtk_uniform_grid_partitioner_set_number_of_partitions(vtkUniformGridPartitioner* sself, int _arg); extern "C" int vtk_uniform_grid_partitioner_get_number_of_ghost_layers(vtkUniformGridPartitioner* sself); @@ -386,7 +337,5 @@ extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_on(vtkUniformGridPa extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_off(vtkUniformGridPartitioner* sself); extern "C" vtkUnstructuredGridAlgorithm * vtkUnstructuredGridAlgorithm_new () ; extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkUnstructuredGridAlgorithm * sself) ; -extern "C" void * vtkUnstructuredGridAlgorithm_get_ptr (vtkUnstructuredGridAlgorithm * sself) ; extern "C" vtkUnstructuredGridBaseAlgorithm * vtkUnstructuredGridBaseAlgorithm_new () ; extern "C" void vtkUnstructuredGridBaseAlgorithm_destructor (vtkUnstructuredGridBaseAlgorithm * sself) ; -extern "C" void * vtkUnstructuredGridBaseAlgorithm_get_ptr (vtkUnstructuredGridBaseAlgorithm * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h index 89d67a5..7935d72 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h @@ -22,7 +22,6 @@ // Declare exported functions extern "C" vtkAmoebaMinimizer * vtkAmoebaMinimizer_new () ; extern "C" void vtkAmoebaMinimizer_destructor (vtkAmoebaMinimizer * sself) ; -extern "C" void * vtkAmoebaMinimizer_get_ptr (vtkAmoebaMinimizer * sself) ; extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkAmoebaMinimizer* sself, const char* name, double value); extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkAmoebaMinimizer* sself, const char* name, double scale); extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkAmoebaMinimizer* sself, const char* name); @@ -53,7 +52,6 @@ extern "C" int vtk_amoeba_minimizer_get_function_evaluations(vtkAmoebaMinimizer* extern "C" void vtk_amoeba_minimizer_evaluate_function(vtkAmoebaMinimizer* sself); extern "C" vtkFFT * vtkFFT_new () ; extern "C" void vtkFFT_destructor (vtkFFT * sself) ; -extern "C" void * vtkFFT_get_ptr (vtkFFT * sself) ; extern "C" double vtk_fft_hanning_generator(vtkFFT* sself, const size_t x, const size_t size); extern "C" double vtk_fft_bartlett_generator(vtkFFT* sself, const size_t x, const size_t size); extern "C" double vtk_fft_sine_generator(vtkFFT* sself, const size_t x, const size_t size); @@ -61,7 +59,6 @@ extern "C" double vtk_fft_blackman_generator(vtkFFT* sself, const size_t x, cons extern "C" double vtk_fft_rectangular_generator(vtkFFT* sself, const size_t x, const size_t size); extern "C" vtkMatrix3x3 * vtkMatrix3x3_new () ; extern "C" void vtkMatrix3x3_destructor (vtkMatrix3x3 * sself) ; -extern "C" void * vtkMatrix3x3_get_ptr (vtkMatrix3x3 * sself) ; extern "C" void vtk_matrix_3_x_3_zero(vtkMatrix3x3* sself); extern "C" void vtk_matrix_3_x_3_identity(vtkMatrix3x3* sself); extern "C" double vtk_matrix_3_x_3_determinant(vtkMatrix3x3* sself); @@ -70,7 +67,6 @@ extern "C" double vtk_matrix_3_x_3_get_element(vtkMatrix3x3* sself, int i, int j extern "C" bool vtk_matrix_3_x_3_is_identity(vtkMatrix3x3* sself); extern "C" vtkMatrix4x4 * vtkMatrix4x4_new () ; extern "C" void vtkMatrix4x4_destructor (vtkMatrix4x4 * sself) ; -extern "C" void * vtkMatrix4x4_get_ptr (vtkMatrix4x4 * sself) ; extern "C" void vtk_matrix_4_x_4_zero(vtkMatrix4x4* sself); extern "C" void vtk_matrix_4_x_4_identity(vtkMatrix4x4* sself); extern "C" bool vtk_matrix_4_x_4_is_identity(vtkMatrix4x4* sself); @@ -79,12 +75,10 @@ extern "C" void vtk_matrix_4_x_4_set_element(vtkMatrix4x4* sself, int i, int j, extern "C" double vtk_matrix_4_x_4_get_element(vtkMatrix4x4* sself, int i, int j); extern "C" vtkPolynomialSolversUnivariate * vtkPolynomialSolversUnivariate_new () ; extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkPolynomialSolversUnivariate * sself) ; -extern "C" void * vtkPolynomialSolversUnivariate_get_ptr (vtkPolynomialSolversUnivariate * sself) ; extern "C" void vtk_polynomial_solvers_univariate_set_division_tolerance(vtkPolynomialSolversUnivariate* sself, double tol); extern "C" double vtk_polynomial_solvers_univariate_get_division_tolerance(vtkPolynomialSolversUnivariate* sself); extern "C" vtkQuaternionInterpolator * vtkQuaternionInterpolator_new () ; extern "C" void vtkQuaternionInterpolator_destructor (vtkQuaternionInterpolator * sself) ; -extern "C" void * vtkQuaternionInterpolator_get_ptr (vtkQuaternionInterpolator * sself) ; extern "C" int vtk_quaternion_interpolator_get_number_of_quaternions(vtkQuaternionInterpolator* sself); extern "C" double vtk_quaternion_interpolator_get_minimum_t(vtkQuaternionInterpolator* sself); extern "C" double vtk_quaternion_interpolator_get_maximum_t(vtkQuaternionInterpolator* sself); @@ -100,10 +94,7 @@ extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_linear(vtk extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_spline(vtkQuaternionInterpolator* sself); extern "C" vtkRungeKutta2 * vtkRungeKutta2_new () ; extern "C" void vtkRungeKutta2_destructor (vtkRungeKutta2 * sself) ; -extern "C" void * vtkRungeKutta2_get_ptr (vtkRungeKutta2 * sself) ; extern "C" vtkRungeKutta4 * vtkRungeKutta4_new () ; extern "C" void vtkRungeKutta4_destructor (vtkRungeKutta4 * sself) ; -extern "C" void * vtkRungeKutta4_get_ptr (vtkRungeKutta4 * sself) ; extern "C" vtkRungeKutta45 * vtkRungeKutta45_new () ; extern "C" void vtkRungeKutta45_destructor (vtkRungeKutta45 * sself) ; -extern "C" void * vtkRungeKutta45_get_ptr (vtkRungeKutta45 * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h index 60aec3c..558db61 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h @@ -14,7 +14,6 @@ // Declare exported functions extern "C" vtkContourValues * vtkContourValues_new () ; extern "C" void vtkContourValues_destructor (vtkContourValues * sself) ; -extern "C" void * vtkContourValues_get_ptr (vtkContourValues * sself) ; extern "C" void vtk_contour_values_set_value(vtkContourValues* sself, int i, double value); extern "C" double vtk_contour_values_get_value(vtkContourValues* sself, int i); extern "C" void vtk_contour_values_set_number_of_contours(vtkContourValues* sself, const int number); @@ -22,7 +21,6 @@ extern "C" int vtk_contour_values_get_number_of_contours(vtkContourValues* sself extern "C" void vtk_contour_values_generate_values(vtkContourValues* sself, int numContours, double rangeStart, double rangeEnd); extern "C" vtkExprTkFunctionParser * vtkExprTkFunctionParser_new () ; extern "C" void vtkExprTkFunctionParser_destructor (vtkExprTkFunctionParser * sself) ; -extern "C" void * vtkExprTkFunctionParser_get_ptr (vtkExprTkFunctionParser * sself) ; extern "C" unsigned long vtk_expr_tk_function_parser_get_m_time(vtkExprTkFunctionParser* sself); extern "C" void vtk_expr_tk_function_parser_set_function(vtkExprTkFunctionParser* sself, const char* function); extern "C" const char* vtk_expr_tk_function_parser_get_function(vtkExprTkFunctionParser* sself); @@ -50,7 +48,6 @@ extern "C" double vtk_expr_tk_function_parser_get_replacement_value(vtkExprTkFun extern "C" void vtk_expr_tk_function_parser_invalidate_function(vtkExprTkFunctionParser* sself); extern "C" vtkFunctionParser * vtkFunctionParser_new () ; extern "C" void vtkFunctionParser_destructor (vtkFunctionParser * sself) ; -extern "C" void * vtkFunctionParser_get_ptr (vtkFunctionParser * sself) ; extern "C" unsigned long vtk_function_parser_get_m_time(vtkFunctionParser* sself); extern "C" void vtk_function_parser_set_function(vtkFunctionParser* sself, const char* function); extern "C" int vtk_function_parser_is_scalar_result(vtkFunctionParser* sself); @@ -79,7 +76,6 @@ extern "C" double vtk_function_parser_get_replacement_value(vtkFunctionParser* s extern "C" void vtk_function_parser_invalidate_function(vtkFunctionParser* sself); extern "C" vtkHeap * vtkHeap_new () ; extern "C" void vtkHeap_destructor (vtkHeap * sself) ; -extern "C" void * vtkHeap_get_ptr (vtkHeap * sself) ; extern "C" void* vtk_heap_allocate_memory(vtkHeap* sself, size_t n); extern "C" void vtk_heap_set_block_size(vtkHeap* sself, size_t p0); extern "C" size_t vtk_heap_get_block_size(vtkHeap* sself); @@ -88,7 +84,6 @@ extern "C" int vtk_heap_get_number_of_allocations(vtkHeap* sself); extern "C" void vtk_heap_reset(vtkHeap* sself); extern "C" vtkResourceFileLocator * vtkResourceFileLocator_new () ; extern "C" void vtkResourceFileLocator_destructor (vtkResourceFileLocator * sself) ; -extern "C" void * vtkResourceFileLocator_get_ptr (vtkResourceFileLocator * sself) ; extern "C" void vtk_resource_file_locator_set_print_debug_information(vtkResourceFileLocator* sself, bool p0); extern "C" bool vtk_resource_file_locator_get_print_debug_information(vtkResourceFileLocator* sself); extern "C" void vtk_resource_file_locator_print_debug_information_on(vtkResourceFileLocator* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h index 511af77..60894a5 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h @@ -17,12 +17,10 @@ // Declare exported functions extern "C" vtkClientSocket * vtkClientSocket_new () ; extern "C" void vtkClientSocket_destructor (vtkClientSocket * sself) ; -extern "C" void * vtkClientSocket_get_ptr (vtkClientSocket * sself) ; extern "C" int vtk_client_socket_connect_to_server(vtkClientSocket* sself, const char* hostname, int port); extern "C" bool vtk_client_socket_get_connecting_side(vtkClientSocket* sself); extern "C" vtkDirectory * vtkDirectory_new () ; extern "C" void vtkDirectory_destructor (vtkDirectory * sself) ; -extern "C" void * vtkDirectory_get_ptr (vtkDirectory * sself) ; extern "C" int vtk_directory_open(vtkDirectory* sself, const char* dir); extern "C" long long vtk_directory_get_number_of_files(vtkDirectory* sself); extern "C" const char* vtk_directory_get_file(vtkDirectory* sself, long long index); @@ -32,7 +30,6 @@ extern "C" int vtk_directory_delete_directory(vtkDirectory* sself, const char* d extern "C" int vtk_directory_rename(vtkDirectory* sself, const char* oldname, const char* newname); extern "C" vtkExecutableRunner * vtkExecutableRunner_new () ; extern "C" void vtkExecutableRunner_destructor (vtkExecutableRunner * sself) ; -extern "C" void * vtkExecutableRunner_get_ptr (vtkExecutableRunner * sself) ; extern "C" void vtk_executable_runner_execute(vtkExecutableRunner* sself); extern "C" void vtk_executable_runner_set_timeout(vtkExecutableRunner* sself, double _arg); extern "C" double vtk_executable_runner_get_timeout(vtkExecutableRunner* sself); @@ -47,16 +44,13 @@ extern "C" const char* vtk_executable_runner_get_std_err(vtkExecutableRunner* ss extern "C" int vtk_executable_runner_get_return_value(vtkExecutableRunner* sself); extern "C" vtkServerSocket * vtkServerSocket_new () ; extern "C" void vtkServerSocket_destructor (vtkServerSocket * sself) ; -extern "C" void * vtkServerSocket_get_ptr (vtkServerSocket * sself) ; extern "C" int vtk_server_socket_create_server(vtkServerSocket* sself, int port); extern "C" int vtk_server_socket_get_server_port(vtkServerSocket* sself); extern "C" vtkSocketCollection * vtkSocketCollection_new () ; extern "C" void vtkSocketCollection_destructor (vtkSocketCollection * sself) ; -extern "C" void * vtkSocketCollection_get_ptr (vtkSocketCollection * sself) ; extern "C" int vtk_socket_collection_select_sockets(vtkSocketCollection* sself, unsigned long msec); extern "C" vtkThreadMessager * vtkThreadMessager_new () ; extern "C" void vtkThreadMessager_destructor (vtkThreadMessager * sself) ; -extern "C" void * vtkThreadMessager_get_ptr (vtkThreadMessager * sself) ; extern "C" void vtk_thread_messager_wait_for_message(vtkThreadMessager* sself); extern "C" void vtk_thread_messager_send_wake_message(vtkThreadMessager* sself); extern "C" void vtk_thread_messager_enable_wait_for_receiver(vtkThreadMessager* sself); @@ -64,7 +58,6 @@ extern "C" void vtk_thread_messager_disable_wait_for_receiver(vtkThreadMessager* extern "C" void vtk_thread_messager_wait_for_receiver(vtkThreadMessager* sself); extern "C" vtkTimerLog * vtkTimerLog_new () ; extern "C" void vtkTimerLog_destructor (vtkTimerLog * sself) ; -extern "C" void * vtkTimerLog_get_ptr (vtkTimerLog * sself) ; extern "C" void vtk_timer_log_set_logging(vtkTimerLog* sself, int v); extern "C" int vtk_timer_log_get_logging(vtkTimerLog* sself); extern "C" void vtk_timer_log_logging_on(vtkTimerLog* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h index 7868a1b..67b1786 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h @@ -26,10 +26,8 @@ // Declare exported functions extern "C" vtkCylindricalTransform * vtkCylindricalTransform_new () ; extern "C" void vtkCylindricalTransform_destructor (vtkCylindricalTransform * sself) ; -extern "C" void * vtkCylindricalTransform_get_ptr (vtkCylindricalTransform * sself) ; extern "C" vtkGeneralTransform * vtkGeneralTransform_new () ; extern "C" void vtkGeneralTransform_destructor (vtkGeneralTransform * sself) ; -extern "C" void * vtkGeneralTransform_get_ptr (vtkGeneralTransform * sself) ; extern "C" void vtk_general_transform_identity(vtkGeneralTransform* sself); extern "C" void vtk_general_transform_inverse(vtkGeneralTransform* sself); extern "C" void vtk_general_transform_translate(vtkGeneralTransform* sself, double x, double y, double z); @@ -47,11 +45,9 @@ extern "C" void vtk_general_transform_pop(vtkGeneralTransform* sself); extern "C" unsigned long vtk_general_transform_get_m_time(vtkGeneralTransform* sself); extern "C" vtkIdentityTransform * vtkIdentityTransform_new () ; extern "C" void vtkIdentityTransform_destructor (vtkIdentityTransform * sself) ; -extern "C" void * vtkIdentityTransform_get_ptr (vtkIdentityTransform * sself) ; extern "C" void vtk_identity_transform_inverse(vtkIdentityTransform* sself); extern "C" vtkLandmarkTransform * vtkLandmarkTransform_new () ; extern "C" void vtkLandmarkTransform_destructor (vtkLandmarkTransform * sself) ; -extern "C" void * vtkLandmarkTransform_get_ptr (vtkLandmarkTransform * sself) ; extern "C" void vtk_landmark_transform_set_mode(vtkLandmarkTransform* sself, int _arg); extern "C" void vtk_landmark_transform_set_mode_to_rigid_body(vtkLandmarkTransform* sself); extern "C" void vtk_landmark_transform_set_mode_to_similarity(vtkLandmarkTransform* sself); @@ -62,17 +58,14 @@ extern "C" void vtk_landmark_transform_inverse(vtkLandmarkTransform* sself); extern "C" unsigned long vtk_landmark_transform_get_m_time(vtkLandmarkTransform* sself); extern "C" vtkMatrixToHomogeneousTransform * vtkMatrixToHomogeneousTransform_new () ; extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkMatrixToHomogeneousTransform * sself) ; -extern "C" void * vtkMatrixToHomogeneousTransform_get_ptr (vtkMatrixToHomogeneousTransform * sself) ; extern "C" void vtk_matrix_to_homogeneous_transform_inverse(vtkMatrixToHomogeneousTransform* sself); extern "C" unsigned long vtk_matrix_to_homogeneous_transform_get_m_time(vtkMatrixToHomogeneousTransform* sself); extern "C" vtkMatrixToLinearTransform * vtkMatrixToLinearTransform_new () ; extern "C" void vtkMatrixToLinearTransform_destructor (vtkMatrixToLinearTransform * sself) ; -extern "C" void * vtkMatrixToLinearTransform_get_ptr (vtkMatrixToLinearTransform * sself) ; extern "C" void vtk_matrix_to_linear_transform_inverse(vtkMatrixToLinearTransform* sself); extern "C" unsigned long vtk_matrix_to_linear_transform_get_m_time(vtkMatrixToLinearTransform* sself); extern "C" vtkPerspectiveTransform * vtkPerspectiveTransform_new () ; extern "C" void vtkPerspectiveTransform_destructor (vtkPerspectiveTransform * sself) ; -extern "C" void * vtkPerspectiveTransform_get_ptr (vtkPerspectiveTransform * sself) ; extern "C" void vtk_perspective_transform_identity(vtkPerspectiveTransform* sself); extern "C" void vtk_perspective_transform_inverse(vtkPerspectiveTransform* sself); extern "C" void vtk_perspective_transform_adjust_viewport(vtkPerspectiveTransform* sself, double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax); @@ -98,10 +91,8 @@ extern "C" void vtk_perspective_transform_pop(vtkPerspectiveTransform* sself); extern "C" unsigned long vtk_perspective_transform_get_m_time(vtkPerspectiveTransform* sself); extern "C" vtkSphericalTransform * vtkSphericalTransform_new () ; extern "C" void vtkSphericalTransform_destructor (vtkSphericalTransform * sself) ; -extern "C" void * vtkSphericalTransform_get_ptr (vtkSphericalTransform * sself) ; extern "C" vtkThinPlateSplineTransform * vtkThinPlateSplineTransform_new () ; extern "C" void vtkThinPlateSplineTransform_destructor (vtkThinPlateSplineTransform * sself) ; -extern "C" void * vtkThinPlateSplineTransform_get_ptr (vtkThinPlateSplineTransform * sself) ; extern "C" double vtk_thin_plate_spline_transform_get_sigma(vtkThinPlateSplineTransform* sself); extern "C" void vtk_thin_plate_spline_transform_set_sigma(vtkThinPlateSplineTransform* sself, double _arg); extern "C" void vtk_thin_plate_spline_transform_set_basis(vtkThinPlateSplineTransform* sself, int basis); @@ -116,7 +107,6 @@ extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_on(vtk extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_off(vtkThinPlateSplineTransform* sself); extern "C" vtkTransform * vtkTransform_new () ; extern "C" void vtkTransform_destructor (vtkTransform * sself) ; -extern "C" void * vtkTransform_get_ptr (vtkTransform * sself) ; extern "C" void vtk_transform_identity(vtkTransform* sself); extern "C" void vtk_transform_inverse(vtkTransform* sself); extern "C" void vtk_transform_translate(vtkTransform* sself, double x, double y, double z); @@ -134,7 +124,6 @@ extern "C" void vtk_transform_pop(vtkTransform* sself); extern "C" unsigned long vtk_transform_get_m_time(vtkTransform* sself); extern "C" vtkTransform2D * vtkTransform2D_new () ; extern "C" void vtkTransform2D_destructor (vtkTransform2D * sself) ; -extern "C" void * vtkTransform2D_get_ptr (vtkTransform2D * sself) ; extern "C" void vtk_transform_2_d_identity(vtkTransform2D* sself); extern "C" void vtk_transform_2_d_inverse(vtkTransform2D* sself); extern "C" void vtk_transform_2_d_translate(vtkTransform2D* sself, double x, double y); @@ -143,4 +132,3 @@ extern "C" void vtk_transform_2_d_scale(vtkTransform2D* sself, double x, double extern "C" unsigned long vtk_transform_2_d_get_m_time(vtkTransform2D* sself); extern "C" vtkTransformCollection * vtkTransformCollection_new () ; extern "C" void vtkTransformCollection_destructor (vtkTransformCollection * sself) ; -extern "C" void * vtkTransformCollection_get_ptr (vtkTransformCollection * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h b/vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h index 9055216..7e04023 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h @@ -49,7 +49,6 @@ // Declare exported functions extern "C" vtkArcSource * vtkArcSource_new () ; extern "C" void vtkArcSource_destructor (vtkArcSource * sself) ; -extern "C" void * vtkArcSource_get_ptr (vtkArcSource * sself) ; extern "C" void vtk_arc_source_set_point_1(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_arc_source_set_point_2(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_arc_source_set_center(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); @@ -75,7 +74,6 @@ extern "C" void vtk_arc_source_set_output_points_precision(vtkArcSource* sself, extern "C" int vtk_arc_source_get_output_points_precision(vtkArcSource* sself); extern "C" vtkArrowSource * vtkArrowSource_new () ; extern "C" void vtkArrowSource_destructor (vtkArrowSource * sself) ; -extern "C" void * vtkArrowSource_get_ptr (vtkArrowSource * sself) ; extern "C" void vtk_arrow_source_set_tip_length(vtkArrowSource* sself, double _arg); extern "C" double vtk_arrow_source_get_tip_length_min_value(vtkArrowSource* sself); extern "C" double vtk_arrow_source_get_tip_length_max_value(vtkArrowSource* sself); @@ -104,7 +102,6 @@ extern "C" void vtk_arrow_source_set_arrow_origin_to_default(vtkArrowSource* sse extern "C" void vtk_arrow_source_set_arrow_origin_to_center(vtkArrowSource* sself); extern "C" vtkCapsuleSource * vtkCapsuleSource_new () ; extern "C" void vtkCapsuleSource_destructor (vtkCapsuleSource * sself) ; -extern "C" void * vtkCapsuleSource_get_ptr (vtkCapsuleSource * sself) ; extern "C" void vtk_capsule_source_set_radius(vtkCapsuleSource* sself, double _arg); extern "C" double vtk_capsule_source_get_radius_min_value(vtkCapsuleSource* sself); extern "C" double vtk_capsule_source_get_radius_max_value(vtkCapsuleSource* sself); @@ -130,7 +127,6 @@ extern "C" void vtk_capsule_source_set_output_points_precision(vtkCapsuleSource* extern "C" int vtk_capsule_source_get_output_points_precision(vtkCapsuleSource* sself); extern "C" vtkCellTypeSource * vtkCellTypeSource_new () ; extern "C" void vtkCellTypeSource_destructor (vtkCellTypeSource * sself) ; -extern "C" void * vtkCellTypeSource_get_ptr (vtkCellTypeSource * sself) ; extern "C" void vtk_cell_type_source_set_cell_type(vtkCellTypeSource* sself, int cellType); extern "C" int vtk_cell_type_source_get_cell_type(vtkCellTypeSource* sself); extern "C" void vtk_cell_type_source_set_cell_order(vtkCellTypeSource* sself, int _arg); @@ -150,7 +146,6 @@ extern "C" int vtk_cell_type_source_get_output_precision_max_value(vtkCellTypeSo extern "C" int vtk_cell_type_source_get_output_precision(vtkCellTypeSource* sself); extern "C" vtkConeSource * vtkConeSource_new () ; extern "C" void vtkConeSource_destructor (vtkConeSource * sself) ; -extern "C" void * vtkConeSource_get_ptr (vtkConeSource * sself) ; extern "C" void vtk_cone_source_set_height(vtkConeSource* sself, double _arg); extern "C" double vtk_cone_source_get_height_min_value(vtkConeSource* sself); extern "C" double vtk_cone_source_get_height_max_value(vtkConeSource* sself); @@ -175,7 +170,6 @@ extern "C" void vtk_cone_source_set_output_points_precision(vtkConeSource* sself extern "C" int vtk_cone_source_get_output_points_precision(vtkConeSource* sself); extern "C" vtkCubeSource * vtkCubeSource_new () ; extern "C" void vtkCubeSource_destructor (vtkCubeSource * sself) ; -extern "C" void * vtkCubeSource_get_ptr (vtkCubeSource * sself) ; extern "C" void vtk_cube_source_set_x_length(vtkCubeSource* sself, double _arg); extern "C" double vtk_cube_source_get_x_length_min_value(vtkCubeSource* sself); extern "C" double vtk_cube_source_get_x_length_max_value(vtkCubeSource* sself); @@ -194,7 +188,6 @@ extern "C" void vtk_cube_source_set_output_points_precision(vtkCubeSource* sself extern "C" int vtk_cube_source_get_output_points_precision(vtkCubeSource* sself); extern "C" vtkCylinderSource * vtkCylinderSource_new () ; extern "C" void vtkCylinderSource_destructor (vtkCylinderSource * sself) ; -extern "C" void * vtkCylinderSource_get_ptr (vtkCylinderSource * sself) ; extern "C" void vtk_cylinder_source_set_height(vtkCylinderSource* sself, double _arg); extern "C" double vtk_cylinder_source_get_height_min_value(vtkCylinderSource* sself); extern "C" double vtk_cylinder_source_get_height_max_value(vtkCylinderSource* sself); @@ -216,7 +209,6 @@ extern "C" void vtk_cylinder_source_set_output_points_precision(vtkCylinderSourc extern "C" int vtk_cylinder_source_get_output_points_precision(vtkCylinderSource* sself); extern "C" vtkDiagonalMatrixSource * vtkDiagonalMatrixSource_new () ; extern "C" void vtkDiagonalMatrixSource_destructor (vtkDiagonalMatrixSource * sself) ; -extern "C" void * vtkDiagonalMatrixSource_get_ptr (vtkDiagonalMatrixSource * sself) ; extern "C" int vtk_diagonal_matrix_source_get_array_type(vtkDiagonalMatrixSource* sself); extern "C" void vtk_diagonal_matrix_source_set_array_type(vtkDiagonalMatrixSource* sself, int _arg); extern "C" long long vtk_diagonal_matrix_source_get_extents(vtkDiagonalMatrixSource* sself); @@ -231,7 +223,6 @@ extern "C" void vtk_diagonal_matrix_source_set_row_label(vtkDiagonalMatrixSource extern "C" void vtk_diagonal_matrix_source_set_column_label(vtkDiagonalMatrixSource* sself, const char* _arg); extern "C" vtkDiskSource * vtkDiskSource_new () ; extern "C" void vtkDiskSource_destructor (vtkDiskSource * sself) ; -extern "C" void * vtkDiskSource_get_ptr (vtkDiskSource * sself) ; extern "C" void vtk_disk_source_set_inner_radius(vtkDiskSource* sself, double _arg); extern "C" double vtk_disk_source_get_inner_radius_min_value(vtkDiskSource* sself); extern "C" double vtk_disk_source_get_inner_radius_max_value(vtkDiskSource* sself); @@ -252,7 +243,6 @@ extern "C" void vtk_disk_source_set_output_points_precision(vtkDiskSource* sself extern "C" int vtk_disk_source_get_output_points_precision(vtkDiskSource* sself); extern "C" vtkEllipseArcSource * vtkEllipseArcSource_new () ; extern "C" void vtkEllipseArcSource_destructor (vtkEllipseArcSource * sself) ; -extern "C" void * vtkEllipseArcSource_get_ptr (vtkEllipseArcSource * sself) ; extern "C" void vtk_ellipse_arc_source_set_center(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_ellipse_arc_source_set_normal(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_ellipse_arc_source_set_major_radius_vector(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3); @@ -280,7 +270,6 @@ extern "C" double vtk_ellipse_arc_source_get_ratio_max_value(vtkEllipseArcSource extern "C" double vtk_ellipse_arc_source_get_ratio(vtkEllipseArcSource* sself); extern "C" vtkEllipticalButtonSource * vtkEllipticalButtonSource_new () ; extern "C" void vtkEllipticalButtonSource_destructor (vtkEllipticalButtonSource * sself) ; -extern "C" void * vtkEllipticalButtonSource_get_ptr (vtkEllipticalButtonSource * sself) ; extern "C" void vtk_elliptical_button_source_set_width(vtkEllipticalButtonSource* sself, double _arg); extern "C" double vtk_elliptical_button_source_get_width_min_value(vtkEllipticalButtonSource* sself); extern "C" double vtk_elliptical_button_source_get_width_max_value(vtkEllipticalButtonSource* sself); @@ -313,7 +302,6 @@ extern "C" void vtk_elliptical_button_source_set_output_points_precision(vtkElli extern "C" int vtk_elliptical_button_source_get_output_points_precision(vtkEllipticalButtonSource* sself); extern "C" vtkFrustumSource * vtkFrustumSource_new () ; extern "C" void vtkFrustumSource_destructor (vtkFrustumSource * sself) ; -extern "C" void * vtkFrustumSource_get_ptr (vtkFrustumSource * sself) ; extern "C" bool vtk_frustum_source_get_show_lines(vtkFrustumSource* sself); extern "C" void vtk_frustum_source_set_show_lines(vtkFrustumSource* sself, bool _arg); extern "C" void vtk_frustum_source_show_lines_on(vtkFrustumSource* sself); @@ -325,7 +313,6 @@ extern "C" void vtk_frustum_source_set_output_points_precision(vtkFrustumSource* extern "C" int vtk_frustum_source_get_output_points_precision(vtkFrustumSource* sself); extern "C" vtkGlyphSource2D * vtkGlyphSource2D_new () ; extern "C" void vtkGlyphSource2D_destructor (vtkGlyphSource2D * sself) ; -extern "C" void * vtkGlyphSource2D_get_ptr (vtkGlyphSource2D * sself) ; extern "C" void vtk_glyph_source_2_d_set_center(vtkGlyphSource2D* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_glyph_source_2_d_set_scale(vtkGlyphSource2D* sself, double _arg); extern "C" double vtk_glyph_source_2_d_get_scale_min_value(vtkGlyphSource2D* sself); @@ -375,7 +362,6 @@ extern "C" void vtk_glyph_source_2_d_set_output_points_precision(vtkGlyphSource2 extern "C" int vtk_glyph_source_2_d_get_output_points_precision(vtkGlyphSource2D* sself); extern "C" vtkGraphToPolyData * vtkGraphToPolyData_new () ; extern "C" void vtkGraphToPolyData_destructor (vtkGraphToPolyData * sself) ; -extern "C" void * vtkGraphToPolyData_get_ptr (vtkGraphToPolyData * sself) ; extern "C" void vtk_graph_to_poly_data_set_edge_glyph_output(vtkGraphToPolyData* sself, bool _arg); extern "C" bool vtk_graph_to_poly_data_get_edge_glyph_output(vtkGraphToPolyData* sself); extern "C" void vtk_graph_to_poly_data_edge_glyph_output_on(vtkGraphToPolyData* sself); @@ -384,7 +370,6 @@ extern "C" void vtk_graph_to_poly_data_set_edge_glyph_position(vtkGraphToPolyDat extern "C" double vtk_graph_to_poly_data_get_edge_glyph_position(vtkGraphToPolyData* sself); extern "C" vtkHyperTreeGridSource * vtkHyperTreeGridSource_new () ; extern "C" void vtkHyperTreeGridSource_destructor (vtkHyperTreeGridSource * sself) ; -extern "C" void * vtkHyperTreeGridSource_get_ptr (vtkHyperTreeGridSource * sself) ; extern "C" unsigned int vtk_hyper_tree_grid_source_get_maximum_level(vtkHyperTreeGridSource* sself); extern "C" void vtk_hyper_tree_grid_source_set_maximum_level(vtkHyperTreeGridSource* sself, unsigned int levels); extern "C" unsigned int vtk_hyper_tree_grid_source_get_max_depth(vtkHyperTreeGridSource* sself); @@ -417,7 +402,6 @@ extern "C" void vtk_hyper_tree_grid_source_set_mask(vtkHyperTreeGridSource* ssel extern "C" unsigned long vtk_hyper_tree_grid_source_get_m_time(vtkHyperTreeGridSource* sself); extern "C" vtkLineSource * vtkLineSource_new () ; extern "C" void vtkLineSource_destructor (vtkLineSource * sself) ; -extern "C" void * vtkLineSource_get_ptr (vtkLineSource * sself) ; extern "C" void vtk_line_source_set_point_1(vtkLineSource* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_line_source_set_point_2(vtkLineSource* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_line_source_set_use_regular_refinement(vtkLineSource* sself, bool _arg); @@ -436,21 +420,18 @@ extern "C" void vtk_line_source_set_output_points_precision(vtkLineSource* sself extern "C" int vtk_line_source_get_output_points_precision(vtkLineSource* sself); extern "C" vtkOutlineCornerFilter * vtkOutlineCornerFilter_new () ; extern "C" void vtkOutlineCornerFilter_destructor (vtkOutlineCornerFilter * sself) ; -extern "C" void * vtkOutlineCornerFilter_get_ptr (vtkOutlineCornerFilter * sself) ; extern "C" void vtk_outline_corner_filter_set_corner_factor(vtkOutlineCornerFilter* sself, double _arg); extern "C" double vtk_outline_corner_filter_get_corner_factor_min_value(vtkOutlineCornerFilter* sself); extern "C" double vtk_outline_corner_filter_get_corner_factor_max_value(vtkOutlineCornerFilter* sself); extern "C" double vtk_outline_corner_filter_get_corner_factor(vtkOutlineCornerFilter* sself); extern "C" vtkOutlineCornerSource * vtkOutlineCornerSource_new () ; extern "C" void vtkOutlineCornerSource_destructor (vtkOutlineCornerSource * sself) ; -extern "C" void * vtkOutlineCornerSource_get_ptr (vtkOutlineCornerSource * sself) ; extern "C" void vtk_outline_corner_source_set_corner_factor(vtkOutlineCornerSource* sself, double _arg); extern "C" double vtk_outline_corner_source_get_corner_factor_min_value(vtkOutlineCornerSource* sself); extern "C" double vtk_outline_corner_source_get_corner_factor_max_value(vtkOutlineCornerSource* sself); extern "C" double vtk_outline_corner_source_get_corner_factor(vtkOutlineCornerSource* sself); extern "C" vtkOutlineSource * vtkOutlineSource_new () ; extern "C" void vtkOutlineSource_destructor (vtkOutlineSource * sself) ; -extern "C" void * vtkOutlineSource_get_ptr (vtkOutlineSource * sself) ; extern "C" void vtk_outline_source_set_box_type(vtkOutlineSource* sself, int _arg); extern "C" int vtk_outline_source_get_box_type(vtkOutlineSource* sself); extern "C" void vtk_outline_source_set_box_type_to_axis_aligned(vtkOutlineSource* sself); @@ -464,7 +445,6 @@ extern "C" void vtk_outline_source_set_output_points_precision(vtkOutlineSource* extern "C" int vtk_outline_source_get_output_points_precision(vtkOutlineSource* sself); extern "C" vtkParametricFunctionSource * vtkParametricFunctionSource_new () ; extern "C" void vtkParametricFunctionSource_destructor (vtkParametricFunctionSource * sself) ; -extern "C" void * vtkParametricFunctionSource_get_ptr (vtkParametricFunctionSource * sself) ; extern "C" void vtk_parametric_function_source_set_u_resolution(vtkParametricFunctionSource* sself, int _arg); extern "C" int vtk_parametric_function_source_get_u_resolution_min_value(vtkParametricFunctionSource* sself); extern "C" int vtk_parametric_function_source_get_u_resolution_max_value(vtkParametricFunctionSource* sself); @@ -512,14 +492,12 @@ extern "C" void vtk_parametric_function_source_set_output_points_precision(vtkPa extern "C" int vtk_parametric_function_source_get_output_points_precision(vtkParametricFunctionSource* sself); extern "C" vtkPartitionedDataSetCollectionSource * vtkPartitionedDataSetCollectionSource_new () ; extern "C" void vtkPartitionedDataSetCollectionSource_destructor (vtkPartitionedDataSetCollectionSource * sself) ; -extern "C" void * vtkPartitionedDataSetCollectionSource_get_ptr (vtkPartitionedDataSetCollectionSource * sself) ; extern "C" void vtk_partitioned_data_set_collection_source_set_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself, int _arg); extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_min_value(vtkPartitionedDataSetCollectionSource* sself); extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_max_value(vtkPartitionedDataSetCollectionSource* sself); extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself); extern "C" vtkPartitionedDataSetSource * vtkPartitionedDataSetSource_new () ; extern "C" void vtkPartitionedDataSetSource_destructor (vtkPartitionedDataSetSource * sself) ; -extern "C" void * vtkPartitionedDataSetSource_get_ptr (vtkPartitionedDataSetSource * sself) ; extern "C" void vtk_partitioned_data_set_source_enable_rank(vtkPartitionedDataSetSource* sself, int rank); extern "C" void vtk_partitioned_data_set_source_enable_all_ranks(vtkPartitionedDataSetSource* sself); extern "C" void vtk_partitioned_data_set_source_disable_rank(vtkPartitionedDataSetSource* sself, int rank); @@ -531,7 +509,6 @@ extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions_max_valu extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions(vtkPartitionedDataSetSource* sself); extern "C" vtkPlaneSource * vtkPlaneSource_new () ; extern "C" void vtkPlaneSource_destructor (vtkPlaneSource * sself) ; -extern "C" void * vtkPlaneSource_get_ptr (vtkPlaneSource * sself) ; extern "C" void vtk_plane_source_set_x_resolution(vtkPlaneSource* sself, int _arg); extern "C" int vtk_plane_source_get_x_resolution(vtkPlaneSource* sself); extern "C" void vtk_plane_source_set_y_resolution(vtkPlaneSource* sself, int _arg); @@ -548,7 +525,6 @@ extern "C" void vtk_plane_source_set_output_points_precision(vtkPlaneSource* sse extern "C" int vtk_plane_source_get_output_points_precision(vtkPlaneSource* sself); extern "C" vtkPlatonicSolidSource * vtkPlatonicSolidSource_new () ; extern "C" void vtkPlatonicSolidSource_destructor (vtkPlatonicSolidSource * sself) ; -extern "C" void * vtkPlatonicSolidSource_get_ptr (vtkPlatonicSolidSource * sself) ; extern "C" void vtk_platonic_solid_source_set_solid_type(vtkPlatonicSolidSource* sself, int _arg); extern "C" int vtk_platonic_solid_source_get_solid_type_min_value(vtkPlatonicSolidSource* sself); extern "C" int vtk_platonic_solid_source_get_solid_type_max_value(vtkPlatonicSolidSource* sself); @@ -562,12 +538,10 @@ extern "C" void vtk_platonic_solid_source_set_output_points_precision(vtkPlatoni extern "C" int vtk_platonic_solid_source_get_output_points_precision(vtkPlatonicSolidSource* sself); extern "C" vtkPointHandleSource * vtkPointHandleSource_new () ; extern "C" void vtkPointHandleSource_destructor (vtkPointHandleSource * sself) ; -extern "C" void * vtkPointHandleSource_get_ptr (vtkPointHandleSource * sself) ; extern "C" void vtk_point_handle_source_set_position(vtkPointHandleSource* sself, double xPos, double yPos, double zPos); extern "C" void vtk_point_handle_source_set_direction(vtkPointHandleSource* sself, double xDir, double yDir, double zDir); extern "C" vtkPointSource * vtkPointSource_new () ; extern "C" void vtkPointSource_destructor (vtkPointSource * sself) ; -extern "C" void * vtkPointSource_get_ptr (vtkPointSource * sself) ; extern "C" void vtk_point_source_set_number_of_points(vtkPointSource* sself, long long _arg); extern "C" long long vtk_point_source_get_number_of_points_min_value(vtkPointSource* sself); extern "C" long long vtk_point_source_get_number_of_points_max_value(vtkPointSource* sself); @@ -585,14 +559,12 @@ extern "C" void vtk_point_source_set_output_points_precision(vtkPointSource* sse extern "C" int vtk_point_source_get_output_points_precision(vtkPointSource* sself); extern "C" vtkPolyLineSource * vtkPolyLineSource_new () ; extern "C" void vtkPolyLineSource_destructor (vtkPolyLineSource * sself) ; -extern "C" void * vtkPolyLineSource_get_ptr (vtkPolyLineSource * sself) ; extern "C" void vtk_poly_line_source_set_closed(vtkPolyLineSource* sself, int _arg); extern "C" int vtk_poly_line_source_get_closed(vtkPolyLineSource* sself); extern "C" void vtk_poly_line_source_closed_on(vtkPolyLineSource* sself); extern "C" void vtk_poly_line_source_closed_off(vtkPolyLineSource* sself); extern "C" vtkPolyPointSource * vtkPolyPointSource_new () ; extern "C" void vtkPolyPointSource_destructor (vtkPolyPointSource * sself) ; -extern "C" void * vtkPolyPointSource_get_ptr (vtkPolyPointSource * sself) ; extern "C" void vtk_poly_point_source_set_number_of_points(vtkPolyPointSource* sself, long long numPoints); extern "C" long long vtk_poly_point_source_get_number_of_points(vtkPolyPointSource* sself); extern "C" void vtk_poly_point_source_resize(vtkPolyPointSource* sself, long long numPoints); @@ -600,13 +572,10 @@ extern "C" void vtk_poly_point_source_set_point(vtkPolyPointSource* sself, long extern "C" unsigned long vtk_poly_point_source_get_m_time(vtkPolyPointSource* sself); extern "C" vtkProgrammableDataObjectSource * vtkProgrammableDataObjectSource_new () ; extern "C" void vtkProgrammableDataObjectSource_destructor (vtkProgrammableDataObjectSource * sself) ; -extern "C" void * vtkProgrammableDataObjectSource_get_ptr (vtkProgrammableDataObjectSource * sself) ; extern "C" vtkProgrammableSource * vtkProgrammableSource_new () ; extern "C" void vtkProgrammableSource_destructor (vtkProgrammableSource * sself) ; -extern "C" void * vtkProgrammableSource_get_ptr (vtkProgrammableSource * sself) ; extern "C" vtkRandomHyperTreeGridSource * vtkRandomHyperTreeGridSource_new () ; extern "C" void vtkRandomHyperTreeGridSource_destructor (vtkRandomHyperTreeGridSource * sself) ; -extern "C" void * vtkRandomHyperTreeGridSource_get_ptr (vtkRandomHyperTreeGridSource * sself) ; extern "C" void vtk_random_hyper_tree_grid_source_set_dimensions(vtkRandomHyperTreeGridSource* sself, unsigned int _arg1, unsigned int _arg2, unsigned int _arg3); extern "C" void vtk_random_hyper_tree_grid_source_set_output_bounds(vtkRandomHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6); extern "C" unsigned int vtk_random_hyper_tree_grid_source_get_seed(vtkRandomHyperTreeGridSource* sself); @@ -621,7 +590,6 @@ extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_min_value extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_max_value(vtkRandomHyperTreeGridSource* sself); extern "C" vtkRectangularButtonSource * vtkRectangularButtonSource_new () ; extern "C" void vtkRectangularButtonSource_destructor (vtkRectangularButtonSource * sself) ; -extern "C" void * vtkRectangularButtonSource_get_ptr (vtkRectangularButtonSource * sself) ; extern "C" void vtk_rectangular_button_source_set_width(vtkRectangularButtonSource* sself, double _arg); extern "C" double vtk_rectangular_button_source_get_width_min_value(vtkRectangularButtonSource* sself); extern "C" double vtk_rectangular_button_source_get_width_max_value(vtkRectangularButtonSource* sself); @@ -650,7 +618,6 @@ extern "C" void vtk_rectangular_button_source_set_output_points_precision(vtkRec extern "C" int vtk_rectangular_button_source_get_output_points_precision(vtkRectangularButtonSource* sself); extern "C" vtkRegularPolygonSource * vtkRegularPolygonSource_new () ; extern "C" void vtkRegularPolygonSource_destructor (vtkRegularPolygonSource * sself) ; -extern "C" void * vtkRegularPolygonSource_get_ptr (vtkRegularPolygonSource * sself) ; extern "C" void vtk_regular_polygon_source_set_number_of_sides(vtkRegularPolygonSource* sself, int _arg); extern "C" int vtk_regular_polygon_source_get_number_of_sides_min_value(vtkRegularPolygonSource* sself); extern "C" int vtk_regular_polygon_source_get_number_of_sides_max_value(vtkRegularPolygonSource* sself); @@ -671,7 +638,6 @@ extern "C" void vtk_regular_polygon_source_set_output_points_precision(vtkRegula extern "C" int vtk_regular_polygon_source_get_output_points_precision(vtkRegularPolygonSource* sself); extern "C" vtkSelectionSource * vtkSelectionSource_new () ; extern "C" void vtkSelectionSource_destructor (vtkSelectionSource * sself) ; -extern "C" void * vtkSelectionSource_get_ptr (vtkSelectionSource * sself) ; extern "C" void vtk_selection_source_add_id(vtkSelectionSource* sself, long long piece, long long id); extern "C" void vtk_selection_source_add_string_id(vtkSelectionSource* sself, long long piece, const char* id); extern "C" void vtk_selection_source_add_location(vtkSelectionSource* sself, double x, double y, double z); @@ -711,7 +677,6 @@ extern "C" void vtk_selection_source_remove_all_selectors(vtkSelectionSource* ss extern "C" void vtk_selection_source_set_query_string(vtkSelectionSource* sself, const char* _arg); extern "C" vtkSphereSource * vtkSphereSource_new () ; extern "C" void vtkSphereSource_destructor (vtkSphereSource * sself) ; -extern "C" void * vtkSphereSource_get_ptr (vtkSphereSource * sself) ; extern "C" void vtk_sphere_source_set_radius(vtkSphereSource* sself, double _arg); extern "C" double vtk_sphere_source_get_radius_min_value(vtkSphereSource* sself); extern "C" double vtk_sphere_source_get_radius_max_value(vtkSphereSource* sself); @@ -753,7 +718,6 @@ extern "C" void vtk_sphere_source_generate_normals_on(vtkSphereSource* sself); extern "C" void vtk_sphere_source_generate_normals_off(vtkSphereSource* sself); extern "C" vtkSuperquadricSource * vtkSuperquadricSource_new () ; extern "C" void vtkSuperquadricSource_destructor (vtkSuperquadricSource * sself) ; -extern "C" void * vtkSuperquadricSource_get_ptr (vtkSuperquadricSource * sself) ; extern "C" void vtk_superquadric_source_set_center(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3); extern "C" void vtk_superquadric_source_set_scale(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3); extern "C" int vtk_superquadric_source_get_theta_resolution(vtkSuperquadricSource* sself); @@ -783,7 +747,6 @@ extern "C" void vtk_superquadric_source_set_output_points_precision(vtkSuperquad extern "C" int vtk_superquadric_source_get_output_points_precision(vtkSuperquadricSource* sself); extern "C" vtkTessellatedBoxSource * vtkTessellatedBoxSource_new () ; extern "C" void vtkTessellatedBoxSource_destructor (vtkTessellatedBoxSource * sself) ; -extern "C" void * vtkTessellatedBoxSource_get_ptr (vtkTessellatedBoxSource * sself) ; extern "C" void vtk_tessellated_box_source_set_bounds(vtkTessellatedBoxSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6); extern "C" void vtk_tessellated_box_source_set_level(vtkTessellatedBoxSource* sself, int _arg); extern "C" int vtk_tessellated_box_source_get_level(vtkTessellatedBoxSource* sself); @@ -799,7 +762,6 @@ extern "C" void vtk_tessellated_box_source_set_output_points_precision(vtkTessel extern "C" int vtk_tessellated_box_source_get_output_points_precision(vtkTessellatedBoxSource* sself); extern "C" vtkTextSource * vtkTextSource_new () ; extern "C" void vtkTextSource_destructor (vtkTextSource * sself) ; -extern "C" void * vtkTextSource_get_ptr (vtkTextSource * sself) ; extern "C" void vtk_text_source_set_text(vtkTextSource* sself, const char* _arg); extern "C" void vtk_text_source_set_backing(vtkTextSource* sself, int _arg); extern "C" int vtk_text_source_get_backing(vtkTextSource* sself); @@ -811,7 +773,6 @@ extern "C" void vtk_text_source_set_output_points_precision(vtkTextSource* sself extern "C" int vtk_text_source_get_output_points_precision(vtkTextSource* sself); extern "C" vtkTexturedSphereSource * vtkTexturedSphereSource_new () ; extern "C" void vtkTexturedSphereSource_destructor (vtkTexturedSphereSource * sself) ; -extern "C" void * vtkTexturedSphereSource_get_ptr (vtkTexturedSphereSource * sself) ; extern "C" void vtk_textured_sphere_source_set_radius(vtkTexturedSphereSource* sself, double _arg); extern "C" double vtk_textured_sphere_source_get_radius_min_value(vtkTexturedSphereSource* sself); extern "C" double vtk_textured_sphere_source_get_radius_max_value(vtkTexturedSphereSource* sself); @@ -836,4 +797,3 @@ extern "C" void vtk_textured_sphere_source_set_output_points_precision(vtkTextur extern "C" int vtk_textured_sphere_source_get_output_points_precision(vtkTexturedSphereSource* sself); extern "C" vtkUniformHyperTreeGridSource * vtkUniformHyperTreeGridSource_new () ; extern "C" void vtkUniformHyperTreeGridSource_destructor (vtkUniformHyperTreeGridSource * sself) ; -extern "C" void * vtkUniformHyperTreeGridSource_get_ptr (vtkUniformHyperTreeGridSource * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp index 7b622bc..fa2697d 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp @@ -12,7 +12,6 @@ // Implement declared functions extern "C" vtkColorSeries * vtkColorSeries_new () {return vtkColorSeries :: New () ;} extern "C" void vtkColorSeries_destructor (vtkColorSeries * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkColorSeries_get_ptr (vtkColorSeries * sself) {return sself ;} extern "C" void vtk_color_series_set_color_scheme(vtkColorSeries* sself, int scheme) { sself->SetColorScheme(scheme); } extern "C" int vtk_color_series_get_number_of_color_schemes(vtkColorSeries* sself) { return sself->GetNumberOfColorSchemes(); } extern "C" int vtk_color_series_get_color_scheme(vtkColorSeries* sself) { return sself->GetColorScheme(); } @@ -22,6 +21,5 @@ extern "C" void vtk_color_series_remove_color(vtkColorSeries* sself, int index) extern "C" void vtk_color_series_clear_colors(vtkColorSeries* sself) { sself->ClearColors(); } extern "C" vtkNamedColors * vtkNamedColors_new () {return vtkNamedColors :: New () ;} extern "C" void vtkNamedColors_destructor (vtkNamedColors * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkNamedColors_get_ptr (vtkNamedColors * sself) {return sself ;} extern "C" int vtk_named_colors_get_number_of_colors(vtkNamedColors* sself) { return sself->GetNumberOfColors(); } extern "C" void vtk_named_colors_reset_colors(vtkNamedColors* sself) { sself->ResetColors(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp index c1b24bb..f4e3506 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp @@ -36,12 +36,10 @@ // Implement declared functions extern "C" vtkCardinalSpline * vtkCardinalSpline_new () {return vtkCardinalSpline :: New () ;} extern "C" void vtkCardinalSpline_destructor (vtkCardinalSpline * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCardinalSpline_get_ptr (vtkCardinalSpline * sself) {return sself ;} extern "C" void vtk_cardinal_spline_compute(vtkCardinalSpline* sself) { sself->Compute(); } extern "C" double vtk_cardinal_spline_evaluate(vtkCardinalSpline* sself, double t) { return sself->Evaluate(t); } extern "C" vtkKochanekSpline * vtkKochanekSpline_new () {return vtkKochanekSpline :: New () ;} extern "C" void vtkKochanekSpline_destructor (vtkKochanekSpline * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkKochanekSpline_get_ptr (vtkKochanekSpline * sself) {return sself ;} extern "C" void vtk_kochanek_spline_compute(vtkKochanekSpline* sself) { sself->Compute(); } extern "C" double vtk_kochanek_spline_evaluate(vtkKochanekSpline* sself, double t) { return sself->Evaluate(t); } extern "C" void vtk_kochanek_spline_set_default_bias(vtkKochanekSpline* sself, double _arg) { sself->SetDefaultBias(_arg); } @@ -52,7 +50,6 @@ extern "C" void vtk_kochanek_spline_set_default_continuity(vtkKochanekSpline* ss extern "C" double vtk_kochanek_spline_get_default_continuity(vtkKochanekSpline* sself) { return sself->GetDefaultContinuity(); } extern "C" vtkParametricBohemianDome * vtkParametricBohemianDome_new () {return vtkParametricBohemianDome :: New () ;} extern "C" void vtkParametricBohemianDome_destructor (vtkParametricBohemianDome * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricBohemianDome_get_ptr (vtkParametricBohemianDome * sself) {return sself ;} extern "C" double vtk_parametric_bohemian_dome_get_a(vtkParametricBohemianDome* sself) { return sself->GetA(); } extern "C" void vtk_parametric_bohemian_dome_set_a(vtkParametricBohemianDome* sself, double _arg) { sself->SetA(_arg); } extern "C" double vtk_parametric_bohemian_dome_get_b(vtkParametricBohemianDome* sself) { return sself->GetB(); } @@ -62,21 +59,17 @@ extern "C" void vtk_parametric_bohemian_dome_set_c(vtkParametricBohemianDome* ss extern "C" int vtk_parametric_bohemian_dome_get_dimension(vtkParametricBohemianDome* sself) { return sself->GetDimension(); } extern "C" vtkParametricBour * vtkParametricBour_new () {return vtkParametricBour :: New () ;} extern "C" void vtkParametricBour_destructor (vtkParametricBour * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricBour_get_ptr (vtkParametricBour * sself) {return sself ;} extern "C" int vtk_parametric_bour_get_dimension(vtkParametricBour* sself) { return sself->GetDimension(); } extern "C" vtkParametricBoy * vtkParametricBoy_new () {return vtkParametricBoy :: New () ;} extern "C" void vtkParametricBoy_destructor (vtkParametricBoy * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricBoy_get_ptr (vtkParametricBoy * sself) {return sself ;} extern "C" int vtk_parametric_boy_get_dimension(vtkParametricBoy* sself) { return sself->GetDimension(); } extern "C" void vtk_parametric_boy_set_z_scale(vtkParametricBoy* sself, double _arg) { sself->SetZScale(_arg); } extern "C" double vtk_parametric_boy_get_z_scale(vtkParametricBoy* sself) { return sself->GetZScale(); } extern "C" vtkParametricCatalanMinimal * vtkParametricCatalanMinimal_new () {return vtkParametricCatalanMinimal :: New () ;} extern "C" void vtkParametricCatalanMinimal_destructor (vtkParametricCatalanMinimal * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricCatalanMinimal_get_ptr (vtkParametricCatalanMinimal * sself) {return sself ;} extern "C" int vtk_parametric_catalan_minimal_get_dimension(vtkParametricCatalanMinimal* sself) { return sself->GetDimension(); } extern "C" vtkParametricConicSpiral * vtkParametricConicSpiral_new () {return vtkParametricConicSpiral :: New () ;} extern "C" void vtkParametricConicSpiral_destructor (vtkParametricConicSpiral * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricConicSpiral_get_ptr (vtkParametricConicSpiral * sself) {return sself ;} extern "C" int vtk_parametric_conic_spiral_get_dimension(vtkParametricConicSpiral* sself) { return sself->GetDimension(); } extern "C" void vtk_parametric_conic_spiral_set_a(vtkParametricConicSpiral* sself, double _arg) { sself->SetA(_arg); } extern "C" double vtk_parametric_conic_spiral_get_a(vtkParametricConicSpiral* sself) { return sself->GetA(); } @@ -88,11 +81,9 @@ extern "C" void vtk_parametric_conic_spiral_set_n(vtkParametricConicSpiral* ssel extern "C" double vtk_parametric_conic_spiral_get_n(vtkParametricConicSpiral* sself) { return sself->GetN(); } extern "C" vtkParametricCrossCap * vtkParametricCrossCap_new () {return vtkParametricCrossCap :: New () ;} extern "C" void vtkParametricCrossCap_destructor (vtkParametricCrossCap * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricCrossCap_get_ptr (vtkParametricCrossCap * sself) {return sself ;} extern "C" int vtk_parametric_cross_cap_get_dimension(vtkParametricCrossCap* sself) { return sself->GetDimension(); } extern "C" vtkParametricDini * vtkParametricDini_new () {return vtkParametricDini :: New () ;} extern "C" void vtkParametricDini_destructor (vtkParametricDini * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricDini_get_ptr (vtkParametricDini * sself) {return sself ;} extern "C" int vtk_parametric_dini_get_dimension(vtkParametricDini* sself) { return sself->GetDimension(); } extern "C" void vtk_parametric_dini_set_a(vtkParametricDini* sself, double _arg) { sself->SetA(_arg); } extern "C" double vtk_parametric_dini_get_a(vtkParametricDini* sself) { return sself->GetA(); } @@ -100,7 +91,6 @@ extern "C" void vtk_parametric_dini_set_b(vtkParametricDini* sself, double _arg) extern "C" double vtk_parametric_dini_get_b(vtkParametricDini* sself) { return sself->GetB(); } extern "C" vtkParametricEllipsoid * vtkParametricEllipsoid_new () {return vtkParametricEllipsoid :: New () ;} extern "C" void vtkParametricEllipsoid_destructor (vtkParametricEllipsoid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricEllipsoid_get_ptr (vtkParametricEllipsoid * sself) {return sself ;} extern "C" int vtk_parametric_ellipsoid_get_dimension(vtkParametricEllipsoid* sself) { return sself->GetDimension(); } extern "C" void vtk_parametric_ellipsoid_set_x_radius(vtkParametricEllipsoid* sself, double _arg) { sself->SetXRadius(_arg); } extern "C" double vtk_parametric_ellipsoid_get_x_radius(vtkParametricEllipsoid* sself) { return sself->GetXRadius(); } @@ -110,47 +100,38 @@ extern "C" void vtk_parametric_ellipsoid_set_z_radius(vtkParametricEllipsoid* ss extern "C" double vtk_parametric_ellipsoid_get_z_radius(vtkParametricEllipsoid* sself) { return sself->GetZRadius(); } extern "C" vtkParametricEnneper * vtkParametricEnneper_new () {return vtkParametricEnneper :: New () ;} extern "C" void vtkParametricEnneper_destructor (vtkParametricEnneper * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricEnneper_get_ptr (vtkParametricEnneper * sself) {return sself ;} extern "C" int vtk_parametric_enneper_get_dimension(vtkParametricEnneper* sself) { return sself->GetDimension(); } extern "C" vtkParametricFigure8Klein * vtkParametricFigure8Klein_new () {return vtkParametricFigure8Klein :: New () ;} extern "C" void vtkParametricFigure8Klein_destructor (vtkParametricFigure8Klein * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricFigure8Klein_get_ptr (vtkParametricFigure8Klein * sself) {return sself ;} extern "C" void vtk_parametric_figure_8_klein_set_radius(vtkParametricFigure8Klein* sself, double _arg) { sself->SetRadius(_arg); } extern "C" double vtk_parametric_figure_8_klein_get_radius(vtkParametricFigure8Klein* sself) { return sself->GetRadius(); } extern "C" int vtk_parametric_figure_8_klein_get_dimension(vtkParametricFigure8Klein* sself) { return sself->GetDimension(); } extern "C" vtkParametricHenneberg * vtkParametricHenneberg_new () {return vtkParametricHenneberg :: New () ;} extern "C" void vtkParametricHenneberg_destructor (vtkParametricHenneberg * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricHenneberg_get_ptr (vtkParametricHenneberg * sself) {return sself ;} extern "C" int vtk_parametric_henneberg_get_dimension(vtkParametricHenneberg* sself) { return sself->GetDimension(); } extern "C" vtkParametricKlein * vtkParametricKlein_new () {return vtkParametricKlein :: New () ;} extern "C" void vtkParametricKlein_destructor (vtkParametricKlein * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricKlein_get_ptr (vtkParametricKlein * sself) {return sself ;} extern "C" int vtk_parametric_klein_get_dimension(vtkParametricKlein* sself) { return sself->GetDimension(); } extern "C" vtkParametricKuen * vtkParametricKuen_new () {return vtkParametricKuen :: New () ;} extern "C" void vtkParametricKuen_destructor (vtkParametricKuen * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricKuen_get_ptr (vtkParametricKuen * sself) {return sself ;} extern "C" int vtk_parametric_kuen_get_dimension(vtkParametricKuen* sself) { return sself->GetDimension(); } extern "C" void vtk_parametric_kuen_set_delta_v_0(vtkParametricKuen* sself, double _arg) { sself->SetDeltaV0(_arg); } extern "C" double vtk_parametric_kuen_get_delta_v_0(vtkParametricKuen* sself) { return sself->GetDeltaV0(); } extern "C" vtkParametricMobius * vtkParametricMobius_new () {return vtkParametricMobius :: New () ;} extern "C" void vtkParametricMobius_destructor (vtkParametricMobius * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricMobius_get_ptr (vtkParametricMobius * sself) {return sself ;} extern "C" void vtk_parametric_mobius_set_radius(vtkParametricMobius* sself, double _arg) { sself->SetRadius(_arg); } extern "C" double vtk_parametric_mobius_get_radius(vtkParametricMobius* sself) { return sself->GetRadius(); } extern "C" int vtk_parametric_mobius_get_dimension(vtkParametricMobius* sself) { return sself->GetDimension(); } extern "C" vtkParametricPluckerConoid * vtkParametricPluckerConoid_new () {return vtkParametricPluckerConoid :: New () ;} extern "C" void vtkParametricPluckerConoid_destructor (vtkParametricPluckerConoid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricPluckerConoid_get_ptr (vtkParametricPluckerConoid * sself) {return sself ;} extern "C" int vtk_parametric_plucker_conoid_get_n(vtkParametricPluckerConoid* sself) { return sself->GetN(); } extern "C" void vtk_parametric_plucker_conoid_set_n(vtkParametricPluckerConoid* sself, int _arg) { sself->SetN(_arg); } extern "C" int vtk_parametric_plucker_conoid_get_dimension(vtkParametricPluckerConoid* sself) { return sself->GetDimension(); } extern "C" vtkParametricPseudosphere * vtkParametricPseudosphere_new () {return vtkParametricPseudosphere :: New () ;} extern "C" void vtkParametricPseudosphere_destructor (vtkParametricPseudosphere * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricPseudosphere_get_ptr (vtkParametricPseudosphere * sself) {return sself ;} extern "C" int vtk_parametric_pseudosphere_get_dimension(vtkParametricPseudosphere* sself) { return sself->GetDimension(); } extern "C" vtkParametricRandomHills * vtkParametricRandomHills_new () {return vtkParametricRandomHills :: New () ;} extern "C" void vtkParametricRandomHills_destructor (vtkParametricRandomHills * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricRandomHills_get_ptr (vtkParametricRandomHills * sself) {return sself ;} extern "C" int vtk_parametric_random_hills_get_dimension(vtkParametricRandomHills* sself) { return sself->GetDimension(); } extern "C" void vtk_parametric_random_hills_set_number_of_hills(vtkParametricRandomHills* sself, int _arg) { sself->SetNumberOfHills(_arg); } extern "C" int vtk_parametric_random_hills_get_number_of_hills(vtkParametricRandomHills* sself) { return sself->GetNumberOfHills(); } @@ -176,13 +157,11 @@ extern "C" void vtk_parametric_random_hills_set_amplitude_scale_factor(vtkParame extern "C" double vtk_parametric_random_hills_get_amplitude_scale_factor(vtkParametricRandomHills* sself) { return sself->GetAmplitudeScaleFactor(); } extern "C" vtkParametricRoman * vtkParametricRoman_new () {return vtkParametricRoman :: New () ;} extern "C" void vtkParametricRoman_destructor (vtkParametricRoman * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricRoman_get_ptr (vtkParametricRoman * sself) {return sself ;} extern "C" int vtk_parametric_roman_get_dimension(vtkParametricRoman* sself) { return sself->GetDimension(); } extern "C" void vtk_parametric_roman_set_radius(vtkParametricRoman* sself, double _arg) { sself->SetRadius(_arg); } extern "C" double vtk_parametric_roman_get_radius(vtkParametricRoman* sself) { return sself->GetRadius(); } extern "C" vtkParametricSpline * vtkParametricSpline_new () {return vtkParametricSpline :: New () ;} extern "C" void vtkParametricSpline_destructor (vtkParametricSpline * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricSpline_get_ptr (vtkParametricSpline * sself) {return sself ;} extern "C" int vtk_parametric_spline_get_dimension(vtkParametricSpline* sself) { return sself->GetDimension(); } extern "C" void vtk_parametric_spline_set_number_of_points(vtkParametricSpline* sself, long long numPts) { sself->SetNumberOfPoints(numPts); } extern "C" void vtk_parametric_spline_set_point(vtkParametricSpline* sself, long long index, double x, double y, double z) { sself->SetPoint(index, x, y, z); } @@ -208,7 +187,6 @@ extern "C" void vtk_parametric_spline_set_right_value(vtkParametricSpline* sself extern "C" double vtk_parametric_spline_get_right_value(vtkParametricSpline* sself) { return sself->GetRightValue(); } extern "C" vtkParametricSuperEllipsoid * vtkParametricSuperEllipsoid_new () {return vtkParametricSuperEllipsoid :: New () ;} extern "C" void vtkParametricSuperEllipsoid_destructor (vtkParametricSuperEllipsoid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricSuperEllipsoid_get_ptr (vtkParametricSuperEllipsoid * sself) {return sself ;} extern "C" int vtk_parametric_super_ellipsoid_get_dimension(vtkParametricSuperEllipsoid* sself) { return sself->GetDimension(); } extern "C" void vtk_parametric_super_ellipsoid_set_x_radius(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetXRadius(_arg); } extern "C" double vtk_parametric_super_ellipsoid_get_x_radius(vtkParametricSuperEllipsoid* sself) { return sself->GetXRadius(); } @@ -222,7 +200,6 @@ extern "C" void vtk_parametric_super_ellipsoid_set_n_2(vtkParametricSuperEllipso extern "C" double vtk_parametric_super_ellipsoid_get_n_2(vtkParametricSuperEllipsoid* sself) { return sself->GetN2(); } extern "C" vtkParametricSuperToroid * vtkParametricSuperToroid_new () {return vtkParametricSuperToroid :: New () ;} extern "C" void vtkParametricSuperToroid_destructor (vtkParametricSuperToroid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricSuperToroid_get_ptr (vtkParametricSuperToroid * sself) {return sself ;} extern "C" int vtk_parametric_super_toroid_get_dimension(vtkParametricSuperToroid* sself) { return sself->GetDimension(); } extern "C" void vtk_parametric_super_toroid_set_ring_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetRingRadius(_arg); } extern "C" double vtk_parametric_super_toroid_get_ring_radius(vtkParametricSuperToroid* sself) { return sself->GetRingRadius(); } @@ -240,7 +217,6 @@ extern "C" void vtk_parametric_super_toroid_set_n_2(vtkParametricSuperToroid* ss extern "C" double vtk_parametric_super_toroid_get_n_2(vtkParametricSuperToroid* sself) { return sself->GetN2(); } extern "C" vtkParametricTorus * vtkParametricTorus_new () {return vtkParametricTorus :: New () ;} extern "C" void vtkParametricTorus_destructor (vtkParametricTorus * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricTorus_get_ptr (vtkParametricTorus * sself) {return sself ;} extern "C" void vtk_parametric_torus_set_ring_radius(vtkParametricTorus* sself, double _arg) { sself->SetRingRadius(_arg); } extern "C" double vtk_parametric_torus_get_ring_radius(vtkParametricTorus* sself) { return sself->GetRingRadius(); } extern "C" void vtk_parametric_torus_set_cross_section_radius(vtkParametricTorus* sself, double _arg) { sself->SetCrossSectionRadius(_arg); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp index ed9a5de..6d165ec 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp @@ -167,7 +167,6 @@ // Implement declared functions extern "C" vtkAnimationCue * vtkAnimationCue_new () {return vtkAnimationCue :: New () ;} extern "C" void vtkAnimationCue_destructor (vtkAnimationCue * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAnimationCue_get_ptr (vtkAnimationCue * sself) {return sself ;} extern "C" void vtk_animation_cue_set_time_mode(vtkAnimationCue* sself, int mode) { sself->SetTimeMode(mode); } extern "C" int vtk_animation_cue_get_time_mode(vtkAnimationCue* sself) { return sself->GetTimeMode(); } extern "C" void vtk_animation_cue_set_time_mode_to_relative(vtkAnimationCue* sself) { sself->SetTimeModeToRelative(); } @@ -184,7 +183,6 @@ extern "C" double vtk_animation_cue_get_delta_time(vtkAnimationCue* sself) { ret extern "C" double vtk_animation_cue_get_clock_time(vtkAnimationCue* sself) { return sself->GetClockTime(); } extern "C" vtkArchiver * vtkArchiver_new () {return vtkArchiver :: New () ;} extern "C" void vtkArchiver_destructor (vtkArchiver * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkArchiver_get_ptr (vtkArchiver * sself) {return sself ;} extern "C" void vtk_archiver_set_archive_name(vtkArchiver* sself, const char* _arg) { sself->SetArchiveName(_arg); } extern "C" void vtk_archiver_open_archive(vtkArchiver* sself) { sself->OpenArchive(); } extern "C" void vtk_archiver_close_archive(vtkArchiver* sself) { sself->CloseArchive(); } @@ -192,7 +190,6 @@ extern "C" void vtk_archiver_insert_into_archive(vtkArchiver* sself, const char* extern "C" bool vtk_archiver_contains(vtkArchiver* sself, const char*& relativePath) { return sself->Contains(relativePath); } extern "C" vtkBitArray * vtkBitArray_new () {return vtkBitArray :: New () ;} extern "C" void vtkBitArray_destructor (vtkBitArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBitArray_get_ptr (vtkBitArray * sself) {return sself ;} extern "C" int vtk_bit_array_allocate(vtkBitArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } extern "C" void vtk_bit_array_initialize(vtkBitArray* sself) { sself->Initialize(); } extern "C" int vtk_bit_array_get_data_type(vtkBitArray* sself) { return sself->GetDataType(); } @@ -215,7 +212,6 @@ extern "C" void vtk_bit_array_data_changed(vtkBitArray* sself) { sself->DataChan extern "C" void vtk_bit_array_clear_lookup(vtkBitArray* sself) { sself->ClearLookup(); } extern "C" vtkBitArrayIterator * vtkBitArrayIterator_new () {return vtkBitArrayIterator :: New () ;} extern "C" void vtkBitArrayIterator_destructor (vtkBitArrayIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBitArrayIterator_get_ptr (vtkBitArrayIterator * sself) {return sself ;} extern "C" int vtk_bit_array_iterator_get_value(vtkBitArrayIterator* sself, long long id) { return sself->GetValue(id); } extern "C" long long vtk_bit_array_iterator_get_number_of_tuples(vtkBitArrayIterator* sself) { return sself->GetNumberOfTuples(); } extern "C" long long vtk_bit_array_iterator_get_number_of_values(vtkBitArrayIterator* sself) { return sself->GetNumberOfValues(); } @@ -225,13 +221,11 @@ extern "C" int vtk_bit_array_iterator_get_data_type_size(vtkBitArrayIterator* ss extern "C" void vtk_bit_array_iterator_set_value(vtkBitArrayIterator* sself, long long id, int value) { sself->SetValue(id, value); } extern "C" vtkBoxMuellerRandomSequence * vtkBoxMuellerRandomSequence_new () {return vtkBoxMuellerRandomSequence :: New () ;} extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkBoxMuellerRandomSequence * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBoxMuellerRandomSequence_get_ptr (vtkBoxMuellerRandomSequence * sself) {return sself ;} extern "C" void vtk_box_mueller_random_sequence_initialize(vtkBoxMuellerRandomSequence* sself, unsigned int seed) { sself->Initialize(seed); } extern "C" double vtk_box_mueller_random_sequence_get_value(vtkBoxMuellerRandomSequence* sself) { return sself->GetValue(); } extern "C" void vtk_box_mueller_random_sequence_next(vtkBoxMuellerRandomSequence* sself) { sself->Next(); } extern "C" vtkByteSwap * vtkByteSwap_new () {return vtkByteSwap :: New () ;} extern "C" void vtkByteSwap_destructor (vtkByteSwap * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkByteSwap_get_ptr (vtkByteSwap * sself) {return sself ;} extern "C" void vtk_byte_swap_swap_2_le(vtkByteSwap* sself, void* p) { sself->Swap2LE(p); } extern "C" void vtk_byte_swap_swap_4_le(vtkByteSwap* sself, void* p) { sself->Swap4LE(p); } extern "C" void vtk_byte_swap_swap_8_le(vtkByteSwap* sself, void* p) { sself->Swap8LE(p); } @@ -247,7 +241,6 @@ extern "C" void vtk_byte_swap_swap_8_be_range(vtkByteSwap* sself, void* p, size_ extern "C" void vtk_byte_swap_swap_void_range(vtkByteSwap* sself, void* buffer, size_t numWords, size_t wordSize) { sself->SwapVoidRange(buffer, numWords, wordSize); } extern "C" vtkCallbackCommand * vtkCallbackCommand_new () {return vtkCallbackCommand :: New () ;} extern "C" void vtkCallbackCommand_destructor (vtkCallbackCommand * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCallbackCommand_get_ptr (vtkCallbackCommand * sself) {return sself ;} extern "C" void vtk_callback_command_set_client_data(vtkCallbackCommand* sself, void* cd) { sself->SetClientData(cd); } extern "C" void* vtk_callback_command_get_client_data(vtkCallbackCommand* sself) { return sself->GetClientData(); } extern "C" void vtk_callback_command_set_abort_flag_on_execute(vtkCallbackCommand* sself, int f) { sself->SetAbortFlagOnExecute(f); } @@ -256,7 +249,6 @@ extern "C" void vtk_callback_command_abort_flag_on_execute_on(vtkCallbackCommand extern "C" void vtk_callback_command_abort_flag_on_execute_off(vtkCallbackCommand* sself) { sself->AbortFlagOnExecuteOff(); } extern "C" vtkCharArray * vtkCharArray_new () {return vtkCharArray :: New () ;} extern "C" void vtkCharArray_destructor (vtkCharArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCharArray_get_ptr (vtkCharArray * sself) {return sself ;} extern "C" int vtk_char_array_get_data_type(vtkCharArray* sself) { return sself->GetDataType(); } extern "C" void vtk_char_array_set_typed_tuple(vtkCharArray* sself, long long i, const char* tuple) { sself->SetTypedTuple(i, tuple); } extern "C" void vtk_char_array_insert_typed_tuple(vtkCharArray* sself, long long i, const char* tuple) { sself->InsertTypedTuple(i, tuple); } @@ -270,33 +262,27 @@ extern "C" char vtk_char_array_get_data_type_value_min(vtkCharArray* sself) { re extern "C" char vtk_char_array_get_data_type_value_max(vtkCharArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkCollection * vtkCollection_new () {return vtkCollection :: New () ;} extern "C" void vtkCollection_destructor (vtkCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCollection_get_ptr (vtkCollection * sself) {return sself ;} extern "C" void vtk_collection_remove_item(vtkCollection* sself, int i) { sself->RemoveItem(i); } extern "C" void vtk_collection_remove_all_items(vtkCollection* sself) { sself->RemoveAllItems(); } extern "C" int vtk_collection_get_number_of_items(vtkCollection* sself) { return sself->GetNumberOfItems(); } extern "C" void vtk_collection_init_traversal(vtkCollection* sself) { sself->InitTraversal(); } extern "C" vtkCollectionIterator * vtkCollectionIterator_new () {return vtkCollectionIterator :: New () ;} extern "C" void vtkCollectionIterator_destructor (vtkCollectionIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCollectionIterator_get_ptr (vtkCollectionIterator * sself) {return sself ;} extern "C" void vtk_collection_iterator_init_traversal(vtkCollectionIterator* sself) { sself->InitTraversal(); } extern "C" void vtk_collection_iterator_go_to_first_item(vtkCollectionIterator* sself) { sself->GoToFirstItem(); } extern "C" void vtk_collection_iterator_go_to_next_item(vtkCollectionIterator* sself) { sself->GoToNextItem(); } extern "C" int vtk_collection_iterator_is_done_with_traversal(vtkCollectionIterator* sself) { return sself->IsDoneWithTraversal(); } extern "C" vtkCriticalSection * vtkCriticalSection_new () {return vtkCriticalSection :: New () ;} extern "C" void vtkCriticalSection_destructor (vtkCriticalSection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCriticalSection_get_ptr (vtkCriticalSection * sself) {return sself ;} extern "C" void vtk_critical_section_lock(vtkCriticalSection* sself) { sself->Lock(); } extern "C" void vtk_critical_section_unlock(vtkCriticalSection* sself) { sself->Unlock(); } extern "C" vtkDataArrayCollection * vtkDataArrayCollection_new () {return vtkDataArrayCollection :: New () ;} extern "C" void vtkDataArrayCollection_destructor (vtkDataArrayCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataArrayCollection_get_ptr (vtkDataArrayCollection * sself) {return sself ;} extern "C" int vtk_data_array_collection_get_number_of_items(vtkDataArrayCollection* sself) { return sself->GetNumberOfItems(); } extern "C" vtkDataArrayCollectionIterator * vtkDataArrayCollectionIterator_new () {return vtkDataArrayCollectionIterator :: New () ;} extern "C" void vtkDataArrayCollectionIterator_destructor (vtkDataArrayCollectionIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataArrayCollectionIterator_get_ptr (vtkDataArrayCollectionIterator * sself) {return sself ;} extern "C" vtkDataArraySelection * vtkDataArraySelection_new () {return vtkDataArraySelection :: New () ;} extern "C" void vtkDataArraySelection_destructor (vtkDataArraySelection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataArraySelection_get_ptr (vtkDataArraySelection * sself) {return sself ;} extern "C" void vtk_data_array_selection_enable_array(vtkDataArraySelection* sself, const char* name) { sself->EnableArray(name); } extern "C" void vtk_data_array_selection_disable_array(vtkDataArraySelection* sself, const char* name) { sself->DisableArray(name); } extern "C" int vtk_data_array_selection_array_is_enabled(vtkDataArraySelection* sself, const char* name) { return sself->ArrayIsEnabled(name); } @@ -318,13 +304,11 @@ extern "C" void vtk_data_array_selection_set_unknown_array_setting(vtkDataArrayS extern "C" int vtk_data_array_selection_get_unknown_array_setting(vtkDataArraySelection* sself) { return sself->GetUnknownArraySetting(); } extern "C" vtkDebugLeaks * vtkDebugLeaks_new () {return vtkDebugLeaks :: New () ;} extern "C" void vtkDebugLeaks_destructor (vtkDebugLeaks * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDebugLeaks_get_ptr (vtkDebugLeaks * sself) {return sself ;} extern "C" int vtk_debug_leaks_print_current_leaks(vtkDebugLeaks* sself) { return sself->PrintCurrentLeaks(); } extern "C" int vtk_debug_leaks_get_exit_error(vtkDebugLeaks* sself) { return sself->GetExitError(); } extern "C" void vtk_debug_leaks_set_exit_error(vtkDebugLeaks* sself, int p0) { sself->SetExitError(p0); } extern "C" vtkDoubleArray * vtkDoubleArray_new () {return vtkDoubleArray :: New () ;} extern "C" void vtkDoubleArray_destructor (vtkDoubleArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDoubleArray_get_ptr (vtkDoubleArray * sself) {return sself ;} extern "C" int vtk_double_array_get_data_type(vtkDoubleArray* sself) { return sself->GetDataType(); } extern "C" double vtk_double_array_get_value(vtkDoubleArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_double_array_set_value(vtkDoubleArray* sself, long long id, double value) { sself->SetValue(id, value); } @@ -335,24 +319,19 @@ extern "C" double vtk_double_array_get_data_type_value_min(vtkDoubleArray* sself extern "C" double vtk_double_array_get_data_type_value_max(vtkDoubleArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkDynamicLoader * vtkDynamicLoader_new () {return vtkDynamicLoader :: New () ;} extern "C" void vtkDynamicLoader_destructor (vtkDynamicLoader * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDynamicLoader_get_ptr (vtkDynamicLoader * sself) {return sself ;} extern "C" const char* vtk_dynamic_loader_lib_prefix(vtkDynamicLoader* sself) { return sself->LibPrefix(); } extern "C" const char* vtk_dynamic_loader_lib_extension(vtkDynamicLoader* sself) { return sself->LibExtension(); } extern "C" const char* vtk_dynamic_loader_last_error(vtkDynamicLoader* sself) { return sself->LastError(); } extern "C" vtkEventDataDevice3D * vtkEventDataDevice3D_new () {return vtkEventDataDevice3D :: New () ;} extern "C" void vtkEventDataDevice3D_destructor (vtkEventDataDevice3D * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkEventDataDevice3D_get_ptr (vtkEventDataDevice3D * sself) {return sself ;} extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkEventDataDevice3D* sself, double x, double y) { sself->SetTrackPadPosition(x, y); } extern "C" vtkEventDataForDevice * vtkEventDataForDevice_new () {return vtkEventDataForDevice :: New () ;} extern "C" void vtkEventDataForDevice_destructor (vtkEventDataForDevice * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkEventDataForDevice_get_ptr (vtkEventDataForDevice * sself) {return sself ;} extern "C" vtkEventForwarderCommand * vtkEventForwarderCommand_new () {return vtkEventForwarderCommand :: New () ;} extern "C" void vtkEventForwarderCommand_destructor (vtkEventForwarderCommand * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkEventForwarderCommand_get_ptr (vtkEventForwarderCommand * sself) {return sself ;} extern "C" void* vtk_event_forwarder_command_get_target(vtkEventForwarderCommand* sself) { return sself->GetTarget(); } extern "C" vtkFileOutputWindow * vtkFileOutputWindow_new () {return vtkFileOutputWindow :: New () ;} extern "C" void vtkFileOutputWindow_destructor (vtkFileOutputWindow * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkFileOutputWindow_get_ptr (vtkFileOutputWindow * sself) {return sself ;} extern "C" void vtk_file_output_window_display_text(vtkFileOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } extern "C" void vtk_file_output_window_set_file_name(vtkFileOutputWindow* sself, const char* _arg) { sself->SetFileName(_arg); } extern "C" void vtk_file_output_window_set_flush(vtkFileOutputWindow* sself, int _arg) { sself->SetFlush(_arg); } @@ -365,7 +344,6 @@ extern "C" void vtk_file_output_window_append_on(vtkFileOutputWindow* sself) { s extern "C" void vtk_file_output_window_append_off(vtkFileOutputWindow* sself) { sself->AppendOff(); } extern "C" vtkFloatArray * vtkFloatArray_new () {return vtkFloatArray :: New () ;} extern "C" void vtkFloatArray_destructor (vtkFloatArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkFloatArray_get_ptr (vtkFloatArray * sself) {return sself ;} extern "C" int vtk_float_array_get_data_type(vtkFloatArray* sself) { return sself->GetDataType(); } extern "C" float vtk_float_array_get_value(vtkFloatArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_float_array_set_value(vtkFloatArray* sself, long long id, float value) { sself->SetValue(id, value); } @@ -376,7 +354,6 @@ extern "C" float vtk_float_array_get_data_type_value_min(vtkFloatArray* sself) { extern "C" float vtk_float_array_get_data_type_value_max(vtkFloatArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkGarbageCollector * vtkGarbageCollector_new () {return vtkGarbageCollector :: New () ;} extern "C" void vtkGarbageCollector_destructor (vtkGarbageCollector * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGarbageCollector_get_ptr (vtkGarbageCollector * sself) {return sself ;} extern "C" void vtk_garbage_collector_collect(vtkGarbageCollector* sself) { sself->Collect(); } extern "C" void vtk_garbage_collector_deferred_collection_push(vtkGarbageCollector* sself) { sself->DeferredCollectionPush(); } extern "C" void vtk_garbage_collector_deferred_collection_pop(vtkGarbageCollector* sself) { sself->DeferredCollectionPop(); } @@ -384,7 +361,6 @@ extern "C" void vtk_garbage_collector_set_global_debug_flag(vtkGarbageCollector* extern "C" bool vtk_garbage_collector_get_global_debug_flag(vtkGarbageCollector* sself) { return sself->GetGlobalDebugFlag(); } extern "C" vtkIdList * vtkIdList_new () {return vtkIdList :: New () ;} extern "C" void vtkIdList_destructor (vtkIdList * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkIdList_get_ptr (vtkIdList * sself) {return sself ;} extern "C" void vtk_id_list_initialize(vtkIdList* sself) { sself->Initialize(); } extern "C" int vtk_id_list_allocate(vtkIdList* sself, const long long sz, const int strategy) { return sself->Allocate(sz, strategy); } extern "C" long long vtk_id_list_get_number_of_ids(vtkIdList* sself) { return sself->GetNumberOfIds(); } @@ -403,11 +379,9 @@ extern "C" void vtk_id_list_delete_id(vtkIdList* sself, long long vtkid) { sself extern "C" long long vtk_id_list_is_id(vtkIdList* sself, long long vtkid) { return sself->IsId(vtkid); } extern "C" vtkIdListCollection * vtkIdListCollection_new () {return vtkIdListCollection :: New () ;} extern "C" void vtkIdListCollection_destructor (vtkIdListCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkIdListCollection_get_ptr (vtkIdListCollection * sself) {return sself ;} extern "C" int vtk_id_list_collection_get_number_of_items(vtkIdListCollection* sself) { return sself->GetNumberOfItems(); } extern "C" vtkIdTypeArray * vtkIdTypeArray_new () {return vtkIdTypeArray :: New () ;} extern "C" void vtkIdTypeArray_destructor (vtkIdTypeArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkIdTypeArray_get_ptr (vtkIdTypeArray * sself) {return sself ;} extern "C" int vtk_id_type_array_get_data_type(vtkIdTypeArray* sself) { return sself->GetDataType(); } extern "C" long long vtk_id_type_array_get_value(vtkIdTypeArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_id_type_array_set_value(vtkIdTypeArray* sself, long long id, long long value) { sself->SetValue(id, value); } @@ -418,28 +392,23 @@ extern "C" long long vtk_id_type_array_get_data_type_value_min(vtkIdTypeArray* s extern "C" long long vtk_id_type_array_get_data_type_value_max(vtkIdTypeArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkInformation * vtkInformation_new () {return vtkInformation :: New () ;} extern "C" void vtkInformation_destructor (vtkInformation * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkInformation_get_ptr (vtkInformation * sself) {return sself ;} extern "C" void vtk_information_modified(vtkInformation* sself) { sself->Modified(); } extern "C" void vtk_information_clear(vtkInformation* sself) { sself->Clear(); } extern "C" int vtk_information_get_number_of_keys(vtkInformation* sself) { return sself->GetNumberOfKeys(); } extern "C" vtkInformationIterator * vtkInformationIterator_new () {return vtkInformationIterator :: New () ;} extern "C" void vtkInformationIterator_destructor (vtkInformationIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkInformationIterator_get_ptr (vtkInformationIterator * sself) {return sself ;} extern "C" void vtk_information_iterator_init_traversal(vtkInformationIterator* sself) { sself->InitTraversal(); } extern "C" void vtk_information_iterator_go_to_first_item(vtkInformationIterator* sself) { sself->GoToFirstItem(); } extern "C" void vtk_information_iterator_go_to_next_item(vtkInformationIterator* sself) { sself->GoToNextItem(); } extern "C" int vtk_information_iterator_is_done_with_traversal(vtkInformationIterator* sself) { return sself->IsDoneWithTraversal(); } extern "C" vtkInformationKeyLookup * vtkInformationKeyLookup_new () {return vtkInformationKeyLookup :: New () ;} extern "C" void vtkInformationKeyLookup_destructor (vtkInformationKeyLookup * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkInformationKeyLookup_get_ptr (vtkInformationKeyLookup * sself) {return sself ;} extern "C" vtkInformationVector * vtkInformationVector_new () {return vtkInformationVector :: New () ;} extern "C" void vtkInformationVector_destructor (vtkInformationVector * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkInformationVector_get_ptr (vtkInformationVector * sself) {return sself ;} extern "C" int vtk_information_vector_get_number_of_information_objects(vtkInformationVector* sself) { return sself->GetNumberOfInformationObjects(); } extern "C" void vtk_information_vector_set_number_of_information_objects(vtkInformationVector* sself, int n) { sself->SetNumberOfInformationObjects(n); } extern "C" vtkIntArray * vtkIntArray_new () {return vtkIntArray :: New () ;} extern "C" void vtkIntArray_destructor (vtkIntArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkIntArray_get_ptr (vtkIntArray * sself) {return sself ;} extern "C" int vtk_int_array_get_data_type(vtkIntArray* sself) { return sself->GetDataType(); } extern "C" int vtk_int_array_get_value(vtkIntArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_int_array_set_value(vtkIntArray* sself, long long id, int value) { sself->SetValue(id, value); } @@ -450,7 +419,6 @@ extern "C" int vtk_int_array_get_data_type_value_min(vtkIntArray* sself) { retur extern "C" int vtk_int_array_get_data_type_value_max(vtkIntArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkLongArray * vtkLongArray_new () {return vtkLongArray :: New () ;} extern "C" void vtkLongArray_destructor (vtkLongArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLongArray_get_ptr (vtkLongArray * sself) {return sself ;} extern "C" int vtk_long_array_get_data_type(vtkLongArray* sself) { return sself->GetDataType(); } extern "C" long vtk_long_array_get_value(vtkLongArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_long_array_set_value(vtkLongArray* sself, long long id, long value) { sself->SetValue(id, value); } @@ -461,7 +429,6 @@ extern "C" long vtk_long_array_get_data_type_value_min(vtkLongArray* sself) { re extern "C" long vtk_long_array_get_data_type_value_max(vtkLongArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkLongLongArray * vtkLongLongArray_new () {return vtkLongLongArray :: New () ;} extern "C" void vtkLongLongArray_destructor (vtkLongLongArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLongLongArray_get_ptr (vtkLongLongArray * sself) {return sself ;} extern "C" int vtk_long_long_array_get_data_type(vtkLongLongArray* sself) { return sself->GetDataType(); } extern "C" long long vtk_long_long_array_get_value(vtkLongLongArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_long_long_array_set_value(vtkLongLongArray* sself, long long id, long long value) { sself->SetValue(id, value); } @@ -472,7 +439,6 @@ extern "C" long long vtk_long_long_array_get_data_type_value_min(vtkLongLongArra extern "C" long long vtk_long_long_array_get_data_type_value_max(vtkLongLongArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkLookupTable * vtkLookupTable_new () {return vtkLookupTable :: New () ;} extern "C" void vtkLookupTable_destructor (vtkLookupTable * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLookupTable_get_ptr (vtkLookupTable * sself) {return sself ;} extern "C" int vtk_lookup_table_is_opaque(vtkLookupTable* sself) { return sself->IsOpaque(); } extern "C" int vtk_lookup_table_allocate(vtkLookupTable* sself, int sz, int ext) { return sself->Allocate(sz, ext); } extern "C" void vtk_lookup_table_build(vtkLookupTable* sself) { sself->Build(); } @@ -515,7 +481,6 @@ extern "C" long long vtk_lookup_table_get_number_of_colors(vtkLookupTable* sself extern "C" int vtk_lookup_table_using_log_scale(vtkLookupTable* sself) { return sself->UsingLogScale(); } extern "C" vtkMath * vtkMath_new () {return vtkMath :: New () ;} extern "C" void vtkMath_destructor (vtkMath * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMath_get_ptr (vtkMath * sself) {return sself ;} extern "C" double vtk_math_pi(vtkMath* sself) { return sself->Pi(); } extern "C" float vtk_math_radians_from_degrees(vtkMath* sself, float degrees) { return sself->RadiansFromDegrees(degrees); } extern "C" float vtk_math_degrees_from_radians(vtkMath* sself, float radians) { return sself->DegreesFromRadians(radians); } @@ -545,7 +510,6 @@ extern "C" int vtk_math_is_nan(vtkMath* sself, double x) { return sself->IsNan(x extern "C" bool vtk_math_is_finite(vtkMath* sself, double x) { return sself->IsFinite(x); } extern "C" vtkMersenneTwister * vtkMersenneTwister_new () {return vtkMersenneTwister :: New () ;} extern "C" void vtkMersenneTwister_destructor (vtkMersenneTwister * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMersenneTwister_get_ptr (vtkMersenneTwister * sself) {return sself ;} extern "C" void vtk_mersenne_twister_initialize(vtkMersenneTwister* sself, unsigned int seed) { sself->Initialize(seed); } extern "C" unsigned int vtk_mersenne_twister_initialize_new_sequence(vtkMersenneTwister* sself, unsigned int seed, int p) { return sself->InitializeNewSequence(seed, p); } extern "C" void vtk_mersenne_twister_initialize_sequence(vtkMersenneTwister* sself, unsigned int id, unsigned int seed, int p) { sself->InitializeSequence(id, seed, p); } @@ -553,7 +517,6 @@ extern "C" double vtk_mersenne_twister_get_value(vtkMersenneTwister* sself, unsi extern "C" void vtk_mersenne_twister_next(vtkMersenneTwister* sself, unsigned int id) { sself->Next(id); } extern "C" vtkMinimalStandardRandomSequence * vtkMinimalStandardRandomSequence_new () {return vtkMinimalStandardRandomSequence :: New () ;} extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkMinimalStandardRandomSequence * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMinimalStandardRandomSequence_get_ptr (vtkMinimalStandardRandomSequence * sself) {return sself ;} extern "C" void vtk_minimal_standard_random_sequence_initialize(vtkMinimalStandardRandomSequence* sself, unsigned int seed) { sself->Initialize(seed); } extern "C" void vtk_minimal_standard_random_sequence_set_seed(vtkMinimalStandardRandomSequence* sself, int value) { sself->SetSeed(value); } extern "C" void vtk_minimal_standard_random_sequence_set_seed_only(vtkMinimalStandardRandomSequence* sself, int value) { sself->SetSeedOnly(value); } @@ -564,7 +527,6 @@ extern "C" double vtk_minimal_standard_random_sequence_get_range_value(vtkMinima extern "C" double vtk_minimal_standard_random_sequence_get_next_range_value(vtkMinimalStandardRandomSequence* sself, double rangeMin, double rangeMax) { return sself->GetNextRangeValue(rangeMin, rangeMax); } extern "C" vtkMultiThreader * vtkMultiThreader_new () {return vtkMultiThreader :: New () ;} extern "C" void vtkMultiThreader_destructor (vtkMultiThreader * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMultiThreader_get_ptr (vtkMultiThreader * sself) {return sself ;} extern "C" void vtk_multi_threader_set_number_of_threads(vtkMultiThreader* sself, int _arg) { sself->SetNumberOfThreads(_arg); } extern "C" int vtk_multi_threader_get_number_of_threads_min_value(vtkMultiThreader* sself) { return sself->GetNumberOfThreadsMinValue(); } extern "C" int vtk_multi_threader_get_number_of_threads_max_value(vtkMultiThreader* sself) { return sself->GetNumberOfThreadsMaxValue(); } @@ -580,7 +542,6 @@ extern "C" void vtk_multi_threader_terminate_thread(vtkMultiThreader* sself, int extern "C" int vtk_multi_threader_is_thread_active(vtkMultiThreader* sself, int threadId) { return sself->IsThreadActive(threadId); } extern "C" vtkObject * vtkObject_new () {return vtkObject :: New () ;} extern "C" void vtkObject_destructor (vtkObject * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkObject_get_ptr (vtkObject * sself) {return sself ;} extern "C" int vtk_object_is_type_of(vtkObject* sself, const char* type) { return sself->IsTypeOf(type); } extern "C" int vtk_object_is_a(vtkObject* sself, const char* type) { return sself->IsA(type); } extern "C" long long vtk_object_get_number_of_generations_from_base_type(vtkObject* sself, const char* type) { return sself->GetNumberOfGenerationsFromBaseType(type); } @@ -600,14 +561,11 @@ extern "C" void vtk_object_remove_all_observers(vtkObject* sself) { sself->Remov extern "C" int vtk_object_invoke_event(vtkObject* sself, unsigned long event, void* callData) { return sself->InvokeEvent(event, callData); } extern "C" vtkObjectFactoryCollection * vtkObjectFactoryCollection_new () {return vtkObjectFactoryCollection :: New () ;} extern "C" void vtkObjectFactoryCollection_destructor (vtkObjectFactoryCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkObjectFactoryCollection_get_ptr (vtkObjectFactoryCollection * sself) {return sself ;} extern "C" vtkOldStyleCallbackCommand * vtkOldStyleCallbackCommand_new () {return vtkOldStyleCallbackCommand :: New () ;} extern "C" void vtkOldStyleCallbackCommand_destructor (vtkOldStyleCallbackCommand * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOldStyleCallbackCommand_get_ptr (vtkOldStyleCallbackCommand * sself) {return sself ;} extern "C" void vtk_old_style_callback_command_set_client_data(vtkOldStyleCallbackCommand* sself, void* cd) { sself->SetClientData(cd); } extern "C" vtkOutputWindow * vtkOutputWindow_new () {return vtkOutputWindow :: New () ;} extern "C" void vtkOutputWindow_destructor (vtkOutputWindow * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOutputWindow_get_ptr (vtkOutputWindow * sself) {return sself ;} extern "C" void vtk_output_window_display_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } extern "C" void vtk_output_window_display_error_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayErrorText(p0); } extern "C" void vtk_output_window_display_warning_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayWarningText(p0); } @@ -630,10 +588,8 @@ extern "C" void vtk_output_window_set_display_mode_to_always(vtkOutputWindow* ss extern "C" void vtk_output_window_set_display_mode_to_always_std_err(vtkOutputWindow* sself) { sself->SetDisplayModeToAlwaysStdErr(); } extern "C" vtkOverrideInformationCollection * vtkOverrideInformationCollection_new () {return vtkOverrideInformationCollection :: New () ;} extern "C" void vtkOverrideInformationCollection_destructor (vtkOverrideInformationCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOverrideInformationCollection_get_ptr (vtkOverrideInformationCollection * sself) {return sself ;} extern "C" vtkPoints * vtkPoints_new () {return vtkPoints :: New () ;} extern "C" void vtkPoints_destructor (vtkPoints * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPoints_get_ptr (vtkPoints * sself) {return sself ;} extern "C" int vtk_points_allocate(vtkPoints* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } extern "C" void vtk_points_initialize(vtkPoints* sself) { sself->Initialize(); } extern "C" int vtk_points_get_data_type(vtkPoints* sself) { return sself->GetDataType(); } @@ -664,7 +620,6 @@ extern "C" unsigned long vtk_points_get_m_time(vtkPoints* sself) { return sself- extern "C" void vtk_points_modified(vtkPoints* sself) { sself->Modified(); } extern "C" vtkPoints2D * vtkPoints2D_new () {return vtkPoints2D :: New () ;} extern "C" void vtkPoints2D_destructor (vtkPoints2D * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPoints2D_get_ptr (vtkPoints2D * sself) {return sself ;} extern "C" int vtk_points_2_d_allocate(vtkPoints2D* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } extern "C" void vtk_points_2_d_initialize(vtkPoints2D* sself) { sself->Initialize(); } extern "C" int vtk_points_2_d_get_data_type(vtkPoints2D* sself) { return sself->GetDataType(); } @@ -694,7 +649,6 @@ extern "C" int vtk_points_2_d_resize(vtkPoints2D* sself, long long numPoints) { extern "C" void vtk_points_2_d_compute_bounds(vtkPoints2D* sself) { sself->ComputeBounds(); } extern "C" vtkPriorityQueue * vtkPriorityQueue_new () {return vtkPriorityQueue :: New () ;} extern "C" void vtkPriorityQueue_destructor (vtkPriorityQueue * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPriorityQueue_get_ptr (vtkPriorityQueue * sself) {return sself ;} extern "C" void vtk_priority_queue_allocate(vtkPriorityQueue* sself, long long sz, long long ext) { sself->Allocate(sz, ext); } extern "C" void vtk_priority_queue_insert(vtkPriorityQueue* sself, double priority, long long id) { sself->Insert(priority, id); } extern "C" long long vtk_priority_queue_pop(vtkPriorityQueue* sself, long long location, double& priority) { return sself->Pop(location, priority); } @@ -705,7 +659,6 @@ extern "C" long long vtk_priority_queue_get_number_of_items(vtkPriorityQueue* ss extern "C" void vtk_priority_queue_reset(vtkPriorityQueue* sself) { sself->Reset(); } extern "C" vtkRandomPool * vtkRandomPool_new () {return vtkRandomPool :: New () ;} extern "C" void vtkRandomPool_destructor (vtkRandomPool * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkRandomPool_get_ptr (vtkRandomPool * sself) {return sself ;} extern "C" void vtk_random_pool_set_size(vtkRandomPool* sself, long long _arg) { sself->SetSize(_arg); } extern "C" long long vtk_random_pool_get_size_min_value(vtkRandomPool* sself) { return sself->GetSizeMinValue(); } extern "C" long long vtk_random_pool_get_size_max_value(vtkRandomPool* sself) { return sself->GetSizeMaxValue(); } @@ -722,10 +675,8 @@ extern "C" long long vtk_random_pool_get_chunk_size_max_value(vtkRandomPool* sse extern "C" long long vtk_random_pool_get_chunk_size(vtkRandomPool* sself) { return sself->GetChunkSize(); } extern "C" vtkReferenceCount * vtkReferenceCount_new () {return vtkReferenceCount :: New () ;} extern "C" void vtkReferenceCount_destructor (vtkReferenceCount * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkReferenceCount_get_ptr (vtkReferenceCount * sself) {return sself ;} extern "C" vtkScalarsToColors * vtkScalarsToColors_new () {return vtkScalarsToColors :: New () ;} extern "C" void vtkScalarsToColors_destructor (vtkScalarsToColors * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkScalarsToColors_get_ptr (vtkScalarsToColors * sself) {return sself ;} extern "C" int vtk_scalars_to_colors_is_opaque(vtkScalarsToColors* sself) { return sself->IsOpaque(); } extern "C" void vtk_scalars_to_colors_build(vtkScalarsToColors* sself) { sself->Build(); } extern "C" void vtk_scalars_to_colors_set_range(vtkScalarsToColors* sself, double min, double max) { sself->SetRange(min, max); } @@ -752,7 +703,6 @@ extern "C" void vtk_scalars_to_colors_indexed_lookup_on(vtkScalarsToColors* ssel extern "C" void vtk_scalars_to_colors_indexed_lookup_off(vtkScalarsToColors* sself) { sself->IndexedLookupOff(); } extern "C" vtkShortArray * vtkShortArray_new () {return vtkShortArray :: New () ;} extern "C" void vtkShortArray_destructor (vtkShortArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkShortArray_get_ptr (vtkShortArray * sself) {return sself ;} extern "C" int vtk_short_array_get_data_type(vtkShortArray* sself) { return sself->GetDataType(); } extern "C" short vtk_short_array_get_value(vtkShortArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_short_array_set_value(vtkShortArray* sself, long long id, short value) { sself->SetValue(id, value); } @@ -763,7 +713,6 @@ extern "C" short vtk_short_array_get_data_type_value_min(vtkShortArray* sself) { extern "C" short vtk_short_array_get_data_type_value_max(vtkShortArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkSignedCharArray * vtkSignedCharArray_new () {return vtkSignedCharArray :: New () ;} extern "C" void vtkSignedCharArray_destructor (vtkSignedCharArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSignedCharArray_get_ptr (vtkSignedCharArray * sself) {return sself ;} extern "C" int vtk_signed_char_array_get_data_type(vtkSignedCharArray* sself) { return sself->GetDataType(); } extern "C" signed char vtk_signed_char_array_get_value(vtkSignedCharArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_signed_char_array_set_value(vtkSignedCharArray* sself, long long id, signed char value) { sself->SetValue(id, value); } @@ -774,10 +723,8 @@ extern "C" signed char vtk_signed_char_array_get_data_type_value_min(vtkSignedCh extern "C" signed char vtk_signed_char_array_get_data_type_value_max(vtkSignedCharArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkSortDataArray * vtkSortDataArray_new () {return vtkSortDataArray :: New () ;} extern "C" void vtkSortDataArray_destructor (vtkSortDataArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSortDataArray_get_ptr (vtkSortDataArray * sself) {return sself ;} extern "C" vtkStringArray * vtkStringArray_new () {return vtkStringArray :: New () ;} extern "C" void vtkStringArray_destructor (vtkStringArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStringArray_get_ptr (vtkStringArray * sself) {return sself ;} extern "C" int vtk_string_array_get_data_type(vtkStringArray* sself) { return sself->GetDataType(); } extern "C" int vtk_string_array_is_numeric(vtkStringArray* sself) { return sself->IsNumeric(); } extern "C" void vtk_string_array_initialize(vtkStringArray* sself) { sself->Initialize(); } @@ -798,11 +745,9 @@ extern "C" void vtk_string_array_data_element_changed(vtkStringArray* sself, lon extern "C" void vtk_string_array_clear_lookup(vtkStringArray* sself) { sself->ClearLookup(); } extern "C" vtkStringOutputWindow * vtkStringOutputWindow_new () {return vtkStringOutputWindow :: New () ;} extern "C" void vtkStringOutputWindow_destructor (vtkStringOutputWindow * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStringOutputWindow_get_ptr (vtkStringOutputWindow * sself) {return sself ;} extern "C" void vtk_string_output_window_display_text(vtkStringOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } extern "C" vtkTimePointUtility * vtkTimePointUtility_new () {return vtkTimePointUtility :: New () ;} extern "C" void vtkTimePointUtility_destructor (vtkTimePointUtility * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTimePointUtility_get_ptr (vtkTimePointUtility * sself) {return sself ;} extern "C" unsigned long long vtk_time_point_utility_date_to_time_point(vtkTimePointUtility* sself, int year, int month, int day) { return sself->DateToTimePoint(year, month, day); } extern "C" unsigned long long vtk_time_point_utility_time_to_time_point(vtkTimePointUtility* sself, int hour, int minute, int second, int millis) { return sself->TimeToTimePoint(hour, minute, second, millis); } extern "C" unsigned long long vtk_time_point_utility_date_time_to_time_point(vtkTimePointUtility* sself, int year, int month, int day, int hour, int minute, int sec, int millis) { return sself->DateTimeToTimePoint(year, month, day, hour, minute, sec, millis); } @@ -819,37 +764,26 @@ extern "C" int vtk_time_point_utility_get_millisecond(vtkTimePointUtility* sself extern "C" const char* vtk_time_point_utility_time_point_to_iso_8601(vtkTimePointUtility* sself, unsigned long long p0, int format) { return sself->TimePointToISO8601(p0, format); } extern "C" vtkTypeFloat32Array * vtkTypeFloat32Array_new () {return vtkTypeFloat32Array :: New () ;} extern "C" void vtkTypeFloat32Array_destructor (vtkTypeFloat32Array * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTypeFloat32Array_get_ptr (vtkTypeFloat32Array * sself) {return sself ;} extern "C" vtkTypeFloat64Array * vtkTypeFloat64Array_new () {return vtkTypeFloat64Array :: New () ;} extern "C" void vtkTypeFloat64Array_destructor (vtkTypeFloat64Array * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTypeFloat64Array_get_ptr (vtkTypeFloat64Array * sself) {return sself ;} extern "C" vtkTypeInt16Array * vtkTypeInt16Array_new () {return vtkTypeInt16Array :: New () ;} extern "C" void vtkTypeInt16Array_destructor (vtkTypeInt16Array * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTypeInt16Array_get_ptr (vtkTypeInt16Array * sself) {return sself ;} extern "C" vtkTypeInt32Array * vtkTypeInt32Array_new () {return vtkTypeInt32Array :: New () ;} extern "C" void vtkTypeInt32Array_destructor (vtkTypeInt32Array * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTypeInt32Array_get_ptr (vtkTypeInt32Array * sself) {return sself ;} extern "C" vtkTypeInt64Array * vtkTypeInt64Array_new () {return vtkTypeInt64Array :: New () ;} extern "C" void vtkTypeInt64Array_destructor (vtkTypeInt64Array * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTypeInt64Array_get_ptr (vtkTypeInt64Array * sself) {return sself ;} extern "C" vtkTypeInt8Array * vtkTypeInt8Array_new () {return vtkTypeInt8Array :: New () ;} extern "C" void vtkTypeInt8Array_destructor (vtkTypeInt8Array * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTypeInt8Array_get_ptr (vtkTypeInt8Array * sself) {return sself ;} extern "C" vtkTypeUInt16Array * vtkTypeUInt16Array_new () {return vtkTypeUInt16Array :: New () ;} extern "C" void vtkTypeUInt16Array_destructor (vtkTypeUInt16Array * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTypeUInt16Array_get_ptr (vtkTypeUInt16Array * sself) {return sself ;} extern "C" vtkTypeUInt32Array * vtkTypeUInt32Array_new () {return vtkTypeUInt32Array :: New () ;} extern "C" void vtkTypeUInt32Array_destructor (vtkTypeUInt32Array * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTypeUInt32Array_get_ptr (vtkTypeUInt32Array * sself) {return sself ;} extern "C" vtkTypeUInt64Array * vtkTypeUInt64Array_new () {return vtkTypeUInt64Array :: New () ;} extern "C" void vtkTypeUInt64Array_destructor (vtkTypeUInt64Array * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTypeUInt64Array_get_ptr (vtkTypeUInt64Array * sself) {return sself ;} extern "C" vtkTypeUInt8Array * vtkTypeUInt8Array_new () {return vtkTypeUInt8Array :: New () ;} extern "C" void vtkTypeUInt8Array_destructor (vtkTypeUInt8Array * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTypeUInt8Array_get_ptr (vtkTypeUInt8Array * sself) {return sself ;} extern "C" vtkUnicodeStringArray * vtkUnicodeStringArray_new () {return vtkUnicodeStringArray :: New () ;} extern "C" void vtkUnicodeStringArray_destructor (vtkUnicodeStringArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUnicodeStringArray_get_ptr (vtkUnicodeStringArray * sself) {return sself ;} extern "C" int vtk_unicode_string_array_allocate(vtkUnicodeStringArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } extern "C" void vtk_unicode_string_array_initialize(vtkUnicodeStringArray* sself) { sself->Initialize(); } extern "C" int vtk_unicode_string_array_get_data_type(vtkUnicodeStringArray* sself) { return sself->GetDataType(); } @@ -869,7 +803,6 @@ extern "C" void vtk_unicode_string_array_set_utf_8_value(vtkUnicodeStringArray* extern "C" const char* vtk_unicode_string_array_get_utf_8_value(vtkUnicodeStringArray* sself, long long i) { return sself->GetUTF8Value(i); } extern "C" vtkUnsignedCharArray * vtkUnsignedCharArray_new () {return vtkUnsignedCharArray :: New () ;} extern "C" void vtkUnsignedCharArray_destructor (vtkUnsignedCharArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUnsignedCharArray_get_ptr (vtkUnsignedCharArray * sself) {return sself ;} extern "C" int vtk_unsigned_char_array_get_data_type(vtkUnsignedCharArray* sself) { return sself->GetDataType(); } extern "C" unsigned char vtk_unsigned_char_array_get_value(vtkUnsignedCharArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_unsigned_char_array_set_value(vtkUnsignedCharArray* sself, long long id, unsigned char value) { sself->SetValue(id, value); } @@ -880,7 +813,6 @@ extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_min(vtkUnsi extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_max(vtkUnsignedCharArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkUnsignedIntArray * vtkUnsignedIntArray_new () {return vtkUnsignedIntArray :: New () ;} extern "C" void vtkUnsignedIntArray_destructor (vtkUnsignedIntArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUnsignedIntArray_get_ptr (vtkUnsignedIntArray * sself) {return sself ;} extern "C" int vtk_unsigned_int_array_get_data_type(vtkUnsignedIntArray* sself) { return sself->GetDataType(); } extern "C" unsigned int vtk_unsigned_int_array_get_value(vtkUnsignedIntArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_unsigned_int_array_set_value(vtkUnsignedIntArray* sself, long long id, unsigned int value) { sself->SetValue(id, value); } @@ -891,7 +823,6 @@ extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_min(vtkUnsign extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_max(vtkUnsignedIntArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkUnsignedLongArray * vtkUnsignedLongArray_new () {return vtkUnsignedLongArray :: New () ;} extern "C" void vtkUnsignedLongArray_destructor (vtkUnsignedLongArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUnsignedLongArray_get_ptr (vtkUnsignedLongArray * sself) {return sself ;} extern "C" int vtk_unsigned_long_array_get_data_type(vtkUnsignedLongArray* sself) { return sself->GetDataType(); } extern "C" unsigned long vtk_unsigned_long_array_get_value(vtkUnsignedLongArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_unsigned_long_array_set_value(vtkUnsignedLongArray* sself, long long id, unsigned long value) { sself->SetValue(id, value); } @@ -902,7 +833,6 @@ extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_min(vtkUnsi extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_max(vtkUnsignedLongArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkUnsignedLongLongArray * vtkUnsignedLongLongArray_new () {return vtkUnsignedLongLongArray :: New () ;} extern "C" void vtkUnsignedLongLongArray_destructor (vtkUnsignedLongLongArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUnsignedLongLongArray_get_ptr (vtkUnsignedLongLongArray * sself) {return sself ;} extern "C" int vtk_unsigned_long_long_array_get_data_type(vtkUnsignedLongLongArray* sself) { return sself->GetDataType(); } extern "C" unsigned long long vtk_unsigned_long_long_array_get_value(vtkUnsignedLongLongArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_unsigned_long_long_array_set_value(vtkUnsignedLongLongArray* sself, long long id, unsigned long long value) { sself->SetValue(id, value); } @@ -913,7 +843,6 @@ extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_m extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_max(vtkUnsignedLongLongArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkUnsignedShortArray * vtkUnsignedShortArray_new () {return vtkUnsignedShortArray :: New () ;} extern "C" void vtkUnsignedShortArray_destructor (vtkUnsignedShortArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUnsignedShortArray_get_ptr (vtkUnsignedShortArray * sself) {return sself ;} extern "C" int vtk_unsigned_short_array_get_data_type(vtkUnsignedShortArray* sself) { return sself->GetDataType(); } extern "C" unsigned short vtk_unsigned_short_array_get_value(vtkUnsignedShortArray* sself, long long id) { return sself->GetValue(id); } extern "C" void vtk_unsigned_short_array_set_value(vtkUnsignedShortArray* sself, long long id, unsigned short value) { sself->SetValue(id, value); } @@ -924,7 +853,6 @@ extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_min(vtkUn extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_max(vtkUnsignedShortArray* sself) { return sself->GetDataTypeValueMax(); } extern "C" vtkVariantArray * vtkVariantArray_new () {return vtkVariantArray :: New () ;} extern "C" void vtkVariantArray_destructor (vtkVariantArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkVariantArray_get_ptr (vtkVariantArray * sself) {return sself ;} extern "C" int vtk_variant_array_allocate(vtkVariantArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } extern "C" void vtk_variant_array_initialize(vtkVariantArray* sself) { sself->Initialize(); } extern "C" int vtk_variant_array_get_data_type(vtkVariantArray* sself) { return sself->GetDataType(); } @@ -943,7 +871,6 @@ extern "C" void vtk_variant_array_data_element_changed(vtkVariantArray* sself, l extern "C" void vtk_variant_array_clear_lookup(vtkVariantArray* sself) { sself->ClearLookup(); } extern "C" vtkVersion * vtkVersion_new () {return vtkVersion :: New () ;} extern "C" void vtkVersion_destructor (vtkVersion * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkVersion_get_ptr (vtkVersion * sself) {return sself ;} extern "C" const char* vtk_version_get_vtk_version(vtkVersion* sself) { return sself->GetVTKVersion(); } extern "C" const char* vtk_version_get_vtk_version_full(vtkVersion* sself) { return sself->GetVTKVersionFull(); } extern "C" int vtk_version_get_vtk_major_version(vtkVersion* sself) { return sself->GetVTKMajorVersion(); } @@ -952,7 +879,6 @@ extern "C" int vtk_version_get_vtk_build_version(vtkVersion* sself) { return sse extern "C" const char* vtk_version_get_vtk_source_version(vtkVersion* sself) { return sself->GetVTKSourceVersion(); } extern "C" vtkVoidArray * vtkVoidArray_new () {return vtkVoidArray :: New () ;} extern "C" void vtkVoidArray_destructor (vtkVoidArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkVoidArray_get_ptr (vtkVoidArray * sself) {return sself ;} extern "C" int vtk_void_array_allocate(vtkVoidArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } extern "C" void vtk_void_array_initialize(vtkVoidArray* sself) { sself->Initialize(); } extern "C" int vtk_void_array_get_data_type(vtkVoidArray* sself) { return sself->GetDataType(); } @@ -967,9 +893,7 @@ extern "C" void vtk_void_array_reset(vtkVoidArray* sself) { sself->Reset(); } extern "C" void vtk_void_array_squeeze(vtkVoidArray* sself) { sself->Squeeze(); } extern "C" vtkWeakReference * vtkWeakReference_new () {return vtkWeakReference :: New () ;} extern "C" void vtkWeakReference_destructor (vtkWeakReference * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkWeakReference_get_ptr (vtkWeakReference * sself) {return sself ;} extern "C" vtkXMLFileOutputWindow * vtkXMLFileOutputWindow_new () {return vtkXMLFileOutputWindow :: New () ;} extern "C" void vtkXMLFileOutputWindow_destructor (vtkXMLFileOutputWindow * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkXMLFileOutputWindow_get_ptr (vtkXMLFileOutputWindow * sself) {return sself ;} extern "C" void vtk_xml_file_output_window_display_text(vtkXMLFileOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } extern "C" void vtk_xml_file_output_window_display_tag(vtkXMLFileOutputWindow* sself, const char* p0) { sself->DisplayTag(p0); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp index 6dad674..9996bda 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp @@ -284,19 +284,16 @@ // Implement declared functions extern "C" vtkAMRDataInternals * vtkAMRDataInternals_new () {return vtkAMRDataInternals :: New () ;} extern "C" void vtkAMRDataInternals_destructor (vtkAMRDataInternals * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAMRDataInternals_get_ptr (vtkAMRDataInternals * sself) {return sself ;} extern "C" void vtk_amr_data_internals_initialize(vtkAMRDataInternals* sself) { sself->Initialize(); } extern "C" bool vtk_amr_data_internals_empty(vtkAMRDataInternals* sself) { return sself->Empty(); } extern "C" unsigned int vtk_amr_data_internals_get_number_of_blocks(vtkAMRDataInternals* sself) { return sself->GetNumberOfBlocks(); } extern "C" vtkAdjacentVertexIterator * vtkAdjacentVertexIterator_new () {return vtkAdjacentVertexIterator :: New () ;} extern "C" void vtkAdjacentVertexIterator_destructor (vtkAdjacentVertexIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAdjacentVertexIterator_get_ptr (vtkAdjacentVertexIterator * sself) {return sself ;} extern "C" long long vtk_adjacent_vertex_iterator_get_vertex(vtkAdjacentVertexIterator* sself) { return sself->GetVertex(); } extern "C" long long vtk_adjacent_vertex_iterator_next(vtkAdjacentVertexIterator* sself) { return sself->Next(); } extern "C" bool vtk_adjacent_vertex_iterator_has_next(vtkAdjacentVertexIterator* sself) { return sself->HasNext(); } extern "C" vtkAnimationScene * vtkAnimationScene_new () {return vtkAnimationScene :: New () ;} extern "C" void vtkAnimationScene_destructor (vtkAnimationScene * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAnimationScene_get_ptr (vtkAnimationScene * sself) {return sself ;} extern "C" void vtk_animation_scene_set_play_mode(vtkAnimationScene* sself, int _arg) { sself->SetPlayMode(_arg); } extern "C" void vtk_animation_scene_set_mode_to_sequence(vtkAnimationScene* sself) { sself->SetModeToSequence(); } extern "C" void vtk_animation_scene_set_mode_to_real_time(vtkAnimationScene* sself) { sself->SetModeToRealTime(); } @@ -314,40 +311,34 @@ extern "C" void vtk_animation_scene_set_time_mode(vtkAnimationScene* sself, int extern "C" int vtk_animation_scene_is_in_play(vtkAnimationScene* sself) { return sself->IsInPlay(); } extern "C" vtkAnnotation * vtkAnnotation_new () {return vtkAnnotation :: New () ;} extern "C" void vtkAnnotation_destructor (vtkAnnotation * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAnnotation_get_ptr (vtkAnnotation * sself) {return sself ;} extern "C" int vtk_annotation_get_data_object_type(vtkAnnotation* sself) { return sself->GetDataObjectType(); } extern "C" void vtk_annotation_initialize(vtkAnnotation* sself) { sself->Initialize(); } extern "C" unsigned long vtk_annotation_get_m_time(vtkAnnotation* sself) { return sself->GetMTime(); } extern "C" vtkAnnotationLayers * vtkAnnotationLayers_new () {return vtkAnnotationLayers :: New () ;} extern "C" void vtkAnnotationLayers_destructor (vtkAnnotationLayers * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAnnotationLayers_get_ptr (vtkAnnotationLayers * sself) {return sself ;} extern "C" int vtk_annotation_layers_get_data_object_type(vtkAnnotationLayers* sself) { return sself->GetDataObjectType(); } extern "C" unsigned int vtk_annotation_layers_get_number_of_annotations(vtkAnnotationLayers* sself) { return sself->GetNumberOfAnnotations(); } extern "C" void vtk_annotation_layers_initialize(vtkAnnotationLayers* sself) { sself->Initialize(); } extern "C" unsigned long vtk_annotation_layers_get_m_time(vtkAnnotationLayers* sself) { return sself->GetMTime(); } extern "C" vtkArrayData * vtkArrayData_new () {return vtkArrayData :: New () ;} extern "C" void vtkArrayData_destructor (vtkArrayData * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkArrayData_get_ptr (vtkArrayData * sself) {return sself ;} extern "C" void vtk_array_data_clear_arrays(vtkArrayData* sself) { sself->ClearArrays(); } extern "C" long long vtk_array_data_get_number_of_arrays(vtkArrayData* sself) { return sself->GetNumberOfArrays(); } extern "C" int vtk_array_data_get_data_object_type(vtkArrayData* sself) { return sself->GetDataObjectType(); } extern "C" vtkAttributesErrorMetric * vtkAttributesErrorMetric_new () {return vtkAttributesErrorMetric :: New () ;} extern "C" void vtkAttributesErrorMetric_destructor (vtkAttributesErrorMetric * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAttributesErrorMetric_get_ptr (vtkAttributesErrorMetric * sself) {return sself ;} extern "C" double vtk_attributes_error_metric_get_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself) { return sself->GetAbsoluteAttributeTolerance(); } extern "C" void vtk_attributes_error_metric_set_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself, double value) { sself->SetAbsoluteAttributeTolerance(value); } extern "C" double vtk_attributes_error_metric_get_attribute_tolerance(vtkAttributesErrorMetric* sself) { return sself->GetAttributeTolerance(); } extern "C" void vtk_attributes_error_metric_set_attribute_tolerance(vtkAttributesErrorMetric* sself, double value) { sself->SetAttributeTolerance(value); } extern "C" vtkBSPCuts * vtkBSPCuts_new () {return vtkBSPCuts :: New () ;} extern "C" void vtkBSPCuts_destructor (vtkBSPCuts * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBSPCuts_get_ptr (vtkBSPCuts * sself) {return sself ;} extern "C" int vtk_bsp_cuts_get_data_object_type(vtkBSPCuts* sself) { return sself->GetDataObjectType(); } extern "C" int vtk_bsp_cuts_get_number_of_cuts(vtkBSPCuts* sself) { return sself->GetNumberOfCuts(); } extern "C" void vtk_bsp_cuts_print_tree(vtkBSPCuts* sself) { sself->PrintTree(); } extern "C" void vtk_bsp_cuts_print_arrays(vtkBSPCuts* sself) { sself->PrintArrays(); } extern "C" vtkBSPIntersections * vtkBSPIntersections_new () {return vtkBSPIntersections :: New () ;} extern "C" void vtkBSPIntersections_destructor (vtkBSPIntersections * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBSPIntersections_get_ptr (vtkBSPIntersections * sself) {return sself ;} extern "C" int vtk_bsp_intersections_get_number_of_regions(vtkBSPIntersections* sself) { return sself->GetNumberOfRegions(); } extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkBSPIntersections* sself, int regionId, double x, double y, double z, double rSquared) { return sself->IntersectsSphere2(regionId, x, y, z, rSquared); } extern "C" int vtk_bsp_intersections_get_compute_intersections_using_data_bounds(vtkBSPIntersections* sself) { return sself->GetComputeIntersectionsUsingDataBounds(); } @@ -356,62 +347,50 @@ extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_on extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_off(vtkBSPIntersections* sself) { sself->ComputeIntersectionsUsingDataBoundsOff(); } extern "C" vtkBezierCurve * vtkBezierCurve_new () {return vtkBezierCurve :: New () ;} extern "C" void vtkBezierCurve_destructor (vtkBezierCurve * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBezierCurve_get_ptr (vtkBezierCurve * sself) {return sself ;} extern "C" int vtk_bezier_curve_get_cell_type(vtkBezierCurve* sself) { return sself->GetCellType(); } extern "C" vtkBezierHexahedron * vtkBezierHexahedron_new () {return vtkBezierHexahedron :: New () ;} extern "C" void vtkBezierHexahedron_destructor (vtkBezierHexahedron * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBezierHexahedron_get_ptr (vtkBezierHexahedron * sself) {return sself ;} extern "C" int vtk_bezier_hexahedron_get_cell_type(vtkBezierHexahedron* sself) { return sself->GetCellType(); } extern "C" vtkBezierInterpolation * vtkBezierInterpolation_new () {return vtkBezierInterpolation :: New () ;} extern "C" void vtkBezierInterpolation_destructor (vtkBezierInterpolation * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBezierInterpolation_get_ptr (vtkBezierInterpolation * sself) {return sself ;} extern "C" vtkBezierQuadrilateral * vtkBezierQuadrilateral_new () {return vtkBezierQuadrilateral :: New () ;} extern "C" void vtkBezierQuadrilateral_destructor (vtkBezierQuadrilateral * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBezierQuadrilateral_get_ptr (vtkBezierQuadrilateral * sself) {return sself ;} extern "C" int vtk_bezier_quadrilateral_get_cell_type(vtkBezierQuadrilateral* sself) { return sself->GetCellType(); } extern "C" vtkBezierTetra * vtkBezierTetra_new () {return vtkBezierTetra :: New () ;} extern "C" void vtkBezierTetra_destructor (vtkBezierTetra * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBezierTetra_get_ptr (vtkBezierTetra * sself) {return sself ;} extern "C" int vtk_bezier_tetra_get_cell_type(vtkBezierTetra* sself) { return sself->GetCellType(); } extern "C" vtkBezierTriangle * vtkBezierTriangle_new () {return vtkBezierTriangle :: New () ;} extern "C" void vtkBezierTriangle_destructor (vtkBezierTriangle * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBezierTriangle_get_ptr (vtkBezierTriangle * sself) {return sself ;} extern "C" int vtk_bezier_triangle_get_cell_type(vtkBezierTriangle* sself) { return sself->GetCellType(); } extern "C" vtkBezierWedge * vtkBezierWedge_new () {return vtkBezierWedge :: New () ;} extern "C" void vtkBezierWedge_destructor (vtkBezierWedge * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBezierWedge_get_ptr (vtkBezierWedge * sself) {return sself ;} extern "C" int vtk_bezier_wedge_get_cell_type(vtkBezierWedge* sself) { return sself->GetCellType(); } extern "C" vtkBiQuadraticQuad * vtkBiQuadraticQuad_new () {return vtkBiQuadraticQuad :: New () ;} extern "C" void vtkBiQuadraticQuad_destructor (vtkBiQuadraticQuad * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBiQuadraticQuad_get_ptr (vtkBiQuadraticQuad * sself) {return sself ;} extern "C" int vtk_bi_quadratic_quad_get_cell_type(vtkBiQuadraticQuad* sself) { return sself->GetCellType(); } extern "C" int vtk_bi_quadratic_quad_get_cell_dimension(vtkBiQuadraticQuad* sself) { return sself->GetCellDimension(); } extern "C" int vtk_bi_quadratic_quad_get_number_of_edges(vtkBiQuadraticQuad* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_bi_quadratic_quad_get_number_of_faces(vtkBiQuadraticQuad* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkBiQuadraticQuadraticHexahedron * vtkBiQuadraticQuadraticHexahedron_new () {return vtkBiQuadraticQuadraticHexahedron :: New () ;} extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkBiQuadraticQuadraticHexahedron * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBiQuadraticQuadraticHexahedron_get_ptr (vtkBiQuadraticQuadraticHexahedron * sself) {return sself ;} extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetCellType(); } extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetCellDimension(); } extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkBiQuadraticQuadraticWedge * vtkBiQuadraticQuadraticWedge_new () {return vtkBiQuadraticQuadraticWedge :: New () ;} extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkBiQuadraticQuadraticWedge * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBiQuadraticQuadraticWedge_get_ptr (vtkBiQuadraticQuadraticWedge * sself) {return sself ;} extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_type(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetCellType(); } extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetCellDimension(); } extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkBiQuadraticTriangle * vtkBiQuadraticTriangle_new () {return vtkBiQuadraticTriangle :: New () ;} extern "C" void vtkBiQuadraticTriangle_destructor (vtkBiQuadraticTriangle * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBiQuadraticTriangle_get_ptr (vtkBiQuadraticTriangle * sself) {return sself ;} extern "C" int vtk_bi_quadratic_triangle_get_cell_type(vtkBiQuadraticTriangle* sself) { return sself->GetCellType(); } extern "C" int vtk_bi_quadratic_triangle_get_cell_dimension(vtkBiQuadraticTriangle* sself) { return sself->GetCellDimension(); } extern "C" int vtk_bi_quadratic_triangle_get_number_of_edges(vtkBiQuadraticTriangle* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_bi_quadratic_triangle_get_number_of_faces(vtkBiQuadraticTriangle* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkBox * vtkBox_new () {return vtkBox :: New () ;} extern "C" void vtkBox_destructor (vtkBox * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkBox_get_ptr (vtkBox * sself) {return sself ;} extern "C" void vtk_box_set_x_min(vtkBox* sself, double x, double y, double z) { sself->SetXMin(x, y, z); } extern "C" void vtk_box_get_x_min(vtkBox* sself, double& x, double& y, double& z) { sself->GetXMin(x, y, z); } extern "C" void vtk_box_set_x_max(vtkBox* sself, double x, double y, double z) { sself->SetXMax(x, y, z); } @@ -420,7 +399,6 @@ extern "C" void vtk_box_set_bounds(vtkBox* sself, double xMin, double xMax, doub extern "C" void vtk_box_get_bounds(vtkBox* sself, double& xMin, double& xMax, double& yMin, double& yMax, double& zMin, double& zMax) { sself->GetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } extern "C" vtkCellArray * vtkCellArray_new () {return vtkCellArray :: New () ;} extern "C" void vtkCellArray_destructor (vtkCellArray * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCellArray_get_ptr (vtkCellArray * sself) {return sself ;} extern "C" int vtk_cell_array_allocate(vtkCellArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } extern "C" bool vtk_cell_array_allocate_estimate(vtkCellArray* sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } extern "C" bool vtk_cell_array_allocate_exact(vtkCellArray* sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } @@ -464,7 +442,6 @@ extern "C" void vtk_cell_array_set_traversal_location(vtkCellArray* sself, long extern "C" void vtk_cell_array_reverse_cell(vtkCellArray* sself, long long loc) { sself->ReverseCell(loc); } extern "C" vtkCellArrayIterator * vtkCellArrayIterator_new () {return vtkCellArrayIterator :: New () ;} extern "C" void vtkCellArrayIterator_destructor (vtkCellArrayIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCellArrayIterator_get_ptr (vtkCellArrayIterator * sself) {return sself ;} extern "C" void vtk_cell_array_iterator_go_to_cell(vtkCellArrayIterator* sself, long long cellId) { sself->GoToCell(cellId); } extern "C" void vtk_cell_array_iterator_go_to_first_cell(vtkCellArrayIterator* sself) { sself->GoToFirstCell(); } extern "C" void vtk_cell_array_iterator_go_to_next_cell(vtkCellArrayIterator* sself) { sself->GoToNextCell(); } @@ -473,10 +450,8 @@ extern "C" long long vtk_cell_array_iterator_get_current_cell_id(vtkCellArrayIte extern "C" void vtk_cell_array_iterator_reverse_current_cell(vtkCellArrayIterator* sself) { sself->ReverseCurrentCell(); } extern "C" vtkCellData * vtkCellData_new () {return vtkCellData :: New () ;} extern "C" void vtkCellData_destructor (vtkCellData * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCellData_get_ptr (vtkCellData * sself) {return sself ;} extern "C" vtkCellLinks * vtkCellLinks_new () {return vtkCellLinks :: New () ;} extern "C" void vtkCellLinks_destructor (vtkCellLinks * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCellLinks_get_ptr (vtkCellLinks * sself) {return sself ;} extern "C" void vtk_cell_links_allocate(vtkCellLinks* sself, long long numLinks, long long ext) { sself->Allocate(numLinks, ext); } extern "C" void vtk_cell_links_initialize(vtkCellLinks* sself) { sself->Initialize(); } extern "C" long long vtk_cell_links_get_ncells(vtkCellLinks* sself, long long ptId) { return sself->GetNcells(ptId); } @@ -491,7 +466,6 @@ extern "C" void vtk_cell_links_reset(vtkCellLinks* sself) { sself->Reset(); } extern "C" unsigned long vtk_cell_links_get_actual_memory_size(vtkCellLinks* sself) { return sself->GetActualMemorySize(); } extern "C" vtkCellLocator * vtkCellLocator_new () {return vtkCellLocator :: New () ;} extern "C" void vtkCellLocator_destructor (vtkCellLocator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCellLocator_get_ptr (vtkCellLocator * sself) {return sself ;} extern "C" void vtk_cell_locator_set_number_of_cells_per_bucket(vtkCellLocator* sself, int N) { sself->SetNumberOfCellsPerBucket(N); } extern "C" int vtk_cell_locator_get_number_of_cells_per_bucket(vtkCellLocator* sself) { return sself->GetNumberOfCellsPerBucket(); } extern "C" int vtk_cell_locator_get_number_of_buckets(vtkCellLocator* sself) { return sself->GetNumberOfBuckets(); } @@ -502,10 +476,8 @@ extern "C" void vtk_cell_locator_force_build_locator(vtkCellLocator* sself) { ss extern "C" void vtk_cell_locator_build_locator_internal(vtkCellLocator* sself) { sself->BuildLocatorInternal(); } extern "C" vtkCellLocatorStrategy * vtkCellLocatorStrategy_new () {return vtkCellLocatorStrategy :: New () ;} extern "C" void vtkCellLocatorStrategy_destructor (vtkCellLocatorStrategy * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCellLocatorStrategy_get_ptr (vtkCellLocatorStrategy * sself) {return sself ;} extern "C" vtkCellTypes * vtkCellTypes_new () {return vtkCellTypes :: New () ;} extern "C" void vtkCellTypes_destructor (vtkCellTypes * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCellTypes_get_ptr (vtkCellTypes * sself) {return sself ;} extern "C" int vtk_cell_types_allocate(vtkCellTypes* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } extern "C" void vtk_cell_types_insert_cell(vtkCellTypes* sself, long long id, unsigned char type, long long loc) { sself->InsertCell(id, type, loc); } extern "C" long long vtk_cell_types_insert_next_cell(vtkCellTypes* sself, unsigned char type, long long loc) { return sself->InsertNextCell(type, loc); } @@ -523,24 +495,20 @@ extern "C" int vtk_cell_types_get_type_id_from_class_name(vtkCellTypes* sself, c extern "C" int vtk_cell_types_is_linear(vtkCellTypes* sself, unsigned char type) { return sself->IsLinear(type); } extern "C" vtkClosestNPointsStrategy * vtkClosestNPointsStrategy_new () {return vtkClosestNPointsStrategy :: New () ;} extern "C" void vtkClosestNPointsStrategy_destructor (vtkClosestNPointsStrategy * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkClosestNPointsStrategy_get_ptr (vtkClosestNPointsStrategy * sself) {return sself ;} extern "C" void vtk_closest_n_points_strategy_set_closest_n_points(vtkClosestNPointsStrategy* sself, int _arg) { sself->SetClosestNPoints(_arg); } extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_min_value(vtkClosestNPointsStrategy* sself) { return sself->GetClosestNPointsMinValue(); } extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_max_value(vtkClosestNPointsStrategy* sself) { return sself->GetClosestNPointsMaxValue(); } extern "C" int vtk_closest_n_points_strategy_get_closest_n_points(vtkClosestNPointsStrategy* sself) { return sself->GetClosestNPoints(); } extern "C" vtkClosestPointStrategy * vtkClosestPointStrategy_new () {return vtkClosestPointStrategy :: New () ;} extern "C" void vtkClosestPointStrategy_destructor (vtkClosestPointStrategy * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkClosestPointStrategy_get_ptr (vtkClosestPointStrategy * sself) {return sself ;} extern "C" vtkCone * vtkCone_new () {return vtkCone :: New () ;} extern "C" void vtkCone_destructor (vtkCone * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCone_get_ptr (vtkCone * sself) {return sself ;} extern "C" void vtk_cone_set_angle(vtkCone* sself, double _arg) { sself->SetAngle(_arg); } extern "C" double vtk_cone_get_angle_min_value(vtkCone* sself) { return sself->GetAngleMinValue(); } extern "C" double vtk_cone_get_angle_max_value(vtkCone* sself) { return sself->GetAngleMaxValue(); } extern "C" double vtk_cone_get_angle(vtkCone* sself) { return sself->GetAngle(); } extern "C" vtkConvexPointSet * vtkConvexPointSet_new () {return vtkConvexPointSet :: New () ;} extern "C" void vtkConvexPointSet_destructor (vtkConvexPointSet * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkConvexPointSet_get_ptr (vtkConvexPointSet * sself) {return sself ;} extern "C" int vtk_convex_point_set_has_fixed_topology(vtkConvexPointSet* sself) { return sself->HasFixedTopology(); } extern "C" int vtk_convex_point_set_get_cell_type(vtkConvexPointSet* sself) { return sself->GetCellType(); } extern "C" int vtk_convex_point_set_requires_initialization(vtkConvexPointSet* sself) { return sself->RequiresInitialization(); } @@ -549,21 +517,18 @@ extern "C" int vtk_convex_point_set_get_number_of_faces(vtkConvexPointSet* sself extern "C" int vtk_convex_point_set_is_primary_cell(vtkConvexPointSet* sself) { return sself->IsPrimaryCell(); } extern "C" vtkCubicLine * vtkCubicLine_new () {return vtkCubicLine :: New () ;} extern "C" void vtkCubicLine_destructor (vtkCubicLine * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCubicLine_get_ptr (vtkCubicLine * sself) {return sself ;} extern "C" int vtk_cubic_line_get_cell_type(vtkCubicLine* sself) { return sself->GetCellType(); } extern "C" int vtk_cubic_line_get_cell_dimension(vtkCubicLine* sself) { return sself->GetCellDimension(); } extern "C" int vtk_cubic_line_get_number_of_edges(vtkCubicLine* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_cubic_line_get_number_of_faces(vtkCubicLine* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkCylinder * vtkCylinder_new () {return vtkCylinder :: New () ;} extern "C" void vtkCylinder_destructor (vtkCylinder * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCylinder_get_ptr (vtkCylinder * sself) {return sself ;} extern "C" void vtk_cylinder_set_radius(vtkCylinder* sself, double _arg) { sself->SetRadius(_arg); } extern "C" double vtk_cylinder_get_radius(vtkCylinder* sself) { return sself->GetRadius(); } extern "C" void vtk_cylinder_set_center(vtkCylinder* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } extern "C" void vtk_cylinder_set_axis(vtkCylinder* sself, double ax, double ay, double az) { sself->SetAxis(ax, ay, az); } extern "C" vtkDataAssembly * vtkDataAssembly_new () {return vtkDataAssembly :: New () ;} extern "C" void vtkDataAssembly_destructor (vtkDataAssembly * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataAssembly_get_ptr (vtkDataAssembly * sself) {return sself ;} extern "C" void vtk_data_assembly_initialize(vtkDataAssembly* sself) { sself->Initialize(); } extern "C" bool vtk_data_assembly_initialize_from_xml(vtkDataAssembly* sself, const char* xmlcontents) { return sself->InitializeFromXML(xmlcontents); } extern "C" int vtk_data_assembly_get_root_node(vtkDataAssembly* sself) { return sself->GetRootNode(); } @@ -591,11 +556,9 @@ extern "C" bool vtk_data_assembly_is_node_name_valid(vtkDataAssembly* sself, con extern "C" bool vtk_data_assembly_is_node_name_reserved(vtkDataAssembly* sself, const char* name) { return sself->IsNodeNameReserved(name); } extern "C" vtkDataAssemblyUtilities * vtkDataAssemblyUtilities_new () {return vtkDataAssemblyUtilities :: New () ;} extern "C" void vtkDataAssemblyUtilities_destructor (vtkDataAssemblyUtilities * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataAssemblyUtilities_get_ptr (vtkDataAssemblyUtilities * sself) {return sself ;} extern "C" const char* vtk_data_assembly_utilities_hierarchy_name(vtkDataAssemblyUtilities* sself) { return sself->HierarchyName(); } extern "C" vtkDataObject * vtkDataObject_new () {return vtkDataObject :: New () ;} extern "C" void vtkDataObject_destructor (vtkDataObject * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataObject_get_ptr (vtkDataObject * sself) {return sself ;} extern "C" unsigned long vtk_data_object_get_m_time(vtkDataObject* sself) { return sself->GetMTime(); } extern "C" void vtk_data_object_initialize(vtkDataObject* sself) { sself->Initialize(); } extern "C" void vtk_data_object_release_data(vtkDataObject* sself) { sself->ReleaseData(); } @@ -615,11 +578,9 @@ extern "C" const char* vtk_data_object_get_association_type_as_string(vtkDataObj extern "C" int vtk_data_object_get_association_type_from_string(vtkDataObject* sself, const char* associationName) { return sself->GetAssociationTypeFromString(associationName); } extern "C" vtkDataObjectCollection * vtkDataObjectCollection_new () {return vtkDataObjectCollection :: New () ;} extern "C" void vtkDataObjectCollection_destructor (vtkDataObjectCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataObjectCollection_get_ptr (vtkDataObjectCollection * sself) {return sself ;} extern "C" int vtk_data_object_collection_get_number_of_items(vtkDataObjectCollection* sself) { return sself->GetNumberOfItems(); } extern "C" vtkDataObjectTreeIterator * vtkDataObjectTreeIterator_new () {return vtkDataObjectTreeIterator :: New () ;} extern "C" void vtkDataObjectTreeIterator_destructor (vtkDataObjectTreeIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataObjectTreeIterator_get_ptr (vtkDataObjectTreeIterator * sself) {return sself ;} extern "C" void vtk_data_object_tree_iterator_go_to_first_item(vtkDataObjectTreeIterator* sself) { sself->GoToFirstItem(); } extern "C" void vtk_data_object_tree_iterator_go_to_next_item(vtkDataObjectTreeIterator* sself) { sself->GoToNextItem(); } extern "C" int vtk_data_object_tree_iterator_is_done_with_traversal(vtkDataObjectTreeIterator* sself) { return sself->IsDoneWithTraversal(); } @@ -635,14 +596,12 @@ extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_on(vtkDataObject extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_off(vtkDataObjectTreeIterator* sself) { sself->TraverseSubTreeOff(); } extern "C" vtkDataObjectTypes * vtkDataObjectTypes_new () {return vtkDataObjectTypes :: New () ;} extern "C" void vtkDataObjectTypes_destructor (vtkDataObjectTypes * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataObjectTypes_get_ptr (vtkDataObjectTypes * sself) {return sself ;} extern "C" const char* vtk_data_object_types_get_class_name_from_type_id(vtkDataObjectTypes* sself, int typeId) { return sself->GetClassNameFromTypeId(typeId); } extern "C" int vtk_data_object_types_get_type_id_from_class_name(vtkDataObjectTypes* sself, const char* classname) { return sself->GetTypeIdFromClassName(classname); } extern "C" bool vtk_data_object_types_type_id_is_a(vtkDataObjectTypes* sself, int typeId, int targetTypeId) { return sself->TypeIdIsA(typeId, targetTypeId); } extern "C" int vtk_data_object_types_get_common_base_type_id(vtkDataObjectTypes* sself, int typeA, int typeB) { return sself->GetCommonBaseTypeId(typeA, typeB); } extern "C" vtkDataSetAttributes * vtkDataSetAttributes_new () {return vtkDataSetAttributes :: New () ;} extern "C" void vtkDataSetAttributes_destructor (vtkDataSetAttributes * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataSetAttributes_get_ptr (vtkDataSetAttributes * sself) {return sself ;} extern "C" void vtk_data_set_attributes_initialize(vtkDataSetAttributes* sself) { sself->Initialize(); } extern "C" void vtk_data_set_attributes_update(vtkDataSetAttributes* sself) { sself->Update(); } extern "C" const char* vtk_data_set_attributes_ghost_array_name(vtkDataSetAttributes* sself) { return sself->GhostArrayName(); } @@ -706,26 +665,20 @@ extern "C" void vtk_data_set_attributes_copy_all_on(vtkDataSetAttributes* sself, extern "C" void vtk_data_set_attributes_copy_all_off(vtkDataSetAttributes* sself, int ctype) { sself->CopyAllOff(ctype); } extern "C" vtkDataSetCellIterator * vtkDataSetCellIterator_new () {return vtkDataSetCellIterator :: New () ;} extern "C" void vtkDataSetCellIterator_destructor (vtkDataSetCellIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataSetCellIterator_get_ptr (vtkDataSetCellIterator * sself) {return sself ;} extern "C" bool vtk_data_set_cell_iterator_is_done_with_traversal(vtkDataSetCellIterator* sself) { return sself->IsDoneWithTraversal(); } extern "C" long long vtk_data_set_cell_iterator_get_cell_id(vtkDataSetCellIterator* sself) { return sself->GetCellId(); } extern "C" vtkDataSetCollection * vtkDataSetCollection_new () {return vtkDataSetCollection :: New () ;} extern "C" void vtkDataSetCollection_destructor (vtkDataSetCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataSetCollection_get_ptr (vtkDataSetCollection * sself) {return sself ;} extern "C" int vtk_data_set_collection_get_number_of_items(vtkDataSetCollection* sself) { return sself->GetNumberOfItems(); } extern "C" vtkDirectedAcyclicGraph * vtkDirectedAcyclicGraph_new () {return vtkDirectedAcyclicGraph :: New () ;} extern "C" void vtkDirectedAcyclicGraph_destructor (vtkDirectedAcyclicGraph * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDirectedAcyclicGraph_get_ptr (vtkDirectedAcyclicGraph * sself) {return sself ;} extern "C" vtkDirectedGraph * vtkDirectedGraph_new () {return vtkDirectedGraph :: New () ;} extern "C" void vtkDirectedGraph_destructor (vtkDirectedGraph * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDirectedGraph_get_ptr (vtkDirectedGraph * sself) {return sself ;} extern "C" vtkEdgeListIterator * vtkEdgeListIterator_new () {return vtkEdgeListIterator :: New () ;} extern "C" void vtkEdgeListIterator_destructor (vtkEdgeListIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkEdgeListIterator_get_ptr (vtkEdgeListIterator * sself) {return sself ;} extern "C" bool vtk_edge_list_iterator_has_next(vtkEdgeListIterator* sself) { return sself->HasNext(); } extern "C" vtkEdgeTable * vtkEdgeTable_new () {return vtkEdgeTable :: New () ;} extern "C" void vtkEdgeTable_destructor (vtkEdgeTable * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkEdgeTable_get_ptr (vtkEdgeTable * sself) {return sself ;} extern "C" void vtk_edge_table_initialize(vtkEdgeTable* sself) { sself->Initialize(); } extern "C" int vtk_edge_table_init_edge_insertion(vtkEdgeTable* sself, long long numPoints, int storeAttributes) { return sself->InitEdgeInsertion(numPoints, storeAttributes); } extern "C" long long vtk_edge_table_insert_edge(vtkEdgeTable* sself, long long p1, long long p2) { return sself->InsertEdge(p1, p2); } @@ -736,14 +689,12 @@ extern "C" long long vtk_edge_table_get_next_edge(vtkEdgeTable* sself, long long extern "C" void vtk_edge_table_reset(vtkEdgeTable* sself) { sself->Reset(); } extern "C" vtkEmptyCell * vtkEmptyCell_new () {return vtkEmptyCell :: New () ;} extern "C" void vtkEmptyCell_destructor (vtkEmptyCell * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkEmptyCell_get_ptr (vtkEmptyCell * sself) {return sself ;} extern "C" int vtk_empty_cell_get_cell_type(vtkEmptyCell* sself) { return sself->GetCellType(); } extern "C" int vtk_empty_cell_get_cell_dimension(vtkEmptyCell* sself) { return sself->GetCellDimension(); } extern "C" int vtk_empty_cell_get_number_of_edges(vtkEmptyCell* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_empty_cell_get_number_of_faces(vtkEmptyCell* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkExplicitStructuredGrid * vtkExplicitStructuredGrid_new () {return vtkExplicitStructuredGrid :: New () ;} extern "C" void vtkExplicitStructuredGrid_destructor (vtkExplicitStructuredGrid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkExplicitStructuredGrid_get_ptr (vtkExplicitStructuredGrid * sself) {return sself ;} extern "C" int vtk_explicit_structured_grid_get_data_object_type(vtkExplicitStructuredGrid* sself) { return sself->GetDataObjectType(); } extern "C" void vtk_explicit_structured_grid_initialize(vtkExplicitStructuredGrid* sself) { sself->Initialize(); } extern "C" int vtk_explicit_structured_grid_get_cell_type(vtkExplicitStructuredGrid* sself, long long cellId) { return sself->GetCellType(cellId); } @@ -766,7 +717,6 @@ extern "C" unsigned long vtk_explicit_structured_grid_get_actual_memory_size(vtk extern "C" void vtk_explicit_structured_grid_check_and_reorder_faces(vtkExplicitStructuredGrid* sself) { sself->CheckAndReorderFaces(); } extern "C" vtkExtractStructuredGridHelper * vtkExtractStructuredGridHelper_new () {return vtkExtractStructuredGridHelper :: New () ;} extern "C" void vtkExtractStructuredGridHelper_destructor (vtkExtractStructuredGridHelper * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkExtractStructuredGridHelper_get_ptr (vtkExtractStructuredGridHelper * sself) {return sself ;} extern "C" bool vtk_extract_structured_grid_helper_is_valid(vtkExtractStructuredGridHelper* sself) { return sself->IsValid(); } extern "C" int vtk_extract_structured_grid_helper_get_size(vtkExtractStructuredGridHelper* sself, const int dim) { return sself->GetSize(dim); } extern "C" int vtk_extract_structured_grid_helper_get_mapped_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx) { return sself->GetMappedIndex(dim, outIdx); } @@ -775,7 +725,6 @@ extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value(vtkExt extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx) { return sself->GetMappedExtentValueFromIndex(dim, outIdx); } extern "C" vtkFieldData * vtkFieldData_new () {return vtkFieldData :: New () ;} extern "C" void vtkFieldData_destructor (vtkFieldData * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkFieldData_get_ptr (vtkFieldData * sself) {return sself ;} extern "C" void vtk_field_data_initialize(vtkFieldData* sself) { sself->Initialize(); } extern "C" int vtk_field_data_allocate(vtkFieldData* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } extern "C" void vtk_field_data_allocate_arrays(vtkFieldData* sself, int num) { sself->AllocateArrays(num); } @@ -798,7 +747,6 @@ extern "C" long long vtk_field_data_get_number_of_tuples(vtkFieldData* sself) { extern "C" void vtk_field_data_set_number_of_tuples(vtkFieldData* sself, const long long number) { sself->SetNumberOfTuples(number); } extern "C" vtkGenericAttributeCollection * vtkGenericAttributeCollection_new () {return vtkGenericAttributeCollection :: New () ;} extern "C" void vtkGenericAttributeCollection_destructor (vtkGenericAttributeCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGenericAttributeCollection_get_ptr (vtkGenericAttributeCollection * sself) {return sself ;} extern "C" int vtk_generic_attribute_collection_get_number_of_attributes(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfAttributes(); } extern "C" int vtk_generic_attribute_collection_get_number_of_components(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfComponents(); } extern "C" int vtk_generic_attribute_collection_get_number_of_point_centered_components(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfPointCenteredComponents(); } @@ -817,7 +765,6 @@ extern "C" int vtk_generic_attribute_collection_get_number_of_attributes_to_inte extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(vtkGenericAttributeCollection* sself) { sself->SetAttributesToInterpolateToAll(); } extern "C" vtkGenericCell * vtkGenericCell_new () {return vtkGenericCell :: New () ;} extern "C" void vtkGenericCell_destructor (vtkGenericCell * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGenericCell_get_ptr (vtkGenericCell * sself) {return sself ;} extern "C" int vtk_generic_cell_get_cell_type(vtkGenericCell* sself) { return sself->GetCellType(); } extern "C" int vtk_generic_cell_get_cell_dimension(vtkGenericCell* sself) { return sself->GetCellDimension(); } extern "C" int vtk_generic_cell_get_number_of_edges(vtkGenericCell* sself) { return sself->GetNumberOfEdges(); } @@ -873,7 +820,6 @@ extern "C" void vtk_generic_cell_set_cell_type_to_bezier_hexahedron(vtkGenericCe extern "C" void vtk_generic_cell_set_cell_type_to_bezier_wedge(vtkGenericCell* sself) { sself->SetCellTypeToBezierWedge(); } extern "C" vtkGenericEdgeTable * vtkGenericEdgeTable_new () {return vtkGenericEdgeTable :: New () ;} extern "C" void vtkGenericEdgeTable_destructor (vtkGenericEdgeTable * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGenericEdgeTable_get_ptr (vtkGenericEdgeTable * sself) {return sself ;} extern "C" void vtk_generic_edge_table_insert_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long cellId, int ref, long long& ptId) { sself->InsertEdge(e1, e2, cellId, ref, ptId); } extern "C" int vtk_generic_edge_table_remove_edge(vtkGenericEdgeTable* sself, long long e1, long long e2) { return sself->RemoveEdge(e1, e2); } extern "C" int vtk_generic_edge_table_check_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long& ptId) { return sself->CheckEdge(e1, e2, ptId); } @@ -889,7 +835,6 @@ extern "C" void vtk_generic_edge_table_dump_table(vtkGenericEdgeTable* sself) { extern "C" void vtk_generic_edge_table_load_factor(vtkGenericEdgeTable* sself) { sself->LoadFactor(); } extern "C" vtkGenericInterpolatedVelocityField * vtkGenericInterpolatedVelocityField_new () {return vtkGenericInterpolatedVelocityField :: New () ;} extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkGenericInterpolatedVelocityField * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGenericInterpolatedVelocityField_get_ptr (vtkGenericInterpolatedVelocityField * sself) {return sself ;} extern "C" void vtk_generic_interpolated_velocity_field_clear_last_cell(vtkGenericInterpolatedVelocityField* sself) { sself->ClearLastCell(); } extern "C" int vtk_generic_interpolated_velocity_field_get_caching(vtkGenericInterpolatedVelocityField* sself) { return sself->GetCaching(); } extern "C" void vtk_generic_interpolated_velocity_field_set_caching(vtkGenericInterpolatedVelocityField* sself, int _arg) { sself->SetCaching(_arg); } @@ -900,13 +845,11 @@ extern "C" int vtk_generic_interpolated_velocity_field_get_cache_miss(vtkGeneric extern "C" void vtk_generic_interpolated_velocity_field_select_vectors(vtkGenericInterpolatedVelocityField* sself, const char* fieldName) { sself->SelectVectors(fieldName); } extern "C" vtkGeometricErrorMetric * vtkGeometricErrorMetric_new () {return vtkGeometricErrorMetric :: New () ;} extern "C" void vtkGeometricErrorMetric_destructor (vtkGeometricErrorMetric * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGeometricErrorMetric_get_ptr (vtkGeometricErrorMetric * sself) {return sself ;} extern "C" double vtk_geometric_error_metric_get_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself) { return sself->GetAbsoluteGeometricTolerance(); } extern "C" void vtk_geometric_error_metric_set_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself, double value) { sself->SetAbsoluteGeometricTolerance(value); } extern "C" int vtk_geometric_error_metric_get_relative(vtkGeometricErrorMetric* sself) { return sself->GetRelative(); } extern "C" vtkGraphEdge * vtkGraphEdge_new () {return vtkGraphEdge :: New () ;} extern "C" void vtkGraphEdge_destructor (vtkGraphEdge * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGraphEdge_get_ptr (vtkGraphEdge * sself) {return sself ;} extern "C" void vtk_graph_edge_set_source(vtkGraphEdge* sself, long long _arg) { sself->SetSource(_arg); } extern "C" long long vtk_graph_edge_get_source(vtkGraphEdge* sself) { return sself->GetSource(); } extern "C" void vtk_graph_edge_set_target(vtkGraphEdge* sself, long long _arg) { sself->SetTarget(_arg); } @@ -915,28 +858,22 @@ extern "C" void vtk_graph_edge_set_id(vtkGraphEdge* sself, long long _arg) { sse extern "C" long long vtk_graph_edge_get_id(vtkGraphEdge* sself) { return sself->GetId(); } extern "C" vtkGraphInternals * vtkGraphInternals_new () {return vtkGraphInternals :: New () ;} extern "C" void vtkGraphInternals_destructor (vtkGraphInternals * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGraphInternals_get_ptr (vtkGraphInternals * sself) {return sself ;} extern "C" vtkHexagonalPrism * vtkHexagonalPrism_new () {return vtkHexagonalPrism :: New () ;} extern "C" void vtkHexagonalPrism_destructor (vtkHexagonalPrism * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHexagonalPrism_get_ptr (vtkHexagonalPrism * sself) {return sself ;} extern "C" int vtk_hexagonal_prism_get_cell_type(vtkHexagonalPrism* sself) { return sself->GetCellType(); } extern "C" int vtk_hexagonal_prism_get_number_of_edges(vtkHexagonalPrism* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_hexagonal_prism_get_number_of_faces(vtkHexagonalPrism* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkHexahedron * vtkHexahedron_new () {return vtkHexahedron :: New () ;} extern "C" void vtkHexahedron_destructor (vtkHexahedron * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHexahedron_get_ptr (vtkHexahedron * sself) {return sself ;} extern "C" int vtk_hexahedron_get_cell_type(vtkHexahedron* sself) { return sself->GetCellType(); } extern "C" int vtk_hexahedron_get_number_of_edges(vtkHexahedron* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_hexahedron_get_number_of_faces(vtkHexahedron* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkHierarchicalBoxDataIterator * vtkHierarchicalBoxDataIterator_new () {return vtkHierarchicalBoxDataIterator :: New () ;} extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkHierarchicalBoxDataIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHierarchicalBoxDataIterator_get_ptr (vtkHierarchicalBoxDataIterator * sself) {return sself ;} extern "C" vtkHierarchicalBoxDataSet * vtkHierarchicalBoxDataSet_new () {return vtkHierarchicalBoxDataSet :: New () ;} extern "C" void vtkHierarchicalBoxDataSet_destructor (vtkHierarchicalBoxDataSet * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHierarchicalBoxDataSet_get_ptr (vtkHierarchicalBoxDataSet * sself) {return sself ;} extern "C" vtkHyperTreeGrid * vtkHyperTreeGrid_new () {return vtkHyperTreeGrid :: New () ;} extern "C" void vtkHyperTreeGrid_destructor (vtkHyperTreeGrid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHyperTreeGrid_get_ptr (vtkHyperTreeGrid * sself) {return sself ;} extern "C" void vtk_hyper_tree_grid_set_mode_squeeze(vtkHyperTreeGrid* sself, const char* _arg) { sself->SetModeSqueeze(_arg); } extern "C" void vtk_hyper_tree_grid_squeeze(vtkHyperTreeGrid* sself) { sself->Squeeze(); } extern "C" int vtk_hyper_tree_grid_get_data_object_type(vtkHyperTreeGrid* sself) { return sself->GetDataObjectType(); } @@ -986,7 +923,6 @@ extern "C" bool vtk_hyper_tree_grid_has_any_ghost_cells(vtkHyperTreeGrid* sself) extern "C" long long vtk_hyper_tree_grid_get_number_of_elements(vtkHyperTreeGrid* sself, int type) { return sself->GetNumberOfElements(type); } extern "C" vtkHyperTreeGridNonOrientedCursor * vtkHyperTreeGridNonOrientedCursor_new () {return vtkHyperTreeGridNonOrientedCursor :: New () ;} extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkHyperTreeGridNonOrientedCursor * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedCursor_get_ptr (vtkHyperTreeGridNonOrientedCursor * sself) {return sself ;} extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_has_tree(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->HasTree(); } extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetVertexId(); } extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetGlobalNodeIndex(); } @@ -1005,7 +941,6 @@ extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_root(vtkHyperTreeGrid extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_parent(vtkHyperTreeGridNonOrientedCursor* sself) { sself->ToParent(); } extern "C" vtkHyperTreeGridNonOrientedGeometryCursor * vtkHyperTreeGridNonOrientedGeometryCursor_new () {return vtkHyperTreeGridNonOrientedGeometryCursor :: New () ;} extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkHyperTreeGridNonOrientedGeometryCursor * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr (vtkHyperTreeGridNonOrientedGeometryCursor * sself) {return sself ;} extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->HasTree(); } extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetVertexId(); } extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetGlobalNodeIndex(); } @@ -1024,19 +959,14 @@ extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(vtkHype extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { sself->ToParent(); } extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursor * vtkHyperTreeGridNonOrientedMooreSuperCursor_new () {return vtkHyperTreeGridNonOrientedMooreSuperCursor :: New () ;} extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursor * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr (vtkHyperTreeGridNonOrientedMooreSuperCursor * sself) {return sself ;} extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursorLight * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new () {return vtkHyperTreeGridNonOrientedMooreSuperCursorLight :: New () ;} extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursorLight * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr (vtkHyperTreeGridNonOrientedMooreSuperCursorLight * sself) {return sself ;} extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new () {return vtkHyperTreeGridNonOrientedVonNeumannSuperCursor :: New () ;} extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr (vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * sself) {return sself ;} extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new () {return vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight :: New () ;} extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr (vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * sself) {return sself ;} extern "C" vtkHyperTreeGridOrientedCursor * vtkHyperTreeGridOrientedCursor_new () {return vtkHyperTreeGridOrientedCursor :: New () ;} extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkHyperTreeGridOrientedCursor * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHyperTreeGridOrientedCursor_get_ptr (vtkHyperTreeGridOrientedCursor * sself) {return sself ;} extern "C" bool vtk_hyper_tree_grid_oriented_cursor_has_tree(vtkHyperTreeGridOrientedCursor* sself) { return sself->HasTree(); } extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetVertexId(); } extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetGlobalNodeIndex(); } @@ -1053,7 +983,6 @@ extern "C" unsigned int vtk_hyper_tree_grid_oriented_cursor_get_level(vtkHyperTr extern "C" void vtk_hyper_tree_grid_oriented_cursor_to_child(vtkHyperTreeGridOrientedCursor* sself, unsigned char ichild) { sself->ToChild(ichild); } extern "C" vtkHyperTreeGridOrientedGeometryCursor * vtkHyperTreeGridOrientedGeometryCursor_new () {return vtkHyperTreeGridOrientedGeometryCursor :: New () ;} extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkHyperTreeGridOrientedGeometryCursor * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHyperTreeGridOrientedGeometryCursor_get_ptr (vtkHyperTreeGridOrientedGeometryCursor * sself) {return sself ;} extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->HasTree(); } extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetVertexId(); } extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetGlobalNodeIndex(); } @@ -1070,7 +999,6 @@ extern "C" unsigned int vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(v extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(vtkHyperTreeGridOrientedGeometryCursor* sself, unsigned char ichild) { sself->ToChild(ichild); } extern "C" vtkImageData * vtkImageData_new () {return vtkImageData :: New () ;} extern "C" void vtkImageData_destructor (vtkImageData * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImageData_get_ptr (vtkImageData * sself) {return sself ;} extern "C" int vtk_image_data_get_data_object_type(vtkImageData* sself) { return sself->GetDataObjectType(); } extern "C" long long vtk_image_data_get_number_of_cells(vtkImageData* sself) { return sself->GetNumberOfCells(); } extern "C" long long vtk_image_data_get_number_of_points(vtkImageData* sself) { return sself->GetNumberOfPoints(); } @@ -1099,10 +1027,8 @@ extern "C" void vtk_image_data_prepare_for_new_data(vtkImageData* sself) { sself extern "C" int vtk_image_data_get_extent_type(vtkImageData* sself) { return sself->GetExtentType(); } extern "C" vtkImageTransform * vtkImageTransform_new () {return vtkImageTransform :: New () ;} extern "C" void vtkImageTransform_destructor (vtkImageTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImageTransform_get_ptr (vtkImageTransform * sself) {return sself ;} extern "C" vtkImplicitBoolean * vtkImplicitBoolean_new () {return vtkImplicitBoolean :: New () ;} extern "C" void vtkImplicitBoolean_destructor (vtkImplicitBoolean * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImplicitBoolean_get_ptr (vtkImplicitBoolean * sself) {return sself ;} extern "C" unsigned long vtk_implicit_boolean_get_m_time(vtkImplicitBoolean* sself) { return sself->GetMTime(); } extern "C" void vtk_implicit_boolean_set_operation_type(vtkImplicitBoolean* sself, int _arg) { sself->SetOperationType(_arg); } extern "C" int vtk_implicit_boolean_get_operation_type_min_value(vtkImplicitBoolean* sself) { return sself->GetOperationTypeMinValue(); } @@ -1115,17 +1041,14 @@ extern "C" void vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(v extern "C" const char* vtk_implicit_boolean_get_operation_type_as_string(vtkImplicitBoolean* sself) { return sself->GetOperationTypeAsString(); } extern "C" vtkImplicitDataSet * vtkImplicitDataSet_new () {return vtkImplicitDataSet :: New () ;} extern "C" void vtkImplicitDataSet_destructor (vtkImplicitDataSet * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImplicitDataSet_get_ptr (vtkImplicitDataSet * sself) {return sself ;} extern "C" unsigned long vtk_implicit_data_set_get_m_time(vtkImplicitDataSet* sself) { return sself->GetMTime(); } extern "C" void vtk_implicit_data_set_set_out_value(vtkImplicitDataSet* sself, double _arg) { sself->SetOutValue(_arg); } extern "C" double vtk_implicit_data_set_get_out_value(vtkImplicitDataSet* sself) { return sself->GetOutValue(); } extern "C" void vtk_implicit_data_set_set_out_gradient(vtkImplicitDataSet* sself, double _arg1, double _arg2, double _arg3) { sself->SetOutGradient(_arg1, _arg2, _arg3); } extern "C" vtkImplicitFunctionCollection * vtkImplicitFunctionCollection_new () {return vtkImplicitFunctionCollection :: New () ;} extern "C" void vtkImplicitFunctionCollection_destructor (vtkImplicitFunctionCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImplicitFunctionCollection_get_ptr (vtkImplicitFunctionCollection * sself) {return sself ;} extern "C" vtkImplicitHalo * vtkImplicitHalo_new () {return vtkImplicitHalo :: New () ;} extern "C" void vtkImplicitHalo_destructor (vtkImplicitHalo * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImplicitHalo_get_ptr (vtkImplicitHalo * sself) {return sself ;} extern "C" void vtk_implicit_halo_set_radius(vtkImplicitHalo* sself, double _arg) { sself->SetRadius(_arg); } extern "C" double vtk_implicit_halo_get_radius(vtkImplicitHalo* sself) { return sself->GetRadius(); } extern "C" void vtk_implicit_halo_set_center(vtkImplicitHalo* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } @@ -1133,7 +1056,6 @@ extern "C" void vtk_implicit_halo_set_fade_out(vtkImplicitHalo* sself, double _a extern "C" double vtk_implicit_halo_get_fade_out(vtkImplicitHalo* sself) { return sself->GetFadeOut(); } extern "C" vtkImplicitSelectionLoop * vtkImplicitSelectionLoop_new () {return vtkImplicitSelectionLoop :: New () ;} extern "C" void vtkImplicitSelectionLoop_destructor (vtkImplicitSelectionLoop * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImplicitSelectionLoop_get_ptr (vtkImplicitSelectionLoop * sself) {return sself ;} extern "C" void vtk_implicit_selection_loop_set_automatic_normal_generation(vtkImplicitSelectionLoop* sself, int _arg) { sself->SetAutomaticNormalGeneration(_arg); } extern "C" int vtk_implicit_selection_loop_get_automatic_normal_generation(vtkImplicitSelectionLoop* sself) { return sself->GetAutomaticNormalGeneration(); } extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_on(vtkImplicitSelectionLoop* sself) { sself->AutomaticNormalGenerationOn(); } @@ -1142,7 +1064,6 @@ extern "C" void vtk_implicit_selection_loop_set_normal(vtkImplicitSelectionLoop* extern "C" unsigned long vtk_implicit_selection_loop_get_m_time(vtkImplicitSelectionLoop* sself) { return sself->GetMTime(); } extern "C" vtkImplicitSum * vtkImplicitSum_new () {return vtkImplicitSum :: New () ;} extern "C" void vtkImplicitSum_destructor (vtkImplicitSum * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImplicitSum_get_ptr (vtkImplicitSum * sself) {return sself ;} extern "C" unsigned long vtk_implicit_sum_get_m_time(vtkImplicitSum* sself) { return sself->GetMTime(); } extern "C" void vtk_implicit_sum_remove_all_functions(vtkImplicitSum* sself) { sself->RemoveAllFunctions(); } extern "C" void vtk_implicit_sum_set_normalize_by_weight(vtkImplicitSum* sself, int _arg) { sself->SetNormalizeByWeight(_arg); } @@ -1151,25 +1072,21 @@ extern "C" void vtk_implicit_sum_normalize_by_weight_on(vtkImplicitSum* sself) { extern "C" void vtk_implicit_sum_normalize_by_weight_off(vtkImplicitSum* sself) { sself->NormalizeByWeightOff(); } extern "C" vtkImplicitVolume * vtkImplicitVolume_new () {return vtkImplicitVolume :: New () ;} extern "C" void vtkImplicitVolume_destructor (vtkImplicitVolume * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImplicitVolume_get_ptr (vtkImplicitVolume * sself) {return sself ;} extern "C" unsigned long vtk_implicit_volume_get_m_time(vtkImplicitVolume* sself) { return sself->GetMTime(); } extern "C" void vtk_implicit_volume_set_out_value(vtkImplicitVolume* sself, double _arg) { sself->SetOutValue(_arg); } extern "C" double vtk_implicit_volume_get_out_value(vtkImplicitVolume* sself) { return sself->GetOutValue(); } extern "C" void vtk_implicit_volume_set_out_gradient(vtkImplicitVolume* sself, double _arg1, double _arg2, double _arg3) { sself->SetOutGradient(_arg1, _arg2, _arg3); } extern "C" vtkImplicitWindowFunction * vtkImplicitWindowFunction_new () {return vtkImplicitWindowFunction :: New () ;} extern "C" void vtkImplicitWindowFunction_destructor (vtkImplicitWindowFunction * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImplicitWindowFunction_get_ptr (vtkImplicitWindowFunction * sself) {return sself ;} extern "C" void vtk_implicit_window_function_set_window_range(vtkImplicitWindowFunction* sself, double _arg1, double _arg2) { sself->SetWindowRange(_arg1, _arg2); } extern "C" void vtk_implicit_window_function_set_window_values(vtkImplicitWindowFunction* sself, double _arg1, double _arg2) { sself->SetWindowValues(_arg1, _arg2); } extern "C" unsigned long vtk_implicit_window_function_get_m_time(vtkImplicitWindowFunction* sself) { return sself->GetMTime(); } extern "C" vtkInEdgeIterator * vtkInEdgeIterator_new () {return vtkInEdgeIterator :: New () ;} extern "C" void vtkInEdgeIterator_destructor (vtkInEdgeIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkInEdgeIterator_get_ptr (vtkInEdgeIterator * sself) {return sself ;} extern "C" long long vtk_in_edge_iterator_get_vertex(vtkInEdgeIterator* sself) { return sself->GetVertex(); } extern "C" bool vtk_in_edge_iterator_has_next(vtkInEdgeIterator* sself) { return sself->HasNext(); } extern "C" vtkIncrementalOctreeNode * vtkIncrementalOctreeNode_new () {return vtkIncrementalOctreeNode :: New () ;} extern "C" void vtkIncrementalOctreeNode_destructor (vtkIncrementalOctreeNode * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkIncrementalOctreeNode_get_ptr (vtkIncrementalOctreeNode * sself) {return sself ;} extern "C" int vtk_incremental_octree_node_get_number_of_points(vtkIncrementalOctreeNode* sself) { return sself->GetNumberOfPoints(); } extern "C" void vtk_incremental_octree_node_delete_child_nodes(vtkIncrementalOctreeNode* sself) { sself->DeleteChildNodes(); } extern "C" void vtk_incremental_octree_node_set_bounds(vtkIncrementalOctreeNode* sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetBounds(x1, x2, y1, y2, z1, z2); } @@ -1178,7 +1095,6 @@ extern "C" int vtk_incremental_octree_node_get_number_of_levels(vtkIncrementalOc extern "C" int vtk_incremental_octree_node_get_id(vtkIncrementalOctreeNode* sself) { return sself->GetID(); } extern "C" vtkIncrementalOctreePointLocator * vtkIncrementalOctreePointLocator_new () {return vtkIncrementalOctreePointLocator :: New () ;} extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkIncrementalOctreePointLocator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkIncrementalOctreePointLocator_get_ptr (vtkIncrementalOctreePointLocator * sself) {return sself ;} extern "C" void vtk_incremental_octree_point_locator_set_max_points_per_leaf(vtkIncrementalOctreePointLocator* sself, int _arg) { sself->SetMaxPointsPerLeaf(_arg); } extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value(vtkIncrementalOctreePointLocator* sself) { return sself->GetMaxPointsPerLeafMinValue(); } extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value(vtkIncrementalOctreePointLocator* sself) { return sself->GetMaxPointsPerLeafMaxValue(); } @@ -1197,7 +1113,6 @@ extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkI extern "C" int vtk_incremental_octree_point_locator_get_number_of_levels(vtkIncrementalOctreePointLocator* sself) { return sself->GetNumberOfLevels(); } extern "C" vtkIterativeClosestPointTransform * vtkIterativeClosestPointTransform_new () {return vtkIterativeClosestPointTransform :: New () ;} extern "C" void vtkIterativeClosestPointTransform_destructor (vtkIterativeClosestPointTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkIterativeClosestPointTransform_get_ptr (vtkIterativeClosestPointTransform * sself) {return sself ;} extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetMaximumNumberOfIterations(_arg); } extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself) { return sself->GetMaximumNumberOfIterations(); } extern "C" int vtk_iterative_closest_point_transform_get_number_of_iterations(vtkIterativeClosestPointTransform* sself) { return sself->GetNumberOfIterations(); } @@ -1224,7 +1139,6 @@ extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroid extern "C" void vtk_iterative_closest_point_transform_inverse(vtkIterativeClosestPointTransform* sself) { sself->Inverse(); } extern "C" vtkKdNode * vtkKdNode_new () {return vtkKdNode :: New () ;} extern "C" void vtkKdNode_destructor (vtkKdNode * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkKdNode_get_ptr (vtkKdNode * sself) {return sself ;} extern "C" void vtk_kd_node_set_dim(vtkKdNode* sself, int _arg) { sself->SetDim(_arg); } extern "C" int vtk_kd_node_get_dim(vtkKdNode* sself) { return sself->GetDim(); } extern "C" double vtk_kd_node_get_division_position(vtkKdNode* sself) { return sself->GetDivisionPosition(); } @@ -1249,7 +1163,6 @@ extern "C" void vtk_kd_node_print_node(vtkKdNode* sself, int depth) { sself->Pri extern "C" void vtk_kd_node_print_verbose_node(vtkKdNode* sself, int depth) { sself->PrintVerboseNode(depth); } extern "C" vtkKdTree * vtkKdTree_new () {return vtkKdTree :: New () ;} extern "C" void vtkKdTree_destructor (vtkKdTree * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkKdTree_get_ptr (vtkKdTree * sself) {return sself ;} extern "C" void vtk_kd_tree_timing_on(vtkKdTree* sself) { sself->TimingOn(); } extern "C" void vtk_kd_tree_timing_off(vtkKdTree* sself) { sself->TimingOff(); } extern "C" void vtk_kd_tree_set_timing(vtkKdTree* sself, int _arg) { sself->SetTiming(_arg); } @@ -1292,39 +1205,30 @@ extern "C" int vtk_kd_tree_new_geometry(vtkKdTree* sself) { return sself->NewGeo extern "C" void vtk_kd_tree_invalidate_geometry(vtkKdTree* sself) { sself->InvalidateGeometry(); } extern "C" vtkKdTreePointLocator * vtkKdTreePointLocator_new () {return vtkKdTreePointLocator :: New () ;} extern "C" void vtkKdTreePointLocator_destructor (vtkKdTreePointLocator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkKdTreePointLocator_get_ptr (vtkKdTreePointLocator * sself) {return sself ;} extern "C" void vtk_kd_tree_point_locator_free_search_structure(vtkKdTreePointLocator* sself) { sself->FreeSearchStructure(); } extern "C" void vtk_kd_tree_point_locator_build_locator(vtkKdTreePointLocator* sself) { sself->BuildLocator(); } extern "C" vtkLagrangeCurve * vtkLagrangeCurve_new () {return vtkLagrangeCurve :: New () ;} extern "C" void vtkLagrangeCurve_destructor (vtkLagrangeCurve * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLagrangeCurve_get_ptr (vtkLagrangeCurve * sself) {return sself ;} extern "C" int vtk_lagrange_curve_get_cell_type(vtkLagrangeCurve* sself) { return sself->GetCellType(); } extern "C" vtkLagrangeHexahedron * vtkLagrangeHexahedron_new () {return vtkLagrangeHexahedron :: New () ;} extern "C" void vtkLagrangeHexahedron_destructor (vtkLagrangeHexahedron * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLagrangeHexahedron_get_ptr (vtkLagrangeHexahedron * sself) {return sself ;} extern "C" int vtk_lagrange_hexahedron_get_cell_type(vtkLagrangeHexahedron* sself) { return sself->GetCellType(); } extern "C" vtkLagrangeInterpolation * vtkLagrangeInterpolation_new () {return vtkLagrangeInterpolation :: New () ;} extern "C" void vtkLagrangeInterpolation_destructor (vtkLagrangeInterpolation * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLagrangeInterpolation_get_ptr (vtkLagrangeInterpolation * sself) {return sself ;} extern "C" vtkLagrangeQuadrilateral * vtkLagrangeQuadrilateral_new () {return vtkLagrangeQuadrilateral :: New () ;} extern "C" void vtkLagrangeQuadrilateral_destructor (vtkLagrangeQuadrilateral * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLagrangeQuadrilateral_get_ptr (vtkLagrangeQuadrilateral * sself) {return sself ;} extern "C" int vtk_lagrange_quadrilateral_get_cell_type(vtkLagrangeQuadrilateral* sself) { return sself->GetCellType(); } extern "C" vtkLagrangeTetra * vtkLagrangeTetra_new () {return vtkLagrangeTetra :: New () ;} extern "C" void vtkLagrangeTetra_destructor (vtkLagrangeTetra * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLagrangeTetra_get_ptr (vtkLagrangeTetra * sself) {return sself ;} extern "C" int vtk_lagrange_tetra_get_cell_type(vtkLagrangeTetra* sself) { return sself->GetCellType(); } extern "C" vtkLagrangeTriangle * vtkLagrangeTriangle_new () {return vtkLagrangeTriangle :: New () ;} extern "C" void vtkLagrangeTriangle_destructor (vtkLagrangeTriangle * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLagrangeTriangle_get_ptr (vtkLagrangeTriangle * sself) {return sself ;} extern "C" int vtk_lagrange_triangle_get_cell_type(vtkLagrangeTriangle* sself) { return sself->GetCellType(); } extern "C" vtkLagrangeWedge * vtkLagrangeWedge_new () {return vtkLagrangeWedge :: New () ;} extern "C" void vtkLagrangeWedge_destructor (vtkLagrangeWedge * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLagrangeWedge_get_ptr (vtkLagrangeWedge * sself) {return sself ;} extern "C" int vtk_lagrange_wedge_get_cell_type(vtkLagrangeWedge* sself) { return sself->GetCellType(); } extern "C" vtkLine * vtkLine_new () {return vtkLine :: New () ;} extern "C" void vtkLine_destructor (vtkLine * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLine_get_ptr (vtkLine * sself) {return sself ;} extern "C" int vtk_line_get_cell_type(vtkLine* sself) { return sself->GetCellType(); } extern "C" int vtk_line_get_cell_dimension(vtkLine* sself) { return sself->GetCellDimension(); } extern "C" int vtk_line_get_number_of_edges(vtkLine* sself) { return sself->GetNumberOfEdges(); } @@ -1332,13 +1236,10 @@ extern "C" int vtk_line_get_number_of_faces(vtkLine* sself) { return sself->GetN extern "C" int vtk_line_inflate(vtkLine* sself, double dist) { return sself->Inflate(dist); } extern "C" vtkMeanValueCoordinatesInterpolator * vtkMeanValueCoordinatesInterpolator_new () {return vtkMeanValueCoordinatesInterpolator :: New () ;} extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkMeanValueCoordinatesInterpolator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMeanValueCoordinatesInterpolator_get_ptr (vtkMeanValueCoordinatesInterpolator * sself) {return sself ;} extern "C" vtkMergePoints * vtkMergePoints_new () {return vtkMergePoints :: New () ;} extern "C" void vtkMergePoints_destructor (vtkMergePoints * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMergePoints_get_ptr (vtkMergePoints * sself) {return sself ;} extern "C" vtkMolecule * vtkMolecule_new () {return vtkMolecule :: New () ;} extern "C" void vtkMolecule_destructor (vtkMolecule * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMolecule_get_ptr (vtkMolecule * sself) {return sself ;} extern "C" long long vtk_molecule_get_number_of_atoms(vtkMolecule* sself) { return sself->GetNumberOfAtoms(); } extern "C" long long vtk_molecule_get_number_of_bonds(vtkMolecule* sself) { return sself->GetNumberOfBonds(); } extern "C" unsigned short vtk_molecule_get_atom_atomic_number(vtkMolecule* sself, long long atomId) { return sself->GetAtomAtomicNumber(atomId); } @@ -1355,19 +1256,16 @@ extern "C" void vtk_molecule_set_atomic_number_array_name(vtkMolecule* sself, co extern "C" void vtk_molecule_set_bond_orders_array_name(vtkMolecule* sself, const char* _arg) { sself->SetBondOrdersArrayName(_arg); } extern "C" vtkMultiBlockDataSet * vtkMultiBlockDataSet_new () {return vtkMultiBlockDataSet :: New () ;} extern "C" void vtkMultiBlockDataSet_destructor (vtkMultiBlockDataSet * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMultiBlockDataSet_get_ptr (vtkMultiBlockDataSet * sself) {return sself ;} extern "C" void vtk_multi_block_data_set_set_number_of_blocks(vtkMultiBlockDataSet* sself, unsigned int numBlocks) { sself->SetNumberOfBlocks(numBlocks); } extern "C" unsigned int vtk_multi_block_data_set_get_number_of_blocks(vtkMultiBlockDataSet* sself) { return sself->GetNumberOfBlocks(); } extern "C" void vtk_multi_block_data_set_remove_block(vtkMultiBlockDataSet* sself, unsigned int blockno) { sself->RemoveBlock(blockno); } extern "C" int vtk_multi_block_data_set_has_meta_data(vtkMultiBlockDataSet* sself, unsigned int blockno) { return sself->HasMetaData(blockno); } extern "C" vtkMultiPieceDataSet * vtkMultiPieceDataSet_new () {return vtkMultiPieceDataSet :: New () ;} extern "C" void vtkMultiPieceDataSet_destructor (vtkMultiPieceDataSet * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMultiPieceDataSet_get_ptr (vtkMultiPieceDataSet * sself) {return sself ;} extern "C" void vtk_multi_piece_data_set_set_number_of_pieces(vtkMultiPieceDataSet* sself, unsigned int numpieces) { sself->SetNumberOfPieces(numpieces); } extern "C" unsigned int vtk_multi_piece_data_set_get_number_of_pieces(vtkMultiPieceDataSet* sself) { return sself->GetNumberOfPieces(); } extern "C" vtkMutableDirectedGraph * vtkMutableDirectedGraph_new () {return vtkMutableDirectedGraph :: New () ;} extern "C" void vtkMutableDirectedGraph_destructor (vtkMutableDirectedGraph * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMutableDirectedGraph_get_ptr (vtkMutableDirectedGraph * sself) {return sself ;} extern "C" long long vtk_mutable_directed_graph_set_number_of_vertices(vtkMutableDirectedGraph* sself, long long numVerts) { return sself->SetNumberOfVertices(numVerts); } extern "C" long long vtk_mutable_directed_graph_add_vertex(vtkMutableDirectedGraph* sself) { return sself->AddVertex(); } extern "C" void vtk_mutable_directed_graph_lazy_add_vertex(vtkMutableDirectedGraph* sself) { sself->LazyAddVertex(); } @@ -1375,7 +1273,6 @@ extern "C" void vtk_mutable_directed_graph_remove_vertex(vtkMutableDirectedGraph extern "C" void vtk_mutable_directed_graph_remove_edge(vtkMutableDirectedGraph* sself, long long e) { sself->RemoveEdge(e); } extern "C" vtkMutableUndirectedGraph * vtkMutableUndirectedGraph_new () {return vtkMutableUndirectedGraph :: New () ;} extern "C" void vtkMutableUndirectedGraph_destructor (vtkMutableUndirectedGraph * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMutableUndirectedGraph_get_ptr (vtkMutableUndirectedGraph * sself) {return sself ;} extern "C" long long vtk_mutable_undirected_graph_set_number_of_vertices(vtkMutableUndirectedGraph* sself, long long numVerts) { return sself->SetNumberOfVertices(numVerts); } extern "C" long long vtk_mutable_undirected_graph_add_vertex(vtkMutableUndirectedGraph* sself) { return sself->AddVertex(); } extern "C" void vtk_mutable_undirected_graph_lazy_add_vertex(vtkMutableUndirectedGraph* sself) { sself->LazyAddVertex(); } @@ -1384,15 +1281,12 @@ extern "C" void vtk_mutable_undirected_graph_remove_vertex(vtkMutableUndirectedG extern "C" void vtk_mutable_undirected_graph_remove_edge(vtkMutableUndirectedGraph* sself, long long e) { sself->RemoveEdge(e); } extern "C" vtkNonMergingPointLocator * vtkNonMergingPointLocator_new () {return vtkNonMergingPointLocator :: New () ;} extern "C" void vtkNonMergingPointLocator_destructor (vtkNonMergingPointLocator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkNonMergingPointLocator_get_ptr (vtkNonMergingPointLocator * sself) {return sself ;} extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNonMergingPointLocator* sself, double p0, double p1, double p2) { return sself->IsInsertedPoint(p0, p1, p2); } extern "C" vtkNonOverlappingAMR * vtkNonOverlappingAMR_new () {return vtkNonOverlappingAMR :: New () ;} extern "C" void vtkNonOverlappingAMR_destructor (vtkNonOverlappingAMR * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkNonOverlappingAMR_get_ptr (vtkNonOverlappingAMR * sself) {return sself ;} extern "C" int vtk_non_overlapping_amr_get_data_object_type(vtkNonOverlappingAMR* sself) { return sself->GetDataObjectType(); } extern "C" vtkOctreePointLocator * vtkOctreePointLocator_new () {return vtkOctreePointLocator :: New () ;} extern "C" void vtkOctreePointLocator_destructor (vtkOctreePointLocator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOctreePointLocator_get_ptr (vtkOctreePointLocator * sself) {return sself ;} extern "C" void vtk_octree_point_locator_set_maximum_points_per_region(vtkOctreePointLocator* sself, int _arg) { sself->SetMaximumPointsPerRegion(_arg); } extern "C" int vtk_octree_point_locator_get_maximum_points_per_region(vtkOctreePointLocator* sself) { return sself->GetMaximumPointsPerRegion(); } extern "C" void vtk_octree_point_locator_set_create_cubic_octants(vtkOctreePointLocator* sself, int _arg) { sself->SetCreateCubicOctants(_arg); } @@ -1406,7 +1300,6 @@ extern "C" long long vtk_octree_point_locator_find_closest_point(vtkOctreePointL extern "C" void vtk_octree_point_locator_free_search_structure(vtkOctreePointLocator* sself) { sself->FreeSearchStructure(); } extern "C" vtkOctreePointLocatorNode * vtkOctreePointLocatorNode_new () {return vtkOctreePointLocatorNode :: New () ;} extern "C" void vtkOctreePointLocatorNode_destructor (vtkOctreePointLocatorNode * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOctreePointLocatorNode_get_ptr (vtkOctreePointLocatorNode * sself) {return sself ;} extern "C" void vtk_octree_point_locator_node_set_number_of_points(vtkOctreePointLocatorNode* sself, int numberOfPoints) { sself->SetNumberOfPoints(numberOfPoints); } extern "C" int vtk_octree_point_locator_node_get_number_of_points(vtkOctreePointLocatorNode* sself) { return sself->GetNumberOfPoints(); } extern "C" void vtk_octree_point_locator_node_set_bounds(vtkOctreePointLocatorNode* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } @@ -1418,7 +1311,6 @@ extern "C" void vtk_octree_point_locator_node_delete_child_nodes(vtkOctreePointL extern "C" int vtk_octree_point_locator_node_contains_point(vtkOctreePointLocatorNode* sself, double x, double y, double z, int useDataBounds) { return sself->ContainsPoint(x, y, z, useDataBounds); } extern "C" vtkOrderedTriangulator * vtkOrderedTriangulator_new () {return vtkOrderedTriangulator :: New () ;} extern "C" void vtkOrderedTriangulator_destructor (vtkOrderedTriangulator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOrderedTriangulator_get_ptr (vtkOrderedTriangulator * sself) {return sself ;} extern "C" void vtk_ordered_triangulator_init_triangulation(vtkOrderedTriangulator* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts) { sself->InitTriangulation(xmin, xmax, ymin, ymax, zmin, zmax, numPts); } extern "C" void vtk_ordered_triangulator_triangulate(vtkOrderedTriangulator* sself) { sself->Triangulate(); } extern "C" void vtk_ordered_triangulator_template_triangulate(vtkOrderedTriangulator* sself, int cellType, int numPts, int numEdges) { sself->TemplateTriangulate(cellType, numPts, numEdges); } @@ -1440,12 +1332,10 @@ extern "C" void vtk_ordered_triangulator_use_two_sort_ids_off(vtkOrderedTriangul extern "C" void vtk_ordered_triangulator_init_tetra_traversal(vtkOrderedTriangulator* sself) { sself->InitTetraTraversal(); } extern "C" vtkOutEdgeIterator * vtkOutEdgeIterator_new () {return vtkOutEdgeIterator :: New () ;} extern "C" void vtkOutEdgeIterator_destructor (vtkOutEdgeIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOutEdgeIterator_get_ptr (vtkOutEdgeIterator * sself) {return sself ;} extern "C" long long vtk_out_edge_iterator_get_vertex(vtkOutEdgeIterator* sself) { return sself->GetVertex(); } extern "C" bool vtk_out_edge_iterator_has_next(vtkOutEdgeIterator* sself) { return sself->HasNext(); } extern "C" vtkOverlappingAMR * vtkOverlappingAMR_new () {return vtkOverlappingAMR :: New () ;} extern "C" void vtkOverlappingAMR_destructor (vtkOverlappingAMR * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOverlappingAMR_get_ptr (vtkOverlappingAMR * sself) {return sself ;} extern "C" void vtk_overlapping_amr_set_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level, int refRatio) { sself->SetRefinementRatio(level, refRatio); } extern "C" int vtk_overlapping_amr_get_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level) { return sself->GetRefinementRatio(level); } extern "C" void vtk_overlapping_amr_set_amr_block_source_index(vtkOverlappingAMR* sself, unsigned int level, unsigned int id, int sourceId) { sself->SetAMRBlockSourceIndex(level, id, sourceId); } @@ -1456,14 +1346,12 @@ extern "C" void vtk_overlapping_amr_print_parent_child_info(vtkOverlappingAMR* s extern "C" void vtk_overlapping_amr_audit(vtkOverlappingAMR* sself) { sself->Audit(); } extern "C" vtkPartitionedDataSet * vtkPartitionedDataSet_new () {return vtkPartitionedDataSet :: New () ;} extern "C" void vtkPartitionedDataSet_destructor (vtkPartitionedDataSet * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPartitionedDataSet_get_ptr (vtkPartitionedDataSet * sself) {return sself ;} extern "C" void vtk_partitioned_data_set_set_number_of_partitions(vtkPartitionedDataSet* sself, unsigned int numPartitions) { sself->SetNumberOfPartitions(numPartitions); } extern "C" unsigned int vtk_partitioned_data_set_get_number_of_partitions(vtkPartitionedDataSet* sself) { return sself->GetNumberOfPartitions(); } extern "C" int vtk_partitioned_data_set_has_meta_data(vtkPartitionedDataSet* sself, unsigned int idx) { return sself->HasMetaData(idx); } extern "C" void vtk_partitioned_data_set_remove_null_partitions(vtkPartitionedDataSet* sself) { sself->RemoveNullPartitions(); } extern "C" vtkPartitionedDataSetCollection * vtkPartitionedDataSetCollection_new () {return vtkPartitionedDataSetCollection :: New () ;} extern "C" void vtkPartitionedDataSetCollection_destructor (vtkPartitionedDataSetCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPartitionedDataSetCollection_get_ptr (vtkPartitionedDataSetCollection * sself) {return sself ;} extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself, unsigned int numDataSets) { sself->SetNumberOfPartitionedDataSets(numDataSets); } extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself) { return sself->GetNumberOfPartitionedDataSets(); } extern "C" void vtk_partitioned_data_set_collection_remove_partitioned_data_set(vtkPartitionedDataSetCollection* sself, unsigned int idx) { sself->RemovePartitionedDataSet(idx); } @@ -1474,7 +1362,6 @@ extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index( extern "C" unsigned long vtk_partitioned_data_set_collection_get_m_time(vtkPartitionedDataSetCollection* sself) { return sself->GetMTime(); } extern "C" vtkPath * vtkPath_new () {return vtkPath :: New () ;} extern "C" void vtkPath_destructor (vtkPath * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPath_get_ptr (vtkPath * sself) {return sself ;} extern "C" int vtk_path_get_data_object_type(vtkPath* sself) { return sself->GetDataObjectType(); } extern "C" void vtk_path_insert_next_point(vtkPath* sself, double x, double y, double z, int code) { sself->InsertNextPoint(x, y, z, code); } extern "C" long long vtk_path_get_number_of_cells(vtkPath* sself) { return sself->GetNumberOfCells(); } @@ -1483,20 +1370,17 @@ extern "C" void vtk_path_allocate(vtkPath* sself, long long size, int extSize) { extern "C" void vtk_path_reset(vtkPath* sself) { sself->Reset(); } extern "C" vtkPentagonalPrism * vtkPentagonalPrism_new () {return vtkPentagonalPrism :: New () ;} extern "C" void vtkPentagonalPrism_destructor (vtkPentagonalPrism * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPentagonalPrism_get_ptr (vtkPentagonalPrism * sself) {return sself ;} extern "C" int vtk_pentagonal_prism_get_cell_type(vtkPentagonalPrism* sself) { return sself->GetCellType(); } extern "C" int vtk_pentagonal_prism_get_number_of_edges(vtkPentagonalPrism* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_pentagonal_prism_get_number_of_faces(vtkPentagonalPrism* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkPerlinNoise * vtkPerlinNoise_new () {return vtkPerlinNoise :: New () ;} extern "C" void vtkPerlinNoise_destructor (vtkPerlinNoise * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPerlinNoise_get_ptr (vtkPerlinNoise * sself) {return sself ;} extern "C" void vtk_perlin_noise_set_frequency(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3) { sself->SetFrequency(_arg1, _arg2, _arg3); } extern "C" void vtk_perlin_noise_set_phase(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3) { sself->SetPhase(_arg1, _arg2, _arg3); } extern "C" void vtk_perlin_noise_set_amplitude(vtkPerlinNoise* sself, double _arg) { sself->SetAmplitude(_arg); } extern "C" double vtk_perlin_noise_get_amplitude(vtkPerlinNoise* sself) { return sself->GetAmplitude(); } extern "C" vtkPiecewiseFunction * vtkPiecewiseFunction_new () {return vtkPiecewiseFunction :: New () ;} extern "C" void vtkPiecewiseFunction_destructor (vtkPiecewiseFunction * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPiecewiseFunction_get_ptr (vtkPiecewiseFunction * sself) {return sself ;} extern "C" int vtk_piecewise_function_get_data_object_type(vtkPiecewiseFunction* sself) { return sself->GetDataObjectType(); } extern "C" int vtk_piecewise_function_get_size(vtkPiecewiseFunction* sself) { return sself->GetSize(); } extern "C" int vtk_piecewise_function_add_point(vtkPiecewiseFunction* sself, double x, double y) { return sself->AddPoint(x, y); } @@ -1523,7 +1407,6 @@ extern "C" void vtk_piecewise_function_allow_duplicate_scalars_off(vtkPiecewiseF extern "C" int vtk_piecewise_function_estimate_min_number_of_samples(vtkPiecewiseFunction* sself, const double& x1, const double& x2) { return sself->EstimateMinNumberOfSamples(x1, x2); } extern "C" vtkPixel * vtkPixel_new () {return vtkPixel :: New () ;} extern "C" void vtkPixel_destructor (vtkPixel * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPixel_get_ptr (vtkPixel * sself) {return sself ;} extern "C" int vtk_pixel_get_cell_type(vtkPixel* sself) { return sself->GetCellType(); } extern "C" int vtk_pixel_get_cell_dimension(vtkPixel* sself) { return sself->GetCellDimension(); } extern "C" int vtk_pixel_get_number_of_edges(vtkPixel* sself) { return sself->GetNumberOfEdges(); } @@ -1531,31 +1414,25 @@ extern "C" int vtk_pixel_get_number_of_faces(vtkPixel* sself) { return sself->Ge extern "C" int vtk_pixel_inflate(vtkPixel* sself, double dist) { return sself->Inflate(dist); } extern "C" vtkPlane * vtkPlane_new () {return vtkPlane :: New () ;} extern "C" void vtkPlane_destructor (vtkPlane * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPlane_get_ptr (vtkPlane * sself) {return sself ;} extern "C" void vtk_plane_set_normal(vtkPlane* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } extern "C" void vtk_plane_set_origin(vtkPlane* sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } extern "C" void vtk_plane_push(vtkPlane* sself, double distance) { sself->Push(distance); } extern "C" vtkPlaneCollection * vtkPlaneCollection_new () {return vtkPlaneCollection :: New () ;} extern "C" void vtkPlaneCollection_destructor (vtkPlaneCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPlaneCollection_get_ptr (vtkPlaneCollection * sself) {return sself ;} extern "C" int vtk_plane_collection_get_number_of_items(vtkPlaneCollection* sself) { return sself->GetNumberOfItems(); } extern "C" vtkPlanes * vtkPlanes_new () {return vtkPlanes :: New () ;} extern "C" void vtkPlanes_destructor (vtkPlanes * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPlanes_get_ptr (vtkPlanes * sself) {return sself ;} extern "C" void vtk_planes_set_bounds(vtkPlanes* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) { sself->SetBounds(xmin, xmax, ymin, ymax, zmin, zmax); } extern "C" int vtk_planes_get_number_of_planes(vtkPlanes* sself) { return sself->GetNumberOfPlanes(); } extern "C" vtkPlanesIntersection * vtkPlanesIntersection_new () {return vtkPlanesIntersection :: New () ;} extern "C" void vtkPlanesIntersection_destructor (vtkPlanesIntersection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPlanesIntersection_get_ptr (vtkPlanesIntersection * sself) {return sself ;} extern "C" int vtk_planes_intersection_get_number_of_region_vertices(vtkPlanesIntersection* sself) { return sself->GetNumberOfRegionVertices(); } extern "C" int vtk_planes_intersection_get_num_region_vertices(vtkPlanesIntersection* sself) { return sself->GetNumRegionVertices(); } extern "C" vtkPointData * vtkPointData_new () {return vtkPointData :: New () ;} extern "C" void vtkPointData_destructor (vtkPointData * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPointData_get_ptr (vtkPointData * sself) {return sself ;} extern "C" void vtk_point_data_null_point(vtkPointData* sself, long long ptId) { sself->NullPoint(ptId); } extern "C" vtkPointLocator * vtkPointLocator_new () {return vtkPointLocator :: New () ;} extern "C" void vtkPointLocator_destructor (vtkPointLocator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPointLocator_get_ptr (vtkPointLocator * sself) {return sself ;} extern "C" void vtk_point_locator_set_divisions(vtkPointLocator* sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } extern "C" void vtk_point_locator_set_number_of_points_per_bucket(vtkPointLocator* sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } extern "C" int vtk_point_locator_get_number_of_points_per_bucket_min_value(vtkPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } @@ -1567,7 +1444,6 @@ extern "C" void vtk_point_locator_free_search_structure(vtkPointLocator* sself) extern "C" void vtk_point_locator_build_locator(vtkPointLocator* sself) { sself->BuildLocator(); } extern "C" vtkPointSet * vtkPointSet_new () {return vtkPointSet :: New () ;} extern "C" void vtkPointSet_destructor (vtkPointSet * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPointSet_get_ptr (vtkPointSet * sself) {return sself ;} extern "C" void vtk_point_set_set_editable(vtkPointSet* sself, bool _arg) { sself->SetEditable(_arg); } extern "C" bool vtk_point_set_get_editable(vtkPointSet* sself) { return sself->GetEditable(); } extern "C" void vtk_point_set_editable_on(vtkPointSet* sself) { sself->EditableOn(); } @@ -1585,19 +1461,16 @@ extern "C" void vtk_point_set_compute_bounds(vtkPointSet* sself) { sself->Comput extern "C" void vtk_point_set_squeeze(vtkPointSet* sself) { sself->Squeeze(); } extern "C" vtkPointSetCellIterator * vtkPointSetCellIterator_new () {return vtkPointSetCellIterator :: New () ;} extern "C" void vtkPointSetCellIterator_destructor (vtkPointSetCellIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPointSetCellIterator_get_ptr (vtkPointSetCellIterator * sself) {return sself ;} extern "C" bool vtk_point_set_cell_iterator_is_done_with_traversal(vtkPointSetCellIterator* sself) { return sself->IsDoneWithTraversal(); } extern "C" long long vtk_point_set_cell_iterator_get_cell_id(vtkPointSetCellIterator* sself) { return sself->GetCellId(); } extern "C" vtkPointsProjectedHull * vtkPointsProjectedHull_new () {return vtkPointsProjectedHull :: New () ;} extern "C" void vtkPointsProjectedHull_destructor (vtkPointsProjectedHull * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPointsProjectedHull_get_ptr (vtkPointsProjectedHull * sself) {return sself ;} extern "C" int vtk_points_projected_hull_get_size_ccw_hull_x(vtkPointsProjectedHull* sself) { return sself->GetSizeCCWHullX(); } extern "C" int vtk_points_projected_hull_get_size_ccw_hull_y(vtkPointsProjectedHull* sself) { return sself->GetSizeCCWHullY(); } extern "C" int vtk_points_projected_hull_get_size_ccw_hull_z(vtkPointsProjectedHull* sself) { return sself->GetSizeCCWHullZ(); } extern "C" void vtk_points_projected_hull_update(vtkPointsProjectedHull* sself) { sself->Update(); } extern "C" vtkPolyData * vtkPolyData_new () {return vtkPolyData :: New () ;} extern "C" void vtkPolyData_destructor (vtkPolyData * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolyData_get_ptr (vtkPolyData * sself) {return sself ;} extern "C" int vtk_poly_data_get_data_object_type(vtkPolyData* sself) { return sself->GetDataObjectType(); } extern "C" long long vtk_poly_data_get_number_of_cells(vtkPolyData* sself) { return sself->GetNumberOfCells(); } extern "C" int vtk_poly_data_get_cell_type(vtkPolyData* sself, long long cellId) { return sself->GetCellType(cellId); } @@ -1641,28 +1514,23 @@ extern "C" unsigned long vtk_poly_data_get_mesh_m_time(vtkPolyData* sself) { ret extern "C" unsigned long vtk_poly_data_get_m_time(vtkPolyData* sself) { return sself->GetMTime(); } extern "C" vtkPolyDataCollection * vtkPolyDataCollection_new () {return vtkPolyDataCollection :: New () ;} extern "C" void vtkPolyDataCollection_destructor (vtkPolyDataCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolyDataCollection_get_ptr (vtkPolyDataCollection * sself) {return sself ;} extern "C" vtkPolyLine * vtkPolyLine_new () {return vtkPolyLine :: New () ;} extern "C" void vtkPolyLine_destructor (vtkPolyLine * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolyLine_get_ptr (vtkPolyLine * sself) {return sself ;} extern "C" int vtk_poly_line_get_cell_type(vtkPolyLine* sself) { return sself->GetCellType(); } extern "C" int vtk_poly_line_get_cell_dimension(vtkPolyLine* sself) { return sself->GetCellDimension(); } extern "C" int vtk_poly_line_get_number_of_edges(vtkPolyLine* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_poly_line_get_number_of_faces(vtkPolyLine* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkPolyPlane * vtkPolyPlane_new () {return vtkPolyPlane :: New () ;} extern "C" void vtkPolyPlane_destructor (vtkPolyPlane * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolyPlane_get_ptr (vtkPolyPlane * sself) {return sself ;} extern "C" unsigned long vtk_poly_plane_get_m_time(vtkPolyPlane* sself) { return sself->GetMTime(); } extern "C" vtkPolyVertex * vtkPolyVertex_new () {return vtkPolyVertex :: New () ;} extern "C" void vtkPolyVertex_destructor (vtkPolyVertex * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolyVertex_get_ptr (vtkPolyVertex * sself) {return sself ;} extern "C" int vtk_poly_vertex_get_cell_type(vtkPolyVertex* sself) { return sself->GetCellType(); } extern "C" int vtk_poly_vertex_get_cell_dimension(vtkPolyVertex* sself) { return sself->GetCellDimension(); } extern "C" int vtk_poly_vertex_get_number_of_edges(vtkPolyVertex* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_poly_vertex_get_number_of_faces(vtkPolyVertex* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkPolygon * vtkPolygon_new () {return vtkPolygon :: New () ;} extern "C" void vtkPolygon_destructor (vtkPolygon * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolygon_get_ptr (vtkPolygon * sself) {return sself ;} extern "C" int vtk_polygon_get_cell_type(vtkPolygon* sself) { return sself->GetCellType(); } extern "C" int vtk_polygon_get_cell_dimension(vtkPolygon* sself) { return sself->GetCellDimension(); } extern "C" int vtk_polygon_get_number_of_edges(vtkPolygon* sself) { return sself->GetNumberOfEdges(); } @@ -1679,7 +1547,6 @@ extern "C" int vtk_polygon_ear_cut_triangulation(vtkPolygon* sself, int measure) extern "C" int vtk_polygon_unbiased_ear_cut_triangulation(vtkPolygon* sself, int seed, int measure) { return sself->UnbiasedEarCutTriangulation(seed, measure); } extern "C" vtkPolyhedron * vtkPolyhedron_new () {return vtkPolyhedron :: New () ;} extern "C" void vtkPolyhedron_destructor (vtkPolyhedron * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolyhedron_get_ptr (vtkPolyhedron * sself) {return sself ;} extern "C" int vtk_polyhedron_get_cell_type(vtkPolyhedron* sself) { return sself->GetCellType(); } extern "C" int vtk_polyhedron_requires_initialization(vtkPolyhedron* sself) { return sself->RequiresInitialization(); } extern "C" int vtk_polyhedron_get_number_of_edges(vtkPolyhedron* sself) { return sself->GetNumberOfEdges(); } @@ -1689,48 +1556,41 @@ extern "C" int vtk_polyhedron_requires_explicit_face_representation(vtkPolyhedro extern "C" bool vtk_polyhedron_is_convex(vtkPolyhedron* sself) { return sself->IsConvex(); } extern "C" vtkPyramid * vtkPyramid_new () {return vtkPyramid :: New () ;} extern "C" void vtkPyramid_destructor (vtkPyramid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPyramid_get_ptr (vtkPyramid * sself) {return sself ;} extern "C" int vtk_pyramid_get_cell_type(vtkPyramid* sself) { return sself->GetCellType(); } extern "C" int vtk_pyramid_get_number_of_edges(vtkPyramid* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_pyramid_get_number_of_faces(vtkPyramid* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuad * vtkQuad_new () {return vtkQuad :: New () ;} extern "C" void vtkQuad_destructor (vtkQuad * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuad_get_ptr (vtkQuad * sself) {return sself ;} extern "C" int vtk_quad_get_cell_type(vtkQuad* sself) { return sself->GetCellType(); } extern "C" int vtk_quad_get_cell_dimension(vtkQuad* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quad_get_number_of_edges(vtkQuad* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_quad_get_number_of_faces(vtkQuad* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuadraticEdge * vtkQuadraticEdge_new () {return vtkQuadraticEdge :: New () ;} extern "C" void vtkQuadraticEdge_destructor (vtkQuadraticEdge * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadraticEdge_get_ptr (vtkQuadraticEdge * sself) {return sself ;} extern "C" int vtk_quadratic_edge_get_cell_type(vtkQuadraticEdge* sself) { return sself->GetCellType(); } extern "C" int vtk_quadratic_edge_get_cell_dimension(vtkQuadraticEdge* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quadratic_edge_get_number_of_edges(vtkQuadraticEdge* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_quadratic_edge_get_number_of_faces(vtkQuadraticEdge* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuadraticHexahedron * vtkQuadraticHexahedron_new () {return vtkQuadraticHexahedron :: New () ;} extern "C" void vtkQuadraticHexahedron_destructor (vtkQuadraticHexahedron * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadraticHexahedron_get_ptr (vtkQuadraticHexahedron * sself) {return sself ;} extern "C" int vtk_quadratic_hexahedron_get_cell_type(vtkQuadraticHexahedron* sself) { return sself->GetCellType(); } extern "C" int vtk_quadratic_hexahedron_get_cell_dimension(vtkQuadraticHexahedron* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quadratic_hexahedron_get_number_of_edges(vtkQuadraticHexahedron* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_quadratic_hexahedron_get_number_of_faces(vtkQuadraticHexahedron* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuadraticLinearQuad * vtkQuadraticLinearQuad_new () {return vtkQuadraticLinearQuad :: New () ;} extern "C" void vtkQuadraticLinearQuad_destructor (vtkQuadraticLinearQuad * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadraticLinearQuad_get_ptr (vtkQuadraticLinearQuad * sself) {return sself ;} extern "C" int vtk_quadratic_linear_quad_get_cell_type(vtkQuadraticLinearQuad* sself) { return sself->GetCellType(); } extern "C" int vtk_quadratic_linear_quad_get_cell_dimension(vtkQuadraticLinearQuad* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quadratic_linear_quad_get_number_of_edges(vtkQuadraticLinearQuad* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_quadratic_linear_quad_get_number_of_faces(vtkQuadraticLinearQuad* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuadraticLinearWedge * vtkQuadraticLinearWedge_new () {return vtkQuadraticLinearWedge :: New () ;} extern "C" void vtkQuadraticLinearWedge_destructor (vtkQuadraticLinearWedge * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadraticLinearWedge_get_ptr (vtkQuadraticLinearWedge * sself) {return sself ;} extern "C" int vtk_quadratic_linear_wedge_get_cell_type(vtkQuadraticLinearWedge* sself) { return sself->GetCellType(); } extern "C" int vtk_quadratic_linear_wedge_get_cell_dimension(vtkQuadraticLinearWedge* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quadratic_linear_wedge_get_number_of_edges(vtkQuadraticLinearWedge* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_quadratic_linear_wedge_get_number_of_faces(vtkQuadraticLinearWedge* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuadraticPolygon * vtkQuadraticPolygon_new () {return vtkQuadraticPolygon :: New () ;} extern "C" void vtkQuadraticPolygon_destructor (vtkQuadraticPolygon * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadraticPolygon_get_ptr (vtkQuadraticPolygon * sself) {return sself ;} extern "C" int vtk_quadratic_polygon_get_cell_type(vtkQuadraticPolygon* sself) { return sself->GetCellType(); } extern "C" int vtk_quadratic_polygon_get_cell_dimension(vtkQuadraticPolygon* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quadratic_polygon_get_number_of_edges(vtkQuadraticPolygon* sself) { return sself->GetNumberOfEdges(); } @@ -1739,42 +1599,36 @@ extern "C" bool vtk_quadratic_polygon_get_use_mvc_interpolation(vtkQuadraticPoly extern "C" void vtk_quadratic_polygon_set_use_mvc_interpolation(vtkQuadraticPolygon* sself, bool _arg) { sself->SetUseMVCInterpolation(_arg); } extern "C" vtkQuadraticPyramid * vtkQuadraticPyramid_new () {return vtkQuadraticPyramid :: New () ;} extern "C" void vtkQuadraticPyramid_destructor (vtkQuadraticPyramid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadraticPyramid_get_ptr (vtkQuadraticPyramid * sself) {return sself ;} extern "C" int vtk_quadratic_pyramid_get_cell_type(vtkQuadraticPyramid* sself) { return sself->GetCellType(); } extern "C" int vtk_quadratic_pyramid_get_cell_dimension(vtkQuadraticPyramid* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quadratic_pyramid_get_number_of_edges(vtkQuadraticPyramid* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_quadratic_pyramid_get_number_of_faces(vtkQuadraticPyramid* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuadraticQuad * vtkQuadraticQuad_new () {return vtkQuadraticQuad :: New () ;} extern "C" void vtkQuadraticQuad_destructor (vtkQuadraticQuad * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadraticQuad_get_ptr (vtkQuadraticQuad * sself) {return sself ;} extern "C" int vtk_quadratic_quad_get_cell_type(vtkQuadraticQuad* sself) { return sself->GetCellType(); } extern "C" int vtk_quadratic_quad_get_cell_dimension(vtkQuadraticQuad* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quadratic_quad_get_number_of_edges(vtkQuadraticQuad* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_quadratic_quad_get_number_of_faces(vtkQuadraticQuad* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuadraticTetra * vtkQuadraticTetra_new () {return vtkQuadraticTetra :: New () ;} extern "C" void vtkQuadraticTetra_destructor (vtkQuadraticTetra * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadraticTetra_get_ptr (vtkQuadraticTetra * sself) {return sself ;} extern "C" int vtk_quadratic_tetra_get_cell_type(vtkQuadraticTetra* sself) { return sself->GetCellType(); } extern "C" int vtk_quadratic_tetra_get_cell_dimension(vtkQuadraticTetra* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quadratic_tetra_get_number_of_edges(vtkQuadraticTetra* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_quadratic_tetra_get_number_of_faces(vtkQuadraticTetra* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuadraticTriangle * vtkQuadraticTriangle_new () {return vtkQuadraticTriangle :: New () ;} extern "C" void vtkQuadraticTriangle_destructor (vtkQuadraticTriangle * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadraticTriangle_get_ptr (vtkQuadraticTriangle * sself) {return sself ;} extern "C" int vtk_quadratic_triangle_get_cell_type(vtkQuadraticTriangle* sself) { return sself->GetCellType(); } extern "C" int vtk_quadratic_triangle_get_cell_dimension(vtkQuadraticTriangle* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quadratic_triangle_get_number_of_edges(vtkQuadraticTriangle* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_quadratic_triangle_get_number_of_faces(vtkQuadraticTriangle* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuadraticWedge * vtkQuadraticWedge_new () {return vtkQuadraticWedge :: New () ;} extern "C" void vtkQuadraticWedge_destructor (vtkQuadraticWedge * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadraticWedge_get_ptr (vtkQuadraticWedge * sself) {return sself ;} extern "C" int vtk_quadratic_wedge_get_cell_type(vtkQuadraticWedge* sself) { return sself->GetCellType(); } extern "C" int vtk_quadratic_wedge_get_cell_dimension(vtkQuadraticWedge* sself) { return sself->GetCellDimension(); } extern "C" int vtk_quadratic_wedge_get_number_of_edges(vtkQuadraticWedge* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_quadratic_wedge_get_number_of_faces(vtkQuadraticWedge* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkQuadratureSchemeDefinition * vtkQuadratureSchemeDefinition_new () {return vtkQuadratureSchemeDefinition :: New () ;} extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkQuadratureSchemeDefinition * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadratureSchemeDefinition_get_ptr (vtkQuadratureSchemeDefinition * sself) {return sself ;} extern "C" void vtk_quadrature_scheme_definition_clear(vtkQuadratureSchemeDefinition* sself) { sself->Clear(); } extern "C" int vtk_quadrature_scheme_definition_get_cell_type(vtkQuadratureSchemeDefinition* sself) { return sself->GetCellType(); } extern "C" int vtk_quadrature_scheme_definition_get_quadrature_key(vtkQuadratureSchemeDefinition* sself) { return sself->GetQuadratureKey(); } @@ -1782,11 +1636,9 @@ extern "C" int vtk_quadrature_scheme_definition_get_number_of_nodes(vtkQuadratur extern "C" int vtk_quadrature_scheme_definition_get_number_of_quadrature_points(vtkQuadratureSchemeDefinition* sself) { return sself->GetNumberOfQuadraturePoints(); } extern "C" vtkQuadric * vtkQuadric_new () {return vtkQuadric :: New () ;} extern "C" void vtkQuadric_destructor (vtkQuadric * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuadric_get_ptr (vtkQuadric * sself) {return sself ;} extern "C" void vtk_quadric_set_coefficients(vtkQuadric* sself, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9) { sself->SetCoefficients(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } extern "C" vtkRectilinearGrid * vtkRectilinearGrid_new () {return vtkRectilinearGrid :: New () ;} extern "C" void vtkRectilinearGrid_destructor (vtkRectilinearGrid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkRectilinearGrid_get_ptr (vtkRectilinearGrid * sself) {return sself ;} extern "C" int vtk_rectilinear_grid_get_data_object_type(vtkRectilinearGrid* sself) { return sself->GetDataObjectType(); } extern "C" void vtk_rectilinear_grid_initialize(vtkRectilinearGrid* sself) { sself->Initialize(); } extern "C" long long vtk_rectilinear_grid_get_number_of_cells(vtkRectilinearGrid* sself) { return sself->GetNumberOfCells(); } @@ -1804,20 +1656,17 @@ extern "C" int vtk_rectilinear_grid_get_extent_type(vtkRectilinearGrid* sself) { extern "C" const char* vtk_rectilinear_grid_get_scalar_type_as_string(vtkRectilinearGrid* sself) { return sself->GetScalarTypeAsString(); } extern "C" vtkReebGraph * vtkReebGraph_new () {return vtkReebGraph :: New () ;} extern "C" void vtkReebGraph_destructor (vtkReebGraph * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkReebGraph_get_ptr (vtkReebGraph * sself) {return sself ;} extern "C" int vtk_reeb_graph_stream_triangle(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2) { return sself->StreamTriangle(vertex0Id, scalar0, vertex1Id, scalar1, vertex2Id, scalar2); } extern "C" int vtk_reeb_graph_stream_tetrahedron(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2, long long vertex3Id, double scalar3) { return sself->StreamTetrahedron(vertex0Id, scalar0, vertex1Id, scalar1, vertex2Id, scalar2, vertex3Id, scalar3); } extern "C" void vtk_reeb_graph_close_stream(vtkReebGraph* sself) { sself->CloseStream(); } extern "C" vtkReebGraphSimplificationMetric * vtkReebGraphSimplificationMetric_new () {return vtkReebGraphSimplificationMetric :: New () ;} extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkReebGraphSimplificationMetric * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkReebGraphSimplificationMetric_get_ptr (vtkReebGraphSimplificationMetric * sself) {return sself ;} extern "C" void vtk_reeb_graph_simplification_metric_set_lower_bound(vtkReebGraphSimplificationMetric* sself, double _arg) { sself->SetLowerBound(_arg); } extern "C" double vtk_reeb_graph_simplification_metric_get_lower_bound(vtkReebGraphSimplificationMetric* sself) { return sself->GetLowerBound(); } extern "C" void vtk_reeb_graph_simplification_metric_set_upper_bound(vtkReebGraphSimplificationMetric* sself, double _arg) { sself->SetUpperBound(_arg); } extern "C" double vtk_reeb_graph_simplification_metric_get_upper_bound(vtkReebGraphSimplificationMetric* sself) { return sself->GetUpperBound(); } extern "C" vtkSelection * vtkSelection_new () {return vtkSelection :: New () ;} extern "C" void vtkSelection_destructor (vtkSelection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSelection_get_ptr (vtkSelection * sself) {return sself ;} extern "C" int vtk_selection_get_data_object_type(vtkSelection* sself) { return sself->GetDataObjectType(); } extern "C" unsigned int vtk_selection_get_number_of_nodes(vtkSelection* sself) { return sself->GetNumberOfNodes(); } extern "C" void vtk_selection_remove_node(vtkSelection* sself, unsigned int idx) { sself->RemoveNode(idx); } @@ -1827,7 +1676,6 @@ extern "C" unsigned long vtk_selection_get_m_time(vtkSelection* sself) { return extern "C" void vtk_selection_dump(vtkSelection* sself) { sself->Dump(); } extern "C" vtkSelectionNode * vtkSelectionNode_new () {return vtkSelectionNode :: New () ;} extern "C" void vtkSelectionNode_destructor (vtkSelectionNode * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSelectionNode_get_ptr (vtkSelectionNode * sself) {return sself ;} extern "C" void vtk_selection_node_initialize(vtkSelectionNode* sself) { sself->Initialize(); } extern "C" unsigned long vtk_selection_node_get_m_time(vtkSelectionNode* sself) { return sself->GetMTime(); } extern "C" void vtk_selection_node_set_content_type(vtkSelectionNode* sself, int type) { sself->SetContentType(type); } @@ -1842,7 +1690,6 @@ extern "C" int vtk_selection_node_convert_attribute_type_to_selection_field(vtkS extern "C" void vtk_selection_node_set_query_string(vtkSelectionNode* sself, const char* _arg) { sself->SetQueryString(_arg); } extern "C" vtkSimpleCellTessellator * vtkSimpleCellTessellator_new () {return vtkSimpleCellTessellator :: New () ;} extern "C" void vtkSimpleCellTessellator_destructor (vtkSimpleCellTessellator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSimpleCellTessellator_get_ptr (vtkSimpleCellTessellator * sself) {return sself ;} extern "C" void vtk_simple_cell_tessellator_reset(vtkSimpleCellTessellator* sself) { sself->Reset(); } extern "C" int vtk_simple_cell_tessellator_get_fixed_subdivisions(vtkSimpleCellTessellator* sself) { return sself->GetFixedSubdivisions(); } extern "C" int vtk_simple_cell_tessellator_get_max_subdivision_level(vtkSimpleCellTessellator* sself) { return sself->GetMaxSubdivisionLevel(); } @@ -1852,25 +1699,20 @@ extern "C" void vtk_simple_cell_tessellator_set_max_subdivision_level(vtkSimpleC extern "C" void vtk_simple_cell_tessellator_set_subdivision_levels(vtkSimpleCellTessellator* sself, int fixed, int maxLevel) { sself->SetSubdivisionLevels(fixed, maxLevel); } extern "C" vtkSmoothErrorMetric * vtkSmoothErrorMetric_new () {return vtkSmoothErrorMetric :: New () ;} extern "C" void vtkSmoothErrorMetric_destructor (vtkSmoothErrorMetric * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSmoothErrorMetric_get_ptr (vtkSmoothErrorMetric * sself) {return sself ;} extern "C" double vtk_smooth_error_metric_get_angle_tolerance(vtkSmoothErrorMetric* sself) { return sself->GetAngleTolerance(); } extern "C" void vtk_smooth_error_metric_set_angle_tolerance(vtkSmoothErrorMetric* sself, double value) { sself->SetAngleTolerance(value); } extern "C" vtkSortFieldData * vtkSortFieldData_new () {return vtkSortFieldData :: New () ;} extern "C" void vtkSortFieldData_destructor (vtkSortFieldData * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSortFieldData_get_ptr (vtkSortFieldData * sself) {return sself ;} extern "C" vtkSphere * vtkSphere_new () {return vtkSphere :: New () ;} extern "C" void vtkSphere_destructor (vtkSphere * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSphere_get_ptr (vtkSphere * sself) {return sself ;} extern "C" void vtk_sphere_set_radius(vtkSphere* sself, double _arg) { sself->SetRadius(_arg); } extern "C" double vtk_sphere_get_radius(vtkSphere* sself) { return sself->GetRadius(); } extern "C" void vtk_sphere_set_center(vtkSphere* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } extern "C" vtkSpheres * vtkSpheres_new () {return vtkSpheres :: New () ;} extern "C" void vtkSpheres_destructor (vtkSpheres * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSpheres_get_ptr (vtkSpheres * sself) {return sself ;} extern "C" int vtk_spheres_get_number_of_spheres(vtkSpheres* sself) { return sself->GetNumberOfSpheres(); } extern "C" vtkStaticCellLinks * vtkStaticCellLinks_new () {return vtkStaticCellLinks :: New () ;} extern "C" void vtkStaticCellLinks_destructor (vtkStaticCellLinks * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStaticCellLinks_get_ptr (vtkStaticCellLinks * sself) {return sself ;} extern "C" long long vtk_static_cell_links_get_number_of_cells(vtkStaticCellLinks* sself, long long ptId) { return sself->GetNumberOfCells(ptId); } extern "C" long long vtk_static_cell_links_get_ncells(vtkStaticCellLinks* sself, long long ptId) { return sself->GetNcells(ptId); } extern "C" void vtk_static_cell_links_initialize(vtkStaticCellLinks* sself) { sself->Initialize(); } @@ -1879,7 +1721,6 @@ extern "C" void vtk_static_cell_links_reset(vtkStaticCellLinks* sself) { sself-> extern "C" unsigned long vtk_static_cell_links_get_actual_memory_size(vtkStaticCellLinks* sself) { return sself->GetActualMemorySize(); } extern "C" vtkStaticCellLocator * vtkStaticCellLocator_new () {return vtkStaticCellLocator :: New () ;} extern "C" void vtkStaticCellLocator_destructor (vtkStaticCellLocator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStaticCellLocator_get_ptr (vtkStaticCellLocator * sself) {return sself ;} extern "C" void vtk_static_cell_locator_set_divisions(vtkStaticCellLocator* sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } extern "C" void vtk_static_cell_locator_free_search_structure(vtkStaticCellLocator* sself) { sself->FreeSearchStructure(); } extern "C" void vtk_static_cell_locator_build_locator(vtkStaticCellLocator* sself) { sself->BuildLocator(); } @@ -1894,7 +1735,6 @@ extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_on(vtkStat extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_off(vtkStaticCellLocator* sself) { sself->UseDiagonalLengthToleranceOff(); } extern "C" vtkStaticPointLocator * vtkStaticPointLocator_new () {return vtkStaticPointLocator :: New () ;} extern "C" void vtkStaticPointLocator_destructor (vtkStaticPointLocator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStaticPointLocator_get_ptr (vtkStaticPointLocator * sself) {return sself ;} extern "C" void vtk_static_point_locator_set_number_of_points_per_bucket(vtkStaticPointLocator* sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } @@ -1911,7 +1751,6 @@ extern "C" long long vtk_static_point_locator_get_max_number_of_buckets(vtkStati extern "C" bool vtk_static_point_locator_get_large_ids(vtkStaticPointLocator* sself) { return sself->GetLargeIds(); } extern "C" vtkStaticPointLocator2D * vtkStaticPointLocator2D_new () {return vtkStaticPointLocator2D :: New () ;} extern "C" void vtkStaticPointLocator2D_destructor (vtkStaticPointLocator2D * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStaticPointLocator2D_get_ptr (vtkStaticPointLocator2D * sself) {return sself ;} extern "C" void vtk_static_point_locator_2_d_set_number_of_points_per_bucket(vtkStaticPointLocator2D* sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator2D* sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator2D* sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } @@ -1928,10 +1767,8 @@ extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets(vtkS extern "C" bool vtk_static_point_locator_2_d_get_large_ids(vtkStaticPointLocator2D* sself) { return sself->GetLargeIds(); } extern "C" vtkStructuredExtent * vtkStructuredExtent_new () {return vtkStructuredExtent :: New () ;} extern "C" void vtkStructuredExtent_destructor (vtkStructuredExtent * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStructuredExtent_get_ptr (vtkStructuredExtent * sself) {return sself ;} extern "C" vtkStructuredGrid * vtkStructuredGrid_new () {return vtkStructuredGrid :: New () ;} extern "C" void vtkStructuredGrid_destructor (vtkStructuredGrid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStructuredGrid_get_ptr (vtkStructuredGrid * sself) {return sself ;} extern "C" int vtk_structured_grid_get_data_object_type(vtkStructuredGrid* sself) { return sself->GetDataObjectType(); } extern "C" long long vtk_structured_grid_get_number_of_points(vtkStructuredGrid* sself) { return sself->GetNumberOfPoints(); } extern "C" int vtk_structured_grid_get_cell_type(vtkStructuredGrid* sself, long long cellId) { return sself->GetCellType(cellId); } @@ -1949,14 +1786,11 @@ extern "C" bool vtk_structured_grid_has_any_blank_points(vtkStructuredGrid* ssel extern "C" bool vtk_structured_grid_has_any_blank_cells(vtkStructuredGrid* sself) { return sself->HasAnyBlankCells(); } extern "C" vtkStructuredPoints * vtkStructuredPoints_new () {return vtkStructuredPoints :: New () ;} extern "C" void vtkStructuredPoints_destructor (vtkStructuredPoints * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStructuredPoints_get_ptr (vtkStructuredPoints * sself) {return sself ;} extern "C" int vtk_structured_points_get_data_object_type(vtkStructuredPoints* sself) { return sself->GetDataObjectType(); } extern "C" vtkStructuredPointsCollection * vtkStructuredPointsCollection_new () {return vtkStructuredPointsCollection :: New () ;} extern "C" void vtkStructuredPointsCollection_destructor (vtkStructuredPointsCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStructuredPointsCollection_get_ptr (vtkStructuredPointsCollection * sself) {return sself ;} extern "C" vtkSuperquadric * vtkSuperquadric_new () {return vtkSuperquadric :: New () ;} extern "C" void vtkSuperquadric_destructor (vtkSuperquadric * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSuperquadric_get_ptr (vtkSuperquadric * sself) {return sself ;} extern "C" void vtk_superquadric_set_center(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } extern "C" void vtk_superquadric_set_scale(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3) { sself->SetScale(_arg1, _arg2, _arg3); } extern "C" double vtk_superquadric_get_thickness(vtkSuperquadric* sself) { return sself->GetThickness(); } @@ -1975,7 +1809,6 @@ extern "C" int vtk_superquadric_get_toroidal(vtkSuperquadric* sself) { return ss extern "C" void vtk_superquadric_set_toroidal(vtkSuperquadric* sself, int _arg) { sself->SetToroidal(_arg); } extern "C" vtkTable * vtkTable_new () {return vtkTable :: New () ;} extern "C" void vtkTable_destructor (vtkTable * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTable_get_ptr (vtkTable * sself) {return sself ;} extern "C" void vtk_table_dump(vtkTable* sself, unsigned int colWidth, int rowLimit) { sself->Dump(colWidth, rowLimit); } extern "C" int vtk_table_get_data_object_type(vtkTable* sself) { return sself->GetDataObjectType(); } extern "C" long long vtk_table_get_number_of_rows(vtkTable* sself) { return sself->GetNumberOfRows(); } @@ -1990,13 +1823,11 @@ extern "C" void vtk_table_initialize(vtkTable* sself) { sself->Initialize(); } extern "C" long long vtk_table_get_number_of_elements(vtkTable* sself, int type) { return sself->GetNumberOfElements(type); } extern "C" vtkTetra * vtkTetra_new () {return vtkTetra :: New () ;} extern "C" void vtkTetra_destructor (vtkTetra * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTetra_get_ptr (vtkTetra * sself) {return sself ;} extern "C" int vtk_tetra_get_cell_type(vtkTetra* sself) { return sself->GetCellType(); } extern "C" int vtk_tetra_get_number_of_edges(vtkTetra* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_tetra_get_number_of_faces(vtkTetra* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkTree * vtkTree_new () {return vtkTree :: New () ;} extern "C" void vtkTree_destructor (vtkTree * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTree_get_ptr (vtkTree * sself) {return sself ;} extern "C" long long vtk_tree_get_root(vtkTree* sself) { return sself->GetRoot(); } extern "C" long long vtk_tree_get_number_of_children(vtkTree* sself, long long v) { return sself->GetNumberOfChildren(v); } extern "C" long long vtk_tree_get_child(vtkTree* sself, long long v, long long i) { return sself->GetChild(v, i); } @@ -2005,29 +1836,24 @@ extern "C" long long vtk_tree_get_level(vtkTree* sself, long long v) { return ss extern "C" bool vtk_tree_is_leaf(vtkTree* sself, long long vertex) { return sself->IsLeaf(vertex); } extern "C" vtkTreeBFSIterator * vtkTreeBFSIterator_new () {return vtkTreeBFSIterator :: New () ;} extern "C" void vtkTreeBFSIterator_destructor (vtkTreeBFSIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTreeBFSIterator_get_ptr (vtkTreeBFSIterator * sself) {return sself ;} extern "C" vtkTreeDFSIterator * vtkTreeDFSIterator_new () {return vtkTreeDFSIterator :: New () ;} extern "C" void vtkTreeDFSIterator_destructor (vtkTreeDFSIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTreeDFSIterator_get_ptr (vtkTreeDFSIterator * sself) {return sself ;} extern "C" void vtk_tree_dfs_iterator_set_mode(vtkTreeDFSIterator* sself, int mode) { sself->SetMode(mode); } extern "C" int vtk_tree_dfs_iterator_get_mode(vtkTreeDFSIterator* sself) { return sself->GetMode(); } extern "C" vtkTriQuadraticHexahedron * vtkTriQuadraticHexahedron_new () {return vtkTriQuadraticHexahedron :: New () ;} extern "C" void vtkTriQuadraticHexahedron_destructor (vtkTriQuadraticHexahedron * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTriQuadraticHexahedron_get_ptr (vtkTriQuadraticHexahedron * sself) {return sself ;} extern "C" int vtk_tri_quadratic_hexahedron_get_cell_type(vtkTriQuadraticHexahedron* sself) { return sself->GetCellType(); } extern "C" int vtk_tri_quadratic_hexahedron_get_cell_dimension(vtkTriQuadraticHexahedron* sself) { return sself->GetCellDimension(); } extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_edges(vtkTriQuadraticHexahedron* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_faces(vtkTriQuadraticHexahedron* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkTriQuadraticPyramid * vtkTriQuadraticPyramid_new () {return vtkTriQuadraticPyramid :: New () ;} extern "C" void vtkTriQuadraticPyramid_destructor (vtkTriQuadraticPyramid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTriQuadraticPyramid_get_ptr (vtkTriQuadraticPyramid * sself) {return sself ;} extern "C" int vtk_tri_quadratic_pyramid_get_cell_type(vtkTriQuadraticPyramid* sself) { return sself->GetCellType(); } extern "C" int vtk_tri_quadratic_pyramid_get_cell_dimension(vtkTriQuadraticPyramid* sself) { return sself->GetCellDimension(); } extern "C" int vtk_tri_quadratic_pyramid_get_number_of_edges(vtkTriQuadraticPyramid* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_tri_quadratic_pyramid_get_number_of_faces(vtkTriQuadraticPyramid* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkTriangle * vtkTriangle_new () {return vtkTriangle :: New () ;} extern "C" void vtkTriangle_destructor (vtkTriangle * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTriangle_get_ptr (vtkTriangle * sself) {return sself ;} extern "C" int vtk_triangle_get_cell_type(vtkTriangle* sself) { return sself->GetCellType(); } extern "C" int vtk_triangle_get_cell_dimension(vtkTriangle* sself) { return sself->GetCellDimension(); } extern "C" int vtk_triangle_get_number_of_edges(vtkTriangle* sself) { return sself->GetNumberOfEdges(); } @@ -2035,18 +1861,15 @@ extern "C" int vtk_triangle_get_number_of_faces(vtkTriangle* sself) { return sse extern "C" double vtk_triangle_compute_area(vtkTriangle* sself) { return sself->ComputeArea(); } extern "C" vtkTriangleStrip * vtkTriangleStrip_new () {return vtkTriangleStrip :: New () ;} extern "C" void vtkTriangleStrip_destructor (vtkTriangleStrip * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTriangleStrip_get_ptr (vtkTriangleStrip * sself) {return sself ;} extern "C" int vtk_triangle_strip_get_cell_type(vtkTriangleStrip* sself) { return sself->GetCellType(); } extern "C" int vtk_triangle_strip_get_cell_dimension(vtkTriangleStrip* sself) { return sself->GetCellDimension(); } extern "C" int vtk_triangle_strip_get_number_of_edges(vtkTriangleStrip* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_triangle_strip_get_number_of_faces(vtkTriangleStrip* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkUndirectedGraph * vtkUndirectedGraph_new () {return vtkUndirectedGraph :: New () ;} extern "C" void vtkUndirectedGraph_destructor (vtkUndirectedGraph * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUndirectedGraph_get_ptr (vtkUndirectedGraph * sself) {return sself ;} extern "C" long long vtk_undirected_graph_get_in_degree(vtkUndirectedGraph* sself, long long v) { return sself->GetInDegree(v); } extern "C" vtkUniformGrid * vtkUniformGrid_new () {return vtkUniformGrid :: New () ;} extern "C" void vtkUniformGrid_destructor (vtkUniformGrid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUniformGrid_get_ptr (vtkUniformGrid * sself) {return sself ;} extern "C" int vtk_uniform_grid_get_grid_description(vtkUniformGrid* sself) { return sself->GetGridDescription(); } extern "C" void vtk_uniform_grid_blank_point(vtkUniformGrid* sself, long long ptId) { sself->BlankPoint(ptId); } extern "C" void vtk_uniform_grid_un_blank_point(vtkUniformGrid* sself, long long ptId) { sself->UnBlankPoint(ptId); } @@ -2056,7 +1879,6 @@ extern "C" unsigned char vtk_uniform_grid_is_point_visible(vtkUniformGrid* sself extern "C" unsigned char vtk_uniform_grid_is_cell_visible(vtkUniformGrid* sself, long long cellId) { return sself->IsCellVisible(cellId); } extern "C" vtkUniformGridAMR * vtkUniformGridAMR_new () {return vtkUniformGridAMR :: New () ;} extern "C" void vtkUniformGridAMR_destructor (vtkUniformGridAMR * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUniformGridAMR_get_ptr (vtkUniformGridAMR * sself) {return sself ;} extern "C" int vtk_uniform_grid_amr_get_data_object_type(vtkUniformGridAMR* sself) { return sself->GetDataObjectType(); } extern "C" void vtk_uniform_grid_amr_initialize(vtkUniformGridAMR* sself) { sself->Initialize(); } extern "C" void vtk_uniform_grid_amr_set_grid_description(vtkUniformGridAMR* sself, int gridDescription) { sself->SetGridDescription(gridDescription); } @@ -2068,7 +1890,6 @@ extern "C" int vtk_uniform_grid_amr_get_composite_index(vtkUniformGridAMR* sself extern "C" void vtk_uniform_grid_amr_get_level_and_index(vtkUniformGridAMR* sself, const unsigned int compositeIdx, unsigned int& level, unsigned int& idx) { sself->GetLevelAndIndex(compositeIdx, level, idx); } extern "C" vtkUniformGridAMRDataIterator * vtkUniformGridAMRDataIterator_new () {return vtkUniformGridAMRDataIterator :: New () ;} extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkUniformGridAMRDataIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUniformGridAMRDataIterator_get_ptr (vtkUniformGridAMRDataIterator * sself) {return sself ;} extern "C" int vtk_uniform_grid_amr_data_iterator_has_current_meta_data(vtkUniformGridAMRDataIterator* sself) { return sself->HasCurrentMetaData(); } extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_flat_index(vtkUniformGridAMRDataIterator* sself) { return sself->GetCurrentFlatIndex(); } extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_level(vtkUniformGridAMRDataIterator* sself) { return sself->GetCurrentLevel(); } @@ -2078,13 +1899,11 @@ extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_next_item(vtkUniformGri extern "C" int vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(vtkUniformGridAMRDataIterator* sself) { return sself->IsDoneWithTraversal(); } extern "C" vtkUniformHyperTreeGrid * vtkUniformHyperTreeGrid_new () {return vtkUniformHyperTreeGrid :: New () ;} extern "C" void vtkUniformHyperTreeGrid_destructor (vtkUniformHyperTreeGrid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUniformHyperTreeGrid_get_ptr (vtkUniformHyperTreeGrid * sself) {return sself ;} extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkUniformHyperTreeGrid* sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkUniformHyperTreeGrid* sself, double p0, double p1, double p2) { sself->SetGridScale(p0, p1, p2); } extern "C" unsigned long vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(vtkUniformHyperTreeGrid* sself) { return sself->GetActualMemorySizeBytes(); } extern "C" vtkUnstructuredGrid * vtkUnstructuredGrid_new () {return vtkUnstructuredGrid :: New () ;} extern "C" void vtkUnstructuredGrid_destructor (vtkUnstructuredGrid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUnstructuredGrid_get_ptr (vtkUnstructuredGrid * sself) {return sself ;} extern "C" int vtk_unstructured_grid_get_data_object_type(vtkUnstructuredGrid* sself) { return sself->GetDataObjectType(); } extern "C" bool vtk_unstructured_grid_allocate_estimate(vtkUnstructuredGrid* sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } extern "C" bool vtk_unstructured_grid_allocate_exact(vtkUnstructuredGrid* sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } @@ -2107,13 +1926,11 @@ extern "C" int vtk_unstructured_grid_initialize_faces_representation(vtkUnstruct extern "C" unsigned long vtk_unstructured_grid_get_mesh_m_time(vtkUnstructuredGrid* sself) { return sself->GetMeshMTime(); } extern "C" vtkUnstructuredGridCellIterator * vtkUnstructuredGridCellIterator_new () {return vtkUnstructuredGridCellIterator :: New () ;} extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkUnstructuredGridCellIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUnstructuredGridCellIterator_get_ptr (vtkUnstructuredGridCellIterator * sself) {return sself ;} extern "C" bool vtk_unstructured_grid_cell_iterator_is_done_with_traversal(vtkUnstructuredGridCellIterator* sself) { return sself->IsDoneWithTraversal(); } extern "C" long long vtk_unstructured_grid_cell_iterator_get_cell_id(vtkUnstructuredGridCellIterator* sself) { return sself->GetCellId(); } extern "C" void vtk_unstructured_grid_cell_iterator_go_to_cell(vtkUnstructuredGridCellIterator* sself, long long cellId) { sself->GoToCell(cellId); } extern "C" vtkVertex * vtkVertex_new () {return vtkVertex :: New () ;} extern "C" void vtkVertex_destructor (vtkVertex * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkVertex_get_ptr (vtkVertex * sself) {return sself ;} extern "C" int vtk_vertex_get_cell_type(vtkVertex* sself) { return sself->GetCellType(); } extern "C" int vtk_vertex_get_cell_dimension(vtkVertex* sself) { return sself->GetCellDimension(); } extern "C" int vtk_vertex_get_number_of_edges(vtkVertex* sself) { return sself->GetNumberOfEdges(); } @@ -2121,25 +1938,21 @@ extern "C" int vtk_vertex_get_number_of_faces(vtkVertex* sself) { return sself-> extern "C" int vtk_vertex_inflate(vtkVertex* sself, double p0) { return sself->Inflate(p0); } extern "C" vtkVertexListIterator * vtkVertexListIterator_new () {return vtkVertexListIterator :: New () ;} extern "C" void vtkVertexListIterator_destructor (vtkVertexListIterator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkVertexListIterator_get_ptr (vtkVertexListIterator * sself) {return sself ;} extern "C" long long vtk_vertex_list_iterator_next(vtkVertexListIterator* sself) { return sself->Next(); } extern "C" bool vtk_vertex_list_iterator_has_next(vtkVertexListIterator* sself) { return sself->HasNext(); } extern "C" vtkVoxel * vtkVoxel_new () {return vtkVoxel :: New () ;} extern "C" void vtkVoxel_destructor (vtkVoxel * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkVoxel_get_ptr (vtkVoxel * sself) {return sself ;} extern "C" int vtk_voxel_get_cell_type(vtkVoxel* sself) { return sself->GetCellType(); } extern "C" int vtk_voxel_get_number_of_edges(vtkVoxel* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_voxel_get_number_of_faces(vtkVoxel* sself) { return sself->GetNumberOfFaces(); } extern "C" int vtk_voxel_inflate(vtkVoxel* sself, double dist) { return sself->Inflate(dist); } extern "C" vtkWedge * vtkWedge_new () {return vtkWedge :: New () ;} extern "C" void vtkWedge_destructor (vtkWedge * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkWedge_get_ptr (vtkWedge * sself) {return sself ;} extern "C" int vtk_wedge_get_cell_type(vtkWedge* sself) { return sself->GetCellType(); } extern "C" int vtk_wedge_get_number_of_edges(vtkWedge* sself) { return sself->GetNumberOfEdges(); } extern "C" int vtk_wedge_get_number_of_faces(vtkWedge* sself) { return sself->GetNumberOfFaces(); } extern "C" vtkXMLDataElement * vtkXMLDataElement_new () {return vtkXMLDataElement :: New () ;} extern "C" void vtkXMLDataElement_destructor (vtkXMLDataElement * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkXMLDataElement_get_ptr (vtkXMLDataElement * sself) {return sself ;} extern "C" void vtk_xml_data_element_set_name(vtkXMLDataElement* sself, const char* _arg) { sself->SetName(_arg); } extern "C" void vtk_xml_data_element_set_id(vtkXMLDataElement* sself, const char* _arg) { sself->SetId(_arg); } extern "C" const char* vtk_xml_data_element_get_attribute(vtkXMLDataElement* sself, const char* name) { return sself->GetAttribute(name); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp index 1a38179..a809822 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp @@ -79,7 +79,6 @@ // Implement declared functions extern "C" vtkAlgorithm * vtkAlgorithm_new () {return vtkAlgorithm :: New () ;} extern "C" void vtkAlgorithm_destructor (vtkAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAlgorithm_get_ptr (vtkAlgorithm * sself) {return sself ;} extern "C" int vtk_algorithm_has_executive(vtkAlgorithm* sself) { return sself->HasExecutive(); } extern "C" int vtk_algorithm_get_number_of_input_ports(vtkAlgorithm* sself) { return sself->GetNumberOfInputPorts(); } extern "C" int vtk_algorithm_get_number_of_output_ports(vtkAlgorithm* sself) { return sself->GetNumberOfOutputPorts(); } @@ -115,38 +114,28 @@ extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkAlgorithm* sself) { extern "C" int vtk_algorithm_get_update_ghost_level(vtkAlgorithm* sself) { return sself->GetUpdateGhostLevel(); } extern "C" vtkAlgorithmOutput * vtkAlgorithmOutput_new () {return vtkAlgorithmOutput :: New () ;} extern "C" void vtkAlgorithmOutput_destructor (vtkAlgorithmOutput * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAlgorithmOutput_get_ptr (vtkAlgorithmOutput * sself) {return sself ;} extern "C" void vtk_algorithm_output_set_index(vtkAlgorithmOutput* sself, int index) { sself->SetIndex(index); } extern "C" int vtk_algorithm_output_get_index(vtkAlgorithmOutput* sself) { return sself->GetIndex(); } extern "C" vtkAnnotationLayersAlgorithm * vtkAnnotationLayersAlgorithm_new () {return vtkAnnotationLayersAlgorithm :: New () ;} extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkAnnotationLayersAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAnnotationLayersAlgorithm_get_ptr (vtkAnnotationLayersAlgorithm * sself) {return sself ;} extern "C" vtkArrayDataAlgorithm * vtkArrayDataAlgorithm_new () {return vtkArrayDataAlgorithm :: New () ;} extern "C" void vtkArrayDataAlgorithm_destructor (vtkArrayDataAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkArrayDataAlgorithm_get_ptr (vtkArrayDataAlgorithm * sself) {return sself ;} extern "C" vtkCachedStreamingDemandDrivenPipeline * vtkCachedStreamingDemandDrivenPipeline_new () {return vtkCachedStreamingDemandDrivenPipeline :: New () ;} extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkCachedStreamingDemandDrivenPipeline * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCachedStreamingDemandDrivenPipeline_get_ptr (vtkCachedStreamingDemandDrivenPipeline * sself) {return sself ;} extern "C" void vtk_cached_streaming_demand_driven_pipeline_set_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself, int size) { sself->SetCacheSize(size); } extern "C" int vtk_cached_streaming_demand_driven_pipeline_get_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself) { return sself->GetCacheSize(); } extern "C" vtkCastToConcrete * vtkCastToConcrete_new () {return vtkCastToConcrete :: New () ;} extern "C" void vtkCastToConcrete_destructor (vtkCastToConcrete * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCastToConcrete_get_ptr (vtkCastToConcrete * sself) {return sself ;} extern "C" vtkCompositeDataPipeline * vtkCompositeDataPipeline_new () {return vtkCompositeDataPipeline :: New () ;} extern "C" void vtkCompositeDataPipeline_destructor (vtkCompositeDataPipeline * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCompositeDataPipeline_get_ptr (vtkCompositeDataPipeline * sself) {return sself ;} extern "C" vtkCompositeDataSetAlgorithm * vtkCompositeDataSetAlgorithm_new () {return vtkCompositeDataSetAlgorithm :: New () ;} extern "C" void vtkCompositeDataSetAlgorithm_destructor (vtkCompositeDataSetAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCompositeDataSetAlgorithm_get_ptr (vtkCompositeDataSetAlgorithm * sself) {return sself ;} extern "C" vtkDataObjectAlgorithm * vtkDataObjectAlgorithm_new () {return vtkDataObjectAlgorithm :: New () ;} extern "C" void vtkDataObjectAlgorithm_destructor (vtkDataObjectAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataObjectAlgorithm_get_ptr (vtkDataObjectAlgorithm * sself) {return sself ;} extern "C" vtkDataSetAlgorithm * vtkDataSetAlgorithm_new () {return vtkDataSetAlgorithm :: New () ;} extern "C" void vtkDataSetAlgorithm_destructor (vtkDataSetAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDataSetAlgorithm_get_ptr (vtkDataSetAlgorithm * sself) {return sself ;} extern "C" vtkDemandDrivenPipeline * vtkDemandDrivenPipeline_new () {return vtkDemandDrivenPipeline :: New () ;} extern "C" void vtkDemandDrivenPipeline_destructor (vtkDemandDrivenPipeline * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDemandDrivenPipeline_get_ptr (vtkDemandDrivenPipeline * sself) {return sself ;} extern "C" unsigned long vtk_demand_driven_pipeline_get_pipeline_m_time(vtkDemandDrivenPipeline* sself) { return sself->GetPipelineMTime(); } extern "C" int vtk_demand_driven_pipeline_set_release_data_flag(vtkDemandDrivenPipeline* sself, int port, int n) { return sself->SetReleaseDataFlag(port, n); } extern "C" int vtk_demand_driven_pipeline_get_release_data_flag(vtkDemandDrivenPipeline* sself, int port) { return sself->GetReleaseDataFlag(port); } @@ -155,20 +144,16 @@ extern "C" int vtk_demand_driven_pipeline_update_data_object(vtkDemandDrivenPipe extern "C" int vtk_demand_driven_pipeline_update_data(vtkDemandDrivenPipeline* sself, int outputPort) { return sself->UpdateData(outputPort); } extern "C" vtkDirectedGraphAlgorithm * vtkDirectedGraphAlgorithm_new () {return vtkDirectedGraphAlgorithm :: New () ;} extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkDirectedGraphAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDirectedGraphAlgorithm_get_ptr (vtkDirectedGraphAlgorithm * sself) {return sself ;} extern "C" vtkEnsembleSource * vtkEnsembleSource_new () {return vtkEnsembleSource :: New () ;} extern "C" void vtkEnsembleSource_destructor (vtkEnsembleSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkEnsembleSource_get_ptr (vtkEnsembleSource * sself) {return sself ;} extern "C" void vtk_ensemble_source_remove_all_members(vtkEnsembleSource* sself) { sself->RemoveAllMembers(); } extern "C" unsigned int vtk_ensemble_source_get_number_of_members(vtkEnsembleSource* sself) { return sself->GetNumberOfMembers(); } extern "C" void vtk_ensemble_source_set_current_member(vtkEnsembleSource* sself, unsigned int _arg) { sself->SetCurrentMember(_arg); } extern "C" unsigned int vtk_ensemble_source_get_current_member(vtkEnsembleSource* sself) { return sself->GetCurrentMember(); } extern "C" vtkExplicitStructuredGridAlgorithm * vtkExplicitStructuredGridAlgorithm_new () {return vtkExplicitStructuredGridAlgorithm :: New () ;} extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkExplicitStructuredGridAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkExplicitStructuredGridAlgorithm_get_ptr (vtkExplicitStructuredGridAlgorithm * sself) {return sself ;} extern "C" vtkExtentRCBPartitioner * vtkExtentRCBPartitioner_new () {return vtkExtentRCBPartitioner :: New () ;} extern "C" void vtkExtentRCBPartitioner_destructor (vtkExtentRCBPartitioner * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkExtentRCBPartitioner_get_ptr (vtkExtentRCBPartitioner * sself) {return sself ;} extern "C" void vtk_extent_rcb_partitioner_set_number_of_partitions(vtkExtentRCBPartitioner* sself, const int N) { sself->SetNumberOfPartitions(N); } extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkExtentRCBPartitioner* sself, int imin, int imax, int jmin, int jmax, int kmin, int kmax) { sself->SetGlobalExtent(imin, imax, jmin, jmax, kmin, kmax); } extern "C" void vtk_extent_rcb_partitioner_set_duplicate_nodes(vtkExtentRCBPartitioner* sself, int _arg) { sself->SetDuplicateNodes(_arg); } @@ -181,7 +166,6 @@ extern "C" int vtk_extent_rcb_partitioner_get_num_extents(vtkExtentRCBPartitione extern "C" void vtk_extent_rcb_partitioner_partition(vtkExtentRCBPartitioner* sself) { sself->Partition(); } extern "C" vtkExtentSplitter * vtkExtentSplitter_new () {return vtkExtentSplitter :: New () ;} extern "C" void vtkExtentSplitter_destructor (vtkExtentSplitter * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkExtentSplitter_get_ptr (vtkExtentSplitter * sself) {return sself ;} extern "C" void vtk_extent_splitter_add_extent_source(vtkExtentSplitter* sself, int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1) { sself->AddExtentSource(id, priority, x0, x1, y0, y1, z0, z1); } extern "C" void vtk_extent_splitter_remove_extent_source(vtkExtentSplitter* sself, int id) { sself->RemoveExtentSource(id); } extern "C" void vtk_extent_splitter_remove_all_extent_sources(vtkExtentSplitter* sself) { sself->RemoveAllExtentSources(); } @@ -195,7 +179,6 @@ extern "C" void vtk_extent_splitter_point_mode_on(vtkExtentSplitter* sself) { ss extern "C" void vtk_extent_splitter_point_mode_off(vtkExtentSplitter* sself) { sself->PointModeOff(); } extern "C" vtkExtentTranslator * vtkExtentTranslator_new () {return vtkExtentTranslator :: New () ;} extern "C" void vtkExtentTranslator_destructor (vtkExtentTranslator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkExtentTranslator_get_ptr (vtkExtentTranslator * sself) {return sself ;} extern "C" void vtk_extent_translator_set_whole_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } extern "C" void vtk_extent_translator_set_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } extern "C" void vtk_extent_translator_set_piece(vtkExtentTranslator* sself, int _arg) { sself->SetPiece(_arg); } @@ -213,40 +196,28 @@ extern "C" void vtk_extent_translator_set_split_mode_to_z_slab(vtkExtentTranslat extern "C" int vtk_extent_translator_get_split_mode(vtkExtentTranslator* sself) { return sself->GetSplitMode(); } extern "C" vtkGraphAlgorithm * vtkGraphAlgorithm_new () {return vtkGraphAlgorithm :: New () ;} extern "C" void vtkGraphAlgorithm_destructor (vtkGraphAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGraphAlgorithm_get_ptr (vtkGraphAlgorithm * sself) {return sself ;} extern "C" vtkHierarchicalBoxDataSetAlgorithm * vtkHierarchicalBoxDataSetAlgorithm_new () {return vtkHierarchicalBoxDataSetAlgorithm :: New () ;} extern "C" void vtkHierarchicalBoxDataSetAlgorithm_destructor (vtkHierarchicalBoxDataSetAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHierarchicalBoxDataSetAlgorithm_get_ptr (vtkHierarchicalBoxDataSetAlgorithm * sself) {return sself ;} extern "C" vtkImageToStructuredGrid * vtkImageToStructuredGrid_new () {return vtkImageToStructuredGrid :: New () ;} extern "C" void vtkImageToStructuredGrid_destructor (vtkImageToStructuredGrid * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImageToStructuredGrid_get_ptr (vtkImageToStructuredGrid * sself) {return sself ;} extern "C" vtkImageToStructuredPoints * vtkImageToStructuredPoints_new () {return vtkImageToStructuredPoints :: New () ;} extern "C" void vtkImageToStructuredPoints_destructor (vtkImageToStructuredPoints * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkImageToStructuredPoints_get_ptr (vtkImageToStructuredPoints * sself) {return sself ;} extern "C" vtkMoleculeAlgorithm * vtkMoleculeAlgorithm_new () {return vtkMoleculeAlgorithm :: New () ;} extern "C" void vtkMoleculeAlgorithm_destructor (vtkMoleculeAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMoleculeAlgorithm_get_ptr (vtkMoleculeAlgorithm * sself) {return sself ;} extern "C" vtkMultiBlockDataSetAlgorithm * vtkMultiBlockDataSetAlgorithm_new () {return vtkMultiBlockDataSetAlgorithm :: New () ;} extern "C" void vtkMultiBlockDataSetAlgorithm_destructor (vtkMultiBlockDataSetAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMultiBlockDataSetAlgorithm_get_ptr (vtkMultiBlockDataSetAlgorithm * sself) {return sself ;} extern "C" vtkMultiTimeStepAlgorithm * vtkMultiTimeStepAlgorithm_new () {return vtkMultiTimeStepAlgorithm :: New () ;} extern "C" void vtkMultiTimeStepAlgorithm_destructor (vtkMultiTimeStepAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMultiTimeStepAlgorithm_get_ptr (vtkMultiTimeStepAlgorithm * sself) {return sself ;} extern "C" vtkNonOverlappingAMRAlgorithm * vtkNonOverlappingAMRAlgorithm_new () {return vtkNonOverlappingAMRAlgorithm :: New () ;} extern "C" void vtkNonOverlappingAMRAlgorithm_destructor (vtkNonOverlappingAMRAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkNonOverlappingAMRAlgorithm_get_ptr (vtkNonOverlappingAMRAlgorithm * sself) {return sself ;} extern "C" vtkOverlappingAMRAlgorithm * vtkOverlappingAMRAlgorithm_new () {return vtkOverlappingAMRAlgorithm :: New () ;} extern "C" void vtkOverlappingAMRAlgorithm_destructor (vtkOverlappingAMRAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOverlappingAMRAlgorithm_get_ptr (vtkOverlappingAMRAlgorithm * sself) {return sself ;} extern "C" vtkPassInputTypeAlgorithm * vtkPassInputTypeAlgorithm_new () {return vtkPassInputTypeAlgorithm :: New () ;} extern "C" void vtkPassInputTypeAlgorithm_destructor (vtkPassInputTypeAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPassInputTypeAlgorithm_get_ptr (vtkPassInputTypeAlgorithm * sself) {return sself ;} extern "C" vtkPiecewiseFunctionAlgorithm * vtkPiecewiseFunctionAlgorithm_new () {return vtkPiecewiseFunctionAlgorithm :: New () ;} extern "C" void vtkPiecewiseFunctionAlgorithm_destructor (vtkPiecewiseFunctionAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPiecewiseFunctionAlgorithm_get_ptr (vtkPiecewiseFunctionAlgorithm * sself) {return sself ;} extern "C" vtkPiecewiseFunctionShiftScale * vtkPiecewiseFunctionShiftScale_new () {return vtkPiecewiseFunctionShiftScale :: New () ;} extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkPiecewiseFunctionShiftScale * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPiecewiseFunctionShiftScale_get_ptr (vtkPiecewiseFunctionShiftScale * sself) {return sself ;} extern "C" void vtk_piecewise_function_shift_scale_set_position_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetPositionShift(_arg); } extern "C" void vtk_piecewise_function_shift_scale_set_position_scale(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetPositionScale(_arg); } extern "C" void vtk_piecewise_function_shift_scale_set_value_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetValueShift(_arg); } @@ -257,31 +228,23 @@ extern "C" double vtk_piecewise_function_shift_scale_get_value_shift(vtkPiecewis extern "C" double vtk_piecewise_function_shift_scale_get_value_scale(vtkPiecewiseFunctionShiftScale* sself) { return sself->GetValueScale(); } extern "C" vtkPointSetAlgorithm * vtkPointSetAlgorithm_new () {return vtkPointSetAlgorithm :: New () ;} extern "C" void vtkPointSetAlgorithm_destructor (vtkPointSetAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPointSetAlgorithm_get_ptr (vtkPointSetAlgorithm * sself) {return sself ;} extern "C" vtkPolyDataAlgorithm * vtkPolyDataAlgorithm_new () {return vtkPolyDataAlgorithm :: New () ;} extern "C" void vtkPolyDataAlgorithm_destructor (vtkPolyDataAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolyDataAlgorithm_get_ptr (vtkPolyDataAlgorithm * sself) {return sself ;} extern "C" vtkProgressObserver * vtkProgressObserver_new () {return vtkProgressObserver :: New () ;} extern "C" void vtkProgressObserver_destructor (vtkProgressObserver * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkProgressObserver_get_ptr (vtkProgressObserver * sself) {return sself ;} extern "C" void vtk_progress_observer_update_progress(vtkProgressObserver* sself, double amount) { sself->UpdateProgress(amount); } extern "C" double vtk_progress_observer_get_progress(vtkProgressObserver* sself) { return sself->GetProgress(); } extern "C" vtkReaderExecutive * vtkReaderExecutive_new () {return vtkReaderExecutive :: New () ;} extern "C" void vtkReaderExecutive_destructor (vtkReaderExecutive * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkReaderExecutive_get_ptr (vtkReaderExecutive * sself) {return sself ;} extern "C" vtkRectilinearGridAlgorithm * vtkRectilinearGridAlgorithm_new () {return vtkRectilinearGridAlgorithm :: New () ;} extern "C" void vtkRectilinearGridAlgorithm_destructor (vtkRectilinearGridAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkRectilinearGridAlgorithm_get_ptr (vtkRectilinearGridAlgorithm * sself) {return sself ;} extern "C" vtkSMPProgressObserver * vtkSMPProgressObserver_new () {return vtkSMPProgressObserver :: New () ;} extern "C" void vtkSMPProgressObserver_destructor (vtkSMPProgressObserver * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSMPProgressObserver_get_ptr (vtkSMPProgressObserver * sself) {return sself ;} extern "C" void vtk_smp_progress_observer_update_progress(vtkSMPProgressObserver* sself, double progress) { sself->UpdateProgress(progress); } extern "C" vtkSelectionAlgorithm * vtkSelectionAlgorithm_new () {return vtkSelectionAlgorithm :: New () ;} extern "C" void vtkSelectionAlgorithm_destructor (vtkSelectionAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSelectionAlgorithm_get_ptr (vtkSelectionAlgorithm * sself) {return sself ;} extern "C" vtkSimpleScalarTree * vtkSimpleScalarTree_new () {return vtkSimpleScalarTree :: New () ;} extern "C" void vtkSimpleScalarTree_destructor (vtkSimpleScalarTree * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSimpleScalarTree_get_ptr (vtkSimpleScalarTree * sself) {return sself ;} extern "C" void vtk_simple_scalar_tree_set_branching_factor(vtkSimpleScalarTree* sself, int _arg) { sself->SetBranchingFactor(_arg); } extern "C" int vtk_simple_scalar_tree_get_branching_factor_min_value(vtkSimpleScalarTree* sself) { return sself->GetBranchingFactorMinValue(); } extern "C" int vtk_simple_scalar_tree_get_branching_factor_max_value(vtkSimpleScalarTree* sself) { return sself->GetBranchingFactorMaxValue(); } @@ -297,7 +260,6 @@ extern "C" void vtk_simple_scalar_tree_init_traversal(vtkSimpleScalarTree* sself extern "C" long long vtk_simple_scalar_tree_get_number_of_cell_batches(vtkSimpleScalarTree* sself, double scalarValue) { return sself->GetNumberOfCellBatches(scalarValue); } extern "C" vtkSpanSpace * vtkSpanSpace_new () {return vtkSpanSpace :: New () ;} extern "C" void vtkSpanSpace_destructor (vtkSpanSpace * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSpanSpace_get_ptr (vtkSpanSpace * sself) {return sself ;} extern "C" void vtk_span_space_set_scalar_range(vtkSpanSpace* sself, double _arg1, double _arg2) { sself->SetScalarRange(_arg1, _arg2); } extern "C" void vtk_span_space_set_compute_scalar_range(vtkSpanSpace* sself, int _arg) { sself->SetComputeScalarRange(_arg); } extern "C" int vtk_span_space_get_compute_scalar_range(vtkSpanSpace* sself) { return sself->GetComputeScalarRange(); } @@ -325,7 +287,6 @@ extern "C" long long vtk_span_space_get_batch_size_max_value(vtkSpanSpace* sself extern "C" long long vtk_span_space_get_batch_size(vtkSpanSpace* sself) { return sself->GetBatchSize(); } extern "C" vtkSphereTree * vtkSphereTree_new () {return vtkSphereTree :: New () ;} extern "C" void vtkSphereTree_destructor (vtkSphereTree * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSphereTree_get_ptr (vtkSphereTree * sself) {return sself ;} extern "C" void vtk_sphere_tree_build(vtkSphereTree* sself) { sself->Build(); } extern "C" void vtk_sphere_tree_set_build_hierarchy(vtkSphereTree* sself, bool _arg) { sself->SetBuildHierarchy(_arg); } extern "C" bool vtk_sphere_tree_get_build_hierarchy(vtkSphereTree* sself) { return sself->GetBuildHierarchy(); } @@ -342,7 +303,6 @@ extern "C" int vtk_sphere_tree_get_max_level(vtkSphereTree* sself) { return ssel extern "C" int vtk_sphere_tree_get_number_of_levels(vtkSphereTree* sself) { return sself->GetNumberOfLevels(); } extern "C" vtkStreamingDemandDrivenPipeline * vtkStreamingDemandDrivenPipeline_new () {return vtkStreamingDemandDrivenPipeline :: New () ;} extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkStreamingDemandDrivenPipeline * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStreamingDemandDrivenPipeline_get_ptr (vtkStreamingDemandDrivenPipeline * sself) {return sself ;} extern "C" int vtk_streaming_demand_driven_pipeline_update(vtkStreamingDemandDrivenPipeline* sself) { return sself->Update(); } extern "C" int vtk_streaming_demand_driven_pipeline_update_whole_extent(vtkStreamingDemandDrivenPipeline* sself) { return sself->UpdateWholeExtent(); } extern "C" int vtk_streaming_demand_driven_pipeline_propagate_update_extent(vtkStreamingDemandDrivenPipeline* sself, int outputPort) { return sself->PropagateUpdateExtent(outputPort); } @@ -352,33 +312,24 @@ extern "C" int vtk_streaming_demand_driven_pipeline_set_request_exact_extent(vtk extern "C" int vtk_streaming_demand_driven_pipeline_get_request_exact_extent(vtkStreamingDemandDrivenPipeline* sself, int port) { return sself->GetRequestExactExtent(port); } extern "C" vtkStructuredGridAlgorithm * vtkStructuredGridAlgorithm_new () {return vtkStructuredGridAlgorithm :: New () ;} extern "C" void vtkStructuredGridAlgorithm_destructor (vtkStructuredGridAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkStructuredGridAlgorithm_get_ptr (vtkStructuredGridAlgorithm * sself) {return sself ;} extern "C" vtkTableAlgorithm * vtkTableAlgorithm_new () {return vtkTableAlgorithm :: New () ;} extern "C" void vtkTableAlgorithm_destructor (vtkTableAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTableAlgorithm_get_ptr (vtkTableAlgorithm * sself) {return sself ;} extern "C" vtkThreadedCompositeDataPipeline * vtkThreadedCompositeDataPipeline_new () {return vtkThreadedCompositeDataPipeline :: New () ;} extern "C" void vtkThreadedCompositeDataPipeline_destructor (vtkThreadedCompositeDataPipeline * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkThreadedCompositeDataPipeline_get_ptr (vtkThreadedCompositeDataPipeline * sself) {return sself ;} extern "C" vtkTreeAlgorithm * vtkTreeAlgorithm_new () {return vtkTreeAlgorithm :: New () ;} extern "C" void vtkTreeAlgorithm_destructor (vtkTreeAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTreeAlgorithm_get_ptr (vtkTreeAlgorithm * sself) {return sself ;} extern "C" vtkTrivialConsumer * vtkTrivialConsumer_new () {return vtkTrivialConsumer :: New () ;} extern "C" void vtkTrivialConsumer_destructor (vtkTrivialConsumer * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTrivialConsumer_get_ptr (vtkTrivialConsumer * sself) {return sself ;} extern "C" vtkTrivialProducer * vtkTrivialProducer_new () {return vtkTrivialProducer :: New () ;} extern "C" void vtkTrivialProducer_destructor (vtkTrivialProducer * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTrivialProducer_get_ptr (vtkTrivialProducer * sself) {return sself ;} extern "C" unsigned long vtk_trivial_producer_get_m_time(vtkTrivialProducer* sself) { return sself->GetMTime(); } extern "C" void vtk_trivial_producer_set_whole_extent(vtkTrivialProducer* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } extern "C" vtkUndirectedGraphAlgorithm * vtkUndirectedGraphAlgorithm_new () {return vtkUndirectedGraphAlgorithm :: New () ;} extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkUndirectedGraphAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUndirectedGraphAlgorithm_get_ptr (vtkUndirectedGraphAlgorithm * sself) {return sself ;} extern "C" vtkUniformGridAMRAlgorithm * vtkUniformGridAMRAlgorithm_new () {return vtkUniformGridAMRAlgorithm :: New () ;} extern "C" void vtkUniformGridAMRAlgorithm_destructor (vtkUniformGridAMRAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUniformGridAMRAlgorithm_get_ptr (vtkUniformGridAMRAlgorithm * sself) {return sself ;} extern "C" vtkUniformGridPartitioner * vtkUniformGridPartitioner_new () {return vtkUniformGridPartitioner :: New () ;} extern "C" void vtkUniformGridPartitioner_destructor (vtkUniformGridPartitioner * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUniformGridPartitioner_get_ptr (vtkUniformGridPartitioner * sself) {return sself ;} extern "C" int vtk_uniform_grid_partitioner_get_number_of_partitions(vtkUniformGridPartitioner* sself) { return sself->GetNumberOfPartitions(); } extern "C" void vtk_uniform_grid_partitioner_set_number_of_partitions(vtkUniformGridPartitioner* sself, int _arg) { sself->SetNumberOfPartitions(_arg); } extern "C" int vtk_uniform_grid_partitioner_get_number_of_ghost_layers(vtkUniformGridPartitioner* sself) { return sself->GetNumberOfGhostLayers(); } @@ -389,7 +340,5 @@ extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_on(vtkUniformGridPa extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_off(vtkUniformGridPartitioner* sself) { sself->DuplicateNodesOff(); } extern "C" vtkUnstructuredGridAlgorithm * vtkUnstructuredGridAlgorithm_new () {return vtkUnstructuredGridAlgorithm :: New () ;} extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkUnstructuredGridAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUnstructuredGridAlgorithm_get_ptr (vtkUnstructuredGridAlgorithm * sself) {return sself ;} extern "C" vtkUnstructuredGridBaseAlgorithm * vtkUnstructuredGridBaseAlgorithm_new () {return vtkUnstructuredGridBaseAlgorithm :: New () ;} extern "C" void vtkUnstructuredGridBaseAlgorithm_destructor (vtkUnstructuredGridBaseAlgorithm * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUnstructuredGridBaseAlgorithm_get_ptr (vtkUnstructuredGridBaseAlgorithm * sself) {return sself ;} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp index adc8a08..c1e7245 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp @@ -25,7 +25,6 @@ // Implement declared functions extern "C" vtkAmoebaMinimizer * vtkAmoebaMinimizer_new () {return vtkAmoebaMinimizer :: New () ;} extern "C" void vtkAmoebaMinimizer_destructor (vtkAmoebaMinimizer * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkAmoebaMinimizer_get_ptr (vtkAmoebaMinimizer * sself) {return sself ;} extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkAmoebaMinimizer* sself, const char* name, double value) { sself->SetParameterValue(name, value); } extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkAmoebaMinimizer* sself, const char* name, double scale) { sself->SetParameterScale(name, scale); } extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkAmoebaMinimizer* sself, const char* name) { return sself->GetParameterScale(name); } @@ -56,7 +55,6 @@ extern "C" int vtk_amoeba_minimizer_get_function_evaluations(vtkAmoebaMinimizer* extern "C" void vtk_amoeba_minimizer_evaluate_function(vtkAmoebaMinimizer* sself) { sself->EvaluateFunction(); } extern "C" vtkFFT * vtkFFT_new () {return vtkFFT :: New () ;} extern "C" void vtkFFT_destructor (vtkFFT * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkFFT_get_ptr (vtkFFT * sself) {return sself ;} extern "C" double vtk_fft_hanning_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->HanningGenerator(x, size); } extern "C" double vtk_fft_bartlett_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->BartlettGenerator(x, size); } extern "C" double vtk_fft_sine_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->SineGenerator(x, size); } @@ -64,7 +62,6 @@ extern "C" double vtk_fft_blackman_generator(vtkFFT* sself, const size_t x, cons extern "C" double vtk_fft_rectangular_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->RectangularGenerator(x, size); } extern "C" vtkMatrix3x3 * vtkMatrix3x3_new () {return vtkMatrix3x3 :: New () ;} extern "C" void vtkMatrix3x3_destructor (vtkMatrix3x3 * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMatrix3x3_get_ptr (vtkMatrix3x3 * sself) {return sself ;} extern "C" void vtk_matrix_3_x_3_zero(vtkMatrix3x3* sself) { sself->Zero(); } extern "C" void vtk_matrix_3_x_3_identity(vtkMatrix3x3* sself) { sself->Identity(); } extern "C" double vtk_matrix_3_x_3_determinant(vtkMatrix3x3* sself) { return sself->Determinant(); } @@ -73,7 +70,6 @@ extern "C" double vtk_matrix_3_x_3_get_element(vtkMatrix3x3* sself, int i, int j extern "C" bool vtk_matrix_3_x_3_is_identity(vtkMatrix3x3* sself) { return sself->IsIdentity(); } extern "C" vtkMatrix4x4 * vtkMatrix4x4_new () {return vtkMatrix4x4 :: New () ;} extern "C" void vtkMatrix4x4_destructor (vtkMatrix4x4 * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMatrix4x4_get_ptr (vtkMatrix4x4 * sself) {return sself ;} extern "C" void vtk_matrix_4_x_4_zero(vtkMatrix4x4* sself) { sself->Zero(); } extern "C" void vtk_matrix_4_x_4_identity(vtkMatrix4x4* sself) { sself->Identity(); } extern "C" bool vtk_matrix_4_x_4_is_identity(vtkMatrix4x4* sself) { return sself->IsIdentity(); } @@ -82,12 +78,10 @@ extern "C" void vtk_matrix_4_x_4_set_element(vtkMatrix4x4* sself, int i, int j, extern "C" double vtk_matrix_4_x_4_get_element(vtkMatrix4x4* sself, int i, int j) { return sself->GetElement(i, j); } extern "C" vtkPolynomialSolversUnivariate * vtkPolynomialSolversUnivariate_new () {return vtkPolynomialSolversUnivariate :: New () ;} extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkPolynomialSolversUnivariate * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolynomialSolversUnivariate_get_ptr (vtkPolynomialSolversUnivariate * sself) {return sself ;} extern "C" void vtk_polynomial_solvers_univariate_set_division_tolerance(vtkPolynomialSolversUnivariate* sself, double tol) { sself->SetDivisionTolerance(tol); } extern "C" double vtk_polynomial_solvers_univariate_get_division_tolerance(vtkPolynomialSolversUnivariate* sself) { return sself->GetDivisionTolerance(); } extern "C" vtkQuaternionInterpolator * vtkQuaternionInterpolator_new () {return vtkQuaternionInterpolator :: New () ;} extern "C" void vtkQuaternionInterpolator_destructor (vtkQuaternionInterpolator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkQuaternionInterpolator_get_ptr (vtkQuaternionInterpolator * sself) {return sself ;} extern "C" int vtk_quaternion_interpolator_get_number_of_quaternions(vtkQuaternionInterpolator* sself) { return sself->GetNumberOfQuaternions(); } extern "C" double vtk_quaternion_interpolator_get_minimum_t(vtkQuaternionInterpolator* sself) { return sself->GetMinimumT(); } extern "C" double vtk_quaternion_interpolator_get_maximum_t(vtkQuaternionInterpolator* sself) { return sself->GetMaximumT(); } @@ -103,10 +97,7 @@ extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_linear(vtk extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_spline(vtkQuaternionInterpolator* sself) { sself->SetInterpolationTypeToSpline(); } extern "C" vtkRungeKutta2 * vtkRungeKutta2_new () {return vtkRungeKutta2 :: New () ;} extern "C" void vtkRungeKutta2_destructor (vtkRungeKutta2 * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkRungeKutta2_get_ptr (vtkRungeKutta2 * sself) {return sself ;} extern "C" vtkRungeKutta4 * vtkRungeKutta4_new () {return vtkRungeKutta4 :: New () ;} extern "C" void vtkRungeKutta4_destructor (vtkRungeKutta4 * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkRungeKutta4_get_ptr (vtkRungeKutta4 * sself) {return sself ;} extern "C" vtkRungeKutta45 * vtkRungeKutta45_new () {return vtkRungeKutta45 :: New () ;} extern "C" void vtkRungeKutta45_destructor (vtkRungeKutta45 * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkRungeKutta45_get_ptr (vtkRungeKutta45 * sself) {return sself ;} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp index 2ae920b..c73a162 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp @@ -17,7 +17,6 @@ // Implement declared functions extern "C" vtkContourValues * vtkContourValues_new () {return vtkContourValues :: New () ;} extern "C" void vtkContourValues_destructor (vtkContourValues * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkContourValues_get_ptr (vtkContourValues * sself) {return sself ;} extern "C" void vtk_contour_values_set_value(vtkContourValues* sself, int i, double value) { sself->SetValue(i, value); } extern "C" double vtk_contour_values_get_value(vtkContourValues* sself, int i) { return sself->GetValue(i); } extern "C" void vtk_contour_values_set_number_of_contours(vtkContourValues* sself, const int number) { sself->SetNumberOfContours(number); } @@ -25,7 +24,6 @@ extern "C" int vtk_contour_values_get_number_of_contours(vtkContourValues* sself extern "C" void vtk_contour_values_generate_values(vtkContourValues* sself, int numContours, double rangeStart, double rangeEnd) { sself->GenerateValues(numContours, rangeStart, rangeEnd); } extern "C" vtkExprTkFunctionParser * vtkExprTkFunctionParser_new () {return vtkExprTkFunctionParser :: New () ;} extern "C" void vtkExprTkFunctionParser_destructor (vtkExprTkFunctionParser * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkExprTkFunctionParser_get_ptr (vtkExprTkFunctionParser * sself) {return sself ;} extern "C" unsigned long vtk_expr_tk_function_parser_get_m_time(vtkExprTkFunctionParser* sself) { return sself->GetMTime(); } extern "C" void vtk_expr_tk_function_parser_set_function(vtkExprTkFunctionParser* sself, const char* function) { sself->SetFunction(function); } extern "C" const char* vtk_expr_tk_function_parser_get_function(vtkExprTkFunctionParser* sself) { return sself->GetFunction(); } @@ -53,7 +51,6 @@ extern "C" double vtk_expr_tk_function_parser_get_replacement_value(vtkExprTkFun extern "C" void vtk_expr_tk_function_parser_invalidate_function(vtkExprTkFunctionParser* sself) { sself->InvalidateFunction(); } extern "C" vtkFunctionParser * vtkFunctionParser_new () {return vtkFunctionParser :: New () ;} extern "C" void vtkFunctionParser_destructor (vtkFunctionParser * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkFunctionParser_get_ptr (vtkFunctionParser * sself) {return sself ;} extern "C" unsigned long vtk_function_parser_get_m_time(vtkFunctionParser* sself) { return sself->GetMTime(); } extern "C" void vtk_function_parser_set_function(vtkFunctionParser* sself, const char* function) { sself->SetFunction(function); } extern "C" int vtk_function_parser_is_scalar_result(vtkFunctionParser* sself) { return sself->IsScalarResult(); } @@ -82,7 +79,6 @@ extern "C" double vtk_function_parser_get_replacement_value(vtkFunctionParser* s extern "C" void vtk_function_parser_invalidate_function(vtkFunctionParser* sself) { sself->InvalidateFunction(); } extern "C" vtkHeap * vtkHeap_new () {return vtkHeap :: New () ;} extern "C" void vtkHeap_destructor (vtkHeap * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHeap_get_ptr (vtkHeap * sself) {return sself ;} extern "C" void* vtk_heap_allocate_memory(vtkHeap* sself, size_t n) { return sself->AllocateMemory(n); } extern "C" void vtk_heap_set_block_size(vtkHeap* sself, size_t p0) { sself->SetBlockSize(p0); } extern "C" size_t vtk_heap_get_block_size(vtkHeap* sself) { return sself->GetBlockSize(); } @@ -91,7 +87,6 @@ extern "C" int vtk_heap_get_number_of_allocations(vtkHeap* sself) { return sself extern "C" void vtk_heap_reset(vtkHeap* sself) { sself->Reset(); } extern "C" vtkResourceFileLocator * vtkResourceFileLocator_new () {return vtkResourceFileLocator :: New () ;} extern "C" void vtkResourceFileLocator_destructor (vtkResourceFileLocator * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkResourceFileLocator_get_ptr (vtkResourceFileLocator * sself) {return sself ;} extern "C" void vtk_resource_file_locator_set_print_debug_information(vtkResourceFileLocator* sself, bool p0) { sself->SetPrintDebugInformation(p0); } extern "C" bool vtk_resource_file_locator_get_print_debug_information(vtkResourceFileLocator* sself) { return sself->GetPrintDebugInformation(); } extern "C" void vtk_resource_file_locator_print_debug_information_on(vtkResourceFileLocator* sself) { sself->PrintDebugInformationOn(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp index 698e9de..1419b6e 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp @@ -20,12 +20,10 @@ // Implement declared functions extern "C" vtkClientSocket * vtkClientSocket_new () {return vtkClientSocket :: New () ;} extern "C" void vtkClientSocket_destructor (vtkClientSocket * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkClientSocket_get_ptr (vtkClientSocket * sself) {return sself ;} extern "C" int vtk_client_socket_connect_to_server(vtkClientSocket* sself, const char* hostname, int port) { return sself->ConnectToServer(hostname, port); } extern "C" bool vtk_client_socket_get_connecting_side(vtkClientSocket* sself) { return sself->GetConnectingSide(); } extern "C" vtkDirectory * vtkDirectory_new () {return vtkDirectory :: New () ;} extern "C" void vtkDirectory_destructor (vtkDirectory * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDirectory_get_ptr (vtkDirectory * sself) {return sself ;} extern "C" int vtk_directory_open(vtkDirectory* sself, const char* dir) { return sself->Open(dir); } extern "C" long long vtk_directory_get_number_of_files(vtkDirectory* sself) { return sself->GetNumberOfFiles(); } extern "C" const char* vtk_directory_get_file(vtkDirectory* sself, long long index) { return sself->GetFile(index); } @@ -35,7 +33,6 @@ extern "C" int vtk_directory_delete_directory(vtkDirectory* sself, const char* d extern "C" int vtk_directory_rename(vtkDirectory* sself, const char* oldname, const char* newname) { return sself->Rename(oldname, newname); } extern "C" vtkExecutableRunner * vtkExecutableRunner_new () {return vtkExecutableRunner :: New () ;} extern "C" void vtkExecutableRunner_destructor (vtkExecutableRunner * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkExecutableRunner_get_ptr (vtkExecutableRunner * sself) {return sself ;} extern "C" void vtk_executable_runner_execute(vtkExecutableRunner* sself) { sself->Execute(); } extern "C" void vtk_executable_runner_set_timeout(vtkExecutableRunner* sself, double _arg) { sself->SetTimeout(_arg); } extern "C" double vtk_executable_runner_get_timeout(vtkExecutableRunner* sself) { return sself->GetTimeout(); } @@ -50,16 +47,13 @@ extern "C" const char* vtk_executable_runner_get_std_err(vtkExecutableRunner* ss extern "C" int vtk_executable_runner_get_return_value(vtkExecutableRunner* sself) { return sself->GetReturnValue(); } extern "C" vtkServerSocket * vtkServerSocket_new () {return vtkServerSocket :: New () ;} extern "C" void vtkServerSocket_destructor (vtkServerSocket * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkServerSocket_get_ptr (vtkServerSocket * sself) {return sself ;} extern "C" int vtk_server_socket_create_server(vtkServerSocket* sself, int port) { return sself->CreateServer(port); } extern "C" int vtk_server_socket_get_server_port(vtkServerSocket* sself) { return sself->GetServerPort(); } extern "C" vtkSocketCollection * vtkSocketCollection_new () {return vtkSocketCollection :: New () ;} extern "C" void vtkSocketCollection_destructor (vtkSocketCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSocketCollection_get_ptr (vtkSocketCollection * sself) {return sself ;} extern "C" int vtk_socket_collection_select_sockets(vtkSocketCollection* sself, unsigned long msec) { return sself->SelectSockets(msec); } extern "C" vtkThreadMessager * vtkThreadMessager_new () {return vtkThreadMessager :: New () ;} extern "C" void vtkThreadMessager_destructor (vtkThreadMessager * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkThreadMessager_get_ptr (vtkThreadMessager * sself) {return sself ;} extern "C" void vtk_thread_messager_wait_for_message(vtkThreadMessager* sself) { sself->WaitForMessage(); } extern "C" void vtk_thread_messager_send_wake_message(vtkThreadMessager* sself) { sself->SendWakeMessage(); } extern "C" void vtk_thread_messager_enable_wait_for_receiver(vtkThreadMessager* sself) { sself->EnableWaitForReceiver(); } @@ -67,7 +61,6 @@ extern "C" void vtk_thread_messager_disable_wait_for_receiver(vtkThreadMessager* extern "C" void vtk_thread_messager_wait_for_receiver(vtkThreadMessager* sself) { sself->WaitForReceiver(); } extern "C" vtkTimerLog * vtkTimerLog_new () {return vtkTimerLog :: New () ;} extern "C" void vtkTimerLog_destructor (vtkTimerLog * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTimerLog_get_ptr (vtkTimerLog * sself) {return sself ;} extern "C" void vtk_timer_log_set_logging(vtkTimerLog* sself, int v) { sself->SetLogging(v); } extern "C" int vtk_timer_log_get_logging(vtkTimerLog* sself) { return sself->GetLogging(); } extern "C" void vtk_timer_log_logging_on(vtkTimerLog* sself) { sself->LoggingOn(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp index e26b45c..8073c30 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp @@ -29,10 +29,8 @@ // Implement declared functions extern "C" vtkCylindricalTransform * vtkCylindricalTransform_new () {return vtkCylindricalTransform :: New () ;} extern "C" void vtkCylindricalTransform_destructor (vtkCylindricalTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCylindricalTransform_get_ptr (vtkCylindricalTransform * sself) {return sself ;} extern "C" vtkGeneralTransform * vtkGeneralTransform_new () {return vtkGeneralTransform :: New () ;} extern "C" void vtkGeneralTransform_destructor (vtkGeneralTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGeneralTransform_get_ptr (vtkGeneralTransform * sself) {return sself ;} extern "C" void vtk_general_transform_identity(vtkGeneralTransform* sself) { sself->Identity(); } extern "C" void vtk_general_transform_inverse(vtkGeneralTransform* sself) { sself->Inverse(); } extern "C" void vtk_general_transform_translate(vtkGeneralTransform* sself, double x, double y, double z) { sself->Translate(x, y, z); } @@ -50,11 +48,9 @@ extern "C" void vtk_general_transform_pop(vtkGeneralTransform* sself) { sself->P extern "C" unsigned long vtk_general_transform_get_m_time(vtkGeneralTransform* sself) { return sself->GetMTime(); } extern "C" vtkIdentityTransform * vtkIdentityTransform_new () {return vtkIdentityTransform :: New () ;} extern "C" void vtkIdentityTransform_destructor (vtkIdentityTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkIdentityTransform_get_ptr (vtkIdentityTransform * sself) {return sself ;} extern "C" void vtk_identity_transform_inverse(vtkIdentityTransform* sself) { sself->Inverse(); } extern "C" vtkLandmarkTransform * vtkLandmarkTransform_new () {return vtkLandmarkTransform :: New () ;} extern "C" void vtkLandmarkTransform_destructor (vtkLandmarkTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLandmarkTransform_get_ptr (vtkLandmarkTransform * sself) {return sself ;} extern "C" void vtk_landmark_transform_set_mode(vtkLandmarkTransform* sself, int _arg) { sself->SetMode(_arg); } extern "C" void vtk_landmark_transform_set_mode_to_rigid_body(vtkLandmarkTransform* sself) { sself->SetModeToRigidBody(); } extern "C" void vtk_landmark_transform_set_mode_to_similarity(vtkLandmarkTransform* sself) { sself->SetModeToSimilarity(); } @@ -65,17 +61,14 @@ extern "C" void vtk_landmark_transform_inverse(vtkLandmarkTransform* sself) { ss extern "C" unsigned long vtk_landmark_transform_get_m_time(vtkLandmarkTransform* sself) { return sself->GetMTime(); } extern "C" vtkMatrixToHomogeneousTransform * vtkMatrixToHomogeneousTransform_new () {return vtkMatrixToHomogeneousTransform :: New () ;} extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkMatrixToHomogeneousTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMatrixToHomogeneousTransform_get_ptr (vtkMatrixToHomogeneousTransform * sself) {return sself ;} extern "C" void vtk_matrix_to_homogeneous_transform_inverse(vtkMatrixToHomogeneousTransform* sself) { sself->Inverse(); } extern "C" unsigned long vtk_matrix_to_homogeneous_transform_get_m_time(vtkMatrixToHomogeneousTransform* sself) { return sself->GetMTime(); } extern "C" vtkMatrixToLinearTransform * vtkMatrixToLinearTransform_new () {return vtkMatrixToLinearTransform :: New () ;} extern "C" void vtkMatrixToLinearTransform_destructor (vtkMatrixToLinearTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkMatrixToLinearTransform_get_ptr (vtkMatrixToLinearTransform * sself) {return sself ;} extern "C" void vtk_matrix_to_linear_transform_inverse(vtkMatrixToLinearTransform* sself) { sself->Inverse(); } extern "C" unsigned long vtk_matrix_to_linear_transform_get_m_time(vtkMatrixToLinearTransform* sself) { return sself->GetMTime(); } extern "C" vtkPerspectiveTransform * vtkPerspectiveTransform_new () {return vtkPerspectiveTransform :: New () ;} extern "C" void vtkPerspectiveTransform_destructor (vtkPerspectiveTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPerspectiveTransform_get_ptr (vtkPerspectiveTransform * sself) {return sself ;} extern "C" void vtk_perspective_transform_identity(vtkPerspectiveTransform* sself) { sself->Identity(); } extern "C" void vtk_perspective_transform_inverse(vtkPerspectiveTransform* sself) { sself->Inverse(); } extern "C" void vtk_perspective_transform_adjust_viewport(vtkPerspectiveTransform* sself, double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax) { sself->AdjustViewport(oldXMin, oldXMax, oldYMin, oldYMax, newXMin, newXMax, newYMin, newYMax); } @@ -101,10 +94,8 @@ extern "C" void vtk_perspective_transform_pop(vtkPerspectiveTransform* sself) { extern "C" unsigned long vtk_perspective_transform_get_m_time(vtkPerspectiveTransform* sself) { return sself->GetMTime(); } extern "C" vtkSphericalTransform * vtkSphericalTransform_new () {return vtkSphericalTransform :: New () ;} extern "C" void vtkSphericalTransform_destructor (vtkSphericalTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSphericalTransform_get_ptr (vtkSphericalTransform * sself) {return sself ;} extern "C" vtkThinPlateSplineTransform * vtkThinPlateSplineTransform_new () {return vtkThinPlateSplineTransform :: New () ;} extern "C" void vtkThinPlateSplineTransform_destructor (vtkThinPlateSplineTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkThinPlateSplineTransform_get_ptr (vtkThinPlateSplineTransform * sself) {return sself ;} extern "C" double vtk_thin_plate_spline_transform_get_sigma(vtkThinPlateSplineTransform* sself) { return sself->GetSigma(); } extern "C" void vtk_thin_plate_spline_transform_set_sigma(vtkThinPlateSplineTransform* sself, double _arg) { sself->SetSigma(_arg); } extern "C" void vtk_thin_plate_spline_transform_set_basis(vtkThinPlateSplineTransform* sself, int basis) { sself->SetBasis(basis); } @@ -119,7 +110,6 @@ extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_on(vtk extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_off(vtkThinPlateSplineTransform* sself) { sself->RegularizeBulkTransformOff(); } extern "C" vtkTransform * vtkTransform_new () {return vtkTransform :: New () ;} extern "C" void vtkTransform_destructor (vtkTransform * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTransform_get_ptr (vtkTransform * sself) {return sself ;} extern "C" void vtk_transform_identity(vtkTransform* sself) { sself->Identity(); } extern "C" void vtk_transform_inverse(vtkTransform* sself) { sself->Inverse(); } extern "C" void vtk_transform_translate(vtkTransform* sself, double x, double y, double z) { sself->Translate(x, y, z); } @@ -137,7 +127,6 @@ extern "C" void vtk_transform_pop(vtkTransform* sself) { sself->Pop(); } extern "C" unsigned long vtk_transform_get_m_time(vtkTransform* sself) { return sself->GetMTime(); } extern "C" vtkTransform2D * vtkTransform2D_new () {return vtkTransform2D :: New () ;} extern "C" void vtkTransform2D_destructor (vtkTransform2D * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTransform2D_get_ptr (vtkTransform2D * sself) {return sself ;} extern "C" void vtk_transform_2_d_identity(vtkTransform2D* sself) { sself->Identity(); } extern "C" void vtk_transform_2_d_inverse(vtkTransform2D* sself) { sself->Inverse(); } extern "C" void vtk_transform_2_d_translate(vtkTransform2D* sself, double x, double y) { sself->Translate(x, y); } @@ -146,4 +135,3 @@ extern "C" void vtk_transform_2_d_scale(vtkTransform2D* sself, double x, double extern "C" unsigned long vtk_transform_2_d_get_m_time(vtkTransform2D* sself) { return sself->GetMTime(); } extern "C" vtkTransformCollection * vtkTransformCollection_new () {return vtkTransformCollection :: New () ;} extern "C" void vtkTransformCollection_destructor (vtkTransformCollection * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTransformCollection_get_ptr (vtkTransformCollection * sself) {return sself ;} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp index 9692df8..f2226a4 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp @@ -52,7 +52,6 @@ // Implement declared functions extern "C" vtkArcSource * vtkArcSource_new () {return vtkArcSource :: New () ;} extern "C" void vtkArcSource_destructor (vtkArcSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkArcSource_get_ptr (vtkArcSource * sself) {return sself ;} extern "C" void vtk_arc_source_set_point_1(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint1(_arg1, _arg2, _arg3); } extern "C" void vtk_arc_source_set_point_2(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint2(_arg1, _arg2, _arg3); } extern "C" void vtk_arc_source_set_center(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } @@ -78,7 +77,6 @@ extern "C" void vtk_arc_source_set_output_points_precision(vtkArcSource* sself, extern "C" int vtk_arc_source_get_output_points_precision(vtkArcSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkArrowSource * vtkArrowSource_new () {return vtkArrowSource :: New () ;} extern "C" void vtkArrowSource_destructor (vtkArrowSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkArrowSource_get_ptr (vtkArrowSource * sself) {return sself ;} extern "C" void vtk_arrow_source_set_tip_length(vtkArrowSource* sself, double _arg) { sself->SetTipLength(_arg); } extern "C" double vtk_arrow_source_get_tip_length_min_value(vtkArrowSource* sself) { return sself->GetTipLengthMinValue(); } extern "C" double vtk_arrow_source_get_tip_length_max_value(vtkArrowSource* sself) { return sself->GetTipLengthMaxValue(); } @@ -107,7 +105,6 @@ extern "C" void vtk_arrow_source_set_arrow_origin_to_default(vtkArrowSource* sse extern "C" void vtk_arrow_source_set_arrow_origin_to_center(vtkArrowSource* sself) { sself->SetArrowOriginToCenter(); } extern "C" vtkCapsuleSource * vtkCapsuleSource_new () {return vtkCapsuleSource :: New () ;} extern "C" void vtkCapsuleSource_destructor (vtkCapsuleSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCapsuleSource_get_ptr (vtkCapsuleSource * sself) {return sself ;} extern "C" void vtk_capsule_source_set_radius(vtkCapsuleSource* sself, double _arg) { sself->SetRadius(_arg); } extern "C" double vtk_capsule_source_get_radius_min_value(vtkCapsuleSource* sself) { return sself->GetRadiusMinValue(); } extern "C" double vtk_capsule_source_get_radius_max_value(vtkCapsuleSource* sself) { return sself->GetRadiusMaxValue(); } @@ -133,7 +130,6 @@ extern "C" void vtk_capsule_source_set_output_points_precision(vtkCapsuleSource* extern "C" int vtk_capsule_source_get_output_points_precision(vtkCapsuleSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkCellTypeSource * vtkCellTypeSource_new () {return vtkCellTypeSource :: New () ;} extern "C" void vtkCellTypeSource_destructor (vtkCellTypeSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCellTypeSource_get_ptr (vtkCellTypeSource * sself) {return sself ;} extern "C" void vtk_cell_type_source_set_cell_type(vtkCellTypeSource* sself, int cellType) { sself->SetCellType(cellType); } extern "C" int vtk_cell_type_source_get_cell_type(vtkCellTypeSource* sself) { return sself->GetCellType(); } extern "C" void vtk_cell_type_source_set_cell_order(vtkCellTypeSource* sself, int _arg) { sself->SetCellOrder(_arg); } @@ -153,7 +149,6 @@ extern "C" int vtk_cell_type_source_get_output_precision_max_value(vtkCellTypeSo extern "C" int vtk_cell_type_source_get_output_precision(vtkCellTypeSource* sself) { return sself->GetOutputPrecision(); } extern "C" vtkConeSource * vtkConeSource_new () {return vtkConeSource :: New () ;} extern "C" void vtkConeSource_destructor (vtkConeSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkConeSource_get_ptr (vtkConeSource * sself) {return sself ;} extern "C" void vtk_cone_source_set_height(vtkConeSource* sself, double _arg) { sself->SetHeight(_arg); } extern "C" double vtk_cone_source_get_height_min_value(vtkConeSource* sself) { return sself->GetHeightMinValue(); } extern "C" double vtk_cone_source_get_height_max_value(vtkConeSource* sself) { return sself->GetHeightMaxValue(); } @@ -178,7 +173,6 @@ extern "C" void vtk_cone_source_set_output_points_precision(vtkConeSource* sself extern "C" int vtk_cone_source_get_output_points_precision(vtkConeSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkCubeSource * vtkCubeSource_new () {return vtkCubeSource :: New () ;} extern "C" void vtkCubeSource_destructor (vtkCubeSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCubeSource_get_ptr (vtkCubeSource * sself) {return sself ;} extern "C" void vtk_cube_source_set_x_length(vtkCubeSource* sself, double _arg) { sself->SetXLength(_arg); } extern "C" double vtk_cube_source_get_x_length_min_value(vtkCubeSource* sself) { return sself->GetXLengthMinValue(); } extern "C" double vtk_cube_source_get_x_length_max_value(vtkCubeSource* sself) { return sself->GetXLengthMaxValue(); } @@ -197,7 +191,6 @@ extern "C" void vtk_cube_source_set_output_points_precision(vtkCubeSource* sself extern "C" int vtk_cube_source_get_output_points_precision(vtkCubeSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkCylinderSource * vtkCylinderSource_new () {return vtkCylinderSource :: New () ;} extern "C" void vtkCylinderSource_destructor (vtkCylinderSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkCylinderSource_get_ptr (vtkCylinderSource * sself) {return sself ;} extern "C" void vtk_cylinder_source_set_height(vtkCylinderSource* sself, double _arg) { sself->SetHeight(_arg); } extern "C" double vtk_cylinder_source_get_height_min_value(vtkCylinderSource* sself) { return sself->GetHeightMinValue(); } extern "C" double vtk_cylinder_source_get_height_max_value(vtkCylinderSource* sself) { return sself->GetHeightMaxValue(); } @@ -219,7 +212,6 @@ extern "C" void vtk_cylinder_source_set_output_points_precision(vtkCylinderSourc extern "C" int vtk_cylinder_source_get_output_points_precision(vtkCylinderSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkDiagonalMatrixSource * vtkDiagonalMatrixSource_new () {return vtkDiagonalMatrixSource :: New () ;} extern "C" void vtkDiagonalMatrixSource_destructor (vtkDiagonalMatrixSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDiagonalMatrixSource_get_ptr (vtkDiagonalMatrixSource * sself) {return sself ;} extern "C" int vtk_diagonal_matrix_source_get_array_type(vtkDiagonalMatrixSource* sself) { return sself->GetArrayType(); } extern "C" void vtk_diagonal_matrix_source_set_array_type(vtkDiagonalMatrixSource* sself, int _arg) { sself->SetArrayType(_arg); } extern "C" long long vtk_diagonal_matrix_source_get_extents(vtkDiagonalMatrixSource* sself) { return sself->GetExtents(); } @@ -234,7 +226,6 @@ extern "C" void vtk_diagonal_matrix_source_set_row_label(vtkDiagonalMatrixSource extern "C" void vtk_diagonal_matrix_source_set_column_label(vtkDiagonalMatrixSource* sself, const char* _arg) { sself->SetColumnLabel(_arg); } extern "C" vtkDiskSource * vtkDiskSource_new () {return vtkDiskSource :: New () ;} extern "C" void vtkDiskSource_destructor (vtkDiskSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkDiskSource_get_ptr (vtkDiskSource * sself) {return sself ;} extern "C" void vtk_disk_source_set_inner_radius(vtkDiskSource* sself, double _arg) { sself->SetInnerRadius(_arg); } extern "C" double vtk_disk_source_get_inner_radius_min_value(vtkDiskSource* sself) { return sself->GetInnerRadiusMinValue(); } extern "C" double vtk_disk_source_get_inner_radius_max_value(vtkDiskSource* sself) { return sself->GetInnerRadiusMaxValue(); } @@ -255,7 +246,6 @@ extern "C" void vtk_disk_source_set_output_points_precision(vtkDiskSource* sself extern "C" int vtk_disk_source_get_output_points_precision(vtkDiskSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkEllipseArcSource * vtkEllipseArcSource_new () {return vtkEllipseArcSource :: New () ;} extern "C" void vtkEllipseArcSource_destructor (vtkEllipseArcSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkEllipseArcSource_get_ptr (vtkEllipseArcSource * sself) {return sself ;} extern "C" void vtk_ellipse_arc_source_set_center(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } extern "C" void vtk_ellipse_arc_source_set_normal(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } extern "C" void vtk_ellipse_arc_source_set_major_radius_vector(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetMajorRadiusVector(_arg1, _arg2, _arg3); } @@ -283,7 +273,6 @@ extern "C" double vtk_ellipse_arc_source_get_ratio_max_value(vtkEllipseArcSource extern "C" double vtk_ellipse_arc_source_get_ratio(vtkEllipseArcSource* sself) { return sself->GetRatio(); } extern "C" vtkEllipticalButtonSource * vtkEllipticalButtonSource_new () {return vtkEllipticalButtonSource :: New () ;} extern "C" void vtkEllipticalButtonSource_destructor (vtkEllipticalButtonSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkEllipticalButtonSource_get_ptr (vtkEllipticalButtonSource * sself) {return sself ;} extern "C" void vtk_elliptical_button_source_set_width(vtkEllipticalButtonSource* sself, double _arg) { sself->SetWidth(_arg); } extern "C" double vtk_elliptical_button_source_get_width_min_value(vtkEllipticalButtonSource* sself) { return sself->GetWidthMinValue(); } extern "C" double vtk_elliptical_button_source_get_width_max_value(vtkEllipticalButtonSource* sself) { return sself->GetWidthMaxValue(); } @@ -316,7 +305,6 @@ extern "C" void vtk_elliptical_button_source_set_output_points_precision(vtkElli extern "C" int vtk_elliptical_button_source_get_output_points_precision(vtkEllipticalButtonSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkFrustumSource * vtkFrustumSource_new () {return vtkFrustumSource :: New () ;} extern "C" void vtkFrustumSource_destructor (vtkFrustumSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkFrustumSource_get_ptr (vtkFrustumSource * sself) {return sself ;} extern "C" bool vtk_frustum_source_get_show_lines(vtkFrustumSource* sself) { return sself->GetShowLines(); } extern "C" void vtk_frustum_source_set_show_lines(vtkFrustumSource* sself, bool _arg) { sself->SetShowLines(_arg); } extern "C" void vtk_frustum_source_show_lines_on(vtkFrustumSource* sself) { sself->ShowLinesOn(); } @@ -328,7 +316,6 @@ extern "C" void vtk_frustum_source_set_output_points_precision(vtkFrustumSource* extern "C" int vtk_frustum_source_get_output_points_precision(vtkFrustumSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkGlyphSource2D * vtkGlyphSource2D_new () {return vtkGlyphSource2D :: New () ;} extern "C" void vtkGlyphSource2D_destructor (vtkGlyphSource2D * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGlyphSource2D_get_ptr (vtkGlyphSource2D * sself) {return sself ;} extern "C" void vtk_glyph_source_2_d_set_center(vtkGlyphSource2D* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } extern "C" void vtk_glyph_source_2_d_set_scale(vtkGlyphSource2D* sself, double _arg) { sself->SetScale(_arg); } extern "C" double vtk_glyph_source_2_d_get_scale_min_value(vtkGlyphSource2D* sself) { return sself->GetScaleMinValue(); } @@ -378,7 +365,6 @@ extern "C" void vtk_glyph_source_2_d_set_output_points_precision(vtkGlyphSource2 extern "C" int vtk_glyph_source_2_d_get_output_points_precision(vtkGlyphSource2D* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkGraphToPolyData * vtkGraphToPolyData_new () {return vtkGraphToPolyData :: New () ;} extern "C" void vtkGraphToPolyData_destructor (vtkGraphToPolyData * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkGraphToPolyData_get_ptr (vtkGraphToPolyData * sself) {return sself ;} extern "C" void vtk_graph_to_poly_data_set_edge_glyph_output(vtkGraphToPolyData* sself, bool _arg) { sself->SetEdgeGlyphOutput(_arg); } extern "C" bool vtk_graph_to_poly_data_get_edge_glyph_output(vtkGraphToPolyData* sself) { return sself->GetEdgeGlyphOutput(); } extern "C" void vtk_graph_to_poly_data_edge_glyph_output_on(vtkGraphToPolyData* sself) { sself->EdgeGlyphOutputOn(); } @@ -387,7 +373,6 @@ extern "C" void vtk_graph_to_poly_data_set_edge_glyph_position(vtkGraphToPolyDat extern "C" double vtk_graph_to_poly_data_get_edge_glyph_position(vtkGraphToPolyData* sself) { return sself->GetEdgeGlyphPosition(); } extern "C" vtkHyperTreeGridSource * vtkHyperTreeGridSource_new () {return vtkHyperTreeGridSource :: New () ;} extern "C" void vtkHyperTreeGridSource_destructor (vtkHyperTreeGridSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkHyperTreeGridSource_get_ptr (vtkHyperTreeGridSource * sself) {return sself ;} extern "C" unsigned int vtk_hyper_tree_grid_source_get_maximum_level(vtkHyperTreeGridSource* sself) { return sself->GetMaximumLevel(); } extern "C" void vtk_hyper_tree_grid_source_set_maximum_level(vtkHyperTreeGridSource* sself, unsigned int levels) { sself->SetMaximumLevel(levels); } extern "C" unsigned int vtk_hyper_tree_grid_source_get_max_depth(vtkHyperTreeGridSource* sself) { return sself->GetMaxDepth(); } @@ -420,7 +405,6 @@ extern "C" void vtk_hyper_tree_grid_source_set_mask(vtkHyperTreeGridSource* ssel extern "C" unsigned long vtk_hyper_tree_grid_source_get_m_time(vtkHyperTreeGridSource* sself) { return sself->GetMTime(); } extern "C" vtkLineSource * vtkLineSource_new () {return vtkLineSource :: New () ;} extern "C" void vtkLineSource_destructor (vtkLineSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkLineSource_get_ptr (vtkLineSource * sself) {return sself ;} extern "C" void vtk_line_source_set_point_1(vtkLineSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint1(_arg1, _arg2, _arg3); } extern "C" void vtk_line_source_set_point_2(vtkLineSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint2(_arg1, _arg2, _arg3); } extern "C" void vtk_line_source_set_use_regular_refinement(vtkLineSource* sself, bool _arg) { sself->SetUseRegularRefinement(_arg); } @@ -439,21 +423,18 @@ extern "C" void vtk_line_source_set_output_points_precision(vtkLineSource* sself extern "C" int vtk_line_source_get_output_points_precision(vtkLineSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkOutlineCornerFilter * vtkOutlineCornerFilter_new () {return vtkOutlineCornerFilter :: New () ;} extern "C" void vtkOutlineCornerFilter_destructor (vtkOutlineCornerFilter * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOutlineCornerFilter_get_ptr (vtkOutlineCornerFilter * sself) {return sself ;} extern "C" void vtk_outline_corner_filter_set_corner_factor(vtkOutlineCornerFilter* sself, double _arg) { sself->SetCornerFactor(_arg); } extern "C" double vtk_outline_corner_filter_get_corner_factor_min_value(vtkOutlineCornerFilter* sself) { return sself->GetCornerFactorMinValue(); } extern "C" double vtk_outline_corner_filter_get_corner_factor_max_value(vtkOutlineCornerFilter* sself) { return sself->GetCornerFactorMaxValue(); } extern "C" double vtk_outline_corner_filter_get_corner_factor(vtkOutlineCornerFilter* sself) { return sself->GetCornerFactor(); } extern "C" vtkOutlineCornerSource * vtkOutlineCornerSource_new () {return vtkOutlineCornerSource :: New () ;} extern "C" void vtkOutlineCornerSource_destructor (vtkOutlineCornerSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOutlineCornerSource_get_ptr (vtkOutlineCornerSource * sself) {return sself ;} extern "C" void vtk_outline_corner_source_set_corner_factor(vtkOutlineCornerSource* sself, double _arg) { sself->SetCornerFactor(_arg); } extern "C" double vtk_outline_corner_source_get_corner_factor_min_value(vtkOutlineCornerSource* sself) { return sself->GetCornerFactorMinValue(); } extern "C" double vtk_outline_corner_source_get_corner_factor_max_value(vtkOutlineCornerSource* sself) { return sself->GetCornerFactorMaxValue(); } extern "C" double vtk_outline_corner_source_get_corner_factor(vtkOutlineCornerSource* sself) { return sself->GetCornerFactor(); } extern "C" vtkOutlineSource * vtkOutlineSource_new () {return vtkOutlineSource :: New () ;} extern "C" void vtkOutlineSource_destructor (vtkOutlineSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkOutlineSource_get_ptr (vtkOutlineSource * sself) {return sself ;} extern "C" void vtk_outline_source_set_box_type(vtkOutlineSource* sself, int _arg) { sself->SetBoxType(_arg); } extern "C" int vtk_outline_source_get_box_type(vtkOutlineSource* sself) { return sself->GetBoxType(); } extern "C" void vtk_outline_source_set_box_type_to_axis_aligned(vtkOutlineSource* sself) { sself->SetBoxTypeToAxisAligned(); } @@ -467,7 +448,6 @@ extern "C" void vtk_outline_source_set_output_points_precision(vtkOutlineSource* extern "C" int vtk_outline_source_get_output_points_precision(vtkOutlineSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkParametricFunctionSource * vtkParametricFunctionSource_new () {return vtkParametricFunctionSource :: New () ;} extern "C" void vtkParametricFunctionSource_destructor (vtkParametricFunctionSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkParametricFunctionSource_get_ptr (vtkParametricFunctionSource * sself) {return sself ;} extern "C" void vtk_parametric_function_source_set_u_resolution(vtkParametricFunctionSource* sself, int _arg) { sself->SetUResolution(_arg); } extern "C" int vtk_parametric_function_source_get_u_resolution_min_value(vtkParametricFunctionSource* sself) { return sself->GetUResolutionMinValue(); } extern "C" int vtk_parametric_function_source_get_u_resolution_max_value(vtkParametricFunctionSource* sself) { return sself->GetUResolutionMaxValue(); } @@ -515,14 +495,12 @@ extern "C" void vtk_parametric_function_source_set_output_points_precision(vtkPa extern "C" int vtk_parametric_function_source_get_output_points_precision(vtkParametricFunctionSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkPartitionedDataSetCollectionSource * vtkPartitionedDataSetCollectionSource_new () {return vtkPartitionedDataSetCollectionSource :: New () ;} extern "C" void vtkPartitionedDataSetCollectionSource_destructor (vtkPartitionedDataSetCollectionSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPartitionedDataSetCollectionSource_get_ptr (vtkPartitionedDataSetCollectionSource * sself) {return sself ;} extern "C" void vtk_partitioned_data_set_collection_source_set_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself, int _arg) { sself->SetNumberOfShapes(_arg); } extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_min_value(vtkPartitionedDataSetCollectionSource* sself) { return sself->GetNumberOfShapesMinValue(); } extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_max_value(vtkPartitionedDataSetCollectionSource* sself) { return sself->GetNumberOfShapesMaxValue(); } extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself) { return sself->GetNumberOfShapes(); } extern "C" vtkPartitionedDataSetSource * vtkPartitionedDataSetSource_new () {return vtkPartitionedDataSetSource :: New () ;} extern "C" void vtkPartitionedDataSetSource_destructor (vtkPartitionedDataSetSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPartitionedDataSetSource_get_ptr (vtkPartitionedDataSetSource * sself) {return sself ;} extern "C" void vtk_partitioned_data_set_source_enable_rank(vtkPartitionedDataSetSource* sself, int rank) { sself->EnableRank(rank); } extern "C" void vtk_partitioned_data_set_source_enable_all_ranks(vtkPartitionedDataSetSource* sself) { sself->EnableAllRanks(); } extern "C" void vtk_partitioned_data_set_source_disable_rank(vtkPartitionedDataSetSource* sself, int rank) { sself->DisableRank(rank); } @@ -534,7 +512,6 @@ extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions_max_valu extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions(vtkPartitionedDataSetSource* sself) { return sself->GetNumberOfPartitions(); } extern "C" vtkPlaneSource * vtkPlaneSource_new () {return vtkPlaneSource :: New () ;} extern "C" void vtkPlaneSource_destructor (vtkPlaneSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPlaneSource_get_ptr (vtkPlaneSource * sself) {return sself ;} extern "C" void vtk_plane_source_set_x_resolution(vtkPlaneSource* sself, int _arg) { sself->SetXResolution(_arg); } extern "C" int vtk_plane_source_get_x_resolution(vtkPlaneSource* sself) { return sself->GetXResolution(); } extern "C" void vtk_plane_source_set_y_resolution(vtkPlaneSource* sself, int _arg) { sself->SetYResolution(_arg); } @@ -551,7 +528,6 @@ extern "C" void vtk_plane_source_set_output_points_precision(vtkPlaneSource* sse extern "C" int vtk_plane_source_get_output_points_precision(vtkPlaneSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkPlatonicSolidSource * vtkPlatonicSolidSource_new () {return vtkPlatonicSolidSource :: New () ;} extern "C" void vtkPlatonicSolidSource_destructor (vtkPlatonicSolidSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPlatonicSolidSource_get_ptr (vtkPlatonicSolidSource * sself) {return sself ;} extern "C" void vtk_platonic_solid_source_set_solid_type(vtkPlatonicSolidSource* sself, int _arg) { sself->SetSolidType(_arg); } extern "C" int vtk_platonic_solid_source_get_solid_type_min_value(vtkPlatonicSolidSource* sself) { return sself->GetSolidTypeMinValue(); } extern "C" int vtk_platonic_solid_source_get_solid_type_max_value(vtkPlatonicSolidSource* sself) { return sself->GetSolidTypeMaxValue(); } @@ -565,12 +541,10 @@ extern "C" void vtk_platonic_solid_source_set_output_points_precision(vtkPlatoni extern "C" int vtk_platonic_solid_source_get_output_points_precision(vtkPlatonicSolidSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkPointHandleSource * vtkPointHandleSource_new () {return vtkPointHandleSource :: New () ;} extern "C" void vtkPointHandleSource_destructor (vtkPointHandleSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPointHandleSource_get_ptr (vtkPointHandleSource * sself) {return sself ;} extern "C" void vtk_point_handle_source_set_position(vtkPointHandleSource* sself, double xPos, double yPos, double zPos) { sself->SetPosition(xPos, yPos, zPos); } extern "C" void vtk_point_handle_source_set_direction(vtkPointHandleSource* sself, double xDir, double yDir, double zDir) { sself->SetDirection(xDir, yDir, zDir); } extern "C" vtkPointSource * vtkPointSource_new () {return vtkPointSource :: New () ;} extern "C" void vtkPointSource_destructor (vtkPointSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPointSource_get_ptr (vtkPointSource * sself) {return sself ;} extern "C" void vtk_point_source_set_number_of_points(vtkPointSource* sself, long long _arg) { sself->SetNumberOfPoints(_arg); } extern "C" long long vtk_point_source_get_number_of_points_min_value(vtkPointSource* sself) { return sself->GetNumberOfPointsMinValue(); } extern "C" long long vtk_point_source_get_number_of_points_max_value(vtkPointSource* sself) { return sself->GetNumberOfPointsMaxValue(); } @@ -588,14 +562,12 @@ extern "C" void vtk_point_source_set_output_points_precision(vtkPointSource* sse extern "C" int vtk_point_source_get_output_points_precision(vtkPointSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkPolyLineSource * vtkPolyLineSource_new () {return vtkPolyLineSource :: New () ;} extern "C" void vtkPolyLineSource_destructor (vtkPolyLineSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolyLineSource_get_ptr (vtkPolyLineSource * sself) {return sself ;} extern "C" void vtk_poly_line_source_set_closed(vtkPolyLineSource* sself, int _arg) { sself->SetClosed(_arg); } extern "C" int vtk_poly_line_source_get_closed(vtkPolyLineSource* sself) { return sself->GetClosed(); } extern "C" void vtk_poly_line_source_closed_on(vtkPolyLineSource* sself) { sself->ClosedOn(); } extern "C" void vtk_poly_line_source_closed_off(vtkPolyLineSource* sself) { sself->ClosedOff(); } extern "C" vtkPolyPointSource * vtkPolyPointSource_new () {return vtkPolyPointSource :: New () ;} extern "C" void vtkPolyPointSource_destructor (vtkPolyPointSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkPolyPointSource_get_ptr (vtkPolyPointSource * sself) {return sself ;} extern "C" void vtk_poly_point_source_set_number_of_points(vtkPolyPointSource* sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } extern "C" long long vtk_poly_point_source_get_number_of_points(vtkPolyPointSource* sself) { return sself->GetNumberOfPoints(); } extern "C" void vtk_poly_point_source_resize(vtkPolyPointSource* sself, long long numPoints) { sself->Resize(numPoints); } @@ -603,13 +575,10 @@ extern "C" void vtk_poly_point_source_set_point(vtkPolyPointSource* sself, long extern "C" unsigned long vtk_poly_point_source_get_m_time(vtkPolyPointSource* sself) { return sself->GetMTime(); } extern "C" vtkProgrammableDataObjectSource * vtkProgrammableDataObjectSource_new () {return vtkProgrammableDataObjectSource :: New () ;} extern "C" void vtkProgrammableDataObjectSource_destructor (vtkProgrammableDataObjectSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkProgrammableDataObjectSource_get_ptr (vtkProgrammableDataObjectSource * sself) {return sself ;} extern "C" vtkProgrammableSource * vtkProgrammableSource_new () {return vtkProgrammableSource :: New () ;} extern "C" void vtkProgrammableSource_destructor (vtkProgrammableSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkProgrammableSource_get_ptr (vtkProgrammableSource * sself) {return sself ;} extern "C" vtkRandomHyperTreeGridSource * vtkRandomHyperTreeGridSource_new () {return vtkRandomHyperTreeGridSource :: New () ;} extern "C" void vtkRandomHyperTreeGridSource_destructor (vtkRandomHyperTreeGridSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkRandomHyperTreeGridSource_get_ptr (vtkRandomHyperTreeGridSource * sself) {return sself ;} extern "C" void vtk_random_hyper_tree_grid_source_set_dimensions(vtkRandomHyperTreeGridSource* sself, unsigned int _arg1, unsigned int _arg2, unsigned int _arg3) { sself->SetDimensions(_arg1, _arg2, _arg3); } extern "C" void vtk_random_hyper_tree_grid_source_set_output_bounds(vtkRandomHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6) { sself->SetOutputBounds(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } extern "C" unsigned int vtk_random_hyper_tree_grid_source_get_seed(vtkRandomHyperTreeGridSource* sself) { return sself->GetSeed(); } @@ -624,7 +593,6 @@ extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_min_value extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_max_value(vtkRandomHyperTreeGridSource* sself) { return sself->GetSplitFractionMaxValue(); } extern "C" vtkRectangularButtonSource * vtkRectangularButtonSource_new () {return vtkRectangularButtonSource :: New () ;} extern "C" void vtkRectangularButtonSource_destructor (vtkRectangularButtonSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkRectangularButtonSource_get_ptr (vtkRectangularButtonSource * sself) {return sself ;} extern "C" void vtk_rectangular_button_source_set_width(vtkRectangularButtonSource* sself, double _arg) { sself->SetWidth(_arg); } extern "C" double vtk_rectangular_button_source_get_width_min_value(vtkRectangularButtonSource* sself) { return sself->GetWidthMinValue(); } extern "C" double vtk_rectangular_button_source_get_width_max_value(vtkRectangularButtonSource* sself) { return sself->GetWidthMaxValue(); } @@ -653,7 +621,6 @@ extern "C" void vtk_rectangular_button_source_set_output_points_precision(vtkRec extern "C" int vtk_rectangular_button_source_get_output_points_precision(vtkRectangularButtonSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkRegularPolygonSource * vtkRegularPolygonSource_new () {return vtkRegularPolygonSource :: New () ;} extern "C" void vtkRegularPolygonSource_destructor (vtkRegularPolygonSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkRegularPolygonSource_get_ptr (vtkRegularPolygonSource * sself) {return sself ;} extern "C" void vtk_regular_polygon_source_set_number_of_sides(vtkRegularPolygonSource* sself, int _arg) { sself->SetNumberOfSides(_arg); } extern "C" int vtk_regular_polygon_source_get_number_of_sides_min_value(vtkRegularPolygonSource* sself) { return sself->GetNumberOfSidesMinValue(); } extern "C" int vtk_regular_polygon_source_get_number_of_sides_max_value(vtkRegularPolygonSource* sself) { return sself->GetNumberOfSidesMaxValue(); } @@ -674,7 +641,6 @@ extern "C" void vtk_regular_polygon_source_set_output_points_precision(vtkRegula extern "C" int vtk_regular_polygon_source_get_output_points_precision(vtkRegularPolygonSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkSelectionSource * vtkSelectionSource_new () {return vtkSelectionSource :: New () ;} extern "C" void vtkSelectionSource_destructor (vtkSelectionSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSelectionSource_get_ptr (vtkSelectionSource * sself) {return sself ;} extern "C" void vtk_selection_source_add_id(vtkSelectionSource* sself, long long piece, long long id) { sself->AddID(piece, id); } extern "C" void vtk_selection_source_add_string_id(vtkSelectionSource* sself, long long piece, const char* id) { sself->AddStringID(piece, id); } extern "C" void vtk_selection_source_add_location(vtkSelectionSource* sself, double x, double y, double z) { sself->AddLocation(x, y, z); } @@ -714,7 +680,6 @@ extern "C" void vtk_selection_source_remove_all_selectors(vtkSelectionSource* ss extern "C" void vtk_selection_source_set_query_string(vtkSelectionSource* sself, const char* _arg) { sself->SetQueryString(_arg); } extern "C" vtkSphereSource * vtkSphereSource_new () {return vtkSphereSource :: New () ;} extern "C" void vtkSphereSource_destructor (vtkSphereSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSphereSource_get_ptr (vtkSphereSource * sself) {return sself ;} extern "C" void vtk_sphere_source_set_radius(vtkSphereSource* sself, double _arg) { sself->SetRadius(_arg); } extern "C" double vtk_sphere_source_get_radius_min_value(vtkSphereSource* sself) { return sself->GetRadiusMinValue(); } extern "C" double vtk_sphere_source_get_radius_max_value(vtkSphereSource* sself) { return sself->GetRadiusMaxValue(); } @@ -756,7 +721,6 @@ extern "C" void vtk_sphere_source_generate_normals_on(vtkSphereSource* sself) { extern "C" void vtk_sphere_source_generate_normals_off(vtkSphereSource* sself) { sself->GenerateNormalsOff(); } extern "C" vtkSuperquadricSource * vtkSuperquadricSource_new () {return vtkSuperquadricSource :: New () ;} extern "C" void vtkSuperquadricSource_destructor (vtkSuperquadricSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkSuperquadricSource_get_ptr (vtkSuperquadricSource * sself) {return sself ;} extern "C" void vtk_superquadric_source_set_center(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } extern "C" void vtk_superquadric_source_set_scale(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetScale(_arg1, _arg2, _arg3); } extern "C" int vtk_superquadric_source_get_theta_resolution(vtkSuperquadricSource* sself) { return sself->GetThetaResolution(); } @@ -786,7 +750,6 @@ extern "C" void vtk_superquadric_source_set_output_points_precision(vtkSuperquad extern "C" int vtk_superquadric_source_get_output_points_precision(vtkSuperquadricSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkTessellatedBoxSource * vtkTessellatedBoxSource_new () {return vtkTessellatedBoxSource :: New () ;} extern "C" void vtkTessellatedBoxSource_destructor (vtkTessellatedBoxSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTessellatedBoxSource_get_ptr (vtkTessellatedBoxSource * sself) {return sself ;} extern "C" void vtk_tessellated_box_source_set_bounds(vtkTessellatedBoxSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6) { sself->SetBounds(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } extern "C" void vtk_tessellated_box_source_set_level(vtkTessellatedBoxSource* sself, int _arg) { sself->SetLevel(_arg); } extern "C" int vtk_tessellated_box_source_get_level(vtkTessellatedBoxSource* sself) { return sself->GetLevel(); } @@ -802,7 +765,6 @@ extern "C" void vtk_tessellated_box_source_set_output_points_precision(vtkTessel extern "C" int vtk_tessellated_box_source_get_output_points_precision(vtkTessellatedBoxSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkTextSource * vtkTextSource_new () {return vtkTextSource :: New () ;} extern "C" void vtkTextSource_destructor (vtkTextSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTextSource_get_ptr (vtkTextSource * sself) {return sself ;} extern "C" void vtk_text_source_set_text(vtkTextSource* sself, const char* _arg) { sself->SetText(_arg); } extern "C" void vtk_text_source_set_backing(vtkTextSource* sself, int _arg) { sself->SetBacking(_arg); } extern "C" int vtk_text_source_get_backing(vtkTextSource* sself) { return sself->GetBacking(); } @@ -814,7 +776,6 @@ extern "C" void vtk_text_source_set_output_points_precision(vtkTextSource* sself extern "C" int vtk_text_source_get_output_points_precision(vtkTextSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkTexturedSphereSource * vtkTexturedSphereSource_new () {return vtkTexturedSphereSource :: New () ;} extern "C" void vtkTexturedSphereSource_destructor (vtkTexturedSphereSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkTexturedSphereSource_get_ptr (vtkTexturedSphereSource * sself) {return sself ;} extern "C" void vtk_textured_sphere_source_set_radius(vtkTexturedSphereSource* sself, double _arg) { sself->SetRadius(_arg); } extern "C" double vtk_textured_sphere_source_get_radius_min_value(vtkTexturedSphereSource* sself) { return sself->GetRadiusMinValue(); } extern "C" double vtk_textured_sphere_source_get_radius_max_value(vtkTexturedSphereSource* sself) { return sself->GetRadiusMaxValue(); } @@ -839,4 +800,3 @@ extern "C" void vtk_textured_sphere_source_set_output_points_precision(vtkTextur extern "C" int vtk_textured_sphere_source_get_output_points_precision(vtkTexturedSphereSource* sself) { return sself->GetOutputPointsPrecision(); } extern "C" vtkUniformHyperTreeGridSource * vtkUniformHyperTreeGridSource_new () {return vtkUniformHyperTreeGridSource :: New () ;} extern "C" void vtkUniformHyperTreeGridSource_destructor (vtkUniformHyperTreeGridSource * sself) {sself -> Delete () ; return ;} -extern "C" void * vtkUniformHyperTreeGridSource_get_ptr (vtkUniformHyperTreeGridSource * sself) {return sself ;}